JAVA数据中心丶授权丶加密传输信息(学习笔记一)

一 : code授权码 ,服务端丶客户端

二 : 数据库查询接口

三 : RSA加密丶Escape编码等方法

VerifyCode授权码,客户端

/***
 * VerifyCode(授权码)客户端
 */
@Controller
public class VerifyCode {

 private static String verifyCode = null; // 授权码

 private static long valid_date = 0; // (授权码)有效期至(毫秒)

 private static String server_puKey = null; // 中控端,加密公钥

 // 获取授权码
 // 同时只有一个线程可进入此方法
 public static synchronized String getCode() {
  if (verifyCode == null || new Date().getTime() >= valid_date) {
   applyCode();
  }
  return verifyCode;
 }

 public static String getServerKey() {
  return server_puKey;
 }

 /** 向"中控"服务器,请求Code验证码 **/
 public static void applyCode() {
  try {
   String puKey = RSAUtils.getPukeyStr(); // RSA公钥(接收参数加密密钥)
   String redirect_uri = "http://127.0.0.1:8080/" + Config.server_name + "/getCode"; // 回调地址(接受参数)
   String url = "http://127.0.0.1:8080/control_center/getCode?redirect_uri=URI&puKey=PUKEY";
   // "中控"服务器接口
   url = url.replace("URI", Escape.escape(redirect_uri)).replace("PUKEY", Escape.escape(puKey));
   Global.info(url);
   String str = HttpGetRequest.doGet(url);
   if (str != null) {
    JSONObject json = JSONObject.fromObject(str);
    int ret = json.getInt("ret");
    if (ret == 0) {
     Thread.sleep(200); // 此线程休眠200(毫秒),等待中控服务器信息反馈完毕
    } else {
     // 获取code失败
     Global.error(json.getString("errorMag"));
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 /** 获取到验证码 */
 @RequestMapping("/getCode")
 public void getCode(HttpServletResponse response, String verifyCode, String valid_time, String server_puKey) {
  if (verifyCode != null) {
   try {
    // 对verifyCode进行解码,解密(已被加密)
    VerifyCode.verifyCode = RSAUtils.decrypt(Escape.unescape(verifyCode), RSAUtils.getPrkey());
    VerifyCode.valid_date = new Date().getTime() + Integer.parseInt(valid_time);
    VerifyCode.server_puKey = Escape.unescape(server_puKey);
   } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  HttpUtils.write(response, "{'ret':0}");
 }
}

VerifyCode授权码,服务端

/**
 * verifyCode(授权)服务端
 **/
@Controller
public class VerifyCode extends Global {

 // 密钥组,JSONObject中存储pukey丶uri等信息
 private static Map<String, JSONObject> codes = new HashMap<String, JSONObject>();

 // 获取verifyCode(uri:回调地址,valid_time:有效时长(毫秒))
 private static String getCode(String puKey, String uri, long valid_time) {
  if (puKey != null) {
   String verifyCode = getRandomStr(50); // 50位随机字符串(不含特殊符号)
   codes.put(verifyCode,
     getJSON("puKey", puKey, "uri", uri, "start_time", new Date().getTime(), "valid_time", valid_time));
   return verifyCode;
  }
  return null;
 }

 // 获取code
 public static JSONObject ready(String code) {
  JSONObject js = codes.get(code);
  if (js != null && (new Date().getTime() - js.getLong("start_time")) > js.getLong("valid_time")) {
   js = null;
   codes.remove(code);
  }
  return js;
 }

 // 获取control_center验证码(url匹配:一般只允许http://127.0.0.1/地址获取)
 @RequestMapping("/getCode")
 public void getCode(HttpServletResponse response, String redirect_uri, String puKey) {
  try {
   redirect_uri = Escape.unescape(redirect_uri); // escape编码解析,js语言方法
   if (Pattern.compile(Config.regex).matcher(redirect_uri).find()) {
    // 公钥
    puKey = Escape.unescape(puKey);
    // 获取VerifyCode验证码,有效期(毫秒/总24h)
    long valid_time = 8640000;
    String verifyCode = getCode(puKey, redirect_uri, valid_time);
    // 加密verifyCode(公钥)
    String en_verifyCode = RSAUtils.encrypt(verifyCode, RSAUtils.getPukey(puKey));
    // 回调verifyCode码(加密后,接收方需进行解码)
    String url = redirect_uri + "?verifyCode=" + Escape.escape(en_verifyCode) + "&valid_time=" + valid_time
      + "&server_puKey=" + Escape.escape(RSAUtils.getPukeyStr());
    info("getCode redirect_uri:" + url);
    HttpGetRequest.doGet(url);
    // 发送,获取成功
    HttpUtils.write(response,
      "{'ret':0,'successMsg':'Code has been callback to the redirect_uri address!'}");
   }
   // 正则匹配失败,uri不是安全域名
   else {
    HttpUtils.write(response, "{'ret':10002,'errorMsg':'redirect_uri is not a secure domain name!'}");
   }
  } catch (Exception e) {
   HttpUtils.write(response, "{'ret':10001,'errorMsg':'parameter anomaly!'}");
   e.printStackTrace();
  }
 }
}

DBServer服务端

/**
 * 数据库服务器端
 */
@Controller
public class DBServer extends Global {

 // 查询用户信息
 @RequestMapping("/queryUser")
 public void queryUser(HttpServletResponse response, String openid, String code) {
  JSONObject json = VerifyCode.ready(code);
  if (json != null) {
   WxUser wxUser = WechatDB.getUserByOpenid(openid);
   if (wxUser != null) {
    try {
     String data = "{'ret':0,'successMsg':'found user success!','data':" + getJSON("user", wxUser) + "}";
     // 此处使用公钥加密信息(数据太长,需使用分段加密丶解密)
     data = RSAUtils.encrypt(data, RSAUtils.getPukey(json.getString("puKey")));
     // 对data字符串进行编码传输(防止乱码)
     HttpUtils.write(response, Escape.escape(data));
    } catch (Exception e) {
     e.printStackTrace();
     HttpUtils.write(response, "{'ret':10003,'errorMsg':'parsing error , please get code again !'}");
    }
   } else {
    HttpUtils.write(response, "{'ret':10002,'errorMsg':'the user was not found!'}");
   }
  } else {
   HttpUtils.write(response, "{'ret':10001,'errorMsg':'code is invalid!'}");
  }
 }

 // 尝试减去用户积分
 @RequestMapping("/subSocre")
 public void subSocre(HttpServletResponse response, String openid, String code, String socre) {
  JSONObject json = VerifyCode.ready(code);
  if (json != null) {
   try {
    Boolean success = WechatDB.subSocerByOpenid(openid, Integer.parseInt(socre));
    String data = "{'ret':0,'successMsg':'return success!','data':{'success':" + success + "}}";
    // 对data字符串进行编码传输(防止乱码)
    HttpUtils.write(response, Escape.escape(data));
   } catch (Exception e) {
    e.printStackTrace();
    HttpUtils.write(response, "{'ret':10003,'errorMsg':'parsing error , please get code again !'}");
   }
  } else {
   HttpUtils.write(response, "{'ret':10001,'errorMsg':'code is invalid!'}");
  }
 }

 // 保存用户
 @RequestMapping("/saveUser")
 public void saveUser(HttpServletResponse response, String data, String code) {
  JSONObject json = VerifyCode.ready(code);
  if (json != null) {
   try {
    // 对data解码丶解密
    data = Escape.unescape(data);
    data = RSAUtils.decrypt(data, RSAUtils.getPrkey());
    // 将data转化为WxUser对象
    WxUser wxUser = (WxUser) JSONObject.toBean(JSONObject.fromObject(data).getJSONObject("user"),
      WxUser.class);
    // 尝试保存用户信息
    Boolean success = WechatDB.saveWechatUser(wxUser);
    String s_data = "{'ret':0,'successMsg':'return success!','data':{'success':" + success + "}}";
    // 对data字符串进行编码传输(防止乱码)
    HttpUtils.write(response, Escape.escape(s_data));
   } catch (Exception e) {
    e.printStackTrace();
    HttpUtils.write(response, "{'ret':10003,'errorMsg':'parsing error , please get code again !'}");
   }
  } else {
   HttpUtils.write(response, "{'ret':10001,'errorMsg':'code is invalid!'}");
  }
 }

}

DBClient客户端

/***
 * 连接中控服务器数据库,客户端
 * 
 */
public class DBClient extends Global {

 /** 获取用户信息 **/
 public static WxUser getUserByOpenid(String openid) {
  try {
   String url = "http://127.0.0.1:8080/control_center/queryUser?openid=" + openid + "&code="
     + VerifyCode.getCode();
   // 连接中控服务器,获取openid对应的用户信息
   String json_string = HttpGetRequest.doGet(url);
   if (json_string != null) {
    // info("源字符串:" + json_string);
    // 对json_string解码(数据已被编码,中文乱码)
    json_string = Escape.unescape(json_string);
    // json_string已被加密,此处需对信息进行解密(!可能需要分段解密)
    json_string = RSAUtils.decrypt(json_string, RSAUtils.getPrkey());
    // info("解码解密:" + json_string);
    JSONObject json = JSONObject.fromObject(json_string);
    int ret = json.getInt("ret");
    // 数据返回成功
    if (ret == 0) {
     JSONObject data = json.getJSONObject("data");
     return (WxUser) JSONObject.toBean(data.getJSONObject("user"), WxUser.class);
    }
    // code码失效
    else if (ret == 10001) {
     info("'中控中心'查询:,code码失效!");
    }
    // 不存在此openid的用户信息
    else if (ret == 10002) {
     info("'中控中心'查询:,不存在此openid的用户信息!");
    }
    // 参数解析失败(可能是上传的密钥问题)
    else if (ret == 10003) {
     info("'中控中心'查询:,参数解析失败(可能是上传的密钥问题)");
    }
   } else {
    info("'中控中心'DBServer无响应!");
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }

 /** 尝试减去用户积分 **/
 public static Boolean subSocreByOpenid(String openid, Integer socre) {
  try {
   String url = "http://127.0.0.1:8080/control_center/subSocre?openid=" + openid + "&code="
     + VerifyCode.getCode() + "&socre=" + socre;
   // 连接中控服务器,获取openid对应的用户信息
   String json_string = HttpGetRequest.doGet(url);
   if (json_string != null) {
    // info("源字符串:" + json_string);
    // 对json_string解码(数据已被编码,中文乱码)
    json_string = Escape.unescape(json_string);
    // info("解码解密:" + json_string);
    JSONObject json = JSONObject.fromObject(json_string);
    int ret = json.getInt("ret");
    // 数据返回成功
    if (ret == 0) {
     JSONObject data = json.getJSONObject("data");
     return data.getBoolean("success");
    }
    // code码失效
    else if (ret == 10001) {
     info("'中控中心'查询:,code码失效!");
    }
    // 参数解析失败(可能是上传的密钥问题)
    else if (ret == 10003) {
     info("'中控中心'查询:,参数解析失败(可能是上传的密钥问题)");
    }
   } else {
    info("'中控中心'DBServer无响应!");
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return false;
 }

 /** 保存一位用户的信息 **/
 public static Boolean saveWechatUser(WxUser wxUser) {
  try {
   String s_data = getJSON("user", wxUser).toString();
   // 对s_data进行加密(使用server_puKey)
   s_data = RSAUtils.encrypt(s_data, RSAUtils.getPukey(VerifyCode.getServerKey()));
   String url = "http://127.0.0.1:8080/control_center/saveUser?data=" + Escape.escape(s_data) + "&code="
     + VerifyCode.getCode();
   // 连接中控服务器,获取openid对应的用户信息
   String json_string = HttpGetRequest.doGet(url);
   if (json_string != null) {
    // 对json_string解码(数据已被编码,中文乱码)
    json_string = Escape.unescape(json_string);
    JSONObject json = JSONObject.fromObject(json_string);
    int ret = json.getInt("ret");
    // 数据返回成功
    if (ret == 0) {
     JSONObject data = json.getJSONObject("data");
     return data.getBoolean("success");
    }
    // code码失效
    else if (ret == 10001) {
     info("'中控中心'查询:,code码失效!");
    }
    // 参数解析失败(可能是上传的密钥问题)
    else if (ret == 10003) {
     info("'中控中心'查询:,参数解析失败(可能是上传的密钥问题)");
    }
   } else {
    info("'中控中心'DBServer无响应!");
   }

  } catch (Exception e) {
   e.printStackTrace();
  }
  return false;
 }
}

RSAutils加密丶解密类( Base64编码,需视当前编译环境,自行更改 )

/**
 * 加解密RSA方式 从字符串中获取加密秘钥和从文件中获取加密秘钥
 */

public class RSAUtils {

 // 指定加密算法为RSA
 private static final String ALGORITHM = "RSA";
 // 密钥长度，用来初始化密钥(常用512/1024/2048/4096)
 private static final int KEYSIZE = 1024;

 // 密钥对象
 private static PublicKey puKey = null;
 private static PrivateKey prKey = null;

 // 加密字符串最大长度(默认KEYSIZE=1024)
 private static int MAX_ENCRYPT_BLOCK = 117; // MAX_ENCRYPT_BLOCK=KEYSIZE/8-11;
 // 解密字符串最大长度(默认KEYSIZE=1024)
 private static int MAX_DECRYPT_BLOCK = 128; // MAX_DECRYPT_BLOCK=KEYSIZE/8;

 /** 公钥加密 **/
 public static String encrypt(String src, PublicKey key) throws Exception {
  return encode(encrypt(key, src.getBytes()));
 }

 /** 私钥解密 **/
 public static String decrypt(String src, PrivateKey key) throws Exception {
  return new String(decrypt(key, decode(src)));
 }

 /**
  * 获取公钥(带标签)
  **/
 public static String getPukeyTag() {
  if (puKey == null)
   initKeyPair();
  return "-----BEGIN PUBLIC KEY-----\n" + getPukeyStr() + "\n-----END PUBLIC KEY-----";
 }

 public static String getPukeyStr() {
  if (puKey == null)
   initKeyPair();
  return new String(encode(puKey.getEncoded()));
 }

 public static PublicKey getPukey() {
  return puKey;
 }

 /**
  * 从字符串中加载公钥
  */
 public static RSAPublicKey getPukey(String publicKeyStr) throws Exception {
  try {
   byte[] buffer = decode(publicKeyStr);
   KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
   X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
   return (RSAPublicKey) keyFactory.generatePublic(keySpec);
  } catch (NoSuchAlgorithmException e) {
   throw new Exception("无此算法");
  } catch (InvalidKeySpecException e) {
   throw new Exception("公钥非法");
  } catch (NullPointerException e) {
   throw new Exception("公钥数据为空");
  }
 }

 /**
  * 获取私钥 (带标签)
  **/
 public static String getPrkeyTag() {
  if (prKey == null)
   initKeyPair();
  return "-----BEGIN RSA PRIVATE KEY-----\n" + getPrkeyStr() + "\n-----END RSA PRIVATE KEY-----";
 }

 public static String getPrkeyStr() {
  if (prKey == null)
   initKeyPair();
  return new String(encode(prKey.getEncoded()));
 }

 public static PrivateKey getPrkey() {
  return prKey;
 }

 /**
  * 从字符串中加载私钥
  */
 public static RSAPrivateKey getPrivateKey(String privateKeyStr) throws Exception {
  try {
   byte[] buffer = decode(privateKeyStr);
   PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
   KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
   return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
  } catch (NoSuchAlgorithmException e) {
   throw new Exception("无此算法");
  } catch (InvalidKeySpecException e) {
   throw new Exception("私钥非法");
  } catch (NullPointerException e) {
   throw new Exception("私钥数据为空");
  }
 }

 // 生成密钥对
 private static void initKeyPair() {
  // RSA算法要求有一个可信任的随机数源
  SecureRandom secureRandom = new SecureRandom();
  try {
   // 为RSA算法创建一个KeyPairGenerator对象
   KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

   // 利用上面的随机数据源初始化这个KeyPairGenerator对
   keyPairGenerator.initialize(KEYSIZE, secureRandom);
   // 生成密匙对
   KeyPair keyPair = keyPairGenerator.generateKeyPair();

   // 得到私钥
   prKey = keyPair.getPrivate();
   // 得到公钥
   puKey = keyPair.getPublic();
   // 加解密数据最大长度
   MAX_DECRYPT_BLOCK = KEYSIZE / 8;
   MAX_ENCRYPT_BLOCK = MAX_DECRYPT_BLOCK - 11;
  } catch (NoSuchAlgorithmException e) {
   e.printStackTrace();
   prKey = null;
   puKey = null;
  }

 }

 // 解密算法(分段)
 private static byte[] decrypt(PrivateKey privateKey, byte[] encryptedData) throws Exception {
  Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
  cipher.init(2, privateKey);
  int inputLen = encryptedData.length;
  int offSet = 0;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  for (int i = 0; inputLen - offSet > 0; offSet = i * MAX_DECRYPT_BLOCK) {
   byte[] cache;
   if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
   } else {
    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
   }
   out.write(cache, 0, cache.length);
   ++i;
  }
  byte[] decryptedData = out.toByteArray();
  out.close();
  return decryptedData;
 }

 // 加密算法(分段)
 private static byte[] encrypt(PublicKey publicKey, byte[] data) throws Exception {
  Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
  cipher.init(1, publicKey);
  int inputLen = data.length;
  int offSet = 0;
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  for (int i = 0; inputLen - offSet > 0; offSet = i * MAX_ENCRYPT_BLOCK) {
   byte[] cache;
   if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
   } else {
    cache = cipher.doFinal(data, offSet, inputLen - offSet);
   }
   out.write(cache, 0, cache.length);
   ++i;
  }
  byte[] encryptedData = out.toByteArray();
  out.close();
  return encryptedData;
 }

 /** Base64解码 **/
 public static String encode(byte[] src) {
  return (new Base64Encoder()).encode(src);
 }

 /** base64编码 **/
 public static byte[] decode(String src) {
  return (new Base64Encoder()).decode(src);
 }

}

Escape编码类(与js的escape()丶unescape()保持一致),在传输中防止乱码

/**
 * js语言escape()编码丶解码方法
 **/
public class Escape {

 public static String escape(String src) {
  int i;
  char j;
  StringBuffer tmp = new StringBuffer();
  tmp.ensureCapacity(src.length() * 6);
  for (i = 0; i < src.length(); i++) {
   j = src.charAt(i);
   if (Character.isDigit(j) || Character.isLowerCase(j) || Character.isUpperCase(j))
    tmp.append(j);
   else if (j < 256) {
    tmp.append("%");
    if (j < 16)
     tmp.append("0");
    tmp.append(Integer.toString(j, 16));
   } else {
    tmp.append("%u");
    tmp.append(Integer.toString(j, 16));
   }
  }
  return tmp.toString();
 }

 public static String unescape(String src) {
  StringBuffer tmp = new StringBuffer();
  tmp.ensureCapacity(src.length());
  int lastPos = 0, pos = 0;
  char ch;
  while (lastPos < src.length()) {
   pos = src.indexOf("%", lastPos);
   if (pos == lastPos) {
    if (src.charAt(pos + 1) == 'u') {
     ch = (char) Integer.parseInt(src.substring(pos + 2, pos + 6), 16);
     tmp.append(ch);
     lastPos = pos + 6;
    } else {
     ch = (char) Integer.parseInt(src.substring(pos + 1, pos + 3), 16);
     tmp.append(ch);
     lastPos = pos + 3;
    }
   } else {
    if (pos == -1) {
     tmp.append(src.substring(lastPos));
     lastPos = src.length();
    } else {
     tmp.append(src.substring(lastPos, pos));
     lastPos = pos;
    }
   }
  }
  return tmp.toString();
 }

 /**
  * @disc 对字符串重新编码
  * @param src
  * @return
  */
 public static String isoToGB(String src) {
  String strRet = null;
  try {
   strRet = new String(src.getBytes("ISO_8859_1"), "GB2312");
  } catch (Exception e) {

  }
  return strRet;
 }

 /**
  * @disc 对字符串重新编码
  * @param src
  * @return
  */
 public static String isoToUTF(String src) {
  String strRet = null;
  try {
   strRet = new String(src.getBytes("ISO_8859_1"), "UTF-8");
  } catch (Exception e) {

  }
  return strRet;
 }

}

其他一些方法:

public class Global {

 // debug等级,0不显示,1错误,2debug,3info
 private static final Integer debugLevel = 3;

 /** INFO信息输出 **/
 public static void info(Object object) {
  if (debugLevel > 2) {
   System.out.println(Config.server_name + "信息 : " + object);
   Logger.info(Config.server_name + "信息 : " + object);
  }
 }

 /** DEBUG信息输出 **/
 public static void debug(Object object) {
  if (debugLevel > 1) {
   System.out.println(Config.server_name + "调试 : " + object);
   Logger.debug(Config.server_name + "调试 : " + object);
  }
 }

 /** ERROR信息输出 **/
 public static void error(Object object) {
  if (debugLevel > 0) {
   System.out.println(Config.server_name + "错误 : " + object);
   Logger.error(Config.server_name + "错误 : " + object);
  }
 }

 /** 将对象转化为String数组 **/
 public static String[] string(Object... args) {
  String[] str_arr = new String[args.length];
  for (int i = 0; i < args.length; i++)
   str_arr[i] = (String) args[i];
  return str_arr;

 }

 /** 快速建立JSON对象 **/
 public static JSONObject getJSON(Object... args) {

  JSONObject json = new JSONObject();
  if (args.length % 2 == 0) {
   for (int i = 0; i < args.length; i += 2) {
    json.put(args[i], args[i + 1]);
   }
  } else {
   Global.error("Global.getJSON() 's args.length% != 0");
  }
  return json;
 }

 /** 获取一个length长度的随机字符串 ***/
 public static String getRandomStr(int length) {
  // 定义一个字符串（A-Z，a-z，0-9）即62位；
  String str = "zxcvbnmlkjhgfdsaqwertyuiopQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
  // 随机数种子
  Random random = getRandom();
  StringBuffer strbuff = new StringBuffer();
  for (int i = 0; i < length; ++i) { // 字符串长度
   int number = random.nextInt(62); // 产生0-61的数字
   strbuff.append(str.charAt(number)); // 将产生的数字通过length次承载到strbuff中
  }
  // 将承载的字符转换成字符串
  return strbuff.toString();
 }

 /** 获取一个random对象 . (基于Date.now's getTime()作为种子) **/
 public static Random getRandom() {
  return new Random(new Date().getTime());
 }
}

/**
 * 错误丶调试信息输出到本地txt文件
 *
 */
public class Logger {

 // 项目编译(运行)路径
 private static String runpath = null;

 /** 获取项目编译(运行)路径 **/
 private static String getRun() {
  if (runpath == null) {
   try {
    runpath = Logger.class.getClassLoader().getResource("").toURI().getPath();
    runpath = runpath.substring(0, runpath.indexOf(Config.server_name)) + Config.server_name;
   } catch (URISyntaxException e) {
    System.out.println("获取项目路径出现异常!");
    e.printStackTrace();
    runpath = null;
   }
  }
  return runpath;
 }

 /** 错误输出日志 ***/
 public static void error(Object message) {
  FileOutputStream writer = null;
  try {
   // 获取文件路径
   String path = getRun() + "/logs/error.txt";
   // 如果文件不存在,则创建对应文件
   File file = new File(path);
   if (!file.exists()) {
    new File(file.getParent()).mkdir();
    file.createNewFile();
   }
   // 写入的数据
   String data = new SimpleDateFormat("yyyy年MM月dd日    EEEE  HH:mm:ss")
     .format(new Date(System.currentTimeMillis())) + "\n" + message.toString() + "\n\n\n";
   // 创建写入流(追加文末写入)
   writer = new FileOutputStream(path, true);
   writer.write(data.getBytes());
   writer.flush();
   writer.close();
   writer = null;
  } catch (IOException e) {
   System.out.println(Config.server_name + "错误:Logger.error() throw exception!");
   e.printStackTrace();
  }
 }

 /** 调试输出日志 ***/
 public static void debug(Object message) {
  FileOutputStream writer = null;
  try {
   // 获取文件路径
   String path = getRun() + "/logs/debug.txt";
   // 如果文件不存在,则创建对应文件
   File file = new File(path);
   if (!file.exists()) {
    new File(file.getParent()).mkdir();
    file.createNewFile();
   }
   // 写入的数据
   String data = new SimpleDateFormat("yyyy年MM月dd日    EEEE  HH:mm:ss")
     .format(new Date(System.currentTimeMillis())) + "\n" + message.toString() + "\n\n\n";
   // 创建写入流(追加文末写入)
   writer = new FileOutputStream(path, true);
   writer.write(data.getBytes());
   writer.flush();
   writer.close();
   writer = null;
  } catch (IOException e) {
   System.out.println(Config.server_name + "错误:Logger.debug() throw exception!");
   e.printStackTrace();
  }
 }

 /** 错误输出日志 ***/
 public static void info(Object message) {
  FileOutputStream writer = null;
  try {
   // 获取文件路径
   String path = getRun() + "/logs/info.txt";
   // 如果文件不存在,则创建对应文件
   File file = new File(path);
   if (!file.exists()) {
    new File(file.getParent()).mkdir();
    file.createNewFile();
   }
   // 写入的数据
   String data = new SimpleDateFormat("yyyy年MM月dd日    EEEE  HH:mm:ss")
     .format(new Date(System.currentTimeMillis())) + "\n" + message.toString() + "\n\n\n";
   // 创建写入流(追加文末写入)
   writer = new FileOutputStream(path, true);
   writer.write(data.getBytes());
   writer.flush();
   writer.close();
   writer = null;
  } catch (IOException e) {
   System.out.println(Config.server_name + "错误:Logger.info() throw exception!");
   e.printStackTrace();
  }
 }

 /** servlet日志 ***/
 public static void servlet(Object message) {
  FileOutputStream writer = null;
  try {
   // 获取文件路径
   String path = getRun() + "/logs/servlet.txt";
   // 如果文件不存在,则创建对应文件
   File file = new File(path);
   if (!file.exists()) {
    new File(file.getParent()).mkdir();
    file.createNewFile();
   }
   // 写入的数据
   String data = new SimpleDateFormat("yyyy年MM月dd日    EEEE  HH:mm:ss")
     .format(new Date(System.currentTimeMillis()))
     + "\n==================================================================================\n"
     + message.toString()
     + "\n==================================================================================\n\n\n";
   // 创建写入流(追加文末写入)
   writer = new FileOutputStream(path, true);
   writer.write(data.getBytes());
   writer.flush();
   writer.close();
   writer = null;
  } catch (IOException e) {
   System.out.println(Config.server_name + "错误:Logger.servlet() throw exception!");
   e.printStackTrace();
  }
 }
}

HttpUtils

public class HttpUtils {

 public static void write(HttpServletResponse response, Object o) {
  try {
   response.setHeader("Access-Control-Allow-Origin", "*");
   response.setContentType("text/html;charset=utf-8");
   response.setCharacterEncoding("utf-8");
   PrintWriter out = response.getWriter();
   out.println(o.toString());
   out.flush();
   out.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 public static void write(HttpServletResponse response, String o) {
  try {
   response.setHeader("Access-Control-Allow-Origin", "*");
   response.setContentType("text/html;charset=utf-8");
   response.setCharacterEncoding("utf-8");
   PrintWriter out = response.getWriter();
   out.println(o);
   out.flush();
   out.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 public static void writeJson(HttpServletResponse respone, String result) {
  try {
   respone.setHeader("Access-Control-Allow-Origin", "*");
   respone.setCharacterEncoding("utf-8");
   respone.setContentType("application/json;charset=utf-8");
   PrintWriter out = respone.getWriter();
   out.print(result);
   out.flush();
   out.close();
  } catch (Exception e) {
   // //System.out.println("Comm_Util_writeJson---->" + e);
   e.printStackTrace();
  }
 }
}

JAVA数据中心丶授权丶加密传输信息(学习笔记 一)

浏览过的版块

JAVA数据中心丶授权丶加密传输信息(学习笔记一)