微信开放平台代码 (备用)

package com.shop.api.controller;

import com.shop.common.config.Global;
import com.shop.common.entity.*;
import com.shop.common.handler.CommercialTenantHandler;
import com.shop.common.handler.TicketHandler;
import com.shop.common.handler.TokenHandler;
import com.shop.common.util.ApiUtils;
import com.shop.common.util.IsObjectNullUtils;
import com.shop.common.util.WXPayUtil;
import com.shop.common.util.WXThirdparty.WXToken;
import com.shop.common.util.WXencryption.AesException;
import com.shop.common.util.WXencryption.WXBizMsgCrypt;
import net.sf.json.JSONObject;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
* Created by Y on 2017/9/6.
* 第三方平台
*/
@Controller
@RequestMapping(value = “/apiauthorizedeventacceptance”)
public class APIAuthorizedeventAcceptance {

@Autowired
private TicketHandler ticketHandler;
@Autowired
private TokenHandler tokenHandler;
@Autowired
private CommercialTenantHandler commercialTenantHandler;

private String authCode;



//test
@RequestMapping(value ="/test",method = RequestMethod.GET)
@ResponseBody
public Map<String,Object> authcallback(
) {
    Map<String,Object> retmap=new HashMap<>();
    try {
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance test into");

        String gettoken = tokenHandler.gettoken();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance test return gettoken={}", gettoken);
        return retmap;
    } catch (Exception ex) {
        ex.printStackTrace();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance test return exception={},retmap={}", ex,retmap);
        return retmap;
    }
}





/**
 * 去往授权页面
 * @return
 */
@RequestMapping(value ="/touser",method = RequestMethod.GET)
public String touser(
        ModelMap modelMap, HttpServletRequest request
) {
    try {
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance userauthorization ","点了");
        //获取预授权码

        String gettoken = tokenHandler.gettoken();
        if (IsObjectNullUtils.is(gettoken)){
            return "wx/400";
        }
        authCode= WXToken.getpreAuthCode(gettoken);

        String wxurl="https://mp.weixin.qq.com/cgi-bin/componentloginpage?component_appid="+Global.getComponent_Appid()+"&pre_auth_code="+authCode+"&redirect_uri=https://open.8d3j.com/apiauthorizedeventacceptance/authcallback";
        modelMap.put("wxurl",wxurl);
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance userauthorization return wxurl={}", wxurl);
        return "wx/userauthorization";

    } catch (Exception ex) {
        ex.printStackTrace();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance message return exception={},retmap={}", ex);
        return "wx/400";
    }
}





/**
 * 授权完成回调页面
 * @param authcode
 * @return
 */
@RequestMapping(value ="/authcallback",method = RequestMethod.GET)
public String authcallback(
        @RequestParam(required = false,value = "auth_code")String authcode,
        @RequestParam(required = false,value = "expires_in")Long expiresin,
        ModelMap modelMap, HttpServletRequest request
) {

    try {
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback into authcode={}",authcode);


        if (IsObjectNullUtils.is(authcode)){
            return "wx/400";
        }
        String gettoken = tokenHandler.gettoken();
        if (IsObjectNullUtils.is(gettoken)){
            return "wx/400";
        }

        //使用授权码换取公众号或小程序的接口调用凭证及信息
        JsonRootBean getsmallroutineinterface = WXToken.getsmallroutineinterface(authcode, gettoken);
        if (IsObjectNullUtils.is(getsmallroutineinterface)){
            ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback null smallroutineinterfacemap");
            return "wx/400";
        }


        if (IsObjectNullUtils.is(getsmallroutineinterface)){
            ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback null getsmallroutineinterface");
            return "wx/400";
        }


        //存入商户基本信息及token
        //创建商户对象
        CommercialTenant commercialTenant=new CommercialTenant();

            //创建token
            Token token=new Token();

            //存入appid
            commercialTenant.setAuthorizerAppid( getsmallroutineinterface.getAuthorization_info().getAuthorizer_appid());
            token.setRemark1(getsmallroutineinterface.getAuthorization_info().getAuthorizer_appid());



        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback null authorizer_access_token"+getsmallroutineinterface.getAuthorization_info().getAuthorizer_access_token());
            token.setToken(getsmallroutineinterface.getAuthorization_info().getAuthorizer_access_token());

            commercialTenant.setAuthorizerRefreshToken(getsmallroutineinterface.getAuthorization_info().getAuthorizer_refresh_token());
        token.setFlag("0");
        token.setUpdataTime(new Date());
        token.setCreateTime(new Date());

        //存入token
        Token selecttoken = tokenHandler.selecttoken(token);
        if (IsObjectNullUtils.is(selecttoken)){
            int save = tokenHandler.save(token);

            if (save>0){
                ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback save token success");
            }else {
                ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback save token fail");
            }

        }else {
            int updateTokens = tokenHandler.updateTokens(token);
            if (updateTokens>0){
                ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback updateTokens token success");
            }else {
                ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback updateTokens token fail");
            }
        }


        //获取授权方基本信息

        Root authorizerbaseinfo = WXToken.getAuthorisedbasicinfo(getsmallroutineinterface.getAuthorization_info().getAuthorizer_appid(), tokenHandler.gettoken());

        //存入授权方基本信息

        if (IsObjectNullUtils.is(authorizerbaseinfo)){
            ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback null authorizerbaseinfo");
            return "wx/400";
        }

        if (!IsObjectNullUtils.is(authorizerbaseinfo.getAuthorizer_info())){
            Authorizer_info authorizer_info = authorizerbaseinfo.getAuthorizer_info();

            //授权方昵称
            if (!IsObjectNullUtils.is(authorizer_info.getNick_name())){
                commercialTenant.setNickName(authorizer_info.getNick_name());
            }

            //授权方头像
            if (!IsObjectNullUtils.is(authorizer_info.getHead_img())){
                commercialTenant.setHeadImg(authorizer_info.getHead_img());
            }

            //授权方公众号类型
            if (!IsObjectNullUtils.is(authorizer_info.getService_type_info().getId())){
                commercialTenant.setServiceTypeInfo( authorizer_info.getService_type_info().getId()+"");
            }

            //授权方 认证类型
            if (!IsObjectNullUtils.is(authorizer_info.getVerify_type_info().getId())){
                commercialTenant.setVerifyTypeInfo(authorizer_info.getVerify_type_info().getId()+"");
            }

            //授权公众号的原始ID
            if (!IsObjectNullUtils.is(authorizer_info.getUser_name())){
                commercialTenant.setUserName(authorizer_info.getUser_name());
            }

            //公众号主体名称
            if (!IsObjectNullUtils.is(authorizer_info.getPrincipal_name())){
                commercialTenant.setPrincipalName(authorizer_info.getPrincipal_name());
            }

            //授权方公众号所设置的微信号
            if (!IsObjectNullUtils.is(authorizer_info.getAlias())){
                commercialTenant.setAlias(authorizer_info.getAlias());
            }

            //开发者图片url
            if (!IsObjectNullUtils.is(authorizer_info.getQrcode_url())){
                commercialTenant.setQrcodeUrl(authorizer_info.getQrcode_url());
            }

            //类型授权 1 小程序 2 公众号
            if (!IsObjectNullUtils.is(authorizer_info.getMiniProgramInfo())){
                commercialTenant.setMiniprograminfo("1");
            }else {
                commercialTenant.setMiniprograminfo("0");

            }

            //帐号介绍
            if (!IsObjectNullUtils.is(authorizer_info.getSignature())){
                commercialTenant.setSignature((authorizer_info.getSignature()));
            }

            commercialTenant.setFlag("0");
            commercialTenant.setCreateTime(new Date());
            commercialTenant.setUpdateTime(new Date());




            CommercialTenant commercialTenant1 = commercialTenantHandler.selectByEntity(commercialTenant);
            if (IsObjectNullUtils.is(commercialTenant1)){
                int insert = commercialTenantHandler.insert(commercialTenant);
                if (insert>0){
                    modelMap.put("merchantid",commercialTenant.getId());
                    return "wx/create_merchant";
                }else {

                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback return save  modelMap={}",modelMap);
                    return "wx/400";
                }
            }else {
                int update = commercialTenantHandler.update(commercialTenant);
                if (update>0){
                    modelMap.put("merchantid",commercialTenant.getId());
                    return "wx/create_merchant";
                }else {

                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback return update  modelMap={}",modelMap);
                    return "wx/400";
                }
            }

        }

        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback return  modelMap={}",modelMap);
        return "wx/400";
    } catch (Exception ex) {
        ex.printStackTrace();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance authcallback return exception={},modelMap={}", ex,modelMap);
        return "wx/400";
    }
}





/**
 * 全网发布
 * @param request
 * @param response
 * @return
 */
@RequestMapping(value = "{appid}/callback")
@ResponseBody
public void message(
        @PathVariable String appid,
        HttpServletRequest request, HttpServletResponse response
        ) {
    Map<String,Object> retmap=new HashMap<>();
    try {

        //appid是用来区分来自于那个公众号或小程序

        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance message request={}",request);
        ApiUtils.logger.info("第三方平台全网发布-------------{appid}/callback-----------验证开始。。。。");



        //获取请求的xml
        StringBuilder sb = new StringBuilder();
        BufferedReader in = request.getReader();
        String line;
        while ((line = in.readLine()) != null) {
            sb.append(line);
        }
        in.close();

        String xml = sb.toString();
        Document doc = DocumentHelper.parseText(xml);
        Element rootElt = doc.getRootElement();
        String toUserName = rootElt.elementText("ToUserName");

        //微信全网测试账号

        ApiUtils.logger.info("全网发布接入检测消息反馈开始--------------------------------------"+toUserName);

        //调用检测微信消息方法
        Method2 m=new Method2();
        m.checkWeixinAllNetworkCheck(request, response, xml);


        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance message return s={}");

    } catch (Exception ex) {
        ex.printStackTrace();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance message return exception={},retmap={}", ex,retmap);
        //return "";
    }
}


public void checkWeixinAllNetworkCheck(HttpServletRequest request, HttpServletResponse response,String xml) throws DocumentException, IOException, AesException {
    String nonce = request.getParameter("nonce");
    String timestamp = request.getParameter("timestamp");
    String msgSignature = request.getParameter("msg_signature");

    WXBizMsgCrypt pc = new WXBizMsgCrypt(Global.getComponent_Token(),Global.getComponent_Key(),Global.getComponent_Appid());
    xml = pc.decryptMsg(msgSignature, timestamp, nonce, xml);

    Document doc = DocumentHelper.parseText(xml);
    Element rootElt = doc.getRootElement();
    String msgType = rootElt.elementText("MsgType");
    String toUserName = rootElt.elementText("ToUserName");
    String fromUserName = rootElt.elementText("FromUserName");

    ApiUtils.logger.info("---全网发布接入检测--step.1-----------msgType="+msgType+"-----------------toUserName="+toUserName+"-----------------fromUserName="+fromUserName);
    ApiUtils.logger.info("---全网发布接入检测--step.2-----------xml="+xml);
    if("event".equals(msgType)){
        ApiUtils.logger.info("---全网发布接入检测--step.3-----------事件消息--------");
        String event = rootElt.elementText("Event");
        replyEventMessage(request,response,event,toUserName,fromUserName);
    }else if("text".equals(msgType)){
        ApiUtils.logger.info("---全网发布接入检测--step.3-----------文本消息--------");
        String content = rootElt.elementText("Content");
        processTextMessage(request,response,content,toUserName,fromUserName);
    }
}



public void replyEventMessage(HttpServletRequest request, HttpServletResponse response, String event, String toUserName, String fromUserName) throws DocumentException, IOException {
    String content = event + "from_callback";
    ApiUtils.logger.info("---全网发布接入检测------step.4-------事件回复消息  content="+content + "   toUserName="+toUserName+"   fromUserName="+fromUserName);
    replyTextMessage(request,response,content,toUserName,fromUserName);
}


public void processTextMessage(HttpServletRequest request, HttpServletResponse response,String content,String toUserName, String fromUserName) throws IOException, DocumentException{
    if("TESTCOMPONENT_MSG_TYPE_TEXT".equals(content)){
        String returnContent = content+"_callback";
        replyTextMessage(request,response,returnContent,toUserName,fromUserName);
    }else {
        output(response, "");
        //接下来客服API再回复一次消息
        replyApiTextMessage(request,response,content.split(":")[1],fromUserName);
    }
}


public void replyApiTextMessage(HttpServletRequest request, HttpServletResponse response, String auth_code, String fromUserName) throws DocumentException, IOException {
    String authorization_code = auth_code;
    // 得到微信授权成功的消息后，应该立刻进行处理！！相关信息只会在首次授权的时候推送过来
    System.out.println("------step.1----使用客服消息接口回复粉丝----逻辑开始-------------------------");
    try {

         /*String gettoken = tokenHandler.gettoken();

        System.out.println("------step.2----使用客服消息接口回复粉丝------- component_access_token = "+gettoken + "---------authorization_code = "+authorization_code);
        net.sf.json.JSONObject authorizationInfoJson = JwThirdAPI.getApiQueryAuthInfo(Global.getComponent_Appid(), authorization_code, gettoken);
        System.out.println("------step.3----使用客服消息接口回复粉丝-------------- 获取authorizationInfoJson = "+authorizationInfoJson);
        net.sf.json.JSONObject infoJson = authorizationInfoJson.getJSONObject("authorization_info");
        String authorizer_access_token = infoJson.getString("authorizer_access_token");*/
        String merchantToken = tokenHandler.getMerchantToken(authorization_code);

        Map<String,Object> obj = new HashMap<String,Object>();
        Map<String,Object> msgMap = new HashMap<String,Object>();
        String msg = auth_code + "_from_api";
        msgMap.put("content", msg);

        obj.put("touser", fromUserName);
        obj.put("msgtype", "text");
        obj.put("text", msgMap);
        WXToken.sendMessage(obj, merchantToken);
    } catch (Exception e) {
        e.printStackTrace();
    }

}






/**
 * 回复微信服务器"文本消息"
 * @param request
 * @param response
 * @param content
 * @param toUserName
 * @param fromUserName
 * @throws DocumentException
 * @throws IOException
 */
public void replyTextMessage(HttpServletRequest request, HttpServletResponse response, String content, String toUserName, String fromUserName) throws DocumentException, IOException {
    System.out.println("------进入replyTextMessage-------------------------");
    Long createTime = Calendar.getInstance().getTimeInMillis() / 1000;
    StringBuffer sb = new StringBuffer();
    sb.append("<xml>");
    sb.append("<ToUserName><![CDATA["+fromUserName+"]]></ToUserName>");
    sb.append("<FromUserName><![CDATA["+toUserName+"]]></FromUserName>");
    sb.append("<CreateTime>"+createTime+"</CreateTime>");
    sb.append("<MsgType><![CDATA[text]]></MsgType>");
    sb.append("<Content><![CDATA["+content+"]]></Content>");
    sb.append("</xml>");
    String replyMsg = sb.toString();

    String returnvaleue = "";
    try {
        WXBizMsgCrypt pc = new WXBizMsgCrypt(Global.getComponent_Token(),Global.getComponent_Key(),Global.getComponent_Appid());
        returnvaleue = pc.encryptMsg(replyMsg, createTime.toString(), "easemob");
        System.out.println("------------------加密后的返回内容 returnvaleue： "+returnvaleue);
    } catch (AesException e) {
        e.printStackTrace();
    }
    output(response, returnvaleue);
}



/**
 * 工具类：回复微信服务器"文本消息"
 * @param response
 * @param returnvaleue
 */
public void output(HttpServletResponse response, String returnvaleue){
    try {
        PrintWriter pw = response.getWriter();
        pw.write(returnvaleue);
        System.out.println("****************returnvaleue***************="+returnvaleue);
        pw.flush();
    } catch (IOException e) {
        e.printStackTrace();
    }
}










/**
 * 授权事件url
 * @param timestamp
 * @param nonce
 * @param msgSignature
 * @param postData
 * @return
 */
@RequestMapping(value ="/testurl")
@ResponseBody
public String testurl(
        @RequestParam("timestamp")String timestamp, @RequestParam("nonce")String nonce,
        @RequestParam("msg_signature")String msgSignature, @RequestBody String postData
       ) {
    Map<String,Object> retmap=new HashMap<>();
    try {
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl timestamp={},nonce={},msgSignature={},postData={}",timestamp,nonce,msgSignature,postData);

        //加密
        WXBizMsgCrypt msg=new WXBizMsgCrypt(Global.getComponent_Token(),"1234567890qwertyuiopASDFGHJKLzxcvbnmQWERTYU",Global.getComponent_Appid());

        // 第三方收到公众号平台发送的消息
        String result2 = msg.decryptMsg(msgSignature,timestamp,nonce,postData);
        System.out.println("解密后明文: " + result2);

        Map<String, String> stringStringMap = WXPayUtil.xmlToMap(result2);
        for (String key : stringStringMap.keySet()) {
            System.out.println("key= "+ key + " and value= " + stringStringMap.get(key));
        }
        if (!IsObjectNullUtils.is(stringStringMap.containsKey("InfoType"))){
            //存入或者更新数据库

            //查询出是否存在appid对应的ticket
            Ticket ticket=new Ticket();
            ticket.setRemark1(Global.getComponent_Appid());
            ticket.setFlag("0");
            Ticket ticketinfo = ticketHandler.selectticket(ticket);

            //判断是否存在
            if (IsObjectNullUtils.is(ticketinfo)){
                //不存在则插入
                Ticket ticketsave=new Ticket();
                ticketsave.setFlag("0");
                ticketsave.setRemark1(Global.getComponent_Appid());
                ticketsave.setCreateTime(new Date());
                ticketsave.setUpdataTime(new Date());
                ticketsave.setTicket(stringStringMap.get("ComponentVerifyTicket")+"");
                int save = ticketHandler.save(ticketsave);
                if (save>0){
                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl save ticket success");
                }else {
                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl save ticket fail");
                }

            }else {
                //存在则更新
                Ticket ticketupdate=new Ticket();
                ticketupdate.setId(ticketinfo.getId());
                ticketupdate.setUpdataTime(new Date());
                ticketupdate.setTicket(stringStringMap.get("ComponentVerifyTicket")+"");
                int update = ticketHandler.updateTickets(ticketupdate);
                if (update>0){
                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl update ticket success");
                }else {
                    ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl update ticket fail");
                }

            }

        }


        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl return retmap={}", result2);
        return "success";

    } catch (Exception ex) {
        ex.printStackTrace();
        ApiUtils.logger.info("class: APIAuthorizedeventAcceptance testurl return exception={},retmap={}", ex,retmap);
        return "";
    }
}

    }

package com.shop.api.controller;

import com.shop.common.config.Global;
import com.shop.common.entity.JsonRootBean;
import com.shop.common.handler.TokenHandler;
import com.shop.common.util.ApiUtils;
import com.shop.common.util.WXThirdparty.WXToken;
import com.shop.common.util.WXencryption.AesException;
import com.shop.common.util.WXencryption.WXBizMsgCrypt;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;

/**
* Created by Y on 2017/9/20.
*/
public class Method2 {
@Autowired
private TokenHandler tokenHandler;

public void checkWeixinAllNetworkCheck(HttpServletRequest request, HttpServletResponse response, String xml) throws Exception {

    String nonce = request.getParameter("nonce");
    String timestamp = request.getParameter("timestamp");
    String msgSignature = request.getParameter("msg_signature");
    //解密xml
    WXBizMsgCrypt pc = new WXBizMsgCrypt(Global.getComponent_Token(),Global.getComponent_Key(),Global.getComponent_Appid());
    xml = pc.decryptMsg(msgSignature, timestamp, nonce, xml);

    //获取xml内容
    Document doc = DocumentHelper.parseText(xml);
    Element rootElt = doc.getRootElement();
    String msgType = rootElt.elementText("MsgType");
    String toUserName = rootElt.elementText("ToUserName");
    String fromUserName = rootElt.elementText("FromUserName");

    ApiUtils.logger.info("---全网发布接入检测--step.1-----------msgType="+msgType+"-----------------toUserName="+toUserName+"-----------------fromUserName="+fromUserName);
    ApiUtils.logger.info("---全网发布接入检测--step.2-----------xml="+xml);
    //事件
    if("event".equals(msgType)){
        ApiUtils.logger.info("---全网发布接入检测--step.3-----------事件消息--------");
        String event = rootElt.elementText("Event");
        //replyEventMessage(request,response,event,toUserName,fromUserName);
        String content = event + "from_callback";
        ApiUtils.logger.info("---全网发布接入检测------step.4-------事件回复消息  content="+content + "   toUserName="+toUserName+"   fromUserName="+fromUserName);

        System.out.println("------进入replyTextMessage-------------------------");
        Long createTime = Calendar.getInstance().getTimeInMillis() / 1000;
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        sb.append("<ToUserName><![CDATA["+fromUserName+"]]></ToUserName>");
        sb.append("<FromUserName><![CDATA["+toUserName+"]]></FromUserName>");
        sb.append("<CreateTime>"+createTime+"</CreateTime>");
        sb.append("<MsgType><![CDATA[text]]></MsgType>");
        sb.append("<Content><![CDATA["+content+"]]></Content>");
        sb.append("</xml>");
        String replyMsg = sb.toString();

        String returnvaleue = "";
        try {
            WXBizMsgCrypt pcs = new WXBizMsgCrypt(Global.getComponent_Token(),Global.getComponent_Key(),Global.getComponent_Appid());
            returnvaleue = pcs.encryptMsg(replyMsg, createTime.toString(), "easemob");
            System.out.println("------------------加密后的返回内容 returnvaleue： "+returnvaleue);
        } catch (AesException e) {
            e.printStackTrace();
        }
        output(response, returnvaleue);





    }else if("text".equals(msgType)){
        //文本消息

        ApiUtils.logger.info("---全网发布接入检测--step.3-----------文本消息--------");
        String content = rootElt.elementText("Content");
        //processTextMessage(request,response,content,toUserName,fromUserName);
        if("TESTCOMPONENT_MSG_TYPE_TEXT".equals(content)){

            //普通文本消息

            String returnContent = content+"_callback";
            //replyTextMessage(request,response,returnContent,toUserName,fromUserName);
            System.out.println("------进入replyTextMessage-------------------------");
            Long createTime = Calendar.getInstance().getTimeInMillis() / 1000;
            StringBuffer sb = new StringBuffer();
            sb.append("<xml>");
            sb.append("<ToUserName><![CDATA["+fromUserName+"]]></ToUserName>");
            sb.append("<FromUserName><![CDATA["+toUserName+"]]></FromUserName>");
            sb.append("<CreateTime>"+createTime+"</CreateTime>");
            sb.append("<MsgType><![CDATA[text]]></MsgType>");
            sb.append("<Content><![CDATA["+returnContent+"]]></Content>");
            sb.append("</xml>");
            String replyMsg = sb.toString();

            String returnvaleue = "";
            try {
                WXBizMsgCrypt p = new WXBizMsgCrypt(Global.getComponent_Token(),Global.getComponent_Key(),Global.getComponent_Appid());
                returnvaleue = p.encryptMsg(replyMsg, createTime.toString(), "easemob");
                System.out.println("------------------加密后的返回内容 returnvaleue： "+returnvaleue);
            } catch (AesException e) {
                e.printStackTrace();
            }
            //return returnvaleue;
            output(response, returnvaleue);

            System.out.println("返回文本消息成功");


        }else {

            //回复api文本消息
            output(response, "");
            //接下来客服API再回复一次消息

            //replyApiTextMessage(request,response,content.split(":")[1],fromUserName);
            String authorization_code = content.split(":")[1];
            // 得到微信授权成功的消息后，应该立刻进行处理！！相关信息只会在首次授权的时候推送过来
            System.out.println("------step.1----使用客服消息接口回复粉丝----逻辑开始-------------------------");
                System.out.println("authorization_code===="+authorization_code);

                //获取第三方token
            //String gettoken = tokenHandler.gettoken();

            JsonRootBean getsmallroutineinterface = WXToken.getsmallroutineinterface(authorization_code, tokenHandler.gettoken());
            String authorizer_access_token = getsmallroutineinterface.getAuthorization_info().getAuthorizer_access_token();
            System.out.println("authorizer_access_token========="+authorizer_access_token);
            Map<String,Object> obj = new HashMap<String,Object>();
                Map<String,Object> msgMap = new HashMap<String,Object>();
                String msg = authorization_code + "_from_api";
                msgMap.put("content", msg);

                obj.put("touser", fromUserName);
                obj.put("msgtype", "text");
                obj.put("text", msgMap);
                WXToken.sendMessage(obj, authorizer_access_token);
        }
    }




}


public void output(HttpServletResponse response, String returnvaleue){
    try {
        PrintWriter pw = response.getWriter();
        pw.write(returnvaleue);
     System.out.println("****************returnvaleue***************="+returnvaleue);
        pw.flush();
        pw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}

package com.shop.common.util.WXThirdparty;

import com.shop.common.config.Global;
import com.shop.common.entity.JsonRootBean;
import com.shop.common.entity.Root;
import com.shop.common.util.ApiUtils;
import com.shop.common.util.IsObjectNullUtils;
import com.shop.common.util.LogUtil;
import com.shop.common.util.http.HttpObject;
import com.shop.common.util.http.HttpRespons;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import java.util.HashMap;
import java.util.Map;

/**
* Created by Y on 2017/9/11.
*/
public class WXToken {

public static Logger logger = LogUtil.getApiLogger();

/**
 * 获取第三方token
 * @param token
 * @param authorizerappid
 * @param authorizerrefreshtoken
 * @return
 * @throws Exception
 */
public static Map<String, Object> getMerchantToken (String token,String authorizerappid,String authorizerrefreshtoken)throws Exception{
    Map<String,Object> map=new HashMap();
    map.put("component_appid", Global.getComponent_Appid());
    map.put("authorizer_appid", authorizerappid);
    map.put("authorizer_refresh_token", authorizerrefreshtoken);

    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https:// api.weixin.qq.com /cgi-bin/component/api_authorizer_token?component_access_token="+token,map);
    logger.info("获取第三方token=" + result1.toString());
    JSONObject jsonObject = JSONObject.fromObject(result1.getContent());
    Map<String, Object> retMap = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);
    logger.info("获取第三方token=" + retMap.toString());
    if (!IsObjectNullUtils.is(retMap)) {
        return retMap;
    }
    return null;
}







/**
 * 获取预授权码
 * @param token
 * @return
 */
public static String getpreAuthCode(String token)throws Exception{
    Map<String,Object> map=new HashMap();
    map.put("component_appid", Global.getComponent_Appid());

    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https://api.weixin.qq.com/cgi-bin/component/api_create_preauthcode?component_access_token="+token,map);
    logger.info("获取pre_auth_code返回result1=" + result1.toString());
    JSONObject jsonObject = JSONObject.fromObject(result1.getContent());
    Map<String, Object> retMap = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);
    logger.info("获取pre_auth_code返回remap=" + retMap.toString());
    if (!IsObjectNullUtils.is(retMap)) {
        return (String)retMap.get("pre_auth_code");
    }
    return null;



}


/**
 * 获取第三方平台component_access_token
 * @return
 */
public static String getComponentAccessToken(String ticket)throws Exception{

    Map<String,Object> map=new HashMap();
    map.put("component_appid", Global.getComponent_Appid());
    map.put("component_appsecret",Global.getComponent_Appsecret());
    map.put("component_verify_ticket",ticket);

    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https://api.weixin.qq.com/cgi-bin/component/api_component_token",map);
    logger.info("获取component_access_token返回result1=" + result1.toString());
    JSONObject jsonObject = JSONObject.fromObject(result1.getContent());
    Map<String, Object> retMap = (Map<String, Object>) JSONObject.toBean(jsonObject, Map.class);
    logger.info("获取omponent_access_token返回remap=" + retMap.toString());
    if (!IsObjectNullUtils.is(retMap)) {
        return (String)retMap.get("component_access_token");
    }
    return null;
}


/**
 * 使用授权码换取公众号或小程序的接口调用凭证及信息
 * @return
 */
public static JsonRootBean getsmallroutineinterface(String authorizationcode,String token)throws Exception{

    if (IsObjectNullUtils.is(authorizationcode)){
        return null;
    }


    if (IsObjectNullUtils.is(token)){
        return null;
    }

    Map<String,Object> map=new HashMap();
    map.put("component_appid", Global.getComponent_Appid());
    map.put("authorization_code",authorizationcode);
    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https://api.weixin.qq.com/cgi-bin/component/api_query_auth?component_access_token="+token,map);
    logger.info("使用授权码换取公众号或小程序的接口调用凭证及信息返回result1=" + result1.toString());
    JSONObject jsonObject = JSONObject.fromObject(result1.getContent());
    JsonRootBean auth=(JsonRootBean)JSONObject.toBean(jsonObject, JsonRootBean.class);
    logger.info("使用授权码换取公众号或小程序的接口调用凭证及信息remap=" + auth.toString());
    if (!IsObjectNullUtils.is(auth)) {
        logger.info("使用授权码换取公众号或小程序的接口调用凭证及信息不为空时remap=");
        return auth;
    }
    return null;
}


/**
 * 回复粉丝消息
 * @param obj
 * @param merchantToken
 * @throws Exception
 */
public static void sendMessage(Map<String,Object> obj,String merchantToken)throws Exception{

    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token="+merchantToken,obj);
    logger.info("回复粉丝消息=" + result1.toString());


}



/**
 * 获取授权方的帐号基本信息
 * @return
 */
public static Root getAuthorisedbasicinfo(String authorizationappid,String token)throws Exception{
    ApiUtils.logger.info("class: WXToken getAuthorisedbasicinfo into authorizationappid={},token={}",authorizationappid,token);
    if (IsObjectNullUtils.is(authorizationappid)){
        return null;
    }

    if (IsObjectNullUtils.is(token)){
        return null;
    }

    Map<String,Object> map=new HashMap();
    map.put("component_appid", Global.getComponent_Appid());
    map.put("authorizer_appid",authorizationappid);

    HttpObject http = new HttpObject();
    HttpRespons result1=http.sendPost("https://api.weixin.qq.com/cgi-bin/component/api_get_authorizer_info?component_access_token="+token,map);
    logger.info("获取授权方的帐号基本信息=" + result1.toString());
    JSONObject jsonObject = JSONObject.fromObject(result1.getContent());
    Root root = (Root)JSONObject.toBean(jsonObject, Root.class);
    logger.info("获取授权方的帐号基本信息=" + root.toString());
    if (!IsObjectNullUtils.is(root)) {
        return root;
    }
    return null;
}

}

其实挺乱的 看不懂的可以找我交流下 微信号:yhhxfhh