两个系统相互交互，一个抛接口，一个接数据

一、服务器向外抛数据：

1.向外发数据：

我这个是在代码里做了一个定时发送，（我这个是2分钟发一次）

//同步手机和微信数据信息
    @Scheduled(cron = "0 0/2 * * * ?")
    public void SyncWechatData() throws Exception {
        //获取本机的InetAddress实例  
        InetAddress address = InetAddress.getLocalHost();
        //获取IP
        String local = address.getHostAddress();
        String server = FinalData.server;
        if(StringUtil.isNotEmpty(server)){
            if(server.equals(local)){
                
                //这里是写方法的
                Map<String, Object> json = WechatPhoneService.DataTransmit();
                WechatAddressService.SendPostInJosn(json);
                
                System.out.println("同步手机和微信数据信息结束：" + sdf.format(new Date()));
                
            }
        }
    }

2.释放一个接口（在spring-mvc.xml文件中）

<value>PhoneController/wchatJosn.do</value>

3.在数据库中取数据，放在map集合中

/**
     * 同步手机和微信数据信息到办公平台（封装）
     */
    public Map<String, Object> DataTransmit(){
        List<PhoneEntity> phones = systemService.findByQueryString(" from PhoneEntity where transfer = '0'");
        List<InfoEntity> wechatInfos = systemService.findByQueryString(" from InfoEntity where transfer = '0'");
        List<PhoneWxEntity> phoneWxs = systemService.findByQueryString(" from PhoneWxEntity where transfer = '0'");
        Map<String, Object> map = new HashMap<String, Object>();
        //手机表id串
        String phoneids = "";
        int i =1;
        if (phones.size() > 0) {
            List<PhoneEntity> phones1 = new ArrayList<tPhoneEntity>();
            //只取1000条数据
            for (PhoneEntity phone : phones) {
                //把取到的数据放在list集合中
                phones1.add(phone);
                if (i > 1000) {
                    break;
                }
                i++;
            }
            map.put("phone", phones1);
            for (PhoneEntity phone : phones) {
                if (StringUtils.isNotEmpty(phoneids)) {
                    phoneids = phoneids + ",'" + phone.getId() + "'";
                }else {
                    phoneids = "'" + phone.getId() + "'";
                }
            }
        }
        //微信表id串
        String infoids = "";
        if (wechatInfos.size() > 0) {
            i = 1;
            List<InfoEntity> wechatInfos1 = new ArrayList<InfoEntity>();
            //只取1000条数据
            for (InfoEntity wechatInfo : wechatInfos) {
                //把取到的数据放在list集合中
                wechatInfos1.add(wechatInfo);
                if (i > 1000) {
                    break;
                }
                i++;
            }
            map.put("wechatInfo", wechatInfos1);
            for (InfoEntity wechatInfo : wechatInfos) {
                if (StringUtils.isNotEmpty(infoids)) {
                    infoids = infoids + ",'" + wechatInfo.getId() + "'";
                }else {
                    infoids = "'" + wechatInfo.getId() + "'";
                }
            }
        }
        //手机微信关系表id串
        String phoneWxids = "";
        if (phoneWxs.size() > 0) {
            i = 1;
            List<PhoneWxEntity> phoneWxs1 = new ArrayList<PhoneWxEntity>();
            //只取1000条数据
            for (PhoneWxEntity phoneWx : phoneWxs) {
                //把取到的数据放在list集合中
                phoneWxs1.add(phoneWx);
                if (i > 1000) {
                    break;
                }
                i++;
            }
            map.put("phoneWx", phoneWxs1);
            for (PhoneWxEntity phoneWx : phoneWxs) {
                if (StringUtils.isNotEmpty(phoneWxids)) {
                    phoneWxids = phoneWxids + ",'" + phoneWx.getId() + "'";
                } else {
                    phoneWxids = "'" + phoneWx.getId() + "'";
                }
            }
        }
        JSONArray arry=JSONArray.fromObject(map);
        String str = arry.toString();
        Map<String, Object> maps = new HashMap<String, Object>();
        maps.put("json", str);
        maps.put("phoneids", phoneids);
        maps.put("infoids", infoids);
        maps.put("phoneWxids", phoneWxids);
        return maps;
    }

4.把返回的map集合中json串取出来发送到另一个服务器上，map集合中剩下的拼接好的id串等返回一个ok值后，在相应的表中把发送过的数据改为已发送状态（这里边要注意：当数据可中的数据添加、修改时要把状态改为为发送状态）

/**
     * 把传过来的数据用接口发送出去，把拼接的id等返回ok后把发送的数据标记为已发送状态
     */
    @Override
    public void SendPostInJosn(Map<String, Object> map){
        String url1 = "域名/服务器名称/控制层/方法名.do";
        String json = map.get("json").toString();//json串
        String phoneids = map.get("phoneids").toString();//电话表id串
        String infoids = map.get("infoids").toString();//微信表id串
        String phoneWxids = map.get("phoneWxids").toString();//手机微信关系表id串
        String result="";
        PrintWriter out = null;  
        BufferedReader in = null; 
        URL url=null;
         try {
             url = new URL(url1);
             URLConnection connect = url.openConnection();
             connect.setRequestProperty("content-type","application/x-www-form-urlencoded;charset=utf-8");
             connect.setRequestProperty("method","POST");
             byte[] bytes= json.getBytes("utf-8") ;
             connect.setDoOutput(true);  
             connect.setDoInput(true);  
             
             out = new PrintWriter(connect.getOutputStream());  
             // 发送请求参数  
             out.print("datas="+json);
             out.flush();  
             //数据交互返回值200/400/500...
             CloseableHttpClient httpClient = HttpClients.createDefault();
             HttpPost post = new HttpPost(url1);
             CloseableHttpResponse response = null;
             StringEntity entitys = new StringEntity(json);
             post.setEntity(entitys);
             response = httpClient.execute(post);
             System.out.println(response.getStatusLine().getStatusCode());
             // 定义BufferedReader输入流来读取URL的响应  
             if (response != null && response.getStatusLine().getStatusCode() == 200) {
                 in = new BufferedReader(new InputStreamReader(connect.getInputStream()));
                 String line = "";  
                 while ((line = in.readLine()) != null) {  
                     result +=  line;  
                     if ("ok".equals(result)) {
                          PhoneService.updateTransferData(phoneids,infoids,phoneWxids);
                    }
                 }   
            }else {
                System.out.println("数据交互出错，请检查办公平台服务是否开启？出错原因报："+response.getStatusLine().getStatusCode());
            }
         } catch (Exception e) {
             System.out.println("数据交互出错，请检查办公平台服务是否开启？？？");
             e.printStackTrace();
         }
    }

5.把拼接好的id串在数据库中检索出对应的数据再把数据改为已发送状态

/**
     * 把电话表、微信表、手机与微信关系表中的是否传送字段改为“1”；（否：0；是：1）
     */
    @Override
    public void updateTransferData(String phoneids, String infoids, String phoneWxids) {
        //修改电话表中的字段是否传送
        if (StringUtils.isNotEmpty(phoneids)) {
            String sql1 = "update phone set transfer = '1' where id in ("+phoneids+")";
            systemService.updateBySqlString(sql1);
        }
        //修改微信表中的字段是否传送
        if (StringUtils.isNotEmpty(infoids)) {
            String sql2 = "update info set transfer = '1' where id in ("+infoids+")";
            systemService.updateBySqlString(sql2);
        }
        //修改手机与微信关系表中的字段是否传送
        if (StringUtils.isNotEmpty(phoneWxids)) {
            String sql3 = "update phone_wx set transfer = '1' where id in ("+phoneWxids+")";
            systemService.updateBySqlString(sql3);
        }
    }

二、服务器接收数据

1.接受接口所传过来的数据（个人认为这个接收方法就像是在一个实体中的方法调用）

/**
     * 接收方法传过来的json串
     * @param request
     * @param response
     * @throws Exception 
     */
    @RequestMapping(value = "/wchatJosn")
    public void wchatJosn(HttpServletRequest request, HttpServletResponse response) throws Exception{
        String result = "";
        boolean isPost = request.getMethod().toLowerCase().equals("post");
        String json = request.getParameter("datas");
        
        PrintWriter wirte = null;
        wirte = response.getWriter();
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        if (isPost) {
            //应答接口，包括注册、接收数据等 使用post协议
            result = PhoneService.wchatJosnAddress(json);
            wirte.print(result);
        }else{
            wirte.print("");
        }
        wirte.flush();            
        wirte.close();
    }

2.把json串解析  然后根据不同的表数据再把不同的数据放在自己对应的数据库中（这个是一个批处理的数据存储和修改的方法）

/**
      * 把传过来的数据放到数据库中
      * 正确时返回“ok”
      * @throws ClassNotFoundException 
      */
    @Override
    public String wchatJosnAddress(String json) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = "";
        int i = 0;
        //手机表
        String phones = "";
        //微信表
        String wechatInfos = "";
        //手机微信表关系表
        String phoneWxs = "";
        if (StringUtils.isNotEmpty(json)) {
            json = json.substring(1,json.length()-1);
        }
        JSONObject objects=JSONObject.fromObject(json);
        JSONArray array1 = null;
        JSONArray array2 = null;
        JSONArray array3 = null;
        if (null != objects) {
 　　　　　　　　　//判断json传过来的数据中是否在map中有这个键值对
            if (StringUtils.isNotEmpty(objects.optString("phone"))) {
                array1 = objects.getJSONArray("phone");
                phones = array1.toString();
            }
            if (StringUtils.isNotEmpty(objects.optString("wechatInfo"))) {
                array2 = objects.getJSONArray("wechatInfo");
                wechatInfos = array2.toString();
            }
            if (StringUtils.isNotEmpty(objects.optString("phoneWx"))) {
                array3 = objects.getJSONArray("phoneWx");
                phoneWxs = array3.toString();
            }
        }
        //数据库配置   这个是我之前自己封装好的在页面中直接修改服务器id
        String[] add = DatabaseaddressController.getDatabasePassworld().split(",");
        Connection conn;
        Class.forName("com.mysql.jdbc.Driver");
        String pwd = "";
        if (add.length<=2) {
            pwd = "";
        }else{
            pwd = add[2];
        }
        
        conn = DriverManager.getConnection(add[0], add[1], pwd);
        conn.setAutoCommit(false);
        // 保存当前自动提交模式
        boolean autoCommit = conn.getAutoCommit();
        // 关闭自动提交
        conn.setAutoCommit(false);
        Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
        //声明变量手机唯一标识拼接字符串用于sql语句
        String imeis = "";
        Map<String, PhoneEntity> maps = new HashMap<String, WechatPhoneEntity>();
        if (StringUtil.isNotEmpty(phones)) {
            JSONArray arrays = JSONArray.fromObject(phones);
            System.out.println("手机数据存储开始执行操作！！！！");
            for (Object array : arrays) {
                JSONObject object=JSONObject.fromObject(array);
                PhoneEntity phone = (PhoneEntity)JSONObject.toBean(object,PhoneEntity.class);
                String imei = phone.getImei();
                if (StringUtils.isNumeric(imeis)) {
                    imeis = imeis + ",'" + imei + "'";
                }else {
                    imeis = "'" + imei + "'";
                }
                //把手机表用手机唯一标识作为键放在map集合中
                maps.put(imei, phone);
            }
        }
        
            //把微信表数据存储在数据库 （这个方法就不写了  其实就是一个数据存储到数据库中的方法  和下边这个一样）
         //   boolean tu = getWechatInfos(wechatInfos);
            if (tu) {
                //把微信表数据存储在数据库
             //   boolean tus = getWechatInfoWxs(phoneWxs);
                if (tus) {
                    if (StringUtil.isNotEmpty(phones)) {
                        String hql = " from PhoneEntity where imei in("+imeis+")";
                        List<PhoneEntity> Phones1 = systemService.findByQueryString(hql);
                        if (Phones1.size() >0) {
                            for (PhoneEntity Phone : Phones1) {
                                String imei1 = Phone.getImei();
                                //在maps集合中把手机实体表数据取出
                                PhoneEntity phone2 = maps.get(Phone.getImei());
                                if (null != phone2) {
                                    stmt.addBatch("update phone set create_date = '"+sdf.format(phone2.getCreateDate())+"',imei = '"+phone2.getImei()+"'"
                                            + ",type = '"+phone2.getType()+"',status = '"+phone2.getStatus()+"',is_root = '"+phone2.getIsRoot()+"'"
                                            + ",soft_version = '"+phone2.getSoftVersion()+"',is_info_plugin = '"+phone2.getIsInfoPlugin()+"',phone_os = '"+phone2.getPhoneOs()+"'"
                                            + ",brand = '"+phone2.getBrand()+"',only_num = '"+phone2.getOnlyNum()+"' where id = '"+Phone.getId()+"'");
                                    
                                    if (i % 1000 == 0 || i == Phones1.size()) {
                                        try {
                                            stmt.executeBatch();
                                            stmt.clearBatch();
                                            conn.commit();
                                        } catch (Exception e) {
                                            conn.close();
                                            e.printStackTrace();
                                        }
                                    }
                                    i = i + 1;
                                }
                                //删除掉maps集合中已经把数据放在数据库手机表中的数据
                                maps.remove(imei1);
                            }
                        }
                        if (maps.size() > 0) {
                            i = 1;
                            //把maps集合循环遍历
                            for (String key : maps.keySet()) {
                                Entity phone = maps.get(key);
                                if (null != phone) {
                                    stmt.addBatch("insert into phone set id = '"+phone.getId()+"',create_date = '"+sdf.format(phone.getCreateDate())+"',imei = '"+phone.getImei()+"'"
                                            + ",person_id = null,person_name = null,dept_id = null"
                                            + ",dept_name = null,type = '"+phone.getType()+"',status = '"+phone.getStatus()+"',is_root = '"+phone.getIsRoot()+"'"
                                            + ",soft_version = '"+phone.getSoftVersion()+"',is_info_plugin = '"+phone.getIsInfoPlugin()+"',phone_os = '"+phone.getPhoneOs()+"'"
                                            + ",brand = '"+phone.getBrand()+"',only_num = '"+phone.getOnlyNum()+"'");
                                    if (i % 1000 == 0 || i == maps.size()) {
                                        try {
                                            stmt.executeBatch();
                                            stmt.clearBatch();
                                            conn.commit();
                                        } catch (Exception e) {
                                            conn.close();
                                            e.printStackTrace();
                                        }
                                    }
                                }
                                i = i + 1;
                            }
                        }
                        conn.close();
                        //成功返回ok
                        str = "ok";
                }else {
                    str = "ok";
                } 
            }else {
                System.out.println("数据存储结束执行失败？？？");
            }
        }else {
             System.out.println("数据存储结束执行失败？？？");
        }
            System.out.println("数据存储结束执行操作！！！！");
        return str;
    }