java实现网站微信扫码支付

/**

  * 保存订单，并生成二维码所需的codeurl

  *

  * @param request

  * @param response

  * @param notifyurlbuf

  * @param order

  * @return

  * @throws exception

  */

  @override

  public map<string, string> getwechatorderinfo(string ip, cuser user, string notifyurl, order order) throws exception {

  map<string, string> resultmap = new hashmap<string, string>();

  // 生成并保存订单

  order.setuserid(user.getid());

  // 支付方式 0：银联 1：支付宝 2：网上银行 3：微信 4：其他

  order.setpaytype( "3" );

  // 生成订单号

  order.setorderno(ordernogenerator.getorderno());

  // 订单类型 1：消费 2：退款

  order.setordertype( "1" );

  // 订单创建时间

  order.setcreatetime( new date());

  // 订单更新时间

  order.setupdatetime( new date());

  // 订单状态 0: 交易中 1：完成 2：已取消

  order.setorderstatus( "0" );

  // 付款状态 0：失败 1:成功 2、待付款

  order.setpaystatus( "2" );

  // 设置订单失效时间

  calendar calendar = calendar.getinstance();

  calendar.add(calendar.hour, 2 );

  order.setexpiretime(calendar.gettime());

  integer orderid = this .balancedao.saveorder(order);

  map<string, string> paypreidmap = new hashmap<>();

  paypreidmap = wechatutil.getpaypreid(string.valueof(orderid), "体检报告" , notifyurl, ip,

   string.valueof((order.getmoney().multiply( new bigdecimal( 100 )).intvalue())), orderid.tostring());

  string prepayid = paypreidmap.get( "prepay_id" );

  // 更新

  order.setid(orderid);

  order.setprepayid(prepayid);

  order.setcodeurl(paypreidmap.get( "code_url" ));

  this .balancedao.updateorder(order);

  // return wechatutil.qrfromgoogle(order.getcodeurl(), 300, 0);

  resultmap.put( "codeurl" , order.getcodeurl());

  resultmap.put( "orderid" , string.valueof(order.getid()));

  return resultmap;

  }

<xml><return_code><![cdata[success]]></return_code>

<return_msg><![cdata[ok]]></return_msg>

<appid><![cdata[wxaf0b*****8afbf]]></appid>

<mch_id><![cdata[ 1408 **** 02 ]]></mch_id>

<nonce_str><![cdata[zf0vgvdtvycbliwb]]></nonce_str>

<sign><![cdata[a2910f16086211153d747058063b3368]]></sign>

<result_code><![cdata[success]]></result_code>

<prepay_id><![cdata[wx201701191109388037e9a12310276591827]]></prepay_id>

<trade_type><![cdata[ native ]]></trade_type>

<code_url><![cdata[weixin: //wxpay/bizpayurl?pr=1ujornx]]></code_url>

</xml>

/**

   * 保存微信通知结果

   *

   * @param request

   * @param response

   * @return

   * @throws exception

   */

  @override

  public string savewechatnotify(string notifyinfoxml) throws exception {

   map<string, string> noticemap = xmlutil.doxmlparse(notifyinfoxml);

   // 这个其实是订单 的id

   string outtradeno = noticemap.get( "out_trade_no" );

   order order = this .balancedao.getorderbyid(integer.valueof(outtradeno));

   // 如果支付通知信息不为，说明请求已经处理过，直接返回

   if (stringutil.isnotempty(order.getnotifyinfo())) {

    return "success" ;

   }

   string sign = noticemap.get( "sign" );

   noticemap.remove( "sign" );

   // 验签通过

   if (wechatutil.getsignveryfy(noticemap, sign)) {

    // 通信成功此字段是通信标识，非交易标识，交易是否成功需要查看result_code来判断

    if ( "success" .equals(noticemap.get( "return_code" ))) {

     // 交易成功

     if ( "success" .equals(noticemap.get( "result_code" ))) {

      // 商户订单号

      // 订单更新时间

      order.setupdatetime( new date());

      // ------------------------------

      // 处理业务开始

      // ------------------------------

      // 是否交易成功,1:成功0：失败

      // 微信支付成功

      order.setpaystatus( "1" );

      // 订单状态 0: 交易中 1：完成 2：已取消

      order.setorderstatus( "1" );

      // 保存通知信息

      order.setnotifyinfo(notifyinfoxml);

      this .balancedao.updateorder(order);

      // 处理业务完毕

     } else {

      // 错误时，返回结果未签名，记录retcode、retmsg看失败详情。

      logger.info( "查询验证签名失败或业务错误" );

      logger.info( "retcode:" + noticemap.get( "retcode" ) + " retmsg:" + noticemap.get( "retmsg" ));

     }

     return "success" ;

    } else {

     logger.info( "后台调用通信失败" );

    }

    return "success" ;

   } else {

    logger.info( "通知签名验证失败" );

   }

   return null ;

  }

package com.caifu.tencent.common;

import java.io.ioexception;

import java.net.urisyntaxexception;

import java.net.urlencoder;

import java.util.arraylist;

import java.util.collections;

import java.util.hashmap;

import java.util.linkedlist;

import java.util.list;

import java.util.map;

import java.util.random;

import org.apache.commons.httpclient.httpstatus;

import org.apache.http.namevaluepair;

import org.apache.http.client.config.requestconfig;

import org.apache.http.client.methods.closeablehttpresponse;

import org.apache.http.client.methods.httppost;

import org.apache.http.client.utils.uribuilder;

import org.apache.http.entity.stringentity;

import org.apache.http.impl.client.closeablehttpclient;

import org.apache.http.impl.client.httpclients;

import org.apache.http.message.basicnamevaluepair;

import org.apache.http.util.entityutils;

import org.jdom2.jdomexception;

import org.slf4j.logger;

import org.slf4j.loggerfactory;

import com.caifu.login.utils.xmlutil;

public class wechatutil {

  private static logger logger = loggerfactory.getlogger(wechatutil. class );

  public static final string tag = "wechat.util" ;

  private static final int timeout = 5000 ;

  public static byte [] httppost(string url, string entity) throws urisyntaxexception, ioexception {

   if (url == null || url.length() == 0 ) {

    logger.info(tag, "httppost, url is null" );

    return null ;

   }

   closeablehttpclient httpclient = httpclients.createdefault();

   uribuilder uribuilder = new uribuilder(url);

   httppost httppost = new httppost(uribuilder.build());

   requestconfig requestconfig = requestconfig.custom().setsockettimeout(timeout).setconnectionrequesttimeout(timeout).setconnecttimeout(timeout).build();

   httppost.setconfig(requestconfig);

   // 避免汉字乱码导致请求失败，

   httppost.setentity( new stringentity(entity, "utf-8" ));

   closeablehttpresponse resp = null ;

   try {

    resp = httpclient.execute(httppost);

    if (resp.getstatusline().getstatuscode() != httpstatus.sc_ok) {

     logger.info(tag, "httpget fail, status code = " + resp.getstatusline().getstatuscode());

     return null ;

    }

    return entityutils.tobytearray(resp.getentity());

   } catch (exception e) {

    logger.info(tag, "httppost exception, e = " + e.getmessage());

    e.printstacktrace();

    return null ;

   } finally {

    if (httpclient != null ) {

     httpclient.close();

    }

    if (resp != null ) {

     resp.close();

    }

   }

  }

  /**

   * 把数组所有元素排序，并按照[参数=参数值]的模式用[&]字符拼接成字符串

   *

   * @param params

   *   需要排序并参与字符拼接的参数组

   * @return 拼接后字符串

   */

  public static string createlinkstring(map<string, string> params) {

   list<string> keys = new arraylist<string>(params.keyset());

   collections.sort(keys);

   string prestr = "" ;

   for ( int i = 0 ; i < keys.size(); i++) {

    string key = keys.get(i);

    string value = params.get(key);

    if (i == keys.size() - 1 ) { // 拼接时，不包括最后一个&字符

     prestr = prestr + key + "=" + value;

    } else {

     prestr = prestr + key + "=" + value + "&" ;

    }

   }

   return prestr;

  }

  /**

   * 根据反馈回来的信息，生成签名结果

   *

   * @param params

   *   通知返回来的参数数组

   * @param sign

   *   比对的签名结果

   * @return 生成的签名结果

   */

  public static boolean getsignveryfy(map<string, string> params, string sign) {

   // 过滤空值、sign与sign_type参数

   // map<string, string> sparanew = alipaycore.parafilter(params);

   // 获取待签名字符串

   string presignstr = createlinkstring(params);

   presignstr += "&key=" + configure.getkey();

   // 获得签名验证结果

   string resultsign = md5.md5encode(presignstr).touppercase();

   // string resultsign = md5util.md5encode(presignstr.tostring(),

   // "utf-8").tolowercase();

   if (sign.equals(resultsign)) {

    return true ;

   } else {

    return false ;

   }

  }

  /**

   * 装配xml,生成请求prepayid所需参数

   *

   * @param params

   * @return

   */

  public static string toxml(list<namevaluepair> params) {

   stringbuilder sb = new stringbuilder();

   sb.append( "<xml>" );

   for ( int i = 0 ; i < params.size(); i++) {

    sb.append( "<" + params.get(i).getname() + ">" );

    sb.append(params.get(i).getvalue());

    sb.append( "</" + params.get(i).getname() + ">" );

   }

   sb.append( "</xml>" );

   return sb.tostring();

  }

  /**

   * 生成签名

   */

  public static string genpackagesign(list<namevaluepair> params) {

   stringbuilder sb = new stringbuilder();

   for ( int i = 0 ; i < params.size(); i++) {

    sb.append(params.get(i).getname());

    sb.append( '=' );

    sb.append(params.get(i).getvalue());

    sb.append( '&' );

   }

   sb.append( "key=" );

   sb.append(configure.getkey());

   string packagesign = md5.md5encode(sb.tostring());

   return packagesign;

  }

  /**

   *

   * @param goodorderno

   * @param body

   * @param noticeurl

   * @param ip

   * @param totalfee

   * @return

   */

  public static string genproductargs(string goodorderno, string body, string noticeurl, string ip, string totalfee, string productid) {

   stringbuffer xml = new stringbuffer();

   try {

    string noncestr = getnoncestr();

    xml.append( "</xml>" );

    list<namevaluepair> packageparams = new linkedlist<namevaluepair>();

    packageparams.add( new basicnamevaluepair( "appid" , configure.getappid()));

    packageparams.add( new basicnamevaluepair( "body" , body));

    packageparams.add( new basicnamevaluepair( "mch_id" , configure.getmchid()));

    packageparams.add( new basicnamevaluepair( "nonce_str" , noncestr));

    packageparams.add( new basicnamevaluepair( "notify_url" , noticeurl));

    packageparams.add( new basicnamevaluepair( "out_trade_no" , goodorderno));

    packageparams.add( new basicnamevaluepair( "product_id" , productid));

    packageparams.add( new basicnamevaluepair( "spbill_create_ip" , ip));

    packageparams.add( new basicnamevaluepair( "total_fee" , totalfee));

    packageparams.add( new basicnamevaluepair( "trade_type" , "native" ));

    string sign = genpackagesign(packageparams);

    packageparams.add( new basicnamevaluepair( "sign" , sign));

    string xmlstring = toxml(packageparams);

    return xmlstring;

   } catch (exception e) {

    logger.info( "genproductargs fail, ex = " + e.getmessage());

    return null ;

   }

  }

  /**

   * 生成支付签名

   *

   * @param params

   * @return

   */

  public static string genappsign(list<namevaluepair> params) {

   stringbuilder sb = new stringbuilder();

   for ( int i = 0 ; i < params.size(); i++) {

    sb.append(params.get(i).getname());

    sb.append( '=' );

    sb.append(params.get(i).getvalue());

    sb.append( '&' );

   }

   sb.append( "key=" );

   sb.append(configure.getkey());

   string appsign = md5.md5encode(sb.tostring()).touppercase();

   logger.info( "orion" , appsign);

   return appsign;

  }

  /**

   * 生成调用微信支付所需参数

   *

   * @param prepayid

   * @return

   */

  public static map<string, string> genpayreq(string prepayid) {

   map<string, string> resultmap = new hashmap<string, string>();

   string timestamp = gettimestamp();

   string noncestr = getnoncestr();

   list<namevaluepair> signparams = new linkedlist<namevaluepair>();

   signparams.add( new basicnamevaluepair( "appid" , configure.getappid()));

   signparams.add( new basicnamevaluepair( "noncestr" , noncestr));

   signparams.add( new basicnamevaluepair( "package" , "sign=wxpay" ));

   signparams.add( new basicnamevaluepair( "partnerid" , configure.getmchid()));

   signparams.add( new basicnamevaluepair( "prepayid" , prepayid));

   signparams.add( new basicnamevaluepair( "timestamp" , timestamp));

   string sign = genappsign(signparams);

   resultmap.put( "appid" , configure.getappid());

   resultmap.put( "noncestr" , noncestr);

   resultmap.put( "packagevalue" , "sign=wxpay" );

   resultmap.put( "partnerid" , configure.getmchid());

   resultmap.put( "prepayid" , prepayid);

   resultmap.put( "timestamp" , timestamp);

   resultmap.put( "sign" , sign);

   return resultmap;

  }

  /**

   * 微信支付生成预支付订单

   *

   * @throws ioexception

   * @throws jdomexception

   */

  public static map<string, string> getpaypreid(string goodorderno, string body, string noticeurl, string ip, string totalfee, string productid) throws exception {

   string paramsxml = genproductargs(goodorderno, body, noticeurl, ip, totalfee, productid);

   logger.info( "orion" , paramsxml);

   byte [] buf = wechatutil.httppost(configure.unifiedorder_api, paramsxml);

   string contentxml = new string(buf);

   map<string, string> resultmap = xmlutil.doxmlparse(contentxml);

   return resultmap;

  }

  public static string getnoncestr() {

   random random = new random();

   return md5.md5encode(string.valueof(random.nextint( 10000 )));

  }

  public static string gettimestamp() {

   return string.valueof(system.currenttimemillis() / 1000 );

  }

  /**

   * 生成支付二维码

   * @param request

   * @param response

   * @param width

   * @param height

   * @param text 微信生成预定id时，返回的codeurl

   */

  public static void getqrcode(httpservletrequest request, httpservletresponse response, integer width, integer height, string text) {

   if (width == null ) {

    width = 300 ;

   }

   if (height == null ) {

    height = 300 ;

   }

   string format = "jpg" ;

   hashtable hints = new hashtable();

   hints.put(encodehinttype.character_set, "utf-8" );

   bitmatrix bitmatrix;

   try {

    bitmatrix = new multiformatwriter().encode(text, barcodeformat.qr_code, width, height, hints);

    matrixtoimagewriter.writetostream(bitmatrix, format, response.getoutputstream());

   } catch (writerexception e) {

    e.printstacktrace();

   } catch (ioexception e) {

    // todo auto-generated catch block

    e.printstacktrace();

   }

  }

}

<!-- google zxing 二维码jar begin -->

   <dependency>

    <groupid>com.google.zxing</groupid>

    <artifactid>core</artifactid>

    <version> 3.3 . 0 </version>

   </dependency>

   <dependency>

    <groupid>com.google.zxing</groupid>

    <artifactid>javase</artifactid>

    <version> 3.3 . 0 </version>

   </dependency>

<!-- google zxing 二维码jar begin -->

package com.caifu.tencent.common;

/**

  * user: rizenguo

  * date: 2014/10/29

  * time: 14:40

  * 这里放置各种配置数据

  */

public class configure {

//这个就是自己要保管好的私有key了（切记只能放在自己的后台代码里，不能放在任何可能被看到源代码的客户端程序中）

  // 每次自己post数据给api的时候都要用这个key来对所有字段进行签名，生成的签名会放在sign这个字段，api收到post数据的时候也会用同样的签名算法对post过来的数据进行签名和验证

  // 收到api的返回的时候也要用这个key来对返回的数据算下签名，跟api的sign数据进行比较，如果值不一致，有可能数据被第三方给篡改

  private static string key = "a6gb0dy4dsfdssupcpsdfdshkscdqcr3exs" ;

  private static string appsecret= "7584sdfdsfe4f26fadsfsdfs56f10728a" ;

  //微信分配的公众号id（开通公众号之后可以获取到）

  private static string appid = "wxaf0b86sdfsdf8afbf" ;

  //微信支付分配的商户号id（开通公众号的微信支付功能之后可以获取到）

  private static string mchid = "14012313702" ;

  //受理模式下给子商户分配的子商户号

  private static string submchid = "" ;

  //https证书的本地路径

  private static string certlocalpath = "" ;

  //https证书密码，默认密码等于商户号mchid

  private static string certpassword = "" ;

  //是否使用异步线程的方式来上报api测速，默认为异步模式

  private static boolean usethreadtodoreport = true ;

  //机器ip

  private static string ip = "" ;

  //以下是几个api的路径：

  //1）被扫支付api

  public static string unifiedorder_api = "https://api.mch.weixin.qq.com/pay/unifiedorder" ;

  public static string pay_api = "https://api.mch.weixin.qq.com/pay/micropay" ;

  //2）被扫支付查询api

  public static string pay_query_api = "https://api.mch.weixin.qq.d/pay/orderquery" ;

  //3）退款api

  public static string refund_api = "https://api.mch.weixin.qq.com/secapi/pay/refund" ;

  //4）退款查询api

  public static string refund_query_api = "https://api.mch.weixin.qq.com/pay/refundquery" ;

  //5）撤销api

  public static string reverse_api = "https://api.mch.weixin.qq.com/secapi/pay/reverse" ;

  //6）下载对账单api

  public static string download_bill_api = "https://api.mch.weixin.qq.com/pay/downloadbill" ;

  //7) 统计上报api

  public static string report_api = "https://api.mch.weixin.qq.com/payitil/report" ;

  public static boolean isusethreadtodoreport() {

   return usethreadtodoreport;

  }

  public static void setusethreadtodoreport( boolean usethreadtodoreport) {

   configure.usethreadtodoreport = usethreadtodoreport;

  }

  public static string httpsrequestclassname = "com.tencent.common.httpsrequest" ;

  public static void setkey(string key) {

   configure.key = key;

  }

  public static void setappid(string appid) {

   configure.appid = appid;

  }

  public static void setmchid(string mchid) {

   configure.mchid = mchid;

  }

  public static void setsubmchid(string submchid) {

   configure.submchid = submchid;

  }

  public static void setcertlocalpath(string certlocalpath) {

   configure.certlocalpath = certlocalpath;

  }

  public static void setcertpassword(string certpassword) {

   configure.certpassword = certpassword;

  }

  public static void setip(string ip) {

   configure.ip = ip;

  }

  public static string getkey(){

   return key;

  }

  public static string getappid(){

   return appid;

  }

  public static string getmchid(){

   return mchid;

  }

  public static string getsubmchid(){

   return submchid;

  }

  public static string getcertlocalpath(){

   return certlocalpath;

  }

  public static string getcertpassword(){

   return certpassword;

  }

  public static string getip(){

   return ip;

  }

  public static void sethttpsrequestclassname(string name){

   httpsrequestclassname = name;

  }

}

package com.caifu.login.utils;

import java.io.bytearrayinputstream;

import java.io.ioexception;

import java.io.inputstream;

import java.util.hashmap;

import java.util.iterator;

import java.util.list;

import java.util.map;

import javax.servlet.http.httpservletrequest;

import org.dom4j.io.saxreader;

import org.jdom2.document;

import org.jdom2.element;

import org.jdom2.jdomexception;

import org.jdom2.input.saxbuilder;

/**

  * xml工具类

  *

  * @author miklchen

  *

  */

public class xmlutil {

  /**

   * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。

   *

   * @param strxml

   * @return

   * @throws jdomexception

   * @throws ioexception

   */

  public static map doxmlparse(string strxml) throws jdomexception, ioexception {

   strxml = strxml.replacefirst( "encoding=\".*\"" , "encoding=\"utf-8\"" );

   if ( null == strxml || "" .equals(strxml)) {

    return null ;

   }

   map m = new hashmap();

   inputstream in = new bytearrayinputstream(strxml.getbytes( "utf-8" ));

   saxbuilder builder = new saxbuilder();

   document doc = builder.build(in);

   element root = doc.getrootelement();

   list list = root.getchildren();

   iterator it = list.iterator();

   while (it.hasnext()) {

    element e = (element) it.next();

    string k = e.getname();

    string v = "" ;

    list children = e.getchildren();

    if (children.isempty()) {

     v = e.gettextnormalize();

    } else {

     v = xmlutil.getchildrentext(children);

    }

    m.put(k, v);

   }

   // 关闭流

   in.close();

   return m;

  }

  /**

   * 获取子结点的xml

   *

   * @param children

   * @return string

   */

  public static string getchildrentext(list children) {

   stringbuffer sb = new stringbuffer();

   if (!children.isempty()) {

    iterator it = children.iterator();

    while (it.hasnext()) {

     element e = (element) it.next();

     string name = e.getname();

     string value = e.gettextnormalize();

     list list = e.getchildren();

     sb.append( "<" + name + ">" );

     if (!list.isempty()) {

      sb.append(xmlutil.getchildrentext(list));

     }

     sb.append(value);

     sb.append( "</" + name + ">" );

    }

   }

   return sb.tostring();

  }

  /**

   * 将requestxml通知结果转出啊成map

   * @param request

   * @return

   * @throws exception

   */

  public static map<string, string> parsexml(httpservletrequest request) throws exception {

   // 解析结果存储在hashmap

   map<string, string> map = new hashmap<string, string>();

   inputstream inputstream = request.getinputstream();

   // 读取输入流

   saxreader reader = new saxreader();

   org.dom4j.document document = reader.read(inputstream);

   // 得到xml根元素

   org.dom4j.element root = document.getrootelement();

   // 得到根元素的所有子节点

   list<org.dom4j.element> elementlist = root.elements();

   // 遍历所有子节点

   for (org.dom4j.element e : elementlist)

    map.put(e.getname(), e.gettext());

   // 释放资源

   inputstream.close();

   inputstream = null ;

   return map;

  }

}

var f;

  /* 定时任务方法，异步请求去查询订单是否支付*/

  function getorder() {

   var orderid = $( '#orderid' ).val();

   if (orderid != '' ) {

    $.ajax({

     url : "${base}/balance/auth/ispay?orderid=" + orderid,

     type : "get" ,

     async : false ,

     success : function(d) {

      if (d == "1" ) {

       //当获取到微信支付结果时，关闭二维码div

       $( ".weixinpay" ).css( "display" , "none" );

       $( "#zhichutankuang" ).css( "display" , "block" );

       ////当获取到微信支付结果时，关闭定时任务

       clearinterval(f);

       // layer.alert('付款成功', {

       // skin : 'layui-layer-molv', // 样式类名

       // closebtn : 0

       // }, function() {

       // location.href = "${base}/balance/auth/presentation?tjno=" + $("#tjno").val();

       // });

      }

     }

    });

   }

  }

  //异步请求获取生成二维码的url

  $( ".paylast" ).click(function() {

   var $paytype = $( 'input:radio:checked' ).val();

   var $money = $( "#money" ).val();

   var $tjreporttype = $( "#tjreporttype" ).val();

   var $tjno = $( "#tjno" ).val();

   $.ajax({

    url : "${base}/balance/auth/wechatinfo" ,

    type : "post" ,

    async : false ,

    data : {

     paytype : $paytype,

     money : $money,

     tjno : $tjno,

     tjreporttype : $tjreporttype

    },

    success : function(d) {

     if (d.resultcode == "1000" ) {

      //当请求成功时，设置二维码图片地址

      $( "#codeimg" ).attr( 'src' , d.obj);

      $( "#orderid" ).val(d.attributes.orderid);

      ////当请求成功时，启动定时任务,每隔3秒去后台查询一次订单是否成功

      f = setinterval(getorder, 3000 );

      // getorder(true);

     }

    }

   });

   $( ".selpaycon" ).css( "display" , "none" );

   $( ".weixinpay" ).css( "display" , "block" );

  });