微信api接口常用操作

其他 2018-06-29 19:05:28 阅读次数: 0

微信接入指南
https://mp.weixin.qq.com/wiki/8/f9a0b8382e0b77d87b3bcc1ce6fbc104.html
目录
1 概述
2 第一步：填写服务器配置
这里写图片描述

3 第二步：验证服务器地址的有效性
package com.web.wexin;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.web.wexin.util.SignUtil;

/** 
 * 核心请求处理类 
 */  
public class WeiXinServlet  extends HttpServlet{
    private static final long serialVersionUID = 1L;

     /** 
     * 确认请求来自微信服务器 
     */  
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
        // 微信加密签名  
        String signature = request.getParameter("signature");  
        // 时间戳  
        String timestamp = request.getParameter("timestamp");  
        // 随机数  
        String nonce = request.getParameter("nonce");  
        // 随机字符串  
        String echostr = request.getParameter("echostr");  

        PrintWriter out = response.getWriter();  
        // 通过检验signature对请求进行校验，若校验成功则原样返回echostr，表示接入成功，否则接入失败  
        if (SignUtil.checkSignature(signature, timestamp, nonce)) {  
            out.print(echostr);
        }  
        out.close();  
        out = null;  
    }  

    /** 
     * 处理微信服务器发来的消息 
     */  
    public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {  
              // 将请求、响应的编码均设置为UTF-8（防止中文乱码）  
            request.setCharacterEncoding("UTF-8");  
            response.setCharacterEncoding("UTF-8");  

            // 调用核心业务类接收消息、处理消息  
            String respMessage = CoreService.processRequest(request);  

            // 响应消息  
            PrintWriter out = response.getWriter();  
            out.print(respMessage);  
            out.close();  

    }  

}

4 第三步：依据接口文档实现业务逻辑

先提供一个工具类
package com.web.wexin.util;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ConnectException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.bean.AccessToken;
import com.web.wexin.vo.Menu;
import com.web.wexin.vo.OAuthInfo;
import com.web.wexin.vo.WxUserinfo;

/**
 * 公众平台通用接口工具类
 * 
 */
public class WeixinUtil {
    private static Logger log = LoggerFactory.getLogger(WeixinUtil.class);
    // 第三方用户唯一凭证
    public final static String appId = "wx71335f894797efd0";
    // 第三方用户唯一凭证密钥
    public final static String appSecret = "d524fcf5147c6c732a2270a64f5869a5";
    // 获取access_token的接口地址（GET）
    public final static String access_token_url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET";
    // 菜单创建
    public final static String menu_create_url = "https://api.weixin.qq.com/cgi-bin/menu/create?access_token=ACCESS_TOKEN";
    // 发送模板消息
    public final static String sendtemplat_url = "https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=ACCESS_TOKEN";
    // 获取code后，请求以下链接获取用户access_token：
    public final static String userinfotoken_url = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=APPSECRET&code=CODE&grant_type=authorization_code";
    // 粉丝列表
    public final static String fansi_url = "https://api.weixin.qq.com/cgi-bin/user/get?access_token=ACCESS_TOKEN";
    // 获取用户信息
    public final static String user_url = "https://api.weixin.qq.com/sns/userinfo?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN";
    // 获取用户基本信息（包括UnionID机制） 粉丝列表时使用
    public final static String fansi_userinfo_url = "https://api.weixin.qq.com/cgi-bin/user/info?access_token=ACCESS_TOKEN&openid=OPENID&lang=zh_CN";
    // 创建临时二维码ticket
    public final static String temporary_url = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=ACCESS_TOKEN";
    // 创建永久二维码ticket
    public final static String permanent_url = "https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=ACCESS_TOKEN";
    // 通过ticket换取二维码 提醒：TICKET记得进行UrlEncode
    public final static String qrcode_url = "https://mp.weixin.qq.com/cgi-bin/showqrcode?ticket=TICKET";
    // 获取用户增减数据 最大时间跨度7天
    public final static String getusersummary_url = "https://api.weixin.qq.com/datacube/getusersummary?access_token=ACCESS_TOKEN";
    // 获取累计用户数据 最大时间跨度7天
    public final static String getusercumulate_url = "https://api.weixin.qq.com/datacube/getusercumulate?access_token=ACCESS_TOKEN";
    // 获取jsapi_ticket
    public final static String jsapi_ticket_url = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=ACCESS_TOKEN&type=jsapi";
    // 创建分组 POST数据例子：{"group":{"name":"test"}}
    public final static String create_group_url = "https://api.weixin.qq.com/cgi-bin/groups/create?access_token=ACCESS_TOKEN";
    // 查询所有分组
    public final static String selete_group_url = "https://api.weixin.qq.com/cgi-bin/groups/get?access_token=ACCESS_TOKEN";
    // 查询用户所在分组 POST数据例子：{"openid":"od8XIjsmk6QdVTETa9jLtGWA6KBc"}
    public final static String selectUsers_group_url = "https://api.weixin.qq.com/cgi-bin/groups/getid?access_token=ACCESS_TOKEN";
    // 修改分组名 POST数据例子：{"group":{"id":108,"name":"test2_modify2"}}
    public final static String update_group_url = "https://api.weixin.qq.com/cgi-bin/groups/update?access_token=ACCESS_TOKEN";
    // 批量移动用户分组
    public final static String batch_group_url = "https://api.weixin.qq.com/cgi-bin/groups/members/batchupdate?access_token=ACCESS_TOKEN";
    // 获取微信卡券 api_ticket
    public final static String api_ticket_url = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=ACCESS_TOKEN&type=wx_card";
    // 批量查询卡券列表
    public final static String batchget_url = "https://api.weixin.qq.com/card/batchget?access_token=ACCESS_TOKEN";
    // 查询卡券详情 http请求方式: POST POST数据 {"card_id":"pFS7Fjg8kV1IdDz01r4SQwMkuCKc"}
    public final static String get_card_url = "https://api.weixin.qq.com/card/get?access_token=ACCESS_TOKEN";
    // 创建卡券二维码 ticket post请求
    public final static String create_cardTicket_url = "https://api.weixin.qq.com/card/qrcode/create?access_token=ACCESS_TOKEN";
    // 核销卡券Code接口
    public final static String delete_code_url = "https://api.weixin.qq.com/card/code/consume?access_token=ACCESS_TOKEN";
    // Code解码接口
    public final static String code_decrypt_url = "https://api.weixin.qq.com/card/code/decrypt?access_token=ACCESS_TOKEN";
    // 检测Code是否正常状态
    public final static String check_code_url = "https://api.weixin.qq.com/card/code/get?access_token=ACCESS_TOKEN";
    // 创建卡券货架接口
    public final static String create_cardhj_url = "https://api.weixin.qq.com/card/landingpage/create?access_token=ACCESS_TOKEN";
    // 获取用户已领取卡券接口
    public final static String getcardlist_url = "https://api.weixin.qq.com/card/user/getcardlist?access_token=ACCESS_TOKEN";

    /**
     * 获取access_token
     * 
     * @param appid
     *            凭证
     * @param appsecret
     *            密钥
     * @return
     */
    public static AccessToken getAccessToken(String appid, String appsecret) {
        AccessToken accessToken = null;
        String requestUrl = access_token_url.replace("APPID", appid).replace(
                "APPSECRET", appsecret);
        JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
        // 如果请求成功
        if (null != jsonObject) {
            try {
                accessToken = new AccessToken();
                accessToken.setToken(jsonObject.getString("access_token"));
                accessToken.setExpiresIn(jsonObject.getInteger("expires_in"));
            } catch (JSONException e) {
                accessToken = null;
                // 获取token失败
                log.error("获取token失败 errcode:{} errmsg:{}",
                        jsonObject.getInteger("errcode"),
                        jsonObject.getString("errmsg"));
            }
        }
        return accessToken;
    }

    /**
     * 获取网页授权用户的token
     * 
     * @param code
     * @return 2016年8月17日
     */
    public static OAuthInfo getUserToken(String code) {
        String requestUrl = userinfotoken_url.replace("APPID", appId)
                .replace("APPSECRET", appSecret).replace("CODE", code);
        JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
        OAuthInfo oa = new OAuthInfo();
        if (null != jsonObject) {
            try {
                oa.setAccessToken(jsonObject.getString("access_token"));
                oa.setExpiresin(jsonObject.getInteger("expires_in").toString());
                oa.setRefreshToken(jsonObject.getString("refresh_token"));
                oa.setOpenid(jsonObject.getString("openid"));
                oa.setScope(jsonObject.getString("scope"));
            } catch (JSONException e) {
                // 获取token失败
                log.error("网页授权获取openId失败 errcode:{} errmsg:{}",
                        jsonObject.getInteger("errcode"),
                        jsonObject.getString("errmsg"));
            }
        }
        return oa;

    }

    /**
     * 获取网页授权用户的详细信息
     * 
     * @param oa
     * @return 2016年8月17日
     */
    public static WxUserinfo getWxUserInfo(OAuthInfo oa) {
        String requestUrl = user_url.replace("ACCESS_TOKEN",
                oa.getAccessToken()).replace("OPENID", oa.getOpenid());
        JSONObject jsonObject = httpRequest(requestUrl, "GET", null);
        WxUserinfo user = new WxUserinfo();
        if (jsonObject != null) {
            user.setOpenid(jsonObject.getString("openid"));
            user.setNickname(jsonObject.getString("nickname"));
            user.setSex(jsonObject.getString("sex"));
            user.setProvince(jsonObject.getString("province"));
            user.setCity(jsonObject.getString("city"));
            user.setCountry(jsonObject.getString("country"));
            user.setHeadimgurl(jsonObject.getString("headimgurl"));
            user.setPrivilege(jsonObject.getString("privilege"));
        }
        return user;
    }

    /**
     * 创建菜单
     * 
     * @param menu
     *            菜单实例
     * @param accessToken
     *            有效的access_token
     * @return 0表示成功，其他值表示失败
     */
    public static int createMenu(Menu menu, String accessToken) {
        int result = 0;

        // 拼装创建菜单的url
        String url = menu_create_url.replace("ACCESS_TOKEN", accessToken);
        // 将菜单对象转换成json字符串
        String jsonMenu = JSONObject.toJSONString(menu);
        // 调用接口创建菜单
        JSONObject jsonObject = httpRequest(url, "POST", jsonMenu);

        if (null != jsonObject) {
            if (0 != jsonObject.getInteger("errcode")) {
                result = jsonObject.getInteger("errcode");
                log.error("创建菜单失败 errcode:{} errmsg:{}",
                        jsonObject.getInteger("errcode"),
                        jsonObject.getString("errmsg"));
            }
        }

        return result;
    }

    /**
     * 获取粉丝列表信息
     * 
     * @param accessToken
     * @param openid
     * @return 2016年8月18日
     */
    public static JSONArray getFansList(String accessToken) {
        JSONArray arrs = new JSONArray();
        String url = fansi_url.replace("ACCESS_TOKEN", accessToken);
        JSONObject jsonObject = httpRequest(url, "GET", null);
        if (null != jsonObject) {
            JSONObject data = (JSONObject) jsonObject.get("data");
            JSONArray openidList = data.getJSONArray("openid");
            for (int i = 0; i < openidList.size(); i++) {
                System.out.println(openidList.getString(i));
                JSONObject obj = httpRequest(
                        fansi_userinfo_url.replace("ACCESS_TOKEN", accessToken)
                                .replace("OPENID", openidList.getString(i)),
                        "GET", null);
                if (obj != null) {
                    arrs.add(obj);
                }
            }
        }
        return arrs;
    }

    /**
     * 创建二维码ticket
     * 
     * @param type
     *            1=临时 ,2=永久
     * @param accessToken
     * @param expire_seconds
     *            该二维码有效时间，以秒为单位。 最大不超过2592000
     * @param scene_id
     *            场景值ID，临时二维码时为32位非0整型，永久二维码时最大值为100000
     * @return 2016年8月18日
     */
    public static JSONObject createTicket(String type, String accessToken,
            String expire_seconds, String scene_id) {
        String requestUrl = "";
        String jsonStr = "";
        if (type.equals("1")) {// 临时
            requestUrl = temporary_url.replace("ACCESS_TOKEN", accessToken);
            jsonStr = "{\"expire_seconds\": 604800, \"action_name\": \"QR_SCENE\", \"action_info\": {\"scene\": {\"scene_id\": 123}}}";
        } else {// 永久
            requestUrl = permanent_url.replace("ACCESS_TOKEN", accessToken);
            jsonStr = "{\"action_name\": \"QR_LIMIT_SCENE\", \"action_info\": {\"scene\": {\"scene_id\": 123}}}";
        }
        JSONObject jsonObject = httpRequest(requestUrl, "POST", jsonStr);
        return jsonObject;
    }

    /**
     * 发起https请求并获取结果
     * 
     * @param requestUrl
     *            请求地址
     * @param requestMethod
     *            请求方式（GET、POST）
     * @param outputStr
     *            提交的数据
     * @return JSONObject(通过JSONObject.get(key)的方式获取json对象的属性值)
     */
    public static JSONObject httpRequest(String requestUrl,
            String requestMethod, String outputStr) {
        JSONObject jsonObject = null;
        StringBuffer buffer = new StringBuffer();
        try {
            // 创建SSLContext对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = { new MyX509TrustManager() };
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述SSLContext对象中得到SSLSocketFactory对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();

            URL url = new URL(requestUrl);
            HttpsURLConnection httpUrlConn = (HttpsURLConnection) url
                    .openConnection();
            httpUrlConn.setSSLSocketFactory(ssf);

            httpUrlConn.setDoOutput(true);
            httpUrlConn.setDoInput(true);
            httpUrlConn.setUseCaches(false);
            // 设置请求方式（GET/POST）
            httpUrlConn.setRequestMethod(requestMethod);

            if ("GET".equalsIgnoreCase(requestMethod))
                httpUrlConn.connect();

            // 当有数据需要提交时
            if (null != outputStr) {
                OutputStream outputStream = httpUrlConn.getOutputStream();
                // 注意编码格式，防止中文乱码
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }

            // 将返回的输入流转换成字符串
            InputStream inputStream = httpUrlConn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(
                    inputStream, "utf-8");
            BufferedReader bufferedReader = new BufferedReader(
                    inputStreamReader);

            String str = null;
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            bufferedReader.close();
            inputStreamReader.close();
            // 释放资源
            inputStream.close();
            inputStream = null;
            httpUrlConn.disconnect();
            jsonObject = JSONObject.parseObject(buffer.toString());
        } catch (ConnectException ce) {
            log.error("Weixin server connection timed out.");
        } catch (Exception e) {
            log.error("https request error:{}", e);
        }
        return jsonObject;
    }

    public static Map<String, Object> wxMsgMap(Map<String, Object> allMap,
            String key, String value, String color) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("value", value);
        map.put("color", color);
        allMap.put(key, map);
        return allMap;

    }

    /**
     * 发送模板消息
     * 
     * @param accessToken
     * @param OpenId
     * @param template_id
     * @param detailUrl
     * @param map
     * @return 2016年9月19日
     */
    public static JSONObject postTemplateMsg(String accessToken, String OpenId,
            String template_id, String detailUrl, Map<String, Object> map) {
        String url = sendtemplat_url.replace("ACCESS_TOKEN", accessToken);
        JSONObject jso = new JSONObject();
        jso.put("touser", OpenId);
        jso.put("template_id", template_id);
        if (detailUrl != null)
            jso.put("url", detailUrl);
        jso.put("data", map);
        return httpRequest(url, "POST", jso.toString());
    }


}
springMVC控制器
package com.web;
import java.util.HashMap;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.bean.CardReceive;
import com.mapper.SqlcardReceive;
import com.util.AjaxUtil;
import com.util.DateUtil;
import com.web.wexin.TokenThread;
import com.web.wexin.util.SignUtil;
import com.web.wexin.util.WeixinUtil;
import com.web.wexin.vo.OAuthInfo;
import com.web.wexin.vo.WxUserinfo;

@Controller
@RequestMapping("/wx")
public class WeiXinController {
    @Resource
    public SqlcardReceive sqlcardReceive;

    /**
     * 网页授权获取用户信息
     * @param view
     * @param req
     * @return
     * 2016年8月16日
     */
    @RequestMapping("/oauth")
    public ModelAndView oauth(ModelAndView view,HttpServletRequest req){
        String  code=req.getParameter("code");
        System.out.println(code);
        OAuthInfo oauth=WeixinUtil.getUserToken(code);
        if(oauth!=null){
                WxUserinfo userinfo=WeixinUtil.getWxUserInfo(oauth);
                System.out.println("oauth===="+userinfo.toString());
            }

        return view;        
    }

    /**
     * 微信jssdk
     * @param request
     * 2016年8月25日
     */
    @RequestMapping("/wxJs")
    public  void wxJs(HttpServletRequest request,HttpServletResponse response){
        String  url=request.getParameter("url");
        String ticket=(String) request.getSession().getAttribute("ticket");
        if(StringUtils.isEmpty(ticket)){
            JSONObject json=WeixinUtil.httpRequest(WeixinUtil.jsapi_ticket_url.replaceAll("ACCESS_TOKEN", TokenThread.accessToken.getToken()), "GET", null);
            ticket=json.getString("ticket");
            request.getSession().setAttribute("ticket", json.getString("ticket"));
            request.getSession().setMaxInactiveInterval(7200);
        }       
           Map<Object, Object> returnMap = SignUtil.sign(ticket, url);
           returnMap.put("appId", "wx71335f894797efd0");
           AjaxUtil.writeJsonMap(returnMap, response);
    }



    /**
     * 过滤已过期的卡券
     * @return
     * 2016年9月7日
     */
    public JSONArray filterCard(String token){
        JSONArray array=new JSONArray();
        String str="{\"offset\": 0, \"count\":50,\"status_list\": [\"CARD_STATUS_VERIFY_OK\"]}";
        //获取卡券id列表
        JSONObject json=WeixinUtil.httpRequest(WeixinUtil.batchget_url.replaceAll("ACCESS_TOKEN", token), "POST", str); 
        if(json.getString("errcode").equals("0")){
            JSONArray arr=(JSONArray) json.get("card_id_list");
            for(int i = 0; i < array.size(); i++){
                JSONObject cardObj=new JSONObject();
                JSONObject outputStr=new JSONObject();
                outputStr.put("card_id", arr.get(i));
                //获取卡券详情
                JSONObject obj=WeixinUtil.httpRequest(WeixinUtil.get_card_url.replaceAll("ACCESS_TOKEN", token), "POST", outputStr.toJSONString());
                if(obj.getString("errcode").equals("0")){
                    JSONObject card= (JSONObject) obj.get("card");
                    JSONObject groupon= (JSONObject) card.get("groupon");
                    JSONObject base_info= (JSONObject) groupon.get("base_info");
                    JSONObject dateInfo= (JSONObject) base_info.get("date_info");
                    int end_timestamp=dateInfo.getIntValue("end_timestamp");
                    int newtimestamp=DateUtil.getUnixDate();
                    if(end_timestamp<=newtimestamp){
                        cardObj.put("card_id", arr.get(i));
//                      cardObj.put("title", base_info.get("title"));
                        array.add(cardObj);
                    }
                }
            }   
        }
        return array;
    }




    /**
     * 创建卡券领取二维码tike
     * @param request
     * @param response
     * 2016年9月6日
     */
    @RequestMapping("/createCardqrCode")
    public void  createCardqrCode(HttpServletRequest request,HttpServletResponse response){
        String token="ko6W-mcZJG_Xlj6H4JExQcrf218i5TymJw9IJtkTSJaplxgRtWDNt6CRgcbMjRERP-yWqaZRt02A0J6zbedB2JELWJ0i8cmAB9UDAcxSyLjvfWjXOtqNTuD-bAOpQJ0bIKFeCBAZBW"; 
//      JSONArray array=filterCard(token);
        JSONArray listarry=new JSONArray();
//      for (int i = 0; i < array.size(); i++){
            JSONObject map=new JSONObject();
            map.put("card_id", "pwibYt5UeRE7KTs4Gn6j1EM_xS-k");
            listarry.add(map);
//      }   
        String url=WeixinUtil.create_cardTicket_url;
        String outputStr="{\"action_name\": \"QR_MULTIPLE_CARD\",";
        outputStr +="\"expire_seconds\": 1800,";    
        outputStr +="\"action_info\":{\"multiple_card\":{\"card_list\":"+listarry.toJSONString()+"}}}";     
        JSONObject obj=WeixinUtil.httpRequest(url.replaceAll("ACCESS_TOKEN", token), "POST", outputStr);
        AjaxUtil.out(obj.toJSONString(), response);     
    }   


    /**
     * 创建卡券货架领取 返回url地址
     * @param request
     * @param response
     * 2016年9月6日
     */
    @RequestMapping("/shelves")
    public void  shelves(HttpServletRequest request,HttpServletResponse response){
        String token="";
        JSONArray array=filterCard(token);
        JSONObject m=new JSONObject();
        m.put("banner", "http://mmbiz.qpic.cn/mmbiz/iaL1LJM1mF9aRKPZJkmG8xXhiaHqkKSVMMWeN3hLut7X7hicFN");
        m.put("page_title", "卡券货架接口测试");
        m.put("can_share", true);
        m.put("scene", "SCENE_H5");
        JSONArray listarry=new JSONArray();
        for (int i = 0; i < array.size(); i++){
            JSONObject map=new JSONObject();
            map.put("thumb_url", "www.qq.com/a.jpg");
            map.put("card_id", ""+array.get(i)+"");
            listarry.add(map);
        }   
        m.put("card_list", listarry);
        System.out.println(m.toJSONString());
        JSONObject obj=WeixinUtil.httpRequest(WeixinUtil.create_cardhj_url.replaceAll("ACCESS_TOKEN", token), "POST", m.toString());
        System.out.println(obj.toJSONString());
        AjaxUtil.out(obj.toJSONString(), response);     
    }   



    /**
     * 卡券内跳转外链的签名中会对code进行加密处理，通过调用解码接口获取真实code。
     * Code解码接口
     * @param request
     * @param response
     * 2016年9月6日
     */
    @RequestMapping("/codeDecrypt")
    public void codeDecrypt(HttpServletRequest request,HttpServletResponse response){
        String token="";
        String encrypt_code=request.getParameter("encrypt_code");
        String url=WeixinUtil.code_decrypt_url;
        JSONObject outputStr=new JSONObject();
        outputStr.put("encrypt_code", encrypt_code);
        JSONObject json=WeixinUtil.httpRequest(url.replaceAll("ACCESS_TOKEN", token), "POST", outputStr.toJSONString());
        AjaxUtil.out(json.toJSONString(), response);        
    }




    /**
     * 核销卡券
     * @param request
     * @param response
     * 2016年9月6日
     */
    @RequestMapping("/consumeCode")
    public void consumeCode(HttpServletRequest request,HttpServletResponse response){
        Map<Object, Object> map=new HashMap<Object, Object>();
        try {           
            String token="";
            String check_code_url=WeixinUtil.check_code_url;    //检测code
            String delete_code_url=WeixinUtil.delete_code_url;   //核销code
            String code=request.getParameter("code");
            String card_id=request.getParameter("card_id");//自定义Code卡券
            JSONObject check=new JSONObject();
            check.put("code", code);
            if(StringUtils.isNotEmpty(card_id)){
                check.put("card_id", card_id);
            }
            check.put("check_consume", true);
            System.out.println(check.toJSONString());
            JSONObject checkStatus=new JSONObject();
            checkStatus=WeixinUtil.httpRequest(check_code_url.replaceAll("ACCESS_TOKEN", token), "POST", check.toJSONString());
            if(checkStatus.getString("errcode").equals("0")){   
                check.remove("check_consume");
                    //核销卡券
                    JSONObject obj=WeixinUtil.httpRequest(delete_code_url.replaceAll("ACCESS_TOKEN", token), "POST", check.toJSONString()); 
                    if(obj.getString("errcode").equals("0")){
                        CardReceive card=new CardReceive();
                        JSONObject cardObj=(JSONObject) obj.get("card");
                        card.setCardId(cardObj.getString("card_id"));
                        card.setUserCardCode(code);
                        card.setOpenid(obj.getString("openid"));
                        card.setSource("卡券核销记录");
                        sqlcardReceive.save(card);
                        map.put("status", 200);
                        map.put("message", "核销成功");
                     }else{
                         map.put("status", 500);
                         map.put("message", "核销失败");
                     }
            }else{
                map.put("status", 500);
                map.put("message", "卡券无效");
            }
        } catch (Exception e) {
            map.put("status", 500);
            map.put("message", "服务器繁忙");
            e.printStackTrace();
        }       
    //  AjaxUtil.out(checkStatus.toJSONString(), response);
        AjaxUtil.writeJsonMap(map, response);
    }

    @RequestMapping("/baidu")
    public String baidu(){
        return "redirect:http://www.baidu.com";

    }
}
微信验证工具 微信js-sdk验证
package com.web.wexin.util;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Formatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class SignUtil {
     // 与接口配置信息中的Token要一致  
    private static String token = "weixinqxw";  

    /** 
     * 验证签名 
     *  
     * @param signature 
     * @param timestamp 
     * @param nonce 
     * @return 
     */  
    public static boolean checkSignature(String signature, String timestamp, String nonce) {  
        String[] arr = new String[] { token, timestamp, nonce };  
        // 将token、timestamp、nonce三个参数进行字典序排序  
        Arrays.sort(arr);  
        StringBuilder content = new StringBuilder();  
        for (int i = 0; i < arr.length; i++) {  
            content.append(arr[i]);  
        }  
        MessageDigest md = null;  
        String tmpStr = null;  

        try {  
            md = MessageDigest.getInstance("SHA-1");  
            // 将三个参数字符串拼接成一个字符串进行sha1加密  
            byte[] digest = md.digest(content.toString().getBytes());  
            tmpStr = byteToStr(digest);  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        }  

        content = null;  
        // 将sha1加密后的字符串可与signature对比，标识该请求来源于微信  
        return tmpStr != null ? tmpStr.equals(signature.toUpperCase()) : false;  
    }  

    /** 
     * 将字节数组转换为十六进制字符串 
     *  
     * @param byteArray 
     * @return 
     */  
    private static String byteToStr(byte[] byteArray) {  
        String strDigest = "";  
        for (int i = 0; i < byteArray.length; i++) {  
            strDigest += byteToHexStr(byteArray[i]);  
        }  
        return strDigest;  
    }  

    /** 
     * 将字节转换为十六进制字符串 
     *  
     * @param mByte 
     * @return 
     */  
    private static String byteToHexStr(byte mByte) {  
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };  
        char[] tempArr = new char[2];  
        tempArr[0] = Digit[(mByte >>> 4) & 0X0F];  
        tempArr[1] = Digit[mByte & 0X0F];  

        String s = new String(tempArr);  
        return s;  
    }


    /**
     * JS-SDK使用权限签名算法
     * @param jsapi_ticket
     * @param url
     * @return
     * 2016年8月25日
     */

    public static Map<Object, Object> sign(String jsapi_ticket, String url) {
        Map<Object, Object> ret = new HashMap<Object, Object>();
        String nonce_str = create_nonce_str();
        String timestamp = create_timestamp();
        String string1;
        String signature = "";

        //注意这里参数名必须全部小写，且必须有序
        string1 = "jsapi_ticket=" + jsapi_ticket +
                  "&noncestr=" + nonce_str +
                  "&timestamp=" + timestamp +
                  "&url=" + url;
        System.out.println(string1);

        try
        {
            MessageDigest crypt = MessageDigest.getInstance("SHA-1");
            crypt.reset();
            crypt.update(string1.getBytes("UTF-8"));
            signature = byteToHex(crypt.digest());
        }
        catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }

        ret.put("url", url);
        ret.put("jsapi_ticket", jsapi_ticket);
        ret.put("nonceStr", nonce_str);
        ret.put("timestamp", timestamp);
        ret.put("signature", signature);

        return ret;
    }


    private static String byteToHex(final byte[] hash) {
        Formatter formatter = new Formatter();
        for (byte b : hash)
        {
            formatter.format("%02x", b);
        }
        String result = formatter.toString();
        formatter.close();
        return result;
    }

    private static String create_nonce_str() {
        return UUID.randomUUID().toString();
    }

    private static String create_timestamp() {
        return Long.toString(System.currentTimeMillis() / 1000);
    }
}
package com.web.wexin.vo;
/**
 * 网页授权用
 * @author admin
 * 2016年8月16日
 */
public class OAuthInfo {
    private String accessToken;
    private String expiresin;
    private String refreshToken;
    private String openid;
    private String scope;
    public String getAccessToken() {
        return accessToken;
    }
    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }
    public String getExpiresin() {
        return expiresin;
    }
    public void setExpiresin(String expiresin) {
        this.expiresin = expiresin;
    }
    public String getRefreshToken() {
        return refreshToken;
    }
    public void setRefreshToken(String refreshToken) {
        this.refreshToken = refreshToken;
    }
    public String getOpenid() {
        return openid;
    }
    public void setOpenid(String openid) {
        this.openid = openid;
    }
    public String getScope() {
        return scope;
    }
    public void setScope(String scope) {
        this.scope = scope;
    }
    @Override
    public String toString() {
        return "OAuthInfo [accessToken=" + accessToken + ", expiresin="
                + expiresin + ", refreshToken=" + refreshToken + ", openid="
                + openid + ", scope=" + scope + "]";
    }


}

猜你喜欢

转载自blog.csdn.net/u010391342/article/details/70157658
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022