手写基于 http 的RPC框架

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了手写基于 http 的RPC框架相关的知识,希望对你有一定的参考价值。

一、模块划分

聚合工程

顶级模块:​new_rpc​

父模块:​httpclient_rpc​

子模块:​​httpclient_rpc_server、httpclient_rpc_client​、​httpclient_rpc_pojo​​

使用顶级模块是因为rpc协议自定义了两种方式,现在介绍的是​​httpclient_rpc​​这种方式

二、pom依赖

1.new_rpc

<groupId>com.zhkucst</groupId>
<artifactId>new_rpc</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>httpclient_rpc</module>
</modules>

2.httpclient_rpc

<parent>
<artifactId>new_rpc</artifactId>
<groupId>com.zhkucst</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>


<artifactId>httpclient_rpc</artifactId>
<packaging>pom</packaging>
<modules>
<module>httpclient_rpc_server</module>
<module>httpclient_rpc_client</module>
<module>httpclient_rpc_pojo</module>
</modules>

3.httpclient_rpc_pojo

<parent>
<artifactId>httpclient_rpc</artifactId>
<groupId>com.zhkucst</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>


<artifactId>httpclient_rpc_pojo</artifactId>

4.httpclient_rpc_server

<parent>
<artifactId>httpclient_rpc</artifactId>
<groupId>com.zhkucst</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>httpclient_rpc_server</artifactId>


<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.2.RELEASE</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>


<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.zhkucst</groupId>
<artifactId>httpclient_rpc_pojo</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>

5.httpclient_rpc_client

<parent>
<artifactId>httpclient_rpc</artifactId>
<groupId>com.zhkucst</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>


<artifactId>httpclient_rpc_client</artifactId>


<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.2.RELEASE</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>


<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--httpclient 依赖-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.13</version>
</dependency>
<dependency>
<groupId>com.zhkucst</groupId>
<artifactId>httpclient_rpc_pojo</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.11.1</version>
</dependency>
</dependencies>

三、内容

1.httpclient_rpc_pojo

pojo类

package com.zhkucst.httpclient.pojo;


import sun.security.jca.GetInstance;


import java.io.Serializable;
import java.util.Date;


/**
* @version v1.0
* @ClassName: User
* @Description: TODO
* @Author: fyp
* @data: 2021年 11月 07日 14:55
*/
public class User implements Serializable


private String name;
private String password;
private Date birth;


public int getAge()
if(birth == null)
return -1;

int birthYear = birth.getYear();
int currentYear = new Date().getYear();
return currentYear - birthYear;



public Date getBirth()
return birth;



public void setBirth(Date birth)
this.birth = birth;



public String getName()
return name;



public void setName(String name)
this.name = name;



public String getPassword()
return password;



public void setPassword(String password)
this.password = password;



@Override
public String toString()
return "\\"name\\":\\""+ name +"\\",\\"password\\":\\""+ password +"\\"";

2.httpclient_rpc_server

服务端控制器,即客户端发起请求的控制区

package com.zhkucst.httpclientserver.controller;


import com.zhkucst.httpclient.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


import java.util.List;


/**
* @version v1.0
* @ClassName: TestController
* @Description: TODO
* @Author: fyp
* @data: 2021年 10月 18日 21:33
*/
@Controller
public class TestController
/**
* CrossOrigin - 跨域请求注解。在响应头上增加跨域处理允许,可以让ajax跨越请求当前的服务方法
* @param users
* @return
*/
//使用请求体传递请求参数
@RequestMapping(value = "/bodyParams", produces = "application/json;charset=UTF-8")
@ResponseBody
@CrossOrigin
public String bodyParams(@RequestBody List<User> users)
System.out.println(users);
return users.toString();



@RequestMapping(value = "/params", produces = "application/json;charset=UTF-8")
@ResponseBody
public String params(String name, String password)
System.out.println("name - " + name + " ; password - " + password);
return "\\"msg\\":\\"登录成功\\",\\"user\\":\\"name\\":\\""+name+"\\",\\"password\\":\\""+password+"\\"";



@RequestMapping(value = "/test", produces = "application/json;charset=UTF-8")
@ResponseBody
public String test()
return "\\"msg\\":\\"处理返回\\"";

3.httpclient_rpc_client

通过后端实现访问请求,后端以SpringBoot方式启动,前端直接java访问

package com.zhkucst.httpclient;


import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zhkucst.httpclient.pojo.User;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;


import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;


/**
* @version v1.0
* @ClassName: TestHttpClient
* @Description: TODO
* @Author: fyp
* @data: 2021年 10月 18日 21:46
*/


public class TestHttpClient
public static void main(String[] args) throws Exception
//testGetNoParams();
//testGetParams();
testPost();
//testGetParams();



/**
* 有参Get请求
* @throws IOException
* @throws URISyntaxException
*/
public static void testGetParams() throws IOException, URISyntaxException
//基于Builder构建请求地址
HttpClient client = HttpClients.createDefault();
URIBuilder builder = new URIBuilder("http://localhost/params");
//基于单参数传递,构建请求地址
//builder.addParameter("name", "bjsxt");
//builder.addParameter("password", "admin123");
//URI uri = builder.build();


//基于多参数传递,构建请求地址
List<NameValuePair> nvps = new ArrayList<>();
nvps.add(new BasicNameValuePair("name", "bjsxt"));
nvps.add(new BasicNameValuePair("password", "admin123"));
builder.addParameters(nvps);
URI uri = builder.build();


String result = EntityUtils.toString(client.execute(new HttpGet(uri)).getEntity());
System.out.println(result);





/**
* 无参数GET请求
* 使用浏览器,访问网站的过程是:
* 1、打开浏览器
* 2、输入网址
* 3、访问
* 4、看结果
* 使用HttpClient,访问WEB服务的过程:
* 1、创建客户端,相当于打开浏览器
* 2、创建请求地址,相当于输入地址
* 3、发起请求,相当于访问网站(回车键)
* 4、处理响应结果,相当于浏览器显示结果
*/
private static void testGetNoParams() throws IOException
// 创建客户端对象
HttpClient client = HttpClients.createDefault();
// 创建请求地址
HttpGet get = new HttpGet("http://localhost:80/test");
// 发起请求,接收响应对象
HttpResponse response = client.execute(get);
// 获取响应体,响应数据是一个基于HTTP协议标准字符串封装的对象
HttpEntity entity = response.getEntity();
// 通过HTT实体工具类,转换响应体数据,使用的字符串是UTF-8
String responseString = EntityUtils.toString(entity, "UTF-8");


System.out.println("服务器响应的数据是 - [ " + responseString + "]");


client = null;



/**
* POST请求
*/
public static void testPost() throws Exception
//无参数Post请求
HttpClient client = HttpClients.createDefault();
HttpPost post = new HttpPost("http://localhost/test");
HttpResponse response = client.execute(post);
System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));


//有参数的Post请求
//请求头传递参数,和Get请求携带参数的方式一致
URIBuilder builder = new URIBuilder("http://localhost/params");
builder.addParameter("name", "post");
builder.addParameter("password", "postPassword");
URI uri = builder.build();
HttpResponse postResponse = client.execute(new HttpPost(uri));
System.out.println(EntityUtils.toString(postResponse.getEntity(), "UTF-8"));


//请求体传递参数
HttpPost bodyParamsPost = new HttpPost("http://localhost/bodyParams");
//定义请求体协议,设置请求参数。使用请求体传递参数的时候,需要定义请求体格式。默认是表单格式
//使用URLBuilder构建的URI对象,就是请求体传递参数的。
User u1 = new User();
u1.setName("zs");
u1.setPassword("123");
User u2 = new User();
u2.setName("ls");
u2.setPassword("456");


//手动json格式化
//String paramsString = "[" + u1.toString() + "," + u2.toString() + "]";


//使用jackson框架格式化
List<User> list = new ArrayList<>();
list.add(u1);
list.add(u2);
String paramsString;
ObjectMapper om = new ObjectMapper();
paramsString = om.writeValueAsString(list);


HttpEntity entity = new StringEntity(paramsString, "application/json", "UTF-8");
bodyParamsPost.setEntity(entity);
System.out.println(EntityUtils.toString(client.execute(bodyParamsPost).getEntity(), "UTF-8"));
String responseString = EntityUtils.toString(client.execute(bodyParamsPost).getEntity(), "UTF-8");
//将一个json格式的对象转换为java对象
String userString = responseString.substring(1, responseString.indexOf(",") + 1);
User responseUser = om.readValue(userString, User.class);
System.out.println(responseUser);
//将以json格式的对象数组转换为java对象数组
JavaType valueType = om.getTypeFactory().constructParametricType(List.class, User.class);
List<User> responseUserList = om.readValue(responseString, valueType);
System.out.println(responseUserList);




通过页面的​​ajax​​​请求访问,后端以​​springboot​​启动,前端以​web​​​启动

注意需要导入​​jquery.js​​包才可使用ajax请求,这里如果使用了跨域请求,也就是前后端分离请求,就需要在后端设置​​@CrossOrigin​​来允许跨域访问

手写基于

手写基于

后端没有设置​​@CrossOrigin​​会导致跨域请求而访问失败

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript" src="jquery-3.5.1.min.js"></script>
<script type="text/javascript">
//javascript中默认的,ajax请求不能跨域
//跨域 - ajax所属的站点,和被请求的站点,不是同一个域
//域 - id,端口,域名,主机名,任何一个有变化,都是不同域
function sendBodyParams()
$.ajax(
"url": "http://localhost:80/bodyParams",
"type": "post",
"data": "[\\"name\\":\\"abc\\",\\"password\\":\\"123\\",\\"name\\":\\"def\\",\\"password\\":\\"456\\"]",
"contentType": "application/json",//必须设定,代表请求体的格式。默认是text/plain,默认是参数名=参数值&参数名=参数值
"dataType": "json",
"success": function(data)
alert(data);
console.log(data);

);

</script>
</head>
<body style="text-align: center">
<button onclick="sendBodyParams()">测试ajax请求,请求体传递JSON数据</button>
</body>
</html>

以上是关于手写基于 http 的RPC框架的主要内容,如果未能解决你的问题,请参考以下文章

手写dubbo 10-基于netty实现RPC

带你手写基于 Spring 的可插拔式 RPC 框架整体结构

带你手写基于 Spring 的可插拔式 RPC 框架代理类的注入与服务启动

基于Netty手写RPC框架进阶版(下)——注册中心及服务的动态扩容

#yyds干货盘点# 基于Netty,20分钟手写一个RPC框架

手写RPC框架-第五天 支持HTTP协议