SpringBoot对接支付宝当面付和手机网站支付

已于 2023-02-28 11:57:40 修改
阅读量1.3k 收藏 4
点赞数 1
文章标签： https http 网络协议 java spring boot
于 2023-02-28 11:42:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52217182/article/details/129213873
版权

一、前期准备：

1.注册商家账号：支付宝

2.登录进入，在产品中心选择自己所需要对接的功能：

 

3.进入对接功能，选择立即开通

4.填写商户信息：

 5.开通成功之后，产品中心>>开发设置>>创建应用并关联，进行应用创建

6.应用创建成功之后步骤：申请应用上线>>进行产品绑定（需要先进行通）

 7.在开发设置中配置密钥（涉及隐私就不付截图）,有证书模式、公钥模式两种，私钥需通过其他平台或支付宝提供的支付宝密钥生成工具生成，生成之后的商家私钥个公钥请妥善保管；

8.开发时需要用到的相关数据（普通公钥模式）：

AppId：前面申请的应用所附带的应用ID；

PrivateKey：商家私钥；

Domain：外网地址，用来接收支付宝异步通知；

ServiceUrl：支付宝网关（固定为沙箱或者正式环境）；

二、代码

1.商户信息：

@Getter
@Setter
@Builder
@AllArgsConstructor
public class Merchant {
    /**
     * 应用appID
     */
    private String appId;
    /**
     * 应用密钥
     */
    private String appKey;
    /**
     * 商户ID
     */
    private String mchId;
    /**
     * 商户密钥
     */
    private String mchKey;

    /**
     * 支付宝公钥
     */
    private String aliPayPublicKey;

    /**
     * 支付宝私钥
     */
    private String privateKey;

    /**
     * 外网访问项目的域名，支付通知中会使用
     */
    private String domain;

    /**
     * 支付宝环境
     * 正式：https://openapi.alipay.com/gateway.do
     * 沙箱：https://openapi.alipaydev.com/gateway.do
     */
    private String serviceUrl;
}

2.依赖：

<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-WxPay</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-AliPay</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-QQ</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-UnionPay</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-JDPay</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.github.javen205</groupId>
			<artifactId>IJPay-PayPal</artifactId>
			<version>${ijapy.version}</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.9</version>
		</dependency>

		<dependency>
			<groupId>com.jfinal</groupId>
			<artifactId>enjoy</artifactId>
			<version>${enjoy.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
	</dependencies>

3.支付客户端：

 /**
     * 预支付
     * @param request 请求体
     * @param merchant 商户配置
     * @return 预支付响应
     */
    public PrePayResponse prePay(PrePayRequest request, Merchant merchant){
        //如果订单号为空，自动生成订单号
        if (StrUtil.isBlank(request.getOrderNo())){
            request.setOrderNo(getOrderNo());
        }
        Method method = getPayMethod(this.superService.getClass(),request.getPayMethod());
        try {
            PrePayResponse response = (PrePayResponse) method.invoke(this.superService,request,merchant);
            if (response.getPayStatus() == null) response.setPayStatus(PayStatus.PAYING);
            return response;
        } catch (IllegalAccessException | InvocationTargetException e) {
            log.error("支付发起失败", e);
            throw new InternalRuntimeException();
        }
    }

    public PrePayResponse webPay(HttpServletResponse httpServletResponse,PrePayRequest request,Merchant merchant) throws NoSuchMethodException {
        //如果订单号为空，自动生成订单号
        if (StrUtil.isBlank(request.getOrderNo())){
            request.setOrderNo(getOrderNo());
        }
        Method method = this.superService.getClass()
                .getMethod(StrUtil.toCamelCase("zfb_web"),
                        HttpServletResponse.class,
                        PrePayRequest.class,
                        Merchant.class);
        try {
            PrePayResponse response = (PrePayResponse)method.invoke(this.superService,httpServletResponse, request, merchant);
            if (response.getPayStatus() == null) response.setPayStatus(PayStatus.PAYING);
            return response;
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new InternalRuntimeException();
        }
    }

    /**
     * 解析支付通知
     * @param request http请求
     * @return 支付通知解析结果
     */
    public PayNotify payNotify(HttpServletRequest request){
        try {
            Method method = this.superService.getClass().getMethod("payNotify", HttpServletRequest.class);
            return (PayNotify) method.invoke(this.superService,request);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("通知处理失败", e);
            throw new InternalRuntimeException();
        }
    }

    /**
     * 验证支付通知
     * @param payNotify 解析后的支付通知
     * @param merchant 商户配置
     * @return true 验证通过， false 验证失败
     */
    public boolean verifyPayNotify(PayNotify payNotify, Merchant merchant){
        try {
            Method method = this.superService.getClass().getMethod("verifyPayNotify", PayNotify.class, Merchant.class);
            return (boolean) method.invoke(this.superService,payNotify,merchant);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("通知验证失败", e);
            throw new InternalRuntimeException();
        }
    }

    /**
     * 响应上游支付通知
     * @param response http响应
     */
    public void payNotifyResponse(HttpServletResponse response){
        try {
            Method method = this.superService.getClass().getMethod("payNotifyResponse", HttpServletResponse.class);
            method.invoke(this.superService,response);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("响应上游支付通知失败", e);
            throw new InternalRuntimeException();
        }
    }

    /**
     * 支付查询
     * @param orderNo 内部订单编号
     * @param merchant 商户配置
     * @return 查询结果
     */
    public PayResult payOrderQuery(String orderNo, Merchant merchant){
        try {
            Method method = this.superService.getClass().getMethod("payOrderQuery", String.class, Merchant.class);
            return (PayResult) method.invoke(this.superService,orderNo, merchant);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            log.error("支付查询失败", e);
            throw new InternalRuntimeException();
        }
    }

    /**
     * 实例化支付服务
     * @param paySuper 上游通道
     * @return 支付服务
     */
    private SuperService getService(PaySuper paySuper){
        try {
            Class<?> adapter = Class.forName(ClassUtil.getPackage(this.getClass()) + ".services." + StrUtil.upperFirst(paySuper.getAdapterIndex()) + "Service");
            return  (SuperService) adapter.newInstance();
        } catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
            log.error("支付服务实例化错误", e);
            throw new InternalRuntimeException();
        }
    }

    /**
     * 实例化支付方法
     * @param serviceClass 服务类
     * @param payMethod 支付方式
     * @return 服务方法
     */
    private Method getPayMethod(Class<?> serviceClass, PayMethod payMethod){
        try {
            return serviceClass.getMethod(StrUtil.toCamelCase(payMethod.getValue()), PrePayRequest.class, Merchant.class);
        } catch (NoSuchMethodException e) {
            log.error("支付服务方法调用错误", e);
            throw new InternalRuntimeException();
        }
    }

    /*private Method getPayMethod(HttpServletResponse response,Class<?> serviceClass, PayMethod payMethod) {
        try {
            return serviceClass.getMethod(StrUtil.toCamelCase(payMethod.getValue()),HttpServletResponse.class, PrePayRequest.class, Merchant.class);
        } catch (NoSuchMethodException var4) {
            log.error("支付服务方法调用错误", var4);
            throw new InternalRuntimeException();
        }
    }*/

    private String getOrderNo(){
        return DateUtil.format(new Date(),"yyMMddhhmmssSSS") + RandomUtil.randomNumbers(7);
    }

     4.通道服务接口：

/**
     * 支付宝二维码支付
     * @param request
     * @param merchant
     * @return
     */
    default PrePayResponse zfbQr(PrePayRequest request, Merchant merchant) throws AlipayApiException {
        throw new NotSupportedMethodException();
    }

    /**
     * 支付宝手机网页支付
     * @param response
     * @param merchant
     * @param request
     * @return
     * @throws AlipayApiException
     */
    default void zfbWeb(HttpServletResponse response,PrePayRequest request,Merchant merchant)throws AlipayApiException{
        throw new NotSupportedMethodException();
    }

    /**
     * 处理支付通知
     * @param request
     * @return
     */
    default PayNotify payNotify(HttpServletRequest request){
        throw new NotSupportedMethodException("支付通知不支持");
    }

    /**
     * 验证支付通知签名或者加密
     * @param notify
     * @param merchant
     * @return
     */
    default boolean verifyPayNotify(PayNotify notify, Merchant merchant) throws AlipayApiException {
        throw new NotSupportedMethodException("通知验证不支持");
    };

    /**
     * 收到上游通知，返回响应
     * @param response
     */
    default void payNotifyResponse(HttpServletResponse response) {}

    /**
     * 订单查询
     * @param orderNo 内部订单编号
     * @param merchant 商户信息
     * @return
     */
    default PayResult payOrderQuery(String orderNo, Merchant merchant) throws AlipayApiException {
        throw new NotSupportedMethodException("订单查询不支持");
    }

 5.支付宝官方对接：

package com.yuheng.payment.services;

import com.alibaba.fastjson.JSONObject;
import com.alipay.api.AlipayApiException;
import com.alipay.api.domain.AlipayTradePrecreateModel;
import com.alipay.api.domain.AlipayTradeQueryModel;
import com.alipay.api.domain.AlipayTradeWapPayModel;
import com.alipay.api.internal.util.AlipaySignature;
import com.ijpay.alipay.AliPayApi;
import com.ijpay.alipay.AliPayApiConfig;
import com.ijpay.alipay.AliPayApiConfigKit;
import com.ijpay.core.kit.HttpKit;
import com.ijpay.core.kit.WxPayKit;
import com.yuheng.payment.constants.PayStatus;
import com.yuheng.payment.exceptions.InternalRuntimeException;
import com.yuheng.payment.exceptions.PrePayResponseException;
import com.yuheng.payment.models.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Map;

/**
 * 支付宝官方
 * @author michael
 * @since  2022/11/15
 */
public class ZhifubaoService implements SuperService {
    private static final Logger log = LoggerFactory.getLogger(ZhifubaoService.class);

    /**
     * 初始化商户、应用信息
     * @param merchant
     * @return
     * @throws AlipayApiException
     */
    public AliPayApiConfig getConfig(Merchant merchant) throws AlipayApiException {
        AliPayApiConfig aliPayApiConfig;
        try {
            aliPayApiConfig = AliPayApiConfigKit.getApiConfig(merchant.getAppId());
        } catch (Exception e) {
            aliPayApiConfig = AliPayApiConfig
                    .builder()
                    .setAppId(merchant.getAppId())
                    .setPrivateKey(merchant.getPrivateKey())
                    /*.setAliPayCertPath(merchant.getAliPayCertPath())
                    .setAppCertPath(merchant.getAppCertPath())
                    .setAliPayRootCertPath(merchant.getAliPayRootCertPath())*/
                    .setAliPayPublicKey(merchant.getAliPayPublicKey())
                    .setCharset("UTF-8")
                    .setSignType("RSA2")
                    .setServiceUrl(merchant.getServiceUrl())
                    // 普通公钥方式
                    .build();
                    // 证书模式
//                    .buildByCert();
        }
        return aliPayApiConfig;
    }

    /**
     * 支付宝扫码支付
     * @param request
     * @param merchant
     * @return
     * @throws AlipayApiException
     */
    @Override
    public PrePayResponse zfbQr(PrePayRequest request, Merchant merchant) throws AlipayApiException {
//        AliPayApiConfigKit.putApiConfig(aliPayApiConfig);
        AliPayApiConfigKit.setThreadLocalAliPayApiConfig(getConfig(merchant));
        AlipayTradePrecreateModel model = new AlipayTradePrecreateModel();
        model.setSubject(request.getBody());
        // 传入金额单位为 分，换成支付宝单位 元
        model.setTotalAmount(Double.toString(request.getAmount() / 100.00));
        model.setOutTradeNo(request.getOrderNo());
        String resultStr = AliPayApi.tradePrecreatePayToResponse(model, request.getNotifyUrl()).getBody();
        JSONObject jsonObject = JSONObject.parseObject(resultStr).getJSONObject("alipay_trade_precreate_response");
        String code = jsonObject.getString("code");
        if (!"10000".equals(code)){
            log.error("支付发起失败{}", jsonObject.getString("sub_msg"));
        }
        String qrCode = jsonObject.getString("qr_code");
        String outTradeNo = jsonObject.getString("out_trade_no");
//        return jsonObject.getJSONObject("alipay_trade_precreate_response").getString("qr_code");
        return PrePayResponse
                .builder()
                .orderNo(outTradeNo)
                .payText(qrCode)
                .payStatus(PayStatus.PAYING)
                .build();
    }

    /**
     * 手机网页支付
     * @param response
     * @param merchant
     * @param request
     * @return
     * @throws AlipayApiException
     */
    @Override
    public void zfbWeb(HttpServletResponse response, PrePayRequest request, Merchant merchant) throws AlipayApiException{
        AliPayApiConfigKit.setThreadLocalAliPayApiConfig(getConfig(merchant));
        AlipayTradeWapPayModel model = new AlipayTradeWapPayModel();
        model.setBody(request.getBody());
        model.setSubject(request.getBody());
        // 传入金额单位为 分，换成支付宝单位 元
        model.setTotalAmount(Double.toString(request.getAmount() / 100.00));
        model.setOutTradeNo(request.getOrderNo());
//        System.out.println("wap outTradeNo>" + outTradeNo);
//        model.setOutTradeNo(outTradeNo);
        model.setProductCode("QUICK_WAP_PAY");
        try {
            AliPayApi.wapPay(response, model, request.getReturnUrl(), request.getNotifyUrl());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 待测试
     * @param request
     * @return
     */
    @Override
    public PayNotify payNotify(HttpServletRequest request) {
            // 获取支付宝POST过来反馈信息
        String readData = HttpKit.readData(request);
        log.debug("收到支付宝支付原始通知："+readData);
        Map<String, String> params = AliPayApi.toMap(request);
     /*       for (Map.Entry<String, String> entry : params.entrySet()) {
                System.out.println(entry.getKey() + " = " + entry.getValue());
            }*/
        if ("10000".equals(params.get("code"))) {
            PayNotify notifyResponse = PayNotify.builder()
                    .orderNo(params.get("out_trade_no"))
                    .outOrderNo(params.get("transaction_id"))
                    .payStatus(PayStatus.PAYING)
                    .build();
            if ("TRADE_SUCCESS".equals(params.get("trade_status"))) {
                notifyResponse.setPayTime(timeFormat(params.get("gmt_create")));
                notifyResponse.setPayStatus(PayStatus.PAID);
            }
            notifyResponse.setRawSignObject(params);
            return notifyResponse;
        } else
             {
                 return null;
             }
    }

    /**
     * 签名验证
     * @param response
     * @param merchant
     * @return
     * @throws AlipayApiException
     */
    @Override
    public boolean verifyPayNotify(PayNotify response, Merchant merchant) throws AlipayApiException {
        return AlipaySignature.rsaCheckV1((Map<String, String>) response.getRawSignObject(), merchant.getAliPayPublicKey(), "UTF-8", "RSA2");
    }


    /**
     * 根据订单号进行查询
     * @param orderNo 内部订单编号
     * @param merchant 商户信息
     * @return
     * @throws AlipayApiException
     */
    @Override
    public PayResult payOrderQuery(String orderNo, Merchant merchant) throws AlipayApiException {
        AliPayApiConfigKit.setThreadLocalAliPayApiConfig(getConfig(merchant));
        AlipayTradeQueryModel model = new AlipayTradeQueryModel();
        model.setOutTradeNo(orderNo);
        String body = AliPayApi.tradeQueryToResponse(model).getBody();
        JSONObject jsonObject = JSONObject.parseObject(body).getJSONObject("alipay_trade_query_response");
        String code = jsonObject.getString("code");
        if (!"10000".equals(code)){
            throw new InternalRuntimeException("发起查询失败，原因["+code+":"+ jsonObject.getString("sub_msg")+"]");
        }
        String tradeStatus = jsonObject.getString("trade_status");
        PayStatus payStatus;
        switch (tradeStatus){
            case "TRADE_FINISHED" :
                payStatus = PayStatus.FINISHED;
                break;
            case "TRADE_SUCCESS" :
                payStatus = PayStatus.PAID;
                break;
            case "TRADE_CLOSED" :
                payStatus = PayStatus.CLOSE;
                break;
            default:
                payStatus = PayStatus.PAYING;
        }
        return PayResult
                .builder()
                .orderNo(jsonObject.getString("trade_no"))
                .outOrderNo(jsonObject.getString("out_trade_no"))
                .payStatus(payStatus)
                .build();
    }


    /**
     * 时间戳转时间字符串
     * @param timeStr 时间戳Long
     * @return String 时间
     */
    private Long timeFormat(String timeStr){
        DateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        try {
            return dateFormat.parse(timeStr).getTime();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 时间戳转时间字符串
     * @param time 时间戳Long
     * @return String 时间
     */
    private String timeFormat(Long time){
        return new SimpleDateFormat("yyyyMMddHHmmss").format(time);
    }

}

6.接口实现：

private static final Logger log = LoggerFactory.getLogger(TestController.class);

	@RequestMapping("/qrPay")
	@ResponseBody
	public PrePayResponse testPay(){
		Client client = Client.newInstance(PaySuper.ALIPAY);
		PrePayRequest request = PrePayRequest.builder()
			.amount(1)
			.body("支付宝扫码支付测试")
			.payMethod(PayMethod.ZFB_QR)
			.notifyUrl(getMerchant().getDomain())
			.build();
		PrePayResponse response = client.prePay(request,getMerchant());
		return PrePayResponse
			.builder()
			.orderNo(response.getOrderNo())
			.payText(response.getPayText())
			.payStatus(response.getPayStatus())
			.build();
	}

	@RequestMapping("/query")
	@ResponseBody
	public PayResult testQuery(String orderNo){
		Client client = Client.newInstance(PaySuper.ALIPAY);
		PayResult result = client.payOrderQuery(orderNo,getMerchant());
		System.out.println(JSONUtil.toJsonStr(result));
		return PayResult
			.builder()
			.payStatus(result.getPayStatus())
			.orderNo(result.getOrderNo())
			.outOrderNo(result.getOutOrderNo())
			.payTime(result.getPayTime())
			.build();
	}

	@RequestMapping("/webPay")
	public void wapPay(HttpServletResponse httpServletResponse) throws NoSuchMethodException {
		Client client = Client.newInstance(PaySuper.ALIPAY);
		PrePayRequest request = PrePayRequest.builder()
			.amount(1)
			.body("支付宝网页支付测试")
			.payMethod(PayMethod.ZFB_WEB)
			.returnUrl(getMerchant().getDomain())
			.notifyUrl(getNotifyURL())
			.build();
		PrePayResponse prePayResponse = client.webPay(httpServletResponse, request, getMerchant());
        System.out.println(JSONUtil.toJsonStr(prePayResponse));
	}



	private Merchant getMerchant(){
		return Merchant.builder()
			.appId("应用ID")
			.privateKey("私钥")
			.aliPayPublicKey("支付宝公钥")
			.serviceUrl("https://openapi.alipay.com/gateway.do")
			.build();
	}

	private String getNotifyURL(){
		return RequestHolder.getAppUrl() + "/test/notify/notify/";
	}

7.异步通知：

@PostMapping
	@ResponseBody
	public void payNotify(HttpServletRequest request) throws UnsupportedEncodingException {
		Client client = Client.newInstance(PaySuper.ALIPAY);
		//获取支付宝GET过来反馈信息
		Map<String,String> params = new HashMap<String,String>();
		Map<String, String> map = AliPayApi.toMap(request);
		for (Map.Entry<String, String> entry : map.entrySet()) {
			System.out.println(entry.getKey() + " = " + entry.getValue());
			params.put(entry.getKey(), entry.getValue());
		}
		String out_trade_no = new String(request.getParameter("out_trade_no").getBytes("ISO-8859-1"),"UTF-8");
		PayNotify payNotify = PayNotify.builder().rawSignObject(params).build();
		boolean result = client.verifyPayNotify(payNotify,getMerchant());
		if(result){//验证成功
			System.out.println("验证成功<br />");
		}else{
			System.out.println("验证失败<br />");
		}
	}

8.支付通知类：

@Getter
@Setter
@Builder
@AllArgsConstructor
public class PayNotify {
    private String orderNo;

    private String outOrderNo;

    private PayStatus payStatus;

    private Long payTime;

    private Object rawSignObject;
}

9.支付结果类：

/**
 * 支付结果
 * @author michael
 * @since  2022/11/15
 */
@Getter
@Setter
@Builder
@AllArgsConstructor
public class PayResult {
    /**
     * 内部订单号
     */
    private String orderNo;

    /**
     * 外部订单号
     */
    private String outOrderNo;

    /**
     * 订单状态
     */
    private PayStatus payStatus;

    /**
     * 支付时间
     */
    private Long payTime;
}

10.预支付响应：

@Getter
@Setter
@AllArgsConstructor
@Builder
public class PrePayResponse {
    /**
     * 内部订单号
     */
    private String orderNo;

    /**
     * 外部订单号
     */
    private String outOrderNo;

    /**
     * 是否为重定向连接
     */
    private Boolean isRedirect;

    /**
     * 支付文本或者支付连接
     */
    private String payText;

    /**
     * 支付状态， 只有当面付中的被扫才会有支付成功（向商家展示付款码，商家扫码枪扫码完成支付）
     */
    private PayStatus payStatus;
}

11.预支付请求：

@Getter
@Setter
@Builder
public class PrePayRequest {
    /**
     * 内部订单号
     */
    private String orderNo;
    /**
     * 支付方式
     */
    private PayMethod payMethod;
    /**
     * 金额，单位分
     */
    private Integer amount;
    /**
     * 支付body, 说明支付场景
     */
    private String body;
    /**
     * 支付成功后跳转地址
     */
    private String returnUrl;
    /**
     * 支付宝userId
     */
    private String openId;
    /**
     * 支付成功后通知地址
     */
    private String notifyUrl;
    /**
     * 只有用户（如微信用户）向商家展示付款码才会用到
     */
    private String authCode;
    /**
     * 过期时间， 大于这个时间节点就过期
     */
    private Long expireTime;
}

三、支付宝相关文档：

商家接入准备

手机网站支付快速接入

当面付

如何使用证书

异步通知说明

对接常见问题

Biubiubiuexo
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot对接支付宝支付接口(详细开发步骤总结)
08-19
主要介绍了springboot对接支付宝支付接口(详细开发步骤总结)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot接入支付宝支付API
weixin_52000926的博客
01-27 1862
基于开发环境搭建springboot接入支付宝沙箱支付，可以换正式环境
Spring Boot 接入支付宝完整流程实战，互联网java工程师面试突击第二季
2401_83946570的博客
04-03 289
接下来看集成步骤。
php 电脑和手机网站支付宝对接示例
01-01
php 电脑和手机网站支付宝对接示例,首先要签约 再申请产品 通过后方可集成到自己的环境里 联系
企业级发卡网（已对接支付宝当面付）
08-10
企业级发卡网（已对接支付宝当面付）
swapidc对接支付宝当面付插件 解密去授权.zip
04-15
swapidc的支付宝当面付对接插件。已解密，去除授权。 我们这里主要为大家介绍一下如何在swapIDC使用当面付，大家都知道swapIDC目前是没有支付宝当面付插件的，因此也给大家带来了很多不便，只能使用码支付或者是易支付来收款（这就给资金带来了很多不安全因素） 现在我们将当面付集合到SWAP插件中，可以实现的功能: 用户后台充值指定金额->返回对应的二维码动态码（支付宝接口生成，不必用户二次填入金额)->用户扫码支付->完成支付->实时到账您的账户->支付宝回调->用户余额增加.
Springboot + vue 实现支付宝支付
m0_67401270的博客
04-08 1516
Springboot + vue 实现支付宝支付 一.引入alipay的pom依赖包 <!-- https://mvnrepository.com/artifact/com.alipay.sdk/alipay-sdk-java --> <dependency> <groupId>com.alipay.sdk</groupId> <artifactId>alipay-sd
Springboot集成第三方jar快速实现微信、支付宝等支付场景
plpldog的博客
07-05 561
前言 最近有个小型的活动外包项目，要集成一下支付功能，因为项目较小，按照微信官方文档的配置开发又极容易出错，加上个人又比较懒。 于是在gitee上找到一个封装好的各种支付场景业务，只需要自己将支付参数修改一下就能成功调起支付业务，实现真正的快速开发。 一、项目地址 官方网站：https://javen205.gitee.io/ijpay/ Gitee仓库: https://gitee.com/javen205/IJPay 官方示例程序源码：https://gitee.com/javen205
android支付宝支付微信支付封装,JPay: 对微信App支付、支付宝App支付、银联APP支付的二次封装,对外提供一个相对简单的接口以及支付结果的回调...
weixin_35048609的博客
05-25 300
JPay 简易而不简单的支付 SDK对微信App支付、支付宝App支付、银联App支付的二次封装,对外提供一个相对简单的接口以及支付结果的回调 客户端与服务端联系方式使用方法1、坐标Step 1. Add it in your root build.gradle at the end of repositories:allprojects {repositories {...mave...
SpringBoot集成支付宝支付 - 少走弯路就看这篇
mxt51220的博客
06-16 1906
在开始集成支付宝支付之前，我们需要准备一个支付宝商家账户，如果是个人开发者，可以通过注册公司或者让有公司资质的单位进行授权，后续在集成相关API的时候需要提供这些信息。下面我以电脑网页端在线支付为例，介绍整个从集成、测试到上线的具体流程。
对接支付宝服务商当面付&手机网页支付
qq_52217182的博客
04-06 1063
1.注册商家账号：支付宝商家平台2.登录进入，在产品中心选择自己所需要对接的功能：3.进入对接功能，选择立即开通4.填写商户信息：5.开通成功之后，产品中心>>开发设置>>创建应用并关联，进行应用创建6.应用创建成功之后，我们需要进行应用相关开发配置：配置成功后获得到我们开发需要的：支付宝公钥、商户私钥、应用ID。
swapidc对接支付宝当面付插件 解密去授权
06-26
swapidc对接支付宝当面付插件 解密去授权
swapidc对接支付宝当面付插件 解密去授权完整版本
最新发布
04-29
SWAPIDC对接支付宝当面付插件 解密去授权，百度上一大堆都是加密的，还弄了授权，这个解密了，去了授权。
Java 微信当面付生成二维码支付实现
-
07-31 2108
Java 微信当面付生成二维码支付实现1. maven依赖2. 准备工作a. WxPayConfig 配置类b. 二维码图片本地存储位置c. 配置虚拟路径3. 代码a. QrCodeUtilb. controller 1. maven依赖 <!-- 微信支付sdk --> <dependency> <groupId>com.github.wxpay</groupId> <ar
Spring Boot 整合支付宝
虚言假面的博客
09-04 1775
文章目录接入准备Spring Boot 整合 接入准备 在整合之前，需要你已经注册成为支付宝开发者。我在 jsp对接支付宝支付接口，实现网站在线支付 这篇文章中有写到接入流程，可供参考。 Spring Boot 整合 添加 Maven 依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId
Spring Boot 集成支付宝支付，看这篇就够了
码猿技术专栏
12-16 132
大家好，我是不才陈某~网页操作步骤1.进入支付宝开发平台—沙箱环境使用开发者账号登录开放平台控制平台2.点击沙箱进入沙箱环境说明：沙箱环境支持的产品，可以在沙箱控制台 沙箱应用 > 产品列表 中查看。3.进入沙箱，配置接口加签方式在沙箱进行调试前需要确保已经配置密钥/证书用于加签，支付宝提供了 系统默认密钥 及 自定义密钥 两种方式进行配置。这里我采取的是默认方式：开发者如需使用系统默认密钥...
【微信支付】微信v3支付案例，SpringBoot集成IJPay实现微信v3支付
Syals的博客
06-15 1993
微信v3支付案例，SpringBoot集成IJPay实现微信v3支付
springboot整合IJPay实现微信支付-V3---微信小程序
qq_37612049的博客
03-16 6748
前言微信支付适用于许多场合，如小程序、网页支付、但微信支付相对于其他支付方式略显麻烦，我们使用IJpay框架进行整合。
SpringBoot支付宝接入实战
努力学习Java的彬彬的博客
04-19 2945
基于SpringBoot的商户支付宝接入实战项目
springboot对接支付宝芝麻免押
12-05
根据提供的引用内容，我们可以了解到支付宝芝麻免押是一种支付方式，而Spring Boot是一种快速开发框架。因此，我们可以使用Spring Boot对接支付宝芝麻免押。 以下是Spring Boot对接支付宝芝麻免押的步骤： 1.在pom.xml文件中添加支付宝SDK的依赖： ```xml <dependency> <groupId>com.alipay.sdk</groupId> <artifactId>alipay-sdk-java</artifactId> <version>3.7.110.ALL</version> </dependency> ``` 2.在application.properties文件中添加支付宝相关配置： ```properties # 支付宝网关 alipay.gatewayUrl=https://openapi.alipay.com/gateway.do # 应用ID alipay.appId=应用ID # 商户私钥 alipay.merchantPrivateKey=商户私钥 # 支付宝公钥 alipay.alipayPublicKey=支付宝公钥 # 编码格式 alipay.charset=UTF-8 # 签名类型 alipay.signType=RSA2 ``` 3.创建一个AlipayClient实例： ```java AlipayClient alipayClient = new DefaultAlipayClient( alipayConfig.getGatewayUrl(), alipayConfig.getAppId(), alipayConfig.getMerchantPrivateKey(), "json", alipayConfig.getCharset(), alipayConfig.getAlipayPublicKey(), alipayConfig.getSignType() ); ``` 4.创建一个AlipayTradePayRequest实例： ```java AlipayTradePayRequest request = new AlipayTradePayRequest(); ``` 5.设置AlipayTradePayRequest实例的参数： ```java request.setBizContent("{" + "\"out_trade_no\":\"20150320010101001\"," + "\"scene\":\"bar_code\"," + "\"auth_code\":\"28763443825664394\"," + "\"subject\":\"Iphone6 16G\"," + "\"total_amount\":0.01" + "}"); ``` 6.调用AlipayClient的execute方法，发送请求并获取响应： ```java AlipayTradePayResponse response = alipayClient.execute(request); ``` 7.根据响应结果进行相应的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值