从哪下手？
接上一节的内容，两个最单的模块我们已经编码完成，现在开始正餐，但是从哪下手呢？
前面我们提到，数据经过网络传输需要有一个序列化 反序列化的过程，那不妨就从序列化开始，因为目前知识写一个乞丐版，暂不考虑不同序列化方式对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的服务端代码都长这样。但是，如果只是这样的模板代码是没有意义的，因为没有处理具体业务的逻辑。