从哪下手?
接上一节的内容,两个最单的模块我们已经编码完成,现在开始正餐,但是从哪下手呢?
前面我们提到,数据经过网络传输需要有一个序列化 反序列化
的过程,那不妨就从序列化开始,因为目前只是写一个乞丐版,暂不考虑不同序列化方式对rpc性能以及传输是否压缩数据等问题,本着能简就减的原则,直接使用jdk自带的序列化方法,余下的后期再调整。
先看看pom
文件,rpc-protocol pom.xml
<?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">
<parent>
<artifactId>custom-rpc</artifactId>
<groupId>com.info</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>rpc-protocol</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- 日志实现 -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
</dependency>
</dependencies>
</project>
目前只知道底层网络传输需要依赖netty
,就先依赖一个netty
,lombok
简化getter/setter
,其他的需要的时候再添加。
实现JDK自带的序列化反序列化
,本着可扩展的原则(面向接口编程),先定义一个序列化接口:
package com.info.protocol.serial;
public interface Serializer {
/**
* 序列化
*
* @param obj 待序列化的对象
* @param <T>
* @return 序列化后得到的二进制数据
*/
<T> byte[] serialize(T obj);
/**
* @param data 待反序列化的byte数组
* @param clz 序列化后的对象class类型
* @param <T>
* @return 序列化后得到的对象
*/
<T> T deserialize(byte[] data, Class<T> clz);
/**
* 序列化的方式,多种序列化方式的时候,该方法可以区分序列化的类型
*
* @return 实现序列化的方式
*/
byte getType();
}
因为后期可能有多种序列化方式,因此定义一个序列化方式的枚举,方便统一管理。
package com.info.protocol.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
@Getter
@AllArgsConstructor
public enum SerializeTypeEnum {
JDK((byte) 1);
private byte code;
/**
* @param code 这里为了调用方便,code 就传 int 类型了
* @return
*/
public static SerializeTypeEnum getSerializeTypeByCode(int code) {
return Arrays.stream(SerializeTypeEnum.values())
.filter(e -> e.getCode() == code)
.findFirst()
.orElseGet(null);
}
}
实现jdk的序列化方法
package com.info.protocol.serial;
import com.info.protocol.enums.SerializeTypeEnum;
import lombok.extern.slf4j.Slf4j;
import java.io.*;
@Slf4j
public class JdkSerializer implements Serializer {
@Override
public <T> byte[] serialize(T obj) {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos)) {
os.writeObject(obj);
return bos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
log.error("序列化 {} 对象出错", obj);
}
return new byte[0];
}
@Override
public <T> T deserialize(byte[] data, Class<T> clz) {
try (ByteArrayInputStream bin = new ByteArrayInputStream(data);
ObjectInputStream oin = new ObjectInputStream(bin)) {
return (T) oin.readObject();
} catch (IOException e) {
e.printStackTrace();
log.error("反序列化 对象出错");
} catch (ClassNotFoundException e) {
e.printStackTrace();
log.error("反序列化对象出错,未找到对应的类型 {}", e.getCause().getMessage());
}
return null;
}
@Override
public byte getType() {
return SerializeTypeEnum.JDK.getCode();
}
}
下面实现一个netty
的客户端和服务端,有的兄弟对此可能已经很熟悉了,一切从零开始,我还是先从最基础的写起,也算是复习下。
package com.info.protocol.netty;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class NettyServer {
private String address;
private int port;
private static final int CORE_CPUS = Runtime.getRuntime().availableProcessors();
public NettyServer(String address, int port) {
this.address = address;
this.port = port;
}
/**
* 启动netty服务端
*/
public void startServer() {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(CORE_CPUS >> 1);
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class);
.childHandler(new CustomServerInitializer());
final ChannelFuture future = bootstrap.bind(this.address, this.port).sync();
log.info("start netty server success on port : " + this.port);
future.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
这就是netty的服务端,属于模板代码
,几乎每个集成netty
的服务端代码都长这样。但是,如果只是这样的模板代码是没有意义的,因为没有处理具体业务的逻辑。
系列文章传送门如下:
手写RPC(一) 絮絮叨叨
手写RPC(二) 碎碎念
手写RPC(三) 基础结构搭建
手写RPC(五) 核心模块网络协议模块编写 ---- 自定义协议
手写RPC(六) 核心模块网络协议模块编写 ---- 实现编解码器
手写RPC(七) 核心模块网络协议模块编写 ---- 实现客户端
手写RPC(八) provider、consumer 实现
手写RPC(九) 测试
手写RPC(十) 优化
关于 LengthFieldBasedFrameDecoder 不得不说的事