更新银行配置、新增接口

yupeng

2025-01-24 f823430e931eec969faf68648c7d9b96d6beba3d

更新银行配置、新增接口

 bankapi/pom.xml

@@ -14,6 +14,9 @@
    <groupId>org.taxi591</groupId>
    <artifactId>bankapi</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <properties>
        <httpclient_version>4.5.2</httpclient_version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.ruoyi</groupId>
@@ -23,6 +26,11 @@
            <groupId>com.ruoyi</groupId>
            <artifactId>ruoyi-common</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${httpclient_version}</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>

 bankapi/src/main/java/com/taxi591/bankapi/BankProperties.java

@@ -15,6 +15,9 @@

    private Boolean enable = true;


    private String baseUrl="http://hello.enjoy.abchina.com";

    /**
     * 证书路径
     */

 bankapi/src/main/java/com/taxi591/bankapi/service/BankService.java

@@ -64,9 +64,10 @@
     */
    public CovertPayBackResult covertPayCallBack(HttpServletRequest httpRequest, Function<ChargeBillRequest,Boolean> consumer) {
        CovertPayBackResult result = new CovertPayBackResult();
        String requestContent = "";
        try {
            // 接收报文
            String requestContent = SignatureAndVerification.getRequestBody(httpRequest).trim();
            requestContent = SignatureAndVerification.getRequestBody(httpRequest).trim();
            String sign = requestContent.substring(0,
                    requestContent.indexOf("||"));;
            String requestBody = requestContent.substring(sign
@@ -95,13 +96,20 @@
            }
            result.setResult(chargeBillRequest);
            result.setBack(createResponse(chargeBillRequest,dealBack));
        }catch (ServiceException e){
            throw e;
        }catch (Exception e){
            log.error("解析报文发生异常",e);
            log.error("解析异常：{}",requestContent,e);
            throw new ServiceException("支付回调解析异常");
        }
        return result;
    }


    public void covertBillTo(){


    }




 bankapi/src/main/java/com/taxi591/bankapi/utils/Base64Util.java

New file
@@ -0,0 +1,50 @@
package com.taxi591.bankapi.utils;

import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;

/**
 * 将String进行base64编码解码，使用utf-8
 * yuan
 */
public class Base64Util {

    private static final Logger LOGGER = LoggerFactory.getLogger(Base64Util.class);
    private static final String UTF_8 = "UTF-8";

    /**
     * 对给定的字符串进行base64解码操作
     */
    public static String decodeData(String inputData) {
        try {
            if (null == inputData) {
                return null;
            }
            return new String(Base64.decodeBase64(inputData.getBytes(UTF_8)), UTF_8);
        } catch (UnsupportedEncodingException e) {
            LOGGER.error(inputData, e);
        }

        return null;
    }

    /**
     * 对给定的字符串进行base64加密操作
     */
    public static String encodeData(String inputData) {
        try {
            if (null == inputData) {
                return null;
            }
            return new String(Base64.encodeBase64(inputData.getBytes(UTF_8)), UTF_8);
        } catch (UnsupportedEncodingException e) {
            LOGGER.error(inputData, e);
        }

        return null;
    }

}

 bankapi/src/main/java/com/taxi591/bankapi/utils/HttpClientUtils.java

New file
@@ -0,0 +1,302 @@
package com.taxi591.bankapi.utils;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.Map.Entry;

/**
 *httpClient操作远程url工具类
 */
public class HttpClientUtils {
    private static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
    /**
     * 发送str格式的post请求
     * @param url
     * @param jsonStr
     * @return
     */
    public static String doPostStr(String url, String str) {
        // 建立HttpPost对象
        HttpPost httppost = new HttpPost(url);
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        CloseableHttpClient client = httpClientBuilder.build();
//        int statusCode = 0;
        String responseBody = null;
        try {
            // 设置发送内容、编码等
            StringEntity stringEntity = new StringEntity(str, "utf-8");
            stringEntity.setContentType("text/plain");
            httppost.setEntity(stringEntity);
            // 发送Post,并返回一个HttpResponse对象
            HttpResponse response = client.execute(httppost);
//            // 获取返回码
//            statusCode = response.getStatusLine().getStatusCode();
            // 获取返回报文
            responseBody = EntityUtils.toString(response.getEntity());
            return responseBody;
        }catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
	
    /**
     * 下载文件
     * @param url
     * @param jsonStr
     * @param 前台的返回流
     * @return
     */
    public static void doPostFile(String url, String str,HttpServletResponse httpResponse) {
        ServletOutputStream out = null;
        // 建立HttpPost对象
        HttpPost httppost = new HttpPost(url);
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        CloseableHttpClient client = httpClientBuilder.build();
        try {
            // 设置发送内容、编码等
            StringEntity stringEntity = new StringEntity(str, "utf-8");
            stringEntity.setContentType("text/plain");
            httppost.setEntity(stringEntity);
            // 发送Post,并返回一个HttpResponse对象
            HttpResponse response = client.execute(httppost);
            // 获取返回报文
            String responseStr = EntityUtils.toString(response.getEntity());
		
            //如果系统返回未加密异常则会返回"{"+json+"}"
            if (responseStr.startsWith("{")){
                //设置响应头信息为页面形式
                httpResponse.setCharacterEncoding("UTF-8");
                httpResponse.setContentType("text/html;charset=utf-8");
                httpResponse.sendRedirect("downloadTraceFail.jsp");
				
            //如果返回内容为异常信息则返回内容为"签名||base64加密"形式
            }else if (responseStr.contains("||")) {
                //截取签名信息
                String headSub = responseStr.substring(0, responseStr.indexOf("||"));
                logger.warn("获取签名的前半部分："+headSub);
                //截取加密的json信息，进行解密
                String tailSub = responseStr.substring(responseStr.indexOf("||")+2);
                logger.warn("获取签名的后半部分："+tailSub);
                //将获取到的json报文进行解析，获取报文体信息
                responseStr = Base64Util.decodeData(tailSub);
                logger.warn("获取签名解密后："+responseStr);
				
                //设置响应头信息为页面形式
                httpResponse.setCharacterEncoding("UTF-8");
                httpResponse.setContentType("text/html;charset=utf-8");
                httpResponse.sendRedirect("downloadTraceFail.jsp");
				
            //返回内容为正常内容，将response消息头读取直接写入httpResponse中
            }else{
                Header[] encode = response.getAllHeaders();
                for (Header header : encode) {
                    httpResponse.setHeader(header.getName(), header.getValue());
                }
            }
            //将获取到的信息封装到httpEntity中，反映到页面中去
            logger.warn("最终获取到的信息："+responseStr);
            HttpEntity entity = new StringEntity(responseStr,"UTF-8");
            //通过输出流将结果反映到页面上
            out = httpResponse.getOutputStream();
            entity.writeTo(out);
            out.flush();
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
	
    /**
     * get 请求方法
     * @param url
     * @return
     */
    public static String doGet(String url) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        String result = "";
		
        try {
            //通过址默认配置创建一个httpClient实例
            httpClient = HttpClients.createDefault();
            //创建httpGet远程连接实例
            HttpGet httpGet = new HttpGet(url);
            //设置配置请求参数
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(35000)//连接主机服务超时时间
                    .setConnectionRequestTimeout(35000)//请求超时时间
                    .setSocketTimeout(60000)//数据读取超时时间
                    .build();
            //为httpGet实例设置配置
            httpGet.setConfig(requestConfig);
            //执行get请求得到返回对象
            response = httpClient.execute(httpGet);
            //通过返回对象获取返回数据
            HttpEntity entity = response.getEntity();
            //通过EntityUtils中的toString方法将结果转换为字符串
            result = EntityUtils.toString(entity);
			
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
			
            if(null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
		
        return result;
    }

    /**
     * post请求
     * @param url
     * @param paramMap
     * @return
     */
    public static String doPost(String url, Map<String,Object> paramMap) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        String result = "";
		
        try {
            //创建httpClient实例
            httpClient = HttpClients.createDefault();
            //创建httpPost远程连接实例
            HttpPost httpPost = new HttpPost(url);
            //配置请求参数实例
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(35000)//设置连接主机服务超时时间
                    .setConnectionRequestTimeout(35000)//设置连接请求超时时间
                    .setSocketTimeout(60000)//设置读取数据连接超时时间
                    .build();
            //为httpPost实例设置配置
            httpPost.setConfig(requestConfig);
			
            //封装post请求参数
            if(null != paramMap && paramMap.size() > 0) {
                List<NameValuePair> nvps = new ArrayList<NameValuePair>();
                //通过map集成entrySet方法获取entity
                Set<Entry<String, Object>> entrySet = paramMap.entrySet();
                //循环遍历，获取迭代器
                Iterator<Entry<String, Object>> iterator = entrySet.iterator();
                while (iterator.hasNext()) {
                    Entry<String, Object> mapEntry = iterator.next();
                    nvps.add(new BasicNameValuePair(mapEntry.getKey(), mapEntry.getValue().toString()));
                }
				
                //为httpPost设置封装好的请求参数
                httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
            }
		
            //执行post请求得到返回对象
            response = httpClient.execute(httpPost);
            //通过返回对象获取数据
            HttpEntity entity = response.getEntity();
            //将返回的数据转换为字符串
            result = EntityUtils.toString(entity);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
			
            if(null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
	

    /**
     * 
     * @param request
     * @return
     * @throws IOException
     */
    public static String getRequestBody(HttpServletRequest request)
            throws IOException {
        /** 读取httpbody内容 */
        StringBuilder httpBody = new StringBuilder();
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(
                    request.getInputStream()));
            String line = null;
            while ((line = br.readLine()) != null) {
                httpBody.append(line);
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
        return httpBody.toString();
    }

	
	
}

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/api/TContractController.java

@@ -12,6 +12,7 @@
import com.ruoyi.system.service.TContractService;
import com.ruoyi.system.service.THouseService;
import com.ruoyi.system.vo.HouseVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;

 ruoyi-system/src/main/java/com/ruoyi/system/query/TBillQuery.java

New file
@@ -0,0 +1,12 @@
package com.ruoyi.system.query;

import com.ruoyi.common.core.domain.BasePage;
import lombok.Data;

@Data
public class TBillQuery extends BasePage {




}

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/TBillServiceImpl.java

@@ -1,9 +1,14 @@
package com.ruoyi.system.service.impl;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.system.mapper.TBillMapper;
import com.ruoyi.system.model.TBill;
import com.ruoyi.system.query.TBillQuery;
import com.ruoyi.system.service.TBillService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import io.jsonwebtoken.lang.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
@@ -17,4 +22,25 @@
@Service
public class TBillServiceImpl extends ServiceImpl<TBillMapper, TBill> implements TBillService {

    @Autowired
    RedisCache redisCache;

    public AjaxResult queryPage(TBillQuery query){
        return AjaxResult.success();
    }



    /**
     * 传的金额
     * @param tBill
     * @return
     */
    public Boolean checkAndUpdateBill(TBill tBill){
        return true;
    }




}