总想自己动动手系列·1·本地和外网（Liunx服务器上部署的web项目）按照自定义的报文格式进行交互（准备篇）

一、准备工作

（1）有一台属于自己的云服务器，并成功部署和发布一个web项目（当然，本质上来说Java-Project也没问题），通过外网IP可以正常访问该web项目。

需要说明的是：任何web项目，只要成功部署后在外网上能访问到即可。本案例注重修改web对请求的监听和过滤的处理（下个版本在弄这个啦！）。

（2）本地新建Java-project，需要准备一些jar包，比如：AES加密相关的包，BASE64加相关的包，解析XML的包，至于通信相关的类，JDK的java.io和java.net自带。

 二、Code部分

（1）第一步：首先创建一个接口，先定义好规则（比如：需要用到哪些方法等）

 package com.xfwl.message.serverMsg;

 import java.net.URL;
 import java.net.URLConnection;
 import java.util.Map;

 /**
  * 通讯类接口
  * @function
  * @author 小风微凉
  * @time  2018-11-8 下午2:03:39
  */
 public interface IHttpClient {
     /**
      * 默认编码格式
      */
     static final String CHARTER_ENCODE="UTF-8";
     //创建报文发送对象
     public URLConnection getClient(String url);
     //创建发送报文方法
     public boolean sendDataMsg(URLConnection url,String encygen);
     //创建接收报文方法
     public StringBuffer receiveDataMsg(URLConnection url,String encygen);
     //创建报文加密方法
     public StringBuffer encryptMsg(String data,String encygen);
     //创建报文解密方法
     public StringBuffer deCioherMsg(String data,String encygen);
 }

（2）第二步：准备要用到的工具类，比如报文的加密、解密等，下面用到的时AES加密（加解密时都需要加密因子，中间使用了Base64改变编码格式）

 package com.xfwl.message.serverMsg;

 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 import javax.crypto.Cipher;
 import javax.crypto.KeyGenerator;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;
 import org.apache.commons.codec.binary.Base64;
 /**
  * AES加密、解密处理工具（加密因子+base64的加解密）
  * @function
  * @author 小风微凉
  * @time  2018-11-8 下午2:35:15
  */
 public class AESUtil {
     //默认加密秘钥
     private static final String KEY_ALGORITHM = "AES";
     //默认的加密算法
     private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
     /**
      * AES 加密操作
      *
      * @param content 待加密内容
      * @param password 加密密码
      * @return 返回Base64转码后的加密数据
      */
     public static String encrypt(String content, String password) {
         try {
             Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

             byte[] byteContent = content.getBytes("utf-8");

             cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));// 初始化为加密模式的密码器

             byte[] result = cipher.doFinal(byteContent);// 加密

             return Base64.encodeBase64String(result);//通过Base64转码返回
         } catch (Exception ex) {
             Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
         }

         return null;
     }

     /**
      * AES 解密操作
      *
      * @param content 数据
      * @param password 加密因子
      * @return
      */
     public static String decrypt(String content, String password) {
         try {
             //实例化
             Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

             //使用密钥初始化，设置为解密模式
             cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));

             //执行操作
             byte[] result = cipher.doFinal(Base64.decodeBase64(content));

             return new String(result, "utf-8");
         } catch (Exception ex) {
             Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
         }

         return null;
     }

     /**
      * 生成加密秘钥
      * @param   password 加密因子
      * @return
      */
     private static SecretKeySpec getSecretKey(final String password) {
         //返回生成指定算法密钥生成器的 KeyGenerator 对象
         KeyGenerator kg = null;
         try {
             kg = KeyGenerator.getInstance(KEY_ALGORITHM);
             //AES 要求密钥长度为 128
             kg.init(128, new SecureRandom(password.getBytes()));
             //生成一个密钥
             SecretKey secretKey = kg.generateKey();

             return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
         } catch (NoSuchAlgorithmException ex) {
             Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
         }
         return null;
     }
     /**
      * 测试
      * @param args
      */
     public static void main(String[] args) {
         String s = "hello,xfwl";
         System.out.println("明文（加密前）:" + s);
         //加密
         String s1 = AESUtil.encrypt(s, "xfwl");
         System.out.println("加密后:" + s1);
         //解密
         System.out.println("解密后:"+AESUtil.decrypt(s1, "xfwl"));
     }
 }

（3）第三步：开始实现步骤一中定义的规则

 package com.xfwl.message.serverMsg;

 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;

 import org.dom4j.Attribute;
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.DocumentHelper;
 import org.dom4j.Element;

 public class HTTPServerClient implements IHttpClient {
     /**
      * 报文上送数据集合
      */
     private Map<String,Object> sendMap=null;
     /**
      * 构造器
      */
     public HTTPServerClient(Map<String,Object> sendMap){
         this.sendMap=sendMap;
     }
     /**
      * 获取连接对象
      */
     public URLConnection getClient(String url) {
         URL u=null;
         try {
              u= new URL(url);
         } catch (MalformedURLException e) {
             e.printStackTrace();
         }
         System.out.println("建立["+url+"]链接....");
         //获取连接对象
         URLConnection uc=null;
         try {
             uc = u.openConnection();
         } catch (IOException e) {
             e.printStackTrace();
         }
         return uc;
     }
     /**
      * 发送报文
      */
     public boolean sendDataMsg(URLConnection uc,String encygen) {
         //打开输出流
         uc.setDoOutput(true);
         //获取输出流对象
         OutputStream raw=null;
         OutputStream buffered = null;
         OutputStreamWriter out=null;
         try {
             raw = uc.getOutputStream();
             buffered = new BufferedOutputStream(raw);
             out = new OutputStreamWriter(buffered, CHARTER_ENCODE);
             StringBuffer data=createMsgFormat(sendMap);
             System.out.println("发送报文[明文]:"+data);
             out.write(encryptMsg(data.toString(),encygen).toString());
             System.out.println("发送报文[密文]:"+encryptMsg(data.toString(),encygen).toString());
             out.flush();
             System.out.println("关闭连接");
             out.close();
         } catch (IOException e) {
             e.printStackTrace();
             return false;
         }
         return true;
     }
     /**
      * 接收报文
      */
     public StringBuffer receiveDataMsg(URLConnection uc,String deciogen) {
         //获取到返回数据的输入流
         InputStream is=null;
         BufferedReader br=null;
         StringBuffer blzRspXml = new StringBuffer();
         try {
             is = uc.getInputStream();
             br = new BufferedReader(new InputStreamReader(is,CHARTER_ENCODE));
             String line = "";
             System.out.println("获取返回数据:");
             while((line = br.readLine()) != null){
                 //读取返回数据，分行读取
                 //System.out.println(deCioherMsg(line.trim(),deciogen));//解密
                 System.out.println(line.trim());
                 blzRspXml.append(line.trim());
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
         return blzRspXml;
     }
     /**
      * 加密数据
      */
     public StringBuffer encryptMsg(String data,String encygen) {
         return new StringBuffer(AESUtil.encrypt(data, encygen));
     }
     /**
      * 解析数据
      */
     public StringBuffer deCioherMsg(String data,String deciogen) {
         return new StringBuffer(AESUtil.decrypt(data, deciogen));
     }

     /**
      * 生成送报文:
      *     上送报文和响应报文都需要约定一种报文格式
      */
     private  StringBuffer createMsgFormat(Map<String,Object> dataMap){
         StringBuffer msg=new StringBuffer();
         msg.append("<service>");
         /*msg.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");*/
         msg.append("<SYS_HEAD>");
         //存放：业务类型码
         msg.append("<HEAD_BSNCODE>100001</HEAD_BSNCODE>");
         msg.append("</SYS_HEAD>");
         msg.append("<BODY>");
         //存放：业务数据
         Set<Entry<String, Object>> set = dataMap.entrySet();
         Iterator<Entry<String, Object>> it = set.iterator();
         while (it.hasNext()) {
             Entry<String, Object> ey = it.next();
             String key = ey.getKey();
             String value = (String) ey.getValue();
             msg.append("<"+key+">"+value+"</"+key+">");
         }
         msg.append("</BODY>");
         msg.append("</service>");
         return msg;
     }
     /**
      * 解析响应报文：通过dom4j解析xml字符串
      * @param args
      */
     public Map<String,Object> parseRecMsgFormat(String xml){
         Map<String,Object> recMap =new HashMap<String, Object>();
         Document doc=null;
         Element root=null;
         List<Element> elems=null;
         List<Element> elems_head=null;
         List<Element> elems_body=null;
         try {
             doc=DocumentHelper.parseText(xml);
             root=doc.getRootElement();
             elems=root.elements();
             for(Element elem:elems){
                 //开始解析结点
                 if("SYS_HEAD".equals(elem.getName())){
                     //检查报文头
                     elems_head=elem.elements();
                     for(Element head:elems_head){
                         if("HEAD_BSNCODE".equals(head.getName())){
                             recMap.put("HEAD_BSNCODE", head.getText());
                         }
                     }
                 }else if("BODY".equals(elem.getName())){
                     //检查报文体
                     elems_body=elem.elements();
                     for(Element body:elems_body){
                         recMap.put(body.getName(), body.getText());
                     }
                 }
                 /*List<Attribute> attrs=elem.attributes();
                 for(Attribute attr:attrs){
                     //开始解析结点的属性
                     if("HEAD_BSNCODE".equals(attr.getText())){
                         System.out.println(elem.getName()+":"+elem.getText());
                     }
                 }*/
             }
         } catch (DocumentException e) {
             e.printStackTrace();
         }
         return recMap;
     }
     public static void main(String[] args) {
         Map<String,Object> sendMap =new HashMap<String, Object>();
         sendMap.put("ADMIN", "小风微灵");
         sendMap.put("PWD", "xfwl123");
         //System.out.println(createMsgFormat(sendMap));
     }
 }

（4）第四步：开始测试一下

 package com.xfwl.message.test;

 import java.net.URLConnection;
 import java.util.HashMap;
 import java.util.Map;

 import com.xfwl.message.serverMsg.HTTPServerClient;

 public class TestAction3 {
     public static void main(String[] args) {
         Map<String,Object> sendMap =new HashMap<String, Object>();
         sendMap.put("ADMIN", "小风微灵");
         sendMap.put("PWD", "xfwl123");

         HTTPServerClient client=new HTTPServerClient(sendMap);
         URLConnection uc=client.getClient("http://47.105.58.153:3000");
         client.sendDataMsg(uc,"lvjun");
         client.receiveDataMsg(uc,"lvjun");
     }
 }

看一下测试结果：

 建立[http://47.105.58.153:3000]链接....
 发送报文[明文]:<service><?xml version="1.0" encoding="UTF-8"?><SYS_HEAD><HEAD_BSNCODE>100001</HEAD_BSNCODE></SYS_HEAD><BODY><ADMIN>小风微灵</ADMIN><PWD>xfwl123</PWD></BODY></service>
 发送报文[密文]:UCr7pP6rDXPVlZzhcTRD20JHzoQSI7/Tb82YL6m6O25tD37RE6lW062yoRvdAv4eWxKWT2shrt97
 t2ZN+kjNVqkhLRaEw96yr1arAWtxri0pX0W3LYXw0Gw4LoTWsPb09a0JRv5p35Dt0QICN/Ve0+mP
 ayN+jCSFE3DKk5xusgSzua3adfnEdELhxbR33+CL09yI+Rc8In2NjYrsg24kkM29dJaWSRGm+ahn
 26OUQnI=

 关闭连接
 获取返回数据:
 {"status":"1","msg":"未登录！","result":""}

 三、接下来准备要做的事情

　从上面的测试结果来看，已经成功完成了第一步，即将本地的请求（用自定义的报文格式处理请求数据）发送到云服务器上部署的web工程服务上，接下来要做的就是在web工程上动手，监听这类请求，根据约定的加密因子和

报文规则，解密和解析析xml报文，获取其中的请求数据，经行业务逻辑处理后按照约定的加密方式和报文规则，生成对应的响应报文，返回给本地的Java-Project，本地Java-Project再解密解析响应报文，获取响应数据，从而经行本

地的业务逻辑处理。

一步步来吧，只要脚步不停下，就是在进步......