微信公众号&&企业微信 获取JD-SDK 签名算法 《Java技术开发》

1.获取token ：

         /**
         * 获取企业微信token
         * 使用该方法获取token需要传入两参数，一个微信appID，一个appsecret。
         * 该工具获取token使用了redis缓存。
         * @param CORPID
         * @param SECRET
         * @return
         * @throws IOException 
         * @throws Exception
         */
        public  String getToken(String appID, String appsecret) throws Exception  {
            
            if((String) RedisUtil.get("token")==null){
            String urlStr =WeChatConstant.TOKEN_Url + appID + "&secret=" + appsecret;
            String  result= HttpRequestUtil.httpGet(urlStr);
            JSONObject jsonObject = new JSONObject(result);
            String accesstoken = jsonObject.getString("access_token");
            RedisUtil.set("token", accesstoken);
            //设置redis有效期刷新token
            RedisUtil.expire("token",1200L);
            logger.info("token========="+accesstoken);
            return accesstoken;
            }else{
                String token =(String) RedisUtil.get("token");
                return token;
            }
            
        }
 二、移动端JS-SDK  获取签名算法

1、获取url 

       ①，在页面上获取的方法：var curWwwPath = window.document.location.href;

       ②/** 
     * url 路径标准化
     * @param request
     * @return
     */
    @ResponseBody
    public String url(HttpServletRequest request) {
        String url = "";
        // http://localhost:8080/blog.do
        /*url = request.getScheme() + "://" + request.getServerName()
                + request.getServletPath();
        if (request.getQueryString() != null) {
            url += "?" + request.getQueryString();
        }*/
        url =request.getScheme() + "://" + request.getServerName()+request.getRequestURI(); 
        return url;

    }

2，/**
     * 获取签名权限
     * @param url
     * @return
     * @throws Exception
     */
    public JSONObject getJsSdkSign(String url) throws Exception {
        
        // 随机数
        String noncestr = create_nonce_str();
        // 时间戳
        String timestamp = create_timestamp();
        // 获取Ticket
        String jsapi_ticket = getJsapiTicket();

        JSONObject result = new JSONObject();
        String signStr = "jsapi_ticket=" + jsapi_ticket + "&noncestr=" + noncestr + "&timestamp=" + timestamp + "&url="
                + url;
        try {
            MessageDigest crypt = MessageDigest.getInstance("SHA-1");
            crypt.reset();
            crypt.update(signStr.getBytes("UTF-8"));
            String signature = byteToHex(crypt.digest());
            logger.info(" signStr==" + signStr + " signature" + signature);
            result.put("url", url);
            result.put("jsapi_ticket", jsapi_ticket);
            result.put("nonceStr", noncestr);
            result.put("timestamp", timestamp);
            result.put("signature", signature);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }

    private static String byteToHex(byte[] hash) {
        Formatter formatter = new Formatter();
        for (byte b : hash) {
            formatter.format("%02x", b);
        }
        String result = formatter.toString();
        formatter.close();
        return result;
    }
    /**
     * 获取jsapiTicket
     */
    private String getJsapiTicket() throws Exception {
        
        if((String) RedisUtil.get("jsapi_ticket")==null){
        String token = getToken(WeChatConstant.appID, WeChatConstant.appsecret);
        String url = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token="+token+"&type=jsapi";
        String result = HttpRequestUtil.httpGet(url);
        JSONObject jsonObject = new JSONObject(result);
        String jsapi_ticket = jsonObject.getString("ticket");
        RedisUtil.set("jsapi_ticket", jsapi_ticket);
        //设置redis有效期刷新jsapi_ticket
        RedisUtil.expire("jsapi_ticket", 1200L);
        logger.info("jsapi_ticket========="+jsapi_ticket);
        return jsapi_ticket;
        }else{
            return (String) RedisUtil.get("jsapi_ticket");
        }
    }
    
    
    

    /**
     * 生成随机字符串
     * 
     * @return
     */
    private static String create_nonce_str() {
        return UUID.randomUUID().toString();
    }

    /**
     * 时间格式化
     * 
     * @return
     */
    private static String create_timestamp() {
        return Long.toString(System.currentTimeMillis() / 1000);
    }

 

 

 

二、HttpRequestUtil 用于发送http请求的工具类

/**
 * 用于发送http请求的工具类
 * @author chen
 *
 */
public class HttpRequestUtil {
    private static Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);

    /**
     * post请求
     * @param url         url地址
     * @return
     */
    public static String httpPost(String url, Map<String,String> params){
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpPost method = new HttpPost(url);
        String strResult = "";
        try {
            List<NameValuePair> nameValuePairList=new ArrayList<NameValuePair>();
            for (String key:params.keySet()){
                nameValuePairList.add(new BasicNameValuePair(key,params.get(key)));
            }
            UrlEncodedFormEntity entity=new UrlEncodedFormEntity(nameValuePairList,"utf-8");
            method.setEntity(entity);

            logger.info("url == " + url);
            HttpResponse result = httpClient.execute(method);
            url = URLDecoder.decode(url, "UTF-8");
            /**请求发送成功，并得到响应**/
            logger.info("statusCode " + result.getStatusLine().getStatusCode());
            if (result.getStatusLine().getStatusCode() == 200) {
                try {
                    /**读取服务器返回过来的json字符串数据**/
                    strResult = EntityUtils.toString(result.getEntity());
                    logger.info("strResult  " + strResult);
                } catch (Exception e) {
                    logger.error("post请求提交失败:" + url, e);
                }
            }
        } catch (IOException e) {
            logger.error("post请求提交失败:" + url, e);
        }
        return strResult;
    }

    public static String httpPostJson(String postUrl, String params){
        try {
            logger.info("httpPostJson   postUrl ==== " + postUrl);
            logger.info("httpPostJson   params ==== " + params);
            // 创建url资源
            URL url = new URL(postUrl);
            logger.info("httpPostJson   url ==== " + url);
            // 建立http连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            // 设置允许输出
            conn.setDoOutput(true);

            conn.setDoInput(true);

            // 设置不用缓存
            conn.setUseCaches(false);
            // 设置传递方式
            conn.setRequestMethod("POST");
            // 设置维持长连接
            conn.setRequestProperty("Connection", "Keep-Alive");
            // 设置文件字符集:
            conn.setRequestProperty("Charset", "UTF-8");
            //转换为字节数组
//            System.out.println("JSON.toJSONString(params)"+JSON.toJSONString(params));
            byte[] data = params.getBytes("UTF-8");
            // 设置文件长度
            conn.setRequestProperty("Content-Length", String.valueOf(data.length));

            // 设置文件类型:
            conn.setRequestProperty("contentType", "application/json");

            // 开始连接请求
            conn.connect();
            OutputStream  out = conn.getOutputStream();
            // 写入请求的字符串
            out.write(data);
            out.flush();
            out.close();

//            System.out.println(conn.getResponseCode());
            // 请求返回的状态
            if (conn.getResponseCode() == 200) {
//                System.out.println("连接成功");
                // 请求返回的数据
                logger.info("httpPostJson   连接成功 ==== ");
                InputStream in = conn.getInputStream();
                String a = null;
                try {
                    byte[] data1 = new byte[in.available()];
                    in.read(data1);
                    // 转成字符串
                    a = new String(data1,"utf-8");
                    System.out.println(a);
                    return a;
                } catch (Exception e1) {
//                    e1.printStackTrace();
                    throw new RuntimeException(e1);
                }
            } else {
                logger.info("httpPostJson   连接failed ==== ");
                return  "failed";
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 发送get请求
     * @param url    路径
     * @return
     */
    public static String httpGet(String url){
        //get请求返回结果
        String strResult = null;
        try {
            DefaultHttpClient client = new DefaultHttpClient();
            //发送get请求
            HttpGet request = new HttpGet(url);
            HttpResponse response = client.execute(request);

            /**请求发送成功，并得到响应**/
            if (response.getStatusLine().getStatusCode() == org.apache.http.HttpStatus.SC_OK) {
                /**读取服务器返回过来的json字符串数据**/
                strResult = EntityUtils.toString(response.getEntity());
                logger.info("httpGet url=="+url+" strResult== " + strResult);
            } else {
                logger.error("get请求提交失败:" + url);
            }
        } catch (IOException e) {
            logger.error("get请求提交失败:" + url, e);
        }
        return strResult;
    }

    public static InputStream httpGetForImage(String url){
        InputStream inputStream = null;
        HttpURLConnection httpURLConnection = null;
        try {
            URL uRL = new URL(url);//创建的URL
            if (uRL!=null) {
                httpURLConnection = (HttpURLConnection) uRL.openConnection();//打开链接
                httpURLConnection.setConnectTimeout(3000);//设置网络链接超时时间，3秒，链接失败后重新链接
                httpURLConnection.setDoInput(true);//打开输入流
                httpURLConnection.setRequestMethod("GET");//表示本次Http请求是GET方式
                int responseCode = httpURLConnection.getResponseCode();//获取返回码
                if (responseCode == 200) {//成功为200
                    //从服务器获得一个输入流
                    inputStream = httpURLConnection.getInputStream();
                }
            }
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return inputStream;
    }
}