接口代码整理-程序员宅基地

1.调用接口：

（1）http协议工具类：

/**
 * 
 */
package kklazy.test.utils;

import java.io.IOException;
import org.apache.http.HttpEntity;
import org.apache.http.StatusLine;
import org.apache.http.client.methods.CloseableHttpResponse;
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.HttpClients;
import org.apache.http.util.EntityUtils;

/**
 * @author whh
 * http协议工具类
 */
public class HttpUtils {
    
    /**
     * 调用接口
     * @param url 被调用接口的IP地址
     * @param msg 上送json数据
     * @param charset 编码格式
     * @return
     */
    public static String callInterface(String url, String msg, String charset){
        //组装设置请求参数
        StringEntity requestEntity = new StringEntity(msg, charset);
        requestEntity.setContentEncoding(charset);
        requestEntity.setContentType("text/json");
        //创建一个httpclient对象
        CloseableHttpClient  httpClient = null;
        //创建post对象
        HttpPost httpPost = new HttpPost(url);
        httpPost.setEntity(requestEntity);
        String entityStr = null;        
        try {
            httpClient = HttpClients.createDefault();//创建默认的httpClient实例
            CloseableHttpResponse  httpResponse = httpClient.execute(httpPost);//执行请求
            try{
                HttpEntity entity = httpResponse.getEntity();    
                entityStr = EntityUtils.toString(entity,"utf-8");            
                System.out.println("接口响应返回内容:"+entityStr);  
            } finally{
                //关闭httpclient连接，释放资源
                httpResponse.close();
            } 
            StatusLine statusLine = httpResponse.getStatusLine();            
            int statusCode = statusLine.getStatusCode();//获取响应的结果            
            System.out.println("statusCode:"+statusCode);            
            
        } catch (Exception e) {   
            
        }finally{
            if(null != httpClient){
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
        }
        return entityStr;
    }

}

（2）接口参数类：

/**
 * 
 */
package kklazy.test.entity;

/**
 * @author whh
 * 调用接口参数
 */
public class ApiParam {
    /**
     * 
     */
    private String version ;//版本号 1.0
    private String reqType;//交易类型:15
    private String desc;//说明
    /**
     * @return the version
     */
    public String getVersion() {
        return version;
    }
    /**
     * @param version the version to set
     */
    public void setVersion(String version) {
        this.version = version;
    }
    /**
     * @return the reqType
     */
    public String getReqType() {
        return reqType;
    }
    /**
     * @param reqType the reqType to set
     */
    public void setReqType(String reqType) {
        this.reqType = reqType;
    }
    /**
     * @return the desc
     */
    public String getDesc() {
        return desc;
    }
    /**
     * @param desc the desc to set
     */
    public void setDesc(String desc) {
        this.desc = desc;
    }
}

（3）HttpService:

package kklazy.test.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.alibaba.fastjson.JSON;
import kklazy.test.entity.ApiParam;
import kklazy.test.utils.HttpUtils;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * @author whh
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class HttpService  {
    
    public void callInterface(){
        ApiParam apiParam  = new  ApiParam();
        apiParam.setVersion("1.0");//版本号
        apiParam.setReqType("15");//交易类型：固定值15
        apiParam.setDesc("ABC");//说明
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("requestData",apiParam);//存入map，key为：requestData
        map.put("signature","111111");//签名：内部使用暂不验签
        /**
         * 需要发送的json数据格式为：
         * {"requestData":{"version":"1.0","reqType":"15","desc":"aaa"},"signature":"11111111"}
         */
        //map转换成json
        String jsonMsg = JSON.toJSONString(map,true);
        System.out.println("调用XX系统接口参数值:"+jsonMsg);
        String responseJson = HttpUtils.callInterface("http://192.168.17.61:9805/UAT/receipt/refund.json", jsonMsg, "UTF-8");//调用接口
        Map<String, Object> responseMap = parseJSONToMap(responseJson);
        //获取XX系统返回信息：应答码，响应信息
        String  respCode = (String) responseMap.get("respCode");
        String  respMsg  = (String) responseMap.get("respMsg");
        System.out.println("XX系统返回responseMap：应答码："+respCode+",响应信息："+respMsg);
        
    }
    
    /**
     * json转换成map类型
     * @param jsonStr
     * @return
     */
  public  Map<String, Object> parseJSONToMap(String jsonStr){
        Map<String,Object> map = new HashMap<String, Object>();
        //最外层解析
        JSONObject    json = JSONObject.fromObject(jsonStr);
        for(Object k :json.keySet()){
            Object v = json.get(k);
            //如果内层还是数组的话，继续解析
            if(v instanceof JSONArray){
                List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
                @SuppressWarnings("unchecked")
                Iterator<JSONObject> it = ((JSONArray)v).iterator();
                while(it.hasNext()){
                    JSONObject json2 = it.next();
                    list.add(parseJSONToMap(json2.toString()));
                }
                map.put(k.toString(), list);
            }else{
                map.put(k.toString(), v);
            }
        }
        return map;
    }
    
}

 2.被调用接口：

（1）InterfaceController:

/**
 * 
 */
package kklazy.test.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import kklazy.api.model.TransAmtWhiteListEntity;
import kklazy.api.service.TransAmtWhiteListService;
import kklazy.api.utils.JSONHelpUtils;
import kklazy.common.controller.BasePageController;
import kklazy.persistence.service.PageService;
import kklazy.persistence.utils.DateUtils;
import kklazy.persistence.utils.StringUtils;
/**
 * 接口（被调用）
 * @author whh
 *
 */
@Controller
@RequestMapping("interfaceController")
public class InterfaceController extends BasePageController<TransAmtWhiteListEntity, String> {

    @Autowired
    private TransAmtWhiteListService transAmtWhiteListService;
    @Override
    public PageService<TransAmtWhiteListEntity, String> pageservice() {
        return transAmtWhiteListService;
    }

    @Override
    public String path() {
        return "";
    }

    /**
     * @param request
     * @param response
     * @param modelMap
     * @return
     */
    @SuppressWarnings("unchecked")
    @ResponseBody
    @RequestMapping(value = "match")//@RequestBody一般情况下来说常用其来处理application/json类型:接收json格式的请求报文
    public Map<String, Map<String, String>> match(HttpServletRequest request, HttpServletResponse response, ModelMap modelMap,@RequestBody String requetData) {
        Map<String, Object> requestBody ;
        Map<String, Object> header;
        Map<String, Object> body ;
        Map<String, Map<String, String>> result = new HashMap<String, Map<String, String>>();//响应结果
        //若请求数据为空，给出提示
        if(StringUtils.isBlank(requetData)){
            Map<String, String> data = new HashMap<String, String>();
            data.put("code","9999");
            data.put("message","请求信息不合格（都为空），请重新发送");
            result.put("data",data );
            return result;
        }
        
        //获取请求报文header和body中参数
        requestBody = JSONHelpUtils.parseJSONToMap(requetData);//json->map
        System.out.println("请求信息："+requestBody.toString());
        header = (Map<String, Object>) requestBody.get("HEADER");
 body = (Map<String, Object>) requestBody.get("BODY");
        //校验请求信息是否合格
        if(null ==header || header.size() <= 0){
            Map<String, String> data = new HashMap<String, String>();
            data.put("code","9999");
            data.put("message","请求信息不合格（HEADER为空），请重新发送");
            result.put("data",data );
            return result;
        }
        if(null ==body || body.size() <= 0){
            Map<String, String> data = new HashMap<String, String>();
            data.put("code","9999");
            data.put("message","请求信息不合格（BODY为空），请重新发送");
            result.put("data",data );
            return result;
        }
        //解析请求报文中header
        String ver = (null!=header.get("VER")?header.get("VER").toString():null);         //版本号1.00
        String sn = (null!=header.get("SN")?header.get("SN").toString():null);              // 请求流水号(同一发起方每次发起的风控请求时，每次送不同的值。便于后续定位风控流水的查询。)
        String reqFrom = (null!=header.get("REQ_FROM")?header.get("REQ_FROM").toString():null);// 请求来源  商户前置：MER_FRONT   C核心：C_CORE
        String tci = (null!=header.get("TCI")?header.get("TCI").toString():null);         //Transcation Channel Identifier交易渠道标识
        String resDt = DateUtils.format("yyyyMMddHHmmss");//获取当前时间为请求响应时间
        String resv1 = (null!=header.get("RESV1")?header.get("RESV1").toString():null);     // 保留域1
        //封装响应报文header
        Map<String, String> headerResult = new HashMap<String, String>();
        headerResult.put("VER", ver);
        headerResult.put("SN", sn);
        headerResult.put("REQ_FROM", reqFrom);
        headerResult.put("TCI", tci);
        headerResult.put("PROC_DT", resDt);
        headerResult.put("RESV1", resv1);
        result.put("HEADER", headerResult);
        //解析body中字段并进行处理
        String formId = (null!=body.get("FORM_ID")?body.get("FORM_ID").toString():null);//长度为15位。
        Map<String, String> bodyResult = new HashMap<String, String>();//把响应报文中body封装为bodyResult
        //校验：formId比较重要，若为空，直接打回
        if (StringUtils.isBlank(formId)) {
            bodyResult.put("RSP_CODE", "1111");
            bodyResult.put("RSP_MSG", "FORM_ID不能为空");
            result.put("BODY", bodyResult);
            return result;
        }
        //当formId为“AvailabilityTest”时，表明用户的请求用于检查接口的可用性。此时，应立刻返回成功报文给用户。
        if("AvailabilityTest".equals(formId)){
            bodyResult.put("RSP_CODE", "0000");
            bodyResult.put("RSP_MSG", "接口可用");
            result.put("BODY", bodyResult);
            return result;
        }
        String orgNo = (null!=body.get("ORG_NO")?body.get("ORG_NO").toString():null);                // 机构号(前端)
        String merchNo = (null!=body.get("MERCH_NO")?body.get("MERCH_NO").toString():null);            // 商户号(前端)
        String transAmt = (null!=body.get("TRANS_AMT")?body.get("TRANS_AMT").toString():null);        // 交易金额
        
        /**
         * 根据机构号，商户号，交易金额和是允许任意金额标志否查询是否存在满足条件的数据
         * 若查询到记录，则
         * （若存在，则说明1.不需规定金额过滤；2.符合白名单金额规则；否则，就是支付金额不符合规定）
         */
        StringBuilder sb = new StringBuilder("select count(*) from dual where exists ( SELECT 1 FROM  YST_TRANS_AMT_WHITE_LIST t where t.is_delete='0' and t.status='1' ");
        sb.append(" and t.form_id='"+formId+"' ");
        if(StringUtils.isNotBlank(orgNo)){
            sb.append(" and t.org_no='"+orgNo+"' ");
        }
        if(StringUtils.isNotBlank(merchNo)){
            sb.append(" and t.merch_no='"+merchNo+"' ");
        }
        sb.append(" and (t.flag_all_amt='1' or (t.flag_all_amt='0' and t.allowed_amt='"+transAmt+"' ))) ");
        @SuppressWarnings("unchecked")
        List<Object> count= (List<Object>) transAmtWhiteListService.findByNativeSql(sb);
        //当查寻出isExist为0时，说明数据库不存在满足条件的白名单，当为1时，存在满足条件的白名单记录
        String isExist=     count.get(0).toString();
        bodyResult.put("RSP_CODE", "0000");
        bodyResult.put("RSP_MSG", "OK");
        if("0".equals(isExist)){
            bodyResult.put("RSP_CODE", "9999");
  　　　　　　bodyResult.put("RSP_MSG", "支付金额不符合规定");
        }
        result.put("BODY", bodyResult);
        
        System.out.println("响应信息："+result.toString());
        return result;
    }
    
    
}

(2)JSONHelpUtils:

package kklazy.api.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * @author14  *
 */
public class JSONHelpUtils {
    /**
     * json转换成map类型
     * @param jsonStr
     * @return
     */
  public static Map<String, Object> parseJSONToMap(String jsonStr){
        Map<String,Object> map = new HashMap<String, Object>();
        //最外层解析
        JSONObject    json = JSONObject.fromObject(jsonStr);
        for(Object k :json.keySet()){
            Object v = json.get(k);
            //如果内层还是数组的话，继续解析
            if(v instanceof JSONArray){
                List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
                @SuppressWarnings("unchecked")
                Iterator<JSONObject> it = ((JSONArray)v).iterator();
                while(it.hasNext()){
                    JSONObject json2 = it.next();
                    list.add(parseJSONToMap(json2.toString()));
                }
                map.put(k.toString(), list);
            }else{
                map.put(k.toString(), v);
            }
        }
        return map;
    }
    
  }

（3）使用Postman发送请求：

方式一：直接url后面跟参：

http://localhost:8080/AAA/interfaceController/match?body={"FORM_ID":" AvailabilityTest","ORG_NO":"","MERCH_NO":" 123456789012345","TERM_NO":null,"ACCT_NO":"01","TRANS_AMT":"2015-11-17 11:16:59","TRANS_TYPE":null}

方式二：json格式

http://localhost:8080/AAA/interfaceController/match

{"HEADER":{"VER":"1.0","SN":"31231","REQ_FROM":"MER_FRONT","TCI":"WECHAT_H5","PROC_DT":"20170717153555","RESV1":null},

"BODY":{"FORM_ID":"000000000008643","ORG_NO":"61000016","MERCH_NO":"939310058120001","TERM_NO":null,"ACCT_NO":"01","TRANS_AMT":"0000000011000","TRANS_TYPE":null}}