HttpClient实现RPC

HTTPClient实现RPC

一、HttpClient简介

在JDK中，java.net包下面提供了用户HTTP访问的基本功能，但是它缺少灵活性或许多应用需要的功能。

HttpClient起初是Apache Jakarta Common的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持Http协议的最新版本。2007年成为顶级项目。

通俗点来说，HTTPClient可以实现使用java代码完成标准的HTTP请求和响应。

二、代码实现

1. 服务端

新建项目HttpClientServer


导入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.veeja</groupId>
    <artifactId>HttpClientServer</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.11.RELEASE</version>
    </parent>

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

① 新建启动类

package com.veeja;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author veeja
 * 2021/1/18 10:16
 */
@SpringBootApplication
public class ServerApplication {

    public static void main(String[] args) {

        SpringApplication.run(ServerApplication.class, args);

    }

}

② 新建控制器

com.veeja.controller.DemoController

package com.veeja.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @Author veeja
 * 2021/1/18 10:19
 */
@Controller
public class DemoController {
    @RequestMapping("/demo")
    @ResponseBody
    public String demo(String param) {
        return param + "by Veeja.Liu";
    }
}

③ 浏览器请求测试

我们可以在浏览器里面请求一下，看到是可以得到符合预期的效果的。

2. 客户端

我们再创建一个项目HttpClientDemo，来模拟我们的客户端：

① 添加依赖

添加http-components依赖：

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.10</version>
</dependency>

② 创建测试方法

测试GET方法：

@Test
public void testGet() {
    try {

        // 1. 创建一个Http工具（可以理解为浏览器），能发送请求，能解析响应
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 2. 确定请求的路径
        URIBuilder uriBuilder = new URIBuilder("http://localhost:8080/demo");
        // 3. 创建HTTP Get请求对象
        HttpGet get = new HttpGet(uriBuilder.build());
        // 4. 创建响应对象，
        CloseableHttpResponse response = httpClient.execute(get);
        // 5. 由于响应体是字符串，因此把HttpEntity类型转换为字符串类型，并且设置字符集编码
        String result = EntityUtils.toString(response.getEntity(), "UTF-8");
        // 6. 输出结果
        System.out.println(result);

        // 释放资源
        response.close();
        httpClient.close();

    } catch (URISyntaxException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

运行结果：

null by Veeja.Liu

③ 测试Post请求方式

@Test
public void testPost() {

    try {
        // 1. 创建HttpClient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        // 2. 创建一个请求对象，HttpPost请求对象
        HttpPost post = new HttpPost("http://localhost:8080/demo");
        // 2.1 创建请求参数
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("param", "Hello,Post!"));
        // 2.2 创建HttpEntity接口的文本实现类对象,放入参数并设置编码
        HttpEntity httpEntity = new UrlEncodedFormEntity(params, "UTF-8");
        // 2.3 放入到HttpPost对象中
        post.setEntity(httpEntity);

        // 3. 创建响应对象
        CloseableHttpResponse response = httpClient.execute(post);

        // 4. 响应体为字符串，把HttpEntity类型转换为字符串类型
        String result = EntityUtils.toString(response.getEntity(), "UTF-8");

        // 5. 输出结果
        System.out.println(result);

        // 6. 释放资源
        response.close();
        httpClient.close();

    } catch (IOException e) {
        e.printStackTrace();
    }

}

测试结果：

Hello,Post! by Veeja.Liu

三、返回对象类型

上面的示例中，我们返回的值都是简单的字符串，而在现实中，我们返回的可能是复杂的对象、实体类。这个时候我们要用“Jackson”。就是将对象，List，Json互相的转换。

我们演示一下：

1. 服务端的编写

① 新建一个实体类User

package com.veeja.bean;

/**
 * @Author veeja
 * 2021/1/18 11:24
 */
public class User {

    private Integer id;
    private String name;

    构造方法()...
    toString()方法...
    get/set方法()...
}

② Controller方法

@RequestMapping("/demo2")
@ResponseBody
public User demo2(User user) {
    return user;
}

③ 浏览器测试

访问http://localhost:8080/demo2?id=1&name=veeja：

2. 客户端代码访问

① json格式输出

我们直接打印输出看一下结果：

/**
 * 响应对象转换为json格式的字符串
 */
@Test
public void testObject() {
    try {
        // 1. 创建http工具
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 2. 创建 Post请求
        HttpPost httpPost = new HttpPost("Http://localhost:8080/demo2");
        // 3. 创建参数
        List<NameValuePair> params = new ArrayList<NameValuePair>();
        params.add(new BasicNameValuePair("id", "001"));
        params.add(new BasicNameValuePair("name", "刘伟佳"));
        // 4. 将参数放入HttpEntity
        HttpEntity httpEntity = new UrlEncodedFormEntity(params, "UTF-8");
        httpPost.setEntity(httpEntity);
        // 5. 获取响应对象
        CloseableHttpResponse response = httpClient.execute(httpPost);
        String content = EntityUtils.toString(response.getEntity());

        System.out.println(content);

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

结果：

{"id":1,"name":"刘伟佳"}

② json转换为对象

在客户端的项目中，我们也先创建User实体类：

同上，省略。

为了能将json格式的字符串转换为Obejct对象，我们需要用到Jackson，首先我们先导入Jackson依赖：

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.0</version>
</dependency>

然后我们把json格式的转换为对象：

// jackson 把字符串转换为对象
ObjectMapper objectMapper = new ObjectMapper();
User user = objectMapper.readValue(content, User.class);
System.out.println(user);

对比上面的输出，我们查看一下：

{"id":1,"name":"刘伟佳"}
User{id=1, name='刘伟佳'}

③ 对象转换为json

// 把对象转换为json
String userJson = objectMapper.writeValueAsString(user);
System.out.println(userJson);

使用writeValueAsString()方法可以将对象转换为json格式。

四、返回集合类型

1. 服务器的编写

① 实体类省略，和上面一样

② Controller方法

@RequestMapping("/demo3")
@ResponseBody
public List<User> demo3() {

    User user = new User(20, "Veeja");
    User user2 = new User(22, "Veeja.Liu");
    User user3 = new User(24, "Andrew");

    List<User> list = new ArrayList<User>();

    list.add(user);
    list.add(user2);
    list.add(user3);

    return list;
}

③ 浏览器测试

2. 客户端代码访问

获取响应内容，并将json解析成List集合：

/**
 * 响应对象为List的字符串
 */
@Test
public void testList() {
    try {
        // 1. 创建http工具
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 2. HttpPost
        HttpPost httpPost = new HttpPost("http://localhost:8080/demo3");
        CloseableHttpResponse response = httpClient.execute(httpPost);

        // String
        String content = EntityUtils.toString(response.getEntity());
        System.out.println(content);

        // Jackson 将json转换为集合类型
        ObjectMapper objectMapper = new ObjectMapper();
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(List.class, User.class);
        List<User> list = objectMapper.readValue(content, javaType);
        System.out.println(list);

        response.close();
        httpClient.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

执行结果：

[{"id":20,"name":"Veeja"},{"id":22,"name":"Veeja.Liu"},{"id":24,"name":"Andrew"}]
[User{id=20, name='Veeja'}, User{id=22, name='Veeja.Liu'}, User{id=24, name='Andrew'}]

五、流数据参数

我们可以看一下上面请求的具体信息：

我们看到响应的content-type是application/json类型的，并不是文本类型，除去文本类型的其他响应类型 我们统称为流数据，而且不仅仅在我们的响应中有流数据，在我们的请求中，也可以用流数据，例如下面的代码：

@RequestMapping("/demo4")
@ResponseBody
public List<User> demo4(HttpServletRequest request) {
    request.getInputStream().read();
}

为什么我们要使用流数据的，这是因为可能有些时候我们使用文本数据类型非常的不方便，比如我们写一个Controller，请求的参数是一个List集合：

@RequestMapping("/demo4")
@ResponseBody
public String demo4(List<User> list) {
    System.out.println(list);
    return list.toString();
}

然后我们模拟客户端进行请求：

@Test
public void testInputStream() {
    try {
        // 1.创建Http工具
        CloseableHttpClient httpClient = HttpClients.createDefault();
        // 2. 创建HttpPost对象
        HttpPost httpPost = new HttpPost("http://localhost:8080/demo4");

        // 3. 创建List集合
        List<User> list = new ArrayList<>();
        list.add(new User(1, "liuweijia"));
        list.add(new User(3, "veeja"));
        list.add(new User(2, "Andrew"));

        // 4. 将集合转换为json类型的字符串
        ObjectMapper objectMapper = new ObjectMapper();
        Object value;
        String jsonParam = objectMapper.writeValueAsString(list);

        HttpEntity httpEntity = new StringEntity(jsonParam, ContentType.APPLICATION_JSON);

        httpPost.setEntity(httpEntity);

        CloseableHttpResponse response = httpClient.execute(httpPost);

        String content = EntityUtils.toString(response.getEntity());
        System.out.println(content);

        response.close();
        httpClient.close();
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

我们尝试一下：

{"timestamp":"2021-01-25T02:04:29.417+0000","status":500,"error":"Internal Server Error","message":"No primary or default constructor found for interface java.util.List","path":"/demo4"}

结果出现了500错误，这个异常是因为我们的服务器端在接收文本类型的时候不知道我们传进去的不是一个文本类型，而是一个流数据。所以我们需要加一个注解@RequestBody，即改为：

@RequestMapping("/demo4")
@ResponseBody
public String demo4(@RequestBody List<User> list) {
    System.out.println(list);
    return list.toString();
}

再次重启服务器并执行测试方法，
结果就是正确的了：

[User{id=1, name='liuweijia'}, User{id=3, name='veeja'}, User{id=2, name='Andrew'}]

六、Ajax完成发送json参数

1. 服务器端

@RequestMapping("/demo5")
@ResponseBody
public List<User> demo5(@RequestBody List<User> list) {
    System.out.println(list.toString());
    return list;    
}

在Resource下建立以下文件及目录：

index.html：

<!DOCTYPE html>
<html lang="en">
	<head>
	    <meta charset="UTF-8">
	    <title>Title</title>
	    <script type="text/javascript" src="/js/jquery-1.7.2.js"></script>
	    <script type="text/javascript">
	        $(function () {
	            $("button").click(function () {
	
	                var json = '[{"id":123,"name":"liuweijia"},{"id":234,"name":"Veeja.Liu"}]'
	
	                $.ajax({
	                    url: '/demo5',
	                    type: 'post',
	                    success: function (data) {
	                        for (var i = 0; i < data.length; i++) {
	                            alert(data[i].id + " " + data[i].name)
	                        }
	                    },
	                    contentType: 'application/json', //请求体中的内容类型
	                    dataType: 'json',//响应内容类型
	                    data: json
	                });
	            });
	        });
	    </script>
	</head>
	<body>
		<button>按钮</button>
	</body>
</html>

2. 请求效果

我们可以在开发者控制台里看到请求和响应的格式都是json的：

七、Ajax跨域请求

我们上面的请求全是在服务端完成了，其实并没有什么意义。

我们把刚才相同的文件和代码拷贝一份放入客户端中：

导入依赖：

新建ServerApplication类：

package com.veeja.httpclient;

import org.springframework.boot.SpringApplication;

/**
 * @Author veeja
 * 2021/2/2 18:02
 */
@SpringBootApplication
public class ServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServerApplication.class,args);
    }
}

因为我们的服务端用的是8080端口，我们的客户端在端口上需要换一个：
resources下面建立文件application.yml文件：

server:
  port: 8081

现在，我们的8080上的服务器端，是有demo5的方法的，而8081上根本没有这个方法。
我们想要访问8080上的demo5，该怎么办呢？

最简单的我们可能想到，前面加上IP地址就行了：

我们启动客户端的服务，访问客户端的html试一试:

我们点击了按钮，出现了403的错误。

这里就涉及到了Ajax的跨域请求：

• 什么是跨域？请求中协议、ip、端口中只要有一个不同就是跨域请求。
• 同源策略︰浏览器默认只允许ajax访问同源(协议、ip、端口都相同)内容。
• 解决方式
  在控制器接口上添加@CrossOrigin。表示允许跨域。
  本质在响应头中添加Access-Control-Allow-origin:*

也就是在服务端改为：

@RequestMapping("/demo5")
@ResponseBody
@CrossOrigin
public List<User> demo5(@RequestBody List<User> list) {
    System.out.println(list.toString());
    return list;
}

我们重启服务，再次访问，就可以了：