HttpClient远程接口调用-实名认证

1、HttpClient远程接口调用

1)用户注册

注册按钮button提交表单时，要return false

form表单

    <!-- action="http://localhost:8082/scw-restapi/member/regist" -->
    <form class="form-signin" role="form" action="${ctp}/member/regist"
        method="post" id="regForm">
    ...
    </form>

js提交表单

    $("#submitBtn").click(function() {

        var loginType = $("select.form-control").val();
        log("注册类型==============>", loginType)
        
        /* if (loginType == "管理") {
            $("#regForm").submit();
        } else {
            alert("此功能尚未开通");
        } */

        $("#regForm").submit();
        return false
    })

2)加载外部资源文件

app.properties

restapi.server.ip=127.0.0.1
restapi.server.port=8082
restapi.server.apppath=scw-restapi

编辑springmvc.xml

    <!-- 引入外部配置文件 -->
    <context:property-placeholder
        location="classpath:other/app.properties" />

RestApiServerInfo.java

    @Controller
    public class RestApiServerInfo {
    
        // MemberService memberService;
        @Value("${restapi.server.ip}")
        private String restapiserver;
    
        @Value("${restapi.server.port}")
        private String restapiport;
    
        @Value("${restapi.server.apppath}")
        private String appPath;
    
        public String getRestApiURL() {
            System.out.println("http://" + restapiserver + ":" + restapiport);
            return "http://" + restapiserver + ":" + restapiport + "/" + appPath;
        }
    }

3)HTTPClient工具远程调用接口

导入依赖

    <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.3</version>
    </dependency>

发送post请求

    public static String httpPostRequest(String url, Map<String, Object> params)

工具类HttpClientUtil.java

package com.atguigu.project;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.client.methods.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

/**
 * @author Nan 2015-11
 */
public class HttpClientUtil {

    private static PoolingHttpClientConnectionManager cm;
    private static String EMPTY_STR = "";
    private static String UTF_8 = "UTF-8";

    private static void init() {
        if (cm == null) {
            cm = new PoolingHttpClientConnectionManager();
            cm.setMaxTotal(50);// 整个连接池最大连接数
            cm.setDefaultMaxPerRoute(5);// 每路由最大连接数，默认值是2
        }
    }

    /**
     * 通过连接池获取HttpClient
     * 
     * @return
     */
    private static CloseableHttpClient getHttpClient() {
        init();
        return HttpClients.custom().setConnectionManager(cm).build();
    }

    /**
     * @param url
     * @return
     */
    public static String httpGetRequest(String url) {
        HttpGet httpGet = new HttpGet(url);
        return getResult(httpGet);
    }

    public static String httpGetRequest(String url, Map<String, Object> params) throws URISyntaxException {
        URIBuilder ub = new URIBuilder();
        ub.setPath(url);

        ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
        ub.setParameters(pairs);

        HttpGet httpGet = new HttpGet(ub.build());
        return getResult(httpGet);
    }

    public static String httpGetRequest(String url, Map<String, Object> headers, Map<String, Object> params)
            throws URISyntaxException {
        URIBuilder ub = new URIBuilder();
        ub.setPath(url);

        ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
        ub.setParameters(pairs);

        HttpGet httpGet = new HttpGet(ub.build());
        for (Map.Entry<String, Object> param : headers.entrySet()) {
            httpGet.addHeader(param.getKey(), String.valueOf(param.getValue()));
        }
        return getResult(httpGet);
    }

    public static String httpPostRequest(String url) {
        HttpPost httpPost = new HttpPost(url);
        return getResult(httpPost);
    }

    public static String httpPostRequest(String url, Map<String, Object> params) throws UnsupportedEncodingException {
        HttpPost httpPost = new HttpPost(url);
        ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
        httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));
        return getResult(httpPost);
    }

    public static String httpPostRequest(String url, Map<String, Object> headers, Map<String, Object> params)
            throws UnsupportedEncodingException {
        HttpPost httpPost = new HttpPost(url);

        for (Map.Entry<String, Object> param : headers.entrySet()) {
            httpPost.addHeader(param.getKey(), String.valueOf(param.getValue()));
        }

        ArrayList<NameValuePair> pairs = covertParams2NVPS(params);
        httpPost.setEntity(new UrlEncodedFormEntity(pairs, UTF_8));

        return getResult(httpPost);
    }

    private static ArrayList<NameValuePair> covertParams2NVPS(Map<String, Object> params) {
        ArrayList<NameValuePair> pairs = new ArrayList<NameValuePair>();
        for (Map.Entry<String, Object> param : params.entrySet()) {
            pairs.add(new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue())));
        }

        return pairs;
    }

    /**
     * 处理Http请求
     * 
     * @param request
     * @return
     */
    private static String getResult(HttpRequestBase request) {
        // CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpClient httpClient = getHttpClient();
        try {
            CloseableHttpResponse response = httpClient.execute(request);
            // response.getStatusLine().getStatusCode();
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                // long len = entity.getContentLength();// -1 表示长度未知
                String result = EntityUtils.toString(entity);
                response.close();
                // httpClient.close();
                return result;
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }

        return EMPTY_STR;
    }

}

远程接口返回ScwReturn<T>封装对象

package com.atguigu.scw.restapi.bean;

import java.util.Map;

public class ScwReturn<T> {

    private int code;// 状态码 1：表示成功 0:表示失败
    private String msg;// 要给的提示信息
    private T content;// 响应的内容；
    private Map<String, Object> ext;// 额外的数据

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    public Map<String, Object> getExt() {
        return ext;
    }

    public void setExt(Map<String, Object> ext) {
        this.ext = ext;
    }

    // 两个快速的成功失败方法
    public static <T> ScwReturn<T> success(String msg, T content, Map<String, Object> ext) {
        ScwReturn<T> t = new ScwReturn<T>();
        t.setCode(1);
        t.setMsg(msg);
        t.setContent(content);
        t.setExt(ext);
        return t;
    }

    public static <T> ScwReturn<T> fail(String msg, T content, Map<String, Object> ext) {
        ScwReturn<T> t = new ScwReturn<T>();
        t.setCode(0);
        t.setMsg(msg);
        t.setContent(content);
        t.setExt(ext);
        return t;
    }
}

注册调用远程接口

发送请求

String response = HttpClientUtil.httpPostRequest(url, params);

远程接口返回的响应字符串转java对象

    readValue = new ObjectMapper().readValue(response.getBytes(), new TypeReference<ScwReturn<TMemeber>>() {
        });

@RequestMapping("/regist")
public String regist(TMemeber memeber, Model model) throws Exception {
    // 需要利用http工具去模拟发调用接口的请求
    // http://localhost:8082/scw-restapi/member/regist
    // <httpclient.version>4.5.3</httpclient.version>
    // httpclient使用java代码来模拟发送请求
    // 能收到api调用后产生的json数据；
    // 1、可以将产生的json逆向成对象ScwReturn<TMemeber>
    // 2、可以直接将json写给页面
    System.out.println("memeber===========>" + memeber);
    // 注册成功以后可以来到一个页面；

    // 1、应该去发送请求来进行注册；java代码发请求
    String url = serverInfo.getRestApiURL() + "/member/regist";
    System.out.println("url===========>" + url);
    // 2、构建请求参数
    Map<String, Object> params = new HashMap<String, Object>();

    params.put("loginacct", memeber.getLoginacct());
    // 密码是业务逻辑加密的，我们不用管
    params.put("userpswd", memeber.getUserpswd());
    params.put("email", memeber.getEmail());

    // 响应内容；
    String response = HttpClientUtil.httpPostRequest(url, params);

    // 封装响应为对象
    ScwReturn<TMemeber> readValue = null;

    readValue = new ObjectMapper().readValue(response.getBytes(), new TypeReference<ScwReturn<TMemeber>>() {
    });

    // 判断，注册成功！来到登陆页面
    if (readValue.getCode() == 1) {
        return "redirect:/login.jsp";
    } else {
        // 注册失败！来到注册页面进行回显
        model.addAttribute("msg", "用户名和邮箱已经被注册了！");
        return "forward:/reg.jsp";
    }
}

远程接口注册方法

控制层

    /**
     * ScwReturn<List<TMemeber>>:泛型是content内容的对象的类型
     * 
     * @Description (TODO这里用一句话描述这个方法的作用)
     * @param memeber
     * @return
     */
    @RequestMapping("/regist")
    public ScwReturn<TMemeber> regist(TMemeber memeber) {

        // 创建一个空的对象
        TMemeber regist = new TMemeber();
        Map<String, Object> hashMap = new HashMap<>();
        try {
            regist = memberService.regist(memeber);
        } catch (Exception e) {
            // 判断异常类型来放错误
            // e.printStackTrace();
            hashMap.put("error", "触犯唯一约束，请保证用户名和邮箱唯一");
        }
        regist.setUserpswd("");
        if (regist.getId() != null) {
            return ScwReturn.success("用户注册成功！", regist, null);
        } else {
            return ScwReturn.fail("用户注册失败!", null, hashMap);
        }
    }

业务层

带条件插入

    int i = memeberMapper.insertSelective(tMemeber);

    @Override
    public TMemeber regist(TMemeber tMemeber) {
        // TODO Auto-generated method stub
        String digest = MD5Util.digest(tMemeber.getUserpswd());
        // 加密密码保存
        tMemeber.setUserpswd(digest);
        // 初始化用户名和账号
        tMemeber.setUsername(tMemeber.getLoginacct());
        // 实名认证状态 0:未实名认证 1::实名认证
        tMemeber.setAuthstatus("0");
        // 真实姓名；实名认证是保存的
        tMemeber.setRealname("未实名");
        // 0：普通会员 1：月费会员 2：年费会员 3：
        tMemeber.setUsertype("0");
        // 身份证号，账户类型；（实名认证是做的）
        // 账户类型：直接保存账户的全名

        int i = memeberMapper.insertSelective(tMemeber);

        // 刚才就是按照这个对象给数据库插入值，希望获取到数据库分配的自增主键
        return tMemeber;
    }

2、实名认证文件上传

1)上传用户资质证件

导入依赖

    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.2</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.5</version>
    </dependency>

编辑springmvc.xml文件

    <!-- 1、文件上传需要一个文件上传解析器 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="utf-8"></property>
    </bean>

前台ajax提交

带有文件表单，一次提交所有项

var fd = new FormData($("#certForm")[0])

带有文件表单,提交部分内容

//使用formData（js对象来包装form表单）
var fd = new FormData();
log($("#ad_name_input").val())
log($("#ad_file_input")[0].files[0])
fd.append("name", $("#ad_name_input").val());
fd.append("ad", $("#ad_file_input")[0].files[0])

processData(默认: true)

默认情况下，通过data选项传递进来的数据，如果是一个对象(技术上讲只要不是字符串)，都会处理转化成一个查询字符串，以配合默认内容类型 "application/x-www-form-urlencoded"。

contentType

不使用默认的内容类型；(默认: "application/x-www-form-urlencoded") 发送信息至服务器时内容编码类型。

    //这是一个资质文件上传的页面
    //发送文件上传资质文件请求；
    var fd = new FormData($("#certForm")[0]);
    $.ajax({
        url:"http://localhost:8082/scw-restapi/auth/upload",
        data:fd,
        type:"post",
        contentType:false,
        dataType:"json",
        processData:false,
        success:function(result){
            //来到邮箱填写页面
            location.href="${ctp}/auth/apply-2.html"
        },
        error:function(e){
            layer.msg("上传失败:"+e);
        }
    });

控制层

    //文件上传
    private String uploadfile(String webPath,MultipartFile file,HttpSession session){
        ServletContext context = session.getServletContext();
        String realPath = context.getRealPath(webPath);
        String name = UUID.randomUUID().toString().replace("-", "").substring(0, 10) +"_file_"+ file.getOriginalFilename();
        try {
            //webPath不存在的情况下必须创建
            File file2 = new File(realPath);
            if(!file2.exists()){
                //创建目录
                file2.mkdirs();
            }
            
            file.transferTo(new File(realPath+"/"+name));
            //返回这个图片在服务器下的路径
            return webPath+"/"+name;
        }catch (Exception e) {
            return null;
        }
    }
    
    @RequestMapping("/upload")
    public ScwReturn<Object> upload(HttpSession session,
            @RequestParam("file")MultipartFile[] file,
            @RequestParam("certid")Integer[] certid,@RequestParam("memberid")Integer memberid){
        
        try {
            System.out.println("资质的id"+certid);
            List<TMemberCert> certsList= new ArrayList<TMemberCert>();
            for (int i=0;i<certid.length;i++) {
                TMemberCert cert = new TMemberCert();
                MultipartFile multipartFile = file[i];
                String uploadfile = uploadfile("/certsimg", multipartFile, session);
                cert.setCertid(certid[i]);
                cert.setMemberid(memberid);
                cert.setIconpath(uploadfile);
                certsList.add(cert);
            }
            //调用业务逻辑进行保存;/删除原有资质，保存新的资质
            certService.insertCerts(certsList);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            System.out.println(e);
            return ScwReturn.fail("资质保存失败！", null, null);
        }
        
        return ScwReturn.success("保存成功！", null, null);
    }

2)批量插入用户资质证件描述信息

业务层

CertService.java

    public void insertCerts(List<TMemberCert> certsList);

CertServiceImpl.java

    @Override
    public void insertCerts(List<TMemberCert> certsList) {
        // TODO Auto-generated method stub
        TMemberCertExample example = new TMemberCertExample();
        Criteria criteria = example.createCriteria();
        criteria.andMemberidEqualTo(certsList.get(0).getMemberid());
        //先删除
        memberCertMapper.deleteByExample(example);
        //后保存
        certMapper.insertBatch(certsList);
    }

dao层

TCertMapper.java

    void insertBatch(@Param("certs")List<TMemberCert> certsList);

TCertMapper.xml

  <!-- void insertBatch(@Param("certs")List<TMemberCert> certsList); -->
  <insert id="insertBatch">
        INSERT INTO t_member_cert(memberid,certid,iconpath) 
        VALUES
        <foreach collection="certs" item="c" separator=",">
            (#{c.memberid},#{c.certid},#{c.iconpath})
        </foreach>
  </insert>

原文链接:https://www.cnblogs.com/lisingshen/p/11569290.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有