全网最全app支付宝支付和微信支付hbuilder（前端+后端）

刚毕业，实习一家私人公司，做app，一头雾水，由于是一个电商的软件。所以支付的环节避免不了，没有一点经验，看文档，百度，用尽各种办法，总之不成功就很烦躁.......认真做还是很简单的，百度也发现好多DEMO不全，我这总结了一份很全的DEMO

废话不多说，直接上代码

支付宝支付：

申请账号，APPID，私钥，秘钥这些的就不用说了，代码部分：

 

Servlet:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        request.setCharacterEncoding("utf-8");//编码格式
        response.setContentType("text/html;charset=utf-8");
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "GET,POST");
     
        //String aa = request.getParameter("Total");//前端传过来的价格参数
        Date time  = new Date();
        SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");//时间
        String date = df.format(time);
        String orderStr="";  //业务逻辑开始                                                                      
         try { 
                Map<String, String> orderMap = new LinkedHashMap<String, String>(); // 订单实体
                Map<String, String> bizModel = new LinkedHashMap<String, String>(); // 公共实体
                /****** 2.商品参数封装开始 *****/ // 手机端用
                // 商户订单号，商户网站订单系统中唯一订单号，必填
                orderMap.put("out_trade_no", String.valueOf(UUID.next())+date);
                // 订单名称，必填
                orderMap.put("subject",name);
                // 付款金额，必填
                orderMap.put("total_amount", String.valueOf(0.1));
                // 销售产品码 必填
                orderMap.put("product_code", "QUICK_WAP_PAY");
                /****** --------------- 3.公共参数封装 开始 ------------------------ *****/ // 支付宝用
                // 1.商户appid
                bizModel.put("app_id", AlipayConfig.APPID);
                // 2.请求网关地址
                bizModel.put("method", AlipayConfig.URL);
                // 3.请求格式
                bizModel.put("format", AlipayConfig.FORMAT);
                // 4.回调地址
                bizModel.put("return_url", AlipayConfig.notify_url);
                // 5.私钥
                bizModel.put("private_key", AlipayConfig.private_key);
                // 6.商家id
                bizModel.put("seller_id", AlipayConfig.partner);
                // 7.加密格式
                bizModel.put("sign_type", AlipayConfig.sign_type);
                /****** --------------- 3.公共参数封装 结束 ------------------------ *****/
                // 实例化客户端
                AlipayClient client = new DefaultAlipayClient(AlipayConfig.URL, AlipayConfig.APPID,
                        AlipayConfig.private_key, AlipayConfig.FORMAT, AlipayConfig.input_charset,
                        AlipayConfig.ali_public_key, AlipayConfig.sign_type);
                // 实例化具体API对应的request类,类名称和接口名称对应,当前调用接口名称：alipay.trade.app.pay
                AlipayTradeAppPayRequest ali_request = new AlipayTradeAppPayRequest();
                // SDK已经封装掉了公共参数，这里只需要传入业务参数。以下方法为sdk的model入参方式(model和biz_content同时                 存在的情况下取biz_content)。
                AlipayTradeAppPayModel model = new AlipayTradeAppPayModel();
                // model.setPassbackParams(URLEncoder.encode((String)orderMap.get("body").toString()));;
                // //描述信息 添加附加数据
                // model.setBody(orderMap.get("body")); //商品信息
                model.setSubject(orderMap.get("subject")); // 商品名称
                model.setOutTradeNo(orderMap.get("out_trade_no")); // 商户订单号(自动生成)
                
                model.setTotalAmount(orderMap.get("total_amount")); // 支付金额
                model.setProductCode(orderMap.get("product_code")); // 销售产品码
                
                ali_request.setBizModel(model);
                ali_request.setNotifyUrl(AlipayConfig.notify_url); // 回调地址一定要写外网能访问的域名，不能带参数
                AlipayTradeAppPayResponse responses = client.sdkExecute(ali_request);
                 orderStr = responses.getBody();
                System.err.println(orderStr); // 就是orderString 可以直接给客户端请求，无需再做处理
                SimpleDateFormat df1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
                
                //System.out.println("name="+name);
                WineshopDao dao1 = new WineshopDao();//以下是我自己生成预支付订单的操作，大家可以写下自己的逻辑
                int Wineshop_ID = dao1.findUserByID2(name);
                System.out.println("Wineshop_id="+Wineshop_ID);
                int number1 = 0;
                
                List<Wineshop> list4 = dao1.findUserByID(Wineshop_ID);
                for(Wineshop wineshop : list4){
                    String wineshop_Address = wineshop.getWineshop_Address();
                    String wineshop_Telephone = wineshop.getWineshop_Telephone();
                IndentDao dao3 = new IndentDao();
                Indent indent = new Indent();
                indent.setIndent_Time(df1.format(new Date()));
                indent.setIndent_Distribution_Time("");
                indent.setWineshop_ID(Wineshop_ID);
                indent.setWineshop_Address(wineshop_Address);
                indent.setIndent_Fare("");
                indent.setIndent_Check_Type("");
                indent.setWineshop_Telephone(wineshop_Telephone);
                indent.setIndent_Status("正在支付");
                indent.setIndent_Type("支付宝支付");
                indent.setIndent_remark(Indent_Remark);
                indent.setIndent_TuiKuan("");
                indent.setIndent_Why("");
                indent.setIndent_PayID(orderMap.get("out_trade_no"));
                System.out.println("pp"+orderMap.get("out_trade_no"));
                indent.setIndent_PayType("预支付");
                dao3.add1000(indent);
                  int Indent_ID = dao3.findID();
                  TotalDao dao5 = new TotalDao();
                  Total total = new Total();
                  total.setIndent_ID(Indent_ID);
                  total.setTotal(Float.parseFloat("0.1"));//金额
                  total.setFare(Fare);
                  total.setGreens(Greens_Price);
                  dao5.add(total);
                  FZDao dao7 = new FZDao();
                  FZ fz = new FZ();
                  fz.setIndent_ID(Indent_ID);
                  fz.setCG_Name(null);
                  fz.setFJ_Name(null);
                  fz.setCourier_Name(null);
                  fz.setXD_Time(df1.format(new Date()));
                  fz.setCG_Time(null);
                  fz.setFJ_Time(null);
                  fz.setPS_Time(null);
                  dao7.add(fz);
                  GreensDao dao10 = new GreensDao();
                  CartDao dao11 = new CartDao();
                  int cart_ID = 0;
                  List<Cart> list11 = dao11.findUserByID(Wineshop_ID);
                  for(Cart cart : list11){
                      cart_ID = cart.getCart_ID();
                      int greens_ID = cart.getGreens_ID();
                      int number = cart.getNumber();
                      String order_Remark = cart.getRemark();
                      List<Greens> list10 = dao10.findUserByID(greens_ID);
                      for(Greens greens :list10){
                          String greens_Name = greens.getGreens_Name();
                          String greens_Unit = greens.getGreens_Unit();
                          
                 Order order = new Order();
                 OrderDao dao9 = new OrderDao(); 
                 order.setIndent_ID(Indent_ID);
                 order.setGreens_ID(greens_ID);
                 order.setNumber(number);
                 order.setOrder_Requirement("");
                 order.setIndent_Status("正在处理");
                 order.setOrder_Remark(order_Remark);
                 order.setGreens_Name(greens_Name);
                 order.setGreens_Unit(greens_Unit);
                 order.setIndent_Time(df1.format(new Date()));
                 order.setWineshop_ID(Wineshop_ID);
                 dao9.add(order);
                 
                 
                  }
                    List<Greens> list12 = dao10.findUserByID(greens_ID);
                    System.out.println("list12="+list12);
                    for(Greens green : list12){
                        int Number = number1-number;
                        green.setGreens_Number(Number);
                        green.setGreens_ID(greens_ID);
                        dao10.update1(green);
                    }
                  }  
                  
                    dao11.delete1(Wineshop_ID);//预支付订单生成完毕，订单生成的有点长......
                  }
        } catch (Exception e) {
            e.printStackTrace();
        }
         PrintWriter out = response.getWriter();
         out.print(orderStr);//orderStr返回给前台就行了
         out.flush();
         out.close();

    }

}

配置文件类：

public class AlipayConfig {

    public static String partner = "2088331674573481";

     // 6.请求网关地址
        public static String URL = "https://openapi.alipay.com/gateway.do";    

        public static String service = "mobile.securitypay.pay";//固定值

        public static String seller_id = "*******@163.com";
        //私钥
        public static String private_key = "";
        // 商户的公钥钥
        public static String public_key ="";
        // 支付宝的公钥，无需修改该值（不要删除也不要修改，在接收通知的时候需要进行签名认证）
        public static String ali_public_key="";

        // 字符编码格式 目前支持 gbk 或 utf-8
        public static String input_charset = "utf-8";
        // 签名方式 不需修改
        public static String sign_type = "RSA2";

        //APPID
        public static String APPID = "2018121862569391";    
       //支付宝回调地址 
        public static String notify_url = "******************";//这里写入自己的回调地址，一定要外网能访问，不能是IP地址，当初害惨了

        // 8.返回格式
       public static String FORMAT = "json";

}

 

回调：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "GET,POST");
         System.out.println("支付宝验证异步通知信息开始");
         //Response resp = this.getReponse();
         try {
         //----------------请求参数------------------//
              

               //获取支付宝POST过来反馈信息
               Map<String,String> params = new HashMap<String,String>();
               Map requestParams = request.getParameterMap();
               for (Iterator iter = requestParams.keySet().iterator(); iter.hasNext();) {
                   String name = (String) iter.next();
                   String[] values = (String[]) requestParams.get(name);
                   String valueStr = "";
                   for (int i = 0; i < values.length; i++) {
                       valueStr = (i == values.length - 1) ? valueStr + values[i]
                                   : valueStr + values[i] + ",";
                     }
                   //乱码解决，这段代码在出现乱码时使用。
                     //valueStr = new String(valueStr.getBytes("ISO-8859-1"), "utf-8");
                     params.put(name, valueStr);
               }
         //切记alipaypublickey是支付宝的公钥，请去open.alipay.com对应应用下查看。
         //boolean AlipaySignature.rsaCheckV1(Map<String, String> params, String publicKey, String charset, String sign_type)
                 boolean flag = AlipaySignature.rsaCheckV1(params, AlipayConfig.ali_public_key, "utf-8","RSA2");
               System.out.println("flag"+flag);
               if(flag) {
                   System.out.println("1");
                   String tradeStatus = request.getParameter("trade_status");//获取上个页面传过来的交易状态
                   String Indent_PayID = params.get("out_trade_no");//订单号
                   System.out.println(tradeStatus+"TradeStatus");//这里一定要判断传过来的订单状态，是否真的钱到了账号
                   if(tradeStatus.equals("TRADE_FINISHED")||tradeStatus.equals("TRADE_SUCCESS")) {
                       System.out.println("Indent_PayID"+Indent_PayID);
                       IndentDao dao = new IndentDao();//修改自己的订单状态从预支付到支付成功
                         Indent indent = new Indent();
                         indent.setIndent_PayType("支付成功");
                         indent.setIndent_Status("正在处理");
                         indent.setIndent_PayID(Indent_PayID);
                         dao.update100(indent);
                         System.out.println("订单更新成功");
                         
                         
                   }
                   PrintWriter out = response.getWriter();
                       out.print("success");//最后返回给支付宝服务器success，不然支付宝会一直给你异步通知
                  
                     /*int Wineshop_ID = dao.Select1(Indent_PayID);
                     CartDao dao1 = new CartDao();
                     dao1.delete1(Wineshop_ID);*/
                     
                      
                     }else {
                         
                        
                         PrintWriter out = response.getWriter();
                             out.print("fail");
                         System.out.println("订单更新失败饿了");
                          
                     }
               
               System.out.println("支付宝验证异步通知信息结束正常");
              
               //return success();
         } catch (AlipayApiException e) {
               System.out.println("支付宝验证异步通知信息结束" + e.getMessage());
               //return resp.failure(e.getMessage());
         }

    
        
    }

前端HTML：

 <button id="xxx" type="button" class="mui-btn  mui-btn-block mui-icon iconfont icon-zhifubaozhifu " style="color: #00a0e9; font-size: 20px;padding: 8;margin: 8;border:none;">
                    <sapn style="color: black;font-size:18px;">支付宝支付</sapn>
                </button>

js：

var aliChannel = null; // 支付宝支付

        var channel = null; 

        // 获取支付通道
                plus.payment.getChannels(function(channels){
                    aliChannel=channels[0];
                },function(e){
                 alert("获取支付通道失败："+e.message);

                }); 
                plus.nativeUI.showWaiting();
                    mui.post(url() + "/Alipay1Servlet?total=" + dd + "&Indent_Remark=" + pppp + "&SC=" + SC + "&Fare=" + Far+                    "&Wineshop_Name=" + zz, function(data) {//ajax中传入自己的参数传到后台生成订单
                        plus.nativeUI.closeWaiting();
                        channel = aliChannel;
                        console.log(data);
                        if (data) {
                            plus.payment.request(channel, data, function(result) {
                                console.log(JSON.stringify(result));
                                console.log("成功");
                                window.location.href="Success.html?id="+dd+"&Fare="+Far+"&SC="+SC;
                               // mui.alert("付费成功");
                                //window.location.href="buy.html";
                            } ,function(e) {
                                console.log(JSON.stringify(e));
                                console.log("失败");
                                //alert(JSON.stringify(e)); 
                               // mui.alert("付费失败");
                            } );
                            console.log("111");
                        } else {
                            console.log("222");
                           // plus.nativeUI.alert("支付失败");
                        }

//
                    });

                                //mui.alert("购买成功");
                            //
                            }
                           
                            
                            //mui.alert("success！");
                            /*var h = plus.webview.getWebviewById("tab-webview-subpagehome.html"); 
                            plus.webview.show( h );
                            */
                            
                             
                            //mui.currentWebview.close(); //关闭当前页面
                    
                            

                            }, 
                            error: function(data){
                                mui.alert("数据获取失败！");
                                //plus.ui.toast();
                                //return false;
                            }
                    });

 

 

支付宝支付

到这就结束了，填入自己的参数后，基本上复制到本地就能调起支付了

 

 

微信支付：

微信支付官方的文档写的比起阿里差的不是一点两点，总之就是让小白很难理解..........

Servlet：

public void doPost(HttpServletRequest request2, HttpServletResponse response) throws IOException{

        request2.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=utf-8");
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "GET,POST");
        
//        private static final Logger logger = LoggerFactory.getLogger(WinxinPay.class); 
        
//            JsonBack jsonBack = null ;
//            int x = Integer.parseInt(tradeMoney);
            //float a = Float.parseFloat(request2.getParameter("total"));
            //int x=(int) (Float.valueOf(a)*100);
            //int cc = x*100;// 微信以分为单位，如果数据库里面的价格没扩大100的话这里要乘以100
            //int cc = x;
        
        //float a = Float.parseFloat(request2.getParameter("total"));
        //System.out.println(a);
        String name = request2.getParameter("Wineshop_UserName");
        int b = (int) (Float.valueOf(0.1+"")*100);
            String total_fee = b+"" ;
            
            String body = "蔬菜购买微信支付系统";  //商品描述
            String mch_id = "********"; //微信支付商户号 
            String currTime = getCurrTime();
            String strTime = currTime.substring(8, currTime.length());
            String strRandom = buildRandom(4) + "";
            String nonce_str = strTime + strRandom;
            String notify_url = "************************";// 回调地址 必须能直接访问 不是二级域名也可以
            String out_trade_no = String.valueOf(UUID.next()); // 订单号
            String timestamp = getTimeStamp();
            SortedMap<Object, Object> packageParams = new TreeMap<Object, Object>();
            packageParams.put("appid", "****************");  // 微信开发平台应用ID 下面参数都不完整  需要写入自己的参数
            packageParams.put("mch_id", mch_id);
            packageParams.put("nonce_str", nonce_str);
            packageParams.put("body", body);//商品标题
            packageParams.put("out_trade_no", out_trade_no);// 商户订单号
            packageParams.put("total_fee", total_fee);// 总金额
//            String addr = AddressUtils.getIpAddr(request);
            String addr = "192.168.1.105";
            packageParams.put("spbill_create_ip", addr);// 发起人IP地址
            packageParams.put("notify_url", notify_url);// 回调地址
            packageParams.put("trade_type", "APP");// 交易类型
            packageParams.put("time_start", timestamp);
            String sign = createSign("UTF-8", packageParams, "********************"); //应用对应的密钥
            packageParams.put("sign", sign);// 签名
            String requestXML = getRequestXml(packageParams);
            String resXml = postData("https://api.mch.weixin.qq.com/pay/unifiedorder", requestXML);
            Map map;
            try {
                map = doXMLParse(resXml);
                String returnCode = (String) map.get("return_code");
                String returnMsg = (String) map.get("return_msg");
                if ("SUCCESS".equals(returnCode)) {
                    String resultCode = (String) map.get("result_code");
                    String prepay_id = (String) map.get("prepay_id");
                    String noncestr = (String) map.get("nonce_str");
                    if ("SUCCESS".equals(resultCode)) {
                        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
                        System.out.println("name="+name);
                        WineshopDao dao1 = new WineshopDao();//开始封装自己的订单
                        int Wineshop_ID = dao1.findUserByID2(name);
                        System.out.println("Wineshop_id="+Wineshop_ID);
                        CartDao dao = new CartDao();
                        int number1 = 0;
                        
                        List<Wineshop> list4 = dao1.findUserByID(Wineshop_ID);
                        for(Wineshop wineshop : list4){
                            String wineshop_Address = wineshop.getWineshop_Address();
                            String wineshop_Telephone = wineshop.getWineshop_Telephone();
                        IndentDao dao3 = new IndentDao();
                        Indent indent = new Indent();
                        indent.setIndent_Time(df.format(new Date()));
                        indent.setIndent_Distribution_Time("");
                        indent.setWineshop_ID(Wineshop_ID);
                        indent.setWineshop_Address(wineshop_Address);
                        indent.setIndent_Fare("");
                        indent.setIndent_Check_Type("");
                        indent.setWineshop_Telephone(wineshop_Telephone);
                        indent.setIndent_Status("正在支付");
                        indent.setIndent_Type("微信支付");
                        indent.setIndent_remark("");
                        indent.setIndent_TuiKuan("");
                        indent.setIndent_Why("");
                        indent.setIndent_PayID(out_trade_no);
                        indent.setIndent_PayType("预支付");
                        dao3.add100(indent);
                          int Indent_ID = dao3.findID();
                          TotalDao dao5 = new TotalDao();
                          Total total = new Total();
                          total.setIndent_ID(Indent_ID);
                          total.setTotal(Float.parseFloat(total_fee));
                          total.setFare(0);
                          total.setGreens(0);
                          dao5.add(total);
                          FZDao dao7 = new FZDao();
                          FZ fz = new FZ();
                          fz.setIndent_ID(Indent_ID);
                          fz.setCG_Name(null);
                          fz.setFJ_Name(null);
                          fz.setCourier_Name(null);
                          fz.setXD_Time(df.format(new Date()));
                          fz.setCG_Time(null);
                          fz.setFJ_Time(null);
                          fz.setPS_Time(null);
                          dao7.add(fz);
                          GreensDao dao10 = new GreensDao();
                          CartDao dao11 = new CartDao();
                          int cart_ID = 0;
                          List<Cart> list11 = dao11.findUserByID(Wineshop_ID);
                          for(Cart cart : list11){
                              cart_ID = cart.getCart_ID();
                              int greens_ID = cart.getGreens_ID();
                              int number = cart.getNumber();
                              String order_Remark = cart.getRemark();
                              List<Greens> list10 = dao10.findUserByID(greens_ID);
                              for(Greens greens :list10){
                                  String greens_Name = greens.getGreens_Name();
                                  String greens_Unit = greens.getGreens_Unit();
                                  
                         Order order = new Order();
                         OrderDao dao9 = new OrderDao();
                         order.setIndent_ID(Indent_ID);
                         order.setGreens_ID(greens_ID);
                         order.setNumber(number);
                         order.setOrder_Requirement("");
                         order.setIndent_Status("正在处理");
                         order.setOrder_Remark(order_Remark);
                         order.setGreens_Name(greens_Name);
                         order.setGreens_Unit(greens_Unit);
                         order.setIndent_Time(df.format(new Date()));
                         order.setWineshop_ID(Wineshop_ID);
                         dao9.add(order);
                         
                         
                          }
                            List<Greens> list12 = dao10.findUserByID(greens_ID);
                            System.out.println("list12="+list12);
                            for(Greens green : list12){
                                int Number = number1-number;
                                green.setGreens_Number(Number);
                                green.setGreens_ID(greens_ID);
                                dao10.update1(green);
                            }
                          }  
                          
                            dao11.delete1(Wineshop_ID);
                          }
                        
                        SortedMap<Object, Object> packageParam = new TreeMap<Object, Object>();
                        packageParam.put("appid", "***************"); //微信开发平台应用ID 下面参数都不完整  需要写入自己的参数
                        packageParam.put("partnerid", mch_id);
                        packageParam.put("prepayid", prepay_id);// 商品描述
                        packageParam.put("package", "Sign=WXPay");// 商户订单号
                        packageParam.put("noncestr", noncestr);
                        packageParam.put("timestamp", timestamp);
                        String sign1 = createSign("UTF-8", packageParam, "****************");// 这里是二次签名    //应用对应的密钥
                        // 处理交易订单信息 // 前台要拿到去调起微信支付，如果这个错了的话会在前台报签名错误
                        Map<String, Object> jsonMap = new TreeMap<String, Object>();
                        jsonMap.put("appid", "***************");//微信开发平台应用ID 下面参数都不完整  需要写入自己的参数
                        jsonMap.put("noncestr", noncestr);
                        jsonMap.put("package", "Sign=WXPay");
                        jsonMap.put("partnerid", mch_id);
                        jsonMap.put("prepayid", prepay_id);
                        jsonMap.put("timestamp", timestamp);
                        jsonMap.put("sign", sign1);
                        System.out.println("jsonMap==="+jsonMap);
                        JSONArray json = JSONArray.fromObject(jsonMap);
                        PrintWriter out = response.getWriter();
                        out.print(json);
                        out.flush();
                        out.close();
//                        jsonBack = new JsonBack(true, "success", jsonMap);
                    }
                }
            } catch (JDOMException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
//            return jsonBack;
        }
        
        // 支付回调通知
            public void getnotify(HttpServletRequest request, HttpServletResponse response) throws IOException {
                System.out.println("微信支付回调");
                PrintWriter writer = response.getWriter();
                InputStream inStream = request.getInputStream();
                ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len = 0;
                while ((len = inStream.read(buffer)) != -1) {
                    outSteam.write(buffer, 0, len);
                }
                outSteam.close();
                inStream.close();
                String result = new String(outSteam.toByteArray(), "utf-8");
                System.out.println("微信支付通知结果：" + result);
                Map<String, String> map = null;
                try {
                    /**
                     * 解析微信通知返回的信息
                     */
                    map = doXMLParse(result);
                } catch (JDOMException e) {
                    e.printStackTrace();
                }
                System.out.println("=========:" + result);
                // 若支付成功，则告知微信服务器收到通知
                if (map.get("return_code").equals("SUCCESS")) {
                    if (map.get("result_code").equals("SUCCESS")) {
                        System.out.println("成功支付后获得的订单号："+map.get("out_trade_no"));
                        Map<String,Object> rechargeRecord = null;
//                        Map<String,Object> rechargeRecord = appUserService.getByTradeNo(map.get("out_trade_no"));
                        // 判断通知是否已处理，若已处理，则不予处理
                        if (rechargeRecord.get("pay_time")==null) {
                            Map<String,Object> mapParams = new HashMap<String,Object>();
                            mapParams.put("pay_time", new Date());
                            float balance = Float.valueOf(map.get("total_fee"))/100;
                            mapParams.put("balance", String.valueOf(balance));
                            mapParams.put("out_trade_no", map.get("out_trade_no"));
                            mapParams.put("pay_state", "1");//支付成功状态
//                            appUserService.updateBytradeNo(mapParams);
                            String notifyStr = setXML("SUCCESS", "支付成功");
                            writer.write(notifyStr);
                            writer.flush();
                        }
                    }
                }
            }
        
         /** 
         * 获取当前时间 yyyyMMddHHmmss 
         *  
         * @return String 
         */  
        public static String getCurrTime() {  
            Date now = new Date();  
            SimpleDateFormat outFormat = new SimpleDateFormat("yyyyMMddHHmmss");  
            String s = outFormat.format(now);  
            return s;  
        }
        
        /**
         * 取出一个指定长度大小的随机正整数. 
         * @Author  japhet_jiu
         * @param length
         * @return  int
         * @Date    2017年7月31日
         * 
         */
         public static int buildRandom(int length) {  
             int num = 1;  
             double random = Math.random();  
             if (random < 0.1) {  
                 random = random + 0.1;  
             }  
             for (int i = 0; i < length; i++) {  
                 num = num * 10;  
             }  
             return (int) ((random * num));  
         }
         
         /**
          * 获取时间戳
          * @return
          */
         public static String getTimeStamp() {
             return String.valueOf(System.currentTimeMillis() / 1000);
         }
         
         /**
          * 获取IP地址
          * @Author japhet_jiu
          * @param request
          * @return  String
          * @Date    2017年7月31日
          *
          */
         public static String getIpAddr(HttpServletRequest request)
         {
             String ip = request.getHeader("X-Real-IP");
             if(!StringUtils.isBlank(ip) && !"unknown".equalsIgnoreCase(ip))
                 return ip;
             ip = request.getHeader("X-Forwarded-For");
             if(!StringUtils.isBlank(ip) && !"unknown".equalsIgnoreCase(ip))
             {
                 int index = ip.indexOf(',');
                 if(index != -1)
                    return ip.substring(0, index);
                 else
                     return ip;
             }
             if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
                 ip = request.getHeader("Proxy-Client-IP");
             if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
                 ip = request.getHeader("WL-Proxy-Client-IP");
             if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
                 ip = request.getHeader("HTTP_CLIENT_IP");
             if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
                 ip = request.getHeader("HTTP_X_FORWARDED_FOR");
             if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
                 ip = request.getRemoteAddr();
             if(ip==null||ip!=null&&ip.indexOf("0:0:0:0:0:0:0")!=-1){
                 return "127.0.0.1";
             }
             return ip;
         }
         
         /** 
          * @author japhet_jiu
          * @Description：sign签名 
          * @param characterEncoding 
          *            编码格式 
          * @param parameters 
          *            请求参数 
          * @return 
          */  
         @SuppressWarnings({ "rawtypes"})
         public static String createSign(String characterEncoding, SortedMap<Object, Object> packageParams, String API_KEY) {  
             StringBuffer sb = new StringBuffer();
             Set es = packageParams.entrySet();  
             Iterator it = es.iterator();  
             while (it.hasNext()) {  
                 Map.Entry entry = (Map.Entry) it.next();  
                 String k = (String) entry.getKey();  
                 String v = (String) entry.getValue();  
                 if (null != v && !"".equals(v) && !"sign".equals(k) && !"key".equals(k)) {  
                     sb.append(k + "=" + v + "&");  
                 }  
             }  
             sb.append("key=" + API_KEY);  
             String sign = MD5Encode(sb.toString(), characterEncoding).toUpperCase();  
             return sign;  
         }
         /**
          *  MD5Encode
          * @param origin
          * @param charsetname
          * @return
          */
         public static String MD5Encode(String origin, String charsetname) {
             String resultString = null;
             try {
                 resultString = new String(origin);
                 MessageDigest md = MessageDigest.getInstance("MD5");
                 if (charsetname == null || "".equals(charsetname))
                     resultString = byteArrayToHexString(md.digest(resultString
                             .getBytes()));
                 else
                     resultString = byteArrayToHexString(md.digest(resultString
                             .getBytes(charsetname)));
             } catch (Exception exception) {
             }
             return resultString;
         }
         
         /**
          * MD5加密
          * @param b
          * @return
          */
         private static String byteArrayToHexString(byte b[]) {
             StringBuffer resultSb = new StringBuffer();
             for (int i = 0; i < b.length; i++)
                 resultSb.append(byteToHexString(b[i]));
     
             return resultSb.toString();
         }
         /**
          * byteToHexString
          * @param b
          * @return
          */
         private static String byteToHexString(byte b) {
             int n = b;
             if (n < 0)
                 n += 256;
             int d1 = n / 16;
             int d2 = n % 16;
             return hexDigits[d1] + hexDigits[d2];
         }
         
         /**
          * hexDigits
          */
         private static final String hexDigits[] = { 
             "0", "1", "2", "3", "4", "5","6", "7", "8", "9", "a", "b", "c", "d", "e", "f" 
         };
         
         /**
          * 将请求参数转换为xml格式的string
          * @Author  japhet_jiu
          * @param parameters
          * @return  String
          * @Date   
          *
          */
          @SuppressWarnings({ "rawtypes"})
          public static String getRequestXml(SortedMap<Object, Object> parameters) {  
              StringBuffer sb = new StringBuffer();  
              sb.append("<xml>");  
              Set es = parameters.entrySet();  
              Iterator it = es.iterator();  
              while (it.hasNext()) {  
                  Map.Entry entry = (Map.Entry) it.next();  
                  String k = (String) entry.getKey();  
                  String v = (String) entry.getValue();  
                  if ("attach".equalsIgnoreCase(k) || "body".equalsIgnoreCase(k) || "sign".equalsIgnoreCase(k)) {  
                      sb.append("<" + k + ">" + "<![CDATA[" + v + "]]></" + k + ">");  
                  } else {  
                      sb.append("<" + k + ">" + v + "</" + k + ">");  
                  }  
              }  
              sb.append("</xml>");  
              return sb.toString();  
          }
          
          /**
           * postData
           * @param urlStr
           * @param data
           * @return
           */
          public static String postData(String urlStr, String data) {
             String postData  = postData2(urlStr, data, null);
             return postData;
          }
          
          /**
           * postData2
           */
          private final static int CONNECT_TIMEOUT = 5000; // in milliseconds
          private final static String DEFAULT_ENCODING = "UTF-8";
          public static String postData2(String urlStr, String data, String contentType) {
              BufferedReader reader = null;  
              try {  
                  URL url = new URL(urlStr);  
                  URLConnection conn = url.openConnection();  
                  conn.setDoOutput(true);  
                  conn.setConnectTimeout(CONNECT_TIMEOUT);  
                  conn.setReadTimeout(CONNECT_TIMEOUT);  
                  if(contentType != null)  
                      conn.setRequestProperty("content-type", contentType);  
                  OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream(), DEFAULT_ENCODING);  
                  if(data == null)  
                      data = "";  
                  writer.write(data);   
                  writer.flush();  
                  writer.close();    
        
                  reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), DEFAULT_ENCODING));  
                  StringBuilder sb = new StringBuilder();  
                  String line = null;  
                  while ((line = reader.readLine()) != null) {  
                      sb.append(line);  
                      sb.append("\r\n");  
                  }  
                  return sb.toString();  
              } catch (IOException e) {  
                  e.printStackTrace();
              } finally {  
                  try {  
                      if (reader != null)  
                          reader.close();  
                  } catch (IOException e) {  
                  }  
              }  
              return null;  
          }
          
          /**
           * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。
           * 
           * @param strxml
           * @return
           * @throws JDOMException
           * @throws IOException
           */
          @SuppressWarnings({ "rawtypes", "unchecked" })
          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 = getChildrenText(children);
                  }
                  m.put(k, v);
              }
              // 关闭流
              in.close();
              return m;
          }
          
     
          /**
           * 获取子结点的xml
           * 
           * @param children
           * @return String
           */
          @SuppressWarnings({ "rawtypes" })
          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(getChildrenText(list));
                      }
                      sb.append(value);
                      sb.append("</" + name + ">");
                  }
              }
              return sb.toString();
          }
          
            /** 
            * 时间戳转换成日期格式字符串 
            * @param seconds 精确到秒的字符串 
            * @param formatStr 
            * @return 
            */  
             public static String timeStamp2Date(String seconds,String format) {  
                 if(seconds == null || seconds.isEmpty() || seconds.equals("null")){  
                     return "";  
                 }  
                 if(format == null || format.isEmpty()){
                     format = "yyyy-MM-dd HH:mm:ss";
                 }   
                 SimpleDateFormat sdf = new SimpleDateFormat(format);  
                 return sdf.format(new Date(Long.valueOf(seconds+"000")));  
             }
          
             /**
              * 支付成功，返回微信那服务器
              * @param return_code
              * @param return_msg
              * @return
              */
             public static String setXML(String return_code, String return_msg) {
                 return "<xml><return_code><![CDATA[" + return_code + "]]></return_code><return_msg><![CDATA[" + return_msg + "]]></return_msg></xml>";
             }
    
        /* WxPayUnifiedOrderRequest request = WxPayUnifiedOrderRequest.newBuilder()
                .body("app 微信支付2")
                .totalFee(1)
                .spbillCreateIp("192.168.0.24")
                .notifyUrl(ConfigUtil.UNIFIED_ORDER_URL)
                .tradeType(WxPayConstants.TradeType.APP)
                .outTradeNo(String.valueOf(UUID.next()))
                .build();
        request.setSignType(WxPayConstants.SignType.MD5);
        Object result;
        try {
            result = wxPayService.createOrder(request);
            System.out.println("result=="+result);
            PrintWriter out = response.getWriter();
            out.print(request);
            out.flush();
            out.close();
        } catch (WxPayException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
//        return  result;
*/    
    }
    微信支付的工具类和回调我都写在了一起，有点乱，但是穿进自己的参数还是直接可以吊起来的

前端JS：

  var basic_url=url()+"/WinxinPay?total=" + dd + "&Indent_Remark=" + pppp + "&SC=" + SC + "&Fare=" + Far+ "&Wineshop_Name=" + oo
                 //var basic_url='http://192.168.0.114:8080/ACPSample_B2C/WinxinPay';
                 
                    mui.ajax(basic_url,{
                        data:{
                               
                        },
                        dataType:"json",
                        type:"post",
                        success:ajax_success_callback,
                        error:ajax_error_callback
                    })
                
                
                //获取微信支付参数成功的回调函数
                function ajax_success_callback(resObj)
                {
 //                   alert("请求微信支付参数成功,返回的json:"+resObj);   
                    var res_str=JSON.stringify(resObj);
 //                   alert("res_str JSON.stringify(resObj)==="+res_str);  
 //                   alert("res_str.appid==="+res_str.appid);  
 //                   alert("resObj.appid==="+resObj.appid);  
 //                   alert("res_str[0].appid==="+res_str[0].appid);
 //                   alert("res_str[0].noncestr==="+res_str[0].noncestr);  
                    
                  //用返回参数 发起微信支付请求
                    //res_str ={"appid":res_str.appid,"noncestr":res_str.noncestr,"package":res_str.package,"partnerid":res_str.partnerid,"prepayid":res_str.prepayid,"timestamp":res_str.timestamp,"sign":res_str.sign};
                    res_str = res_str.split("[")[1];
                    res_str = res_str.split("]")[0];
//                    alert("res_str==="+res_str);
                    plus.payment.request(channel, res_str, function(data) {
                        
                    },function(error) { //失败回调
                        alert("支付失败");
                    })
                    
                }
                //获取微信支付参数失败的回调函数
                function ajax_error_callback(e){
                    console.log(JSON.stringify(e))   
                    alert("ajax获取参数失败");                 
                }
                //微信支付成功回调
                function wxpay_success(result){
                    plus.ui.alert("支付成功!",function()    
                    {
                        back();
                    })
                }
                //微信支付失败回调
                function wxpay_error(error){
                    alert("支付失败!");
                  alert(JSON.stringify(error));
                   alert(JSON.stringify(error));
                }
                //微信支付按钮 发起微信支付
               }
                }
            });
                
    到这里微信支付和支付宝支付都完成了

总结：总结下来，还是没有好好的看文档，太浮躁，不成功就很烦躁！也让我这个小白对编程有了初步的了解！