很楠不爱3

这个屌丝很懒，什么也没留下！

热门标签

手写一个简单rpc框架（一）_springbeanfactory.getbeanlistbyannotationclass方法

作者：很楠不爱3 | 2024-06-06 01:04:31

踩

springbeanfactory.getbeanlistbyannotationclass方法

扑街前言：前面说了netty的基本运用、Java的NIO等一系列的知识，这些知识已经可以做一个简单的rpc框架，本篇和下篇我们一起了解一个怎么完成一个rpc框架，当然个只是为了更好的了解rpc框架的基本逻辑，并不是真的可以用于业务使用。（认识到自己是菜鸟的第47天，今天突然记起来是多少天了）

在编写具体代码之前，我们要了解什么是rpc框架，它是由什么结构组成的，而最常见RPC框架就是Dubbo。

RPC 的主要功能目标是让构建分布式计算（应用）更容易，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议规范，简单的来说就是像调用本地服务一样调用远程服务，对开发者而言是透明的。

RPC的优势

RPC框架一般使用长链接，不必每次通信都要3次握手，减少网络开销。
RPC框架一般都有注册中心，有丰富的监控管理。
发布、下线接口、动态扩展等，对调用方来说是无感知、统一化的操作。
协议私密，安全性较高。
rpc 能做到协议更简单内容更小，效率更高。
rpc是面向服务的更高级的抽象，支持服务注册发现，负载均衡，超时重试，熔断降级等高级特性。

RPC架构设计

一幅图片解释整个rpc的架构设计

上述简单描述一下rpc的一些简单概念，那么首先来编写服务端的代码，因为服务端的编写难度要小于客户端。从上面图片可以看出服务端主要是：服务注册（这里用zookeeper作为注册中心）、监听端口接收连接（包括请求解码、响应编码、请求处理，而编码和解码又有一次编、解码和二次编、解码）。当然这是简单的基本功能，比如限流、健康监测之类的后续再说，先迈出第一步很重要。

zookeeper

在代码开始之前，还需要简单的了解zookeeper的安装和使用，安装就是在zookeeper的官网下载一下最新的稳定版本，然后解压，打开bin目录，运行zkServer.cmd即可。具体的详细下篇文章再说，本篇文章重点是rpc框架的基本编写。至于Java中使用zookeeper，可以类比Redis的使用，Redis为Java提供了两个客户端 Jedis 和 Redisson，下面代码我们也是使用zookeeper了一个客户端 zkclient。

代码逻辑示例

上述内容结合之前文章的相关的网络编程内容，可以先写一个服务端，代码如下。首先结合上面的流程图，大致说一下逻辑。1、需要一个引导类，用于引导整个rpc服务的启动；2、有一个启动器，在启动器中完成服务注册和基于netty的监听；3、需要一个服务注册的server，基于zookeeper实现服务注册，需要封装zookeeper的连接和调用；4、需要一个netty的server，实现一次、二次编解码，并且实现请求处理调用具体的业务逻辑。

引导类

这里单独说明一下@PostConstruct注解，这个具体作用是当这个类被注册bean的时候，会运行一次被修饰的方法，但是在jdk9之后就去除了。


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
 
import javax.annotation.PostConstruct;
 
@Configuration
public class RpcServerBootstrap {
 
    @Autowired
    private RpcServerRnner rpcServerRnner;
 
    @PostConstruct
    public void initRpcServer (){
        // 运行启动器
        rpcServerRnner.run();
    }
}

启动器


import com.rpc.server.registry.RpcRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import javax.annotation.Resource;
 
@Component
public class RpcServerRnner {
    @Autowired
    private RpcRegistry rpcRegistry;
 
    @Resource
    private RpcServer rpcServer;
 
    /**
     * 用于服务注册和netty监听
     */
    public void run () {
        // 服务注册
        rpcRegistry.serviceRegistry();
 
        // 启动服务，监听端口，接收连接请求
        rpcServer.start();
    }
}

配置信息对象


import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
@Data
@Component
public class RpcServerConfiguration {
 
    /**
     * ZK根节点名称
     */
    @Value("${rpc.server.zk.root}")
    private String zkRoot;
 
    /**
     * ZK地址信息
     */
    @Value("${rpc.server.zk.addr}")
    private String zkAddr;
 
 
    /**
     * RPC通讯端口
     */
    @Value("${rpc.network.port}")
    private int rpcPort;
 
    /**
     * Spring Boot 服务端口
     */
    @Value("${server.port}")
    private int serverPort;
 
    /**
     * ZK连接超时时间配置
     */
    @Value("${rpc.server.zk.timeout:10000}")
    private int connectTimeout;
}

zookeeper客户端连接


import org.I0Itec.zkclient.ZkClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class ServerZkClientConfig {
 
    /**
     * RPC服务端配置
     */
    @Autowired
    private RpcServerConfiguration rpcServerConfiguration;
 
    /**
     * 声音ZK客户端
     * @return
     */
    @Bean
    public ZkClient zkClient() {
        return new ZkClient(rpcServerConfiguration.getZkAddr(), rpcServerConfiguration.getConnectTimeout());
    }
}

zookeeper连接操作接口


import org.I0Itec.zkclient.ZkClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
/**
 * Zookeeper连接操作接口
 */
@Component
public class ServerZKit {
 
    @Autowired
    private ZkClient zkClient;
 
    @Autowired
    private RpcServerConfiguration rpcServerConfiguration;
 
    /***
     * 根节点创建
     */
    public void createRootNode() {
        boolean exists = zkClient.exists(rpcServerConfiguration.getZkRoot());
        if (!exists) {
            zkClient.createPersistent(rpcServerConfiguration.getZkRoot());
        }
    }
 
    /***
     * 创建其他节点
     * @param path
     */
    public void createPersistentNode(String path) {
        String pathName = rpcServerConfiguration.getZkRoot() + "/" + path;
        boolean exists = zkClient.exists(pathName);
        if (!exists) {
            zkClient.createPersistent(pathName);
        }
    }
 
    /***
     * 创建节点
     * @param path
     */
    public void createNode(String path) {
        String pathName = rpcServerConfiguration.getZkRoot() + "/" + path;
        boolean exists = zkClient.exists(pathName);
        if (!exists) {
            zkClient.createEphemeral(pathName);
        }
    }
}

用于服务请求连接的注解


import org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Component;
import java.lang.annotation.*;
 
@Component
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface HrpcService {
 
    /**
     * 等同于@Component的value
     * @return
     */
    @AliasFor(annotation = Component.class)
    String value() default "";
 
    /**
     * 服务接口Class
     * @return
     */
    Class<?> interfaceClass() default void.class;
 
    /**
     * 服务接口名称
     * @return
     */
    String interfaceName() default "";
 
    /**
     * 服务版本号
     * @return
     */
    String version() default "";
 
    /**
     * 服务分组
     * @return
     */
    String group() default "";
}

创建一个Spring的Bean工厂，用于封装获取IOC容器中的bean信息


import org.springframework.beans.BeansException;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
import java.lang.annotation.Annotation;
import java.util.Map;
 
@Component
public class SpringBeanFactory implements ApplicationContextAware {
 
    /**
     * ioc容器
     */
    private static ApplicationContext context;
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }
 
    /*public static ApplicationContext getApplicationContext() {
        return context;
    }*/
 
    /**
     * 根据Class获取bean
     * @param cls
     * @param <T>
     * @return
     */
    public static   <T> T getBean(Class<T> cls) {
        return context.getBean(cls);
    }
 
    /**
     * 根据beanName获取bean
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName) {
        return context.getBean(beanName);
    }
 
    /***
     * 获取有指定注解的对象
     * @param annotationClass
     * @return
     */
    public static Map<String, Object> getBeanListByAnnotationClass(Class<? extends Annotation> annotationClass) {
         return context.getBeansWithAnnotation(annotationClass);
    }
 
    /**
     * 向容器注册单例bean
     * @param bean
     */
    public static void registerSingleton(Object bean) {
        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getAutowireCapableBeanFactory();
        // 让bean完成Spring初始化过程中所有增强器检验，只是不重新创建bean
        beanFactory.applyBeanPostProcessorsAfterInitialization(bean,bean.getClass().getName());
        //将bean以单例的形式入驻到容器中，此时通过bean.getClass().getName()或bean.getClass()都可以拿到放入Spring容器的Bean
        beanFactory.registerSingleton(bean.getClass().getName(),bean);
    }
}

服务注册

上面的准备工作基本上就做完了，下面开始正式的逻辑代码。这里提一点，当spring boot整合这个自定义框架的时候，可以有很多方式，这个不再细说，可以参考文章spring boot的自动配置，这里可以直接粗暴一点在spring boot项目的启动类上@SpringBootApplication(scanBasePackages ={"包路径","包路径"})。

再说一下@component 注解，这是由spring 提供，被其修饰的类被声明为spring 的组件，简单来说就是创建bean并放置IOC容器中。


/**
 * 服务注册接口
 */
public interface RpcRegistry {
    /**
     * 服务注册
     */
    void serviceRegistry();
}
 
import com.rpc.annotation.HrpcService;
import com.rpc.server.config.RpcServerConfiguration;
import com.rpc.server.registry.RpcRegistry;
import com.rpc.spring.SpringBeanFactory;
import com.rpc.util.IpUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
@Component
@Slf4j
public class ZkRegistry implements RpcRegistry {
    /**
     * 封装的bean工厂
     */
    @Autowired
    private SpringBeanFactory springBeanFactory;
 
    /**
     * 封装的zookeeper的客户端
     */
    @Autowired
    private ServerZKit zKitClient;
 
    /**
     * 配置信息对象
     */
    @Autowired
    private RpcServerConfiguration rpcServerConfiguration;
 
    @Override
    public void serviceRegistry() {
        /*
         * 1、首先要获取被HrpcService 注解修饰的，IOC中的所有的bean信息
         * 2、拿到bean之后，再获取bean上的HrpcService 注解对象
         * 3、拿到HrpcService 注解上面的接口信息
         * 4、创建zookeeper上的根节点，并获取服务端ip和配置文件中的zookeeper端口，创建以接口名称为key，ip+端口为value的子节点
         * 5、注册成功
         */
        // 获取被HrpcService 注解修饰的，IOC中的所有的bean信息
        Map<String, Object> annotationClass = springBeanFactory.getBeanListByAnnotationClass(HrpcService.class);
 
        // 没被注册信息，直接结束
        if (annotationClass == null || annotationClass.size() < 0){
            return;
        }
 
        // 迭代所有的bean
        for (Object bean : annotationClass.values()) {
            // 获取HrpcService 注解信息
            HrpcService hrpcService = bean.getClass().getAnnotation(HrpcService.class);
 
            // 获取HrpcService 注解的interfaceClass属性，也就是接口对象
            Class<?> interfaceClass = hrpcService.interfaceClass();
 
            // 获取接口的名称
            String name = interfaceClass.getName();
 
            /*
             * 开始往zookeeper添加节点
             */
            // 根节点
            zKitClient.createRootNode();
 
            // 子节点，用于接口名称
            zKitClient.createPersistentNode(name);
 
            // 获取ip
            String ip = IpUtil.getRealIp();
            // ip + 端口
            String node = ip + rpcServerConfiguration.getZkAddr();
            // 子节点对应下级节点
            zKitClient.createNode(name + "/" + node);
 
            // 打印日志
            log.info("服务{}-{}注册成功", name, node);
        }
    }
}

序列化工具


import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import lombok.extern.slf4j.Slf4j;
 
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
 
/**
 * @description
 * @author: ts
 * @create:2021-04-08 10:31
 */
@Slf4j
public class ProtostuffUtil {
	
	//存储因为无法直接序列化/反序列化 而需要被包装的类型Class
	private static final Set<Class<?>> WRAPPER_SET = new HashSet<Class<?>>();
	
	static {
		WRAPPER_SET.add(List.class);
		WRAPPER_SET.add(ArrayList.class);
		WRAPPER_SET.add(CopyOnWriteArrayList.class);
		WRAPPER_SET.add(LinkedList.class);
		WRAPPER_SET.add(Stack.class);
		WRAPPER_SET.add(Vector.class);
		WRAPPER_SET.add(Map.class);
		WRAPPER_SET.add(HashMap.class);
		WRAPPER_SET.add(TreeMap.class);
		WRAPPER_SET.add(LinkedHashMap.class);
		WRAPPER_SET.add(Hashtable.class);
		WRAPPER_SET.add(SortedMap.class);
		WRAPPER_SET.add(Object.class);
	}
	
	//注册需要使用包装类进行序列化的Class对象
	public static void registerWrapperClass(Class<?> clazz) {
		WRAPPER_SET.add(clazz);
	}
	
	/**
	 * 将对象序列化为字节数组
	 * @param t
	 * @param useWrapper 为true完全使用包装模式 为false则选择性的使用包装模式
	 * @param <T>
	 * @return
	 */
	public static <T> byte[] serialize(T t,boolean useWrapper) {
		Object serializerObj = t;
		if (useWrapper) {
			serializerObj = SerializeDeserializeWrapper.build(t);
		}
		return serialize(serializerObj);
	}
	
	/**
	 * 将对象序列化为字节数组
	 * @param t
	 * @param <T>
	 * @return
	 */
	public static <T> byte[] serialize(T t) {
		//获取序列化对象的class
		Class<T> clazz = (Class<T>) t.getClass();
		Object serializerObj = t;
		if (WRAPPER_SET.contains(clazz)) {
			serializerObj = SerializeDeserializeWrapper.build(t);//将原始序列化对象进行包装
		}
		return doSerialize(serializerObj);
	}
	
	
	/**
	 * 执行序列化
	 * @param t
	 * @param <T>
	 * @return
	 */
	public static <T> byte[] doSerialize(T t) {
		//获取序列化对象的class
		Class<T> clazz = (Class<T>) t.getClass();
		//获取Schema
		// RuntimeSchema<T> schema = RuntimeSchema.createFrom(clazz);//根据给定的class创建schema
		/**
		 * this is lazily created and cached by RuntimeSchema
		 * so its safe to call RuntimeSchema.getSchema() over and over The getSchema method is also thread-safe
		 */
		Schema<T> schema = RuntimeSchema.getSchema(clazz);//内部有缓存机制
		/**
		 * Re-use (manage) this buffer to avoid allocating on every serialization
		 */
		LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
		byte[] protostuff = null;
		try {
			protostuff = ProtostuffIOUtil.toByteArray(t, schema, buffer);
		} catch (Exception e){
			log.error("protostuff serialize error,{}",e.getMessage());
		}finally {
			buffer.clear();
		}
		return protostuff;
	}
	
	
	/**
	 * 反序列化
	 * @param data
	 * @param clazz
	 * @param <T>
	 * @return
	 */
	public static <T> T deserialize(byte[] data,Class<T> clazz) {
		//判断是否经过包装
		if (WRAPPER_SET.contains(clazz)) {
			SerializeDeserializeWrapper<T> wrapper = new SerializeDeserializeWrapper<T>();
			ProtostuffIOUtil.mergeFrom(data,wrapper,RuntimeSchema.getSchema(SerializeDeserializeWrapper.class));
			return wrapper.getData();
		}else {
			Schema<T> schema = RuntimeSchema.getSchema(clazz);
			T newMessage = schema.newMessage();
			ProtostuffIOUtil.mergeFrom(data,newMessage,schema);
			return newMessage;
		}
	}
	
	
	private static class SerializeDeserializeWrapper<T> {
		//被包装的数据
		T data;
		
		public static <T> SerializeDeserializeWrapper<T> build(T data){
			SerializeDeserializeWrapper<T> wrapper = new SerializeDeserializeWrapper<T>();
			wrapper.setData(data);
			return wrapper;
		}
		
		public T getData() {
			return data;
		}
		
		public void setData(T data) {
			this.data = data;
		}
	}
}

一次编码


import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
 
/**
 * 一次解码
 */
public class FrameDecoder extends LengthFieldBasedFrameDecoder {
    public FrameDecoder() {
        super(Integer.MAX_VALUE, 0, 4, 0, 4);
    }
}

二次编码


import com.rpc.util.ProtostuffUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;
import lombok.extern.slf4j.Slf4j;
 
import java.util.List;
 
/**
 * 服务端的二次编码
 */
@Slf4j
public class RpcResponseEncoder extends MessageToMessageEncoder<ByteBuf> {
    @Override
    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        /*
         * 首先将传入的ByteBuf 序列化为一个byte 数组
         * 然后用ChannelHandlerContext 构建一个buffer对象
         * 最后写入buffer，添加out写出
         */
        try {
            // 使用序列化工具，将msg序列化
            byte[] bytes = ProtostuffUtil.serialize(msg);
 
            // 由ctx分配构建一个buffer对象
            ByteBuf buffer = ctx.alloc().buffer(bytes.length);
            // 将数据交给buffer
            buffer.writeBytes(bytes);
 
            // 添加写出
            out.add(buffer);
        } catch (Exception e) {
            // 异常
            log.error("RpcResponseEncoder exception ,msg={}",e.getMessage());
        }
    }
}

一次解码


import io.netty.handler.codec.LengthFieldPrepender;
 
/**
 * 一次解码
 */
public class FrameEncoder extends LengthFieldPrepender {
    public FrameEncoder() {
        super(4);
    }
}

二次解码


import com.itheima.rpc.util.ProtostuffUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;
import lombok.extern.slf4j.Slf4j;
 
import java.util.List;
 
/**
 * 服务端的二次编码
 */
@Slf4j
public class RpcResponseEncoder extends MessageToMessageEncoder<ByteBuf> {
    @Override
    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        /*
         * 首先将传入的ByteBuf 序列化为一个byte 数组
         * 然后用ChannelHandlerContext 构建一个buffer对象
         * 最后写入buffer，添加out写出
         */
        try {
            // 使用序列化工具，将msg序列化
            byte[] bytes = ProtostuffUtil.serialize(msg);
 
            // 由ctx分配构建一个buffer对象
            ByteBuf buffer = ctx.alloc().buffer(bytes.length);
            // 将数据交给buffer
            buffer.writeBytes(bytes);
 
            // 添加写出
            out.add(buffer);
        } catch (Exception e) {
            // 异常
            log.error("RpcResponseEncoder exception ,msg={}",e.getMessage());
        }
    }
}

响应对象


import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
 
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RpcResponse {
    private String requestId;
    private Object result;
    private Throwable cause;
 
    public boolean isError() {
        return cause != null;
    }
}

请求对象


import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
 
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RpcRequest {
    private String requestId;
    private String className;
    private String methodName;
    private Class<?>[] parameterTypes;
    private Object[] parameters;
}

业务逻辑调用Handler


import com.itheima.rpc.data.RpcRequest;
import com.itheima.rpc.data.RpcResponse;
import com.itheima.rpc.spring.SpringBeanFactory;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import lombok.extern.slf4j.Slf4j;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
/**
 * 客户端请求业务调用
 */
@Slf4j
public class RpcRequestHandler extends SimpleChannelInboundHandler<RpcRequest> {
 
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcRequest rpcRequest) throws Exception {
        /*
         * 先创建请求对应的响应对象
         * 从请求对象中获取相关接口信息，接口名称、方法名称、参数类型、参数
         * 根据接名称从容器中获取bean
         * 用反射，根据方法和参数类型拿到Method 对象
         * 将参数传入Method 对象，然后运行，拿到返回值
         * 将返回值给到响应对象
         * 一定要将响应对象回写给客户端
         */
        log.info("服务端收到的请求是:{}",rpcRequest);
        // 构建响应对象
        RpcResponse rpcResponse = new RpcResponse();
        // 于请求对象关联
        rpcResponse.setRequestId(rpcRequest.getRequestId());
 
        try {
            // 接口名称
            String interfaceName = rpcRequest.getClassName();
            // 方法名称
            String methodName = rpcRequest.getMethodName();
            // 参数类型
            Class<?>[] parameterTypes = rpcRequest.getParameterTypes();
            // 实际参数
            Object[] parameters = rpcRequest.getParameters();
 
            // 从容器中获取bean实例
            Object bean = SpringBeanFactory.getBean(Class.forName(interfaceName));
            // 反射获取method 对象
            Method method = bean.getClass().getMethod(methodName, parameterTypes);
            // 执行对应方法，拿到返回值
            Object result = method.invoke(bean, parameters);
 
            // 添加到响应对象
            rpcResponse.setResult(result);
        } catch (Exception e) {
            log.error("RpcRequestHandler exception,msg={}",e.getMessage());
            rpcResponse.setCause(e);
        } finally {
            // 将结果写回
            log.info("向客户端发送响应,{}",rpcResponse);
            ctx.writeAndFlush(rpcResponse);
        }
    }
}

netty代码实现


import com.rpc.netty.codec.FrameDecoder;
import com.rpc.netty.codec.FrameEncoder;
import com.rpc.netty.codec.RpcRequestDecoder;
import com.rpc.netty.codec.RpcResponseEncoder;
import com.rpc.netty.handler.RpcRequestHandler;
import com.rpc.server.boot.RpcServer;
import com.rpc.server.config.RpcServerConfiguration;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.NettyRuntime;
import io.netty.util.concurrent.DefaultThreadFactory;
import org.springframework.beans.factory.annotation.Autowired;
 
public class NettServer implements RpcServer {
    @Autowired
    private RpcServerConfiguration rpcServerConfiguration;
 
 
    @Override
    public void start() {
        /*
         * 首先要获取三个线程池，用于注册serverSocketChannel、socketChannel 还有业务逻辑处理（即请求调用）
         * 再构建引导类，并配置先关信息，将注册请求和处理读写的线程池配置到引导类中，然后配置好相关的 handler（第一、二次编解码，请求调用），注意请求调用使用线程池做处理
         * 最后启动引导类，绑定监听端口，设置同步
         * 监控等待关闭
         * 优雅的关闭线程池
         */
        // 构建注册serverSocketChannel 的线程池
        NioEventLoopGroup boss = new NioEventLoopGroup(1, new DefaultThreadFactory("boss"));
        // 构建注册socketChannel 的线程池
        NioEventLoopGroup worker = new NioEventLoopGroup(0, new DefaultThreadFactory("worker"));
        // 构建业务调用的线程池
        NioEventLoopGroup rpcRequestHandler = new NioEventLoopGroup(NettyRuntime.availableProcessors() * 2, new DefaultThreadFactory("reqRequestHandler"));
 
        // 业务逻辑调用
        RpcRequestHandler requestHandler = new RpcRequestHandler();
 
        try {
            // 构建引导类
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 配置引导类
            serverBootstrap.group(boss, worker)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG,1024)
                    .childOption(ChannelOption.TCP_NODELAY,true)
                    .childOption(ChannelOption.SO_KEEPALIVE,true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // 获取 pipeline
                            ChannelPipeline pipeline = socketChannel.pipeline();
 
                            /*
                             * 配置 handler
                             */
                            // 一级编码
                            pipeline.addLast("FrameEncoder", new FrameEncoder());
                            // 二级编码
                            pipeline.addLast("RpcResponseEncoder", new RpcResponseEncoder());
 
                            // 一级解码
                            pipeline.addLast("FrameDecoder", new FrameDecoder());
                            // 二级解码
                            pipeline.addLast("RpcRequestDecoder", new RpcRequestDecoder());
 
                            // 业务线程池调用
                            pipeline.addLast(rpcRequestHandler, "requestHandler", requestHandler);
                        }
                    });
 
            // 启动引导类，监听端口，设置同步
            ChannelFuture future = serverBootstrap.bind(rpcServerConfiguration.getRpcPort()).sync();
            // 监控等待关闭
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            // 异常
            e.printStackTrace();
        } finally {
            /*
             * 优雅的关闭各个线程池
             */
            boss.shutdownGracefully();
            worker.shutdownGracefully();
            rpcRequestHandler.shutdownGracefully();
        }
    }
}

上述内容就已经完成了一个服务端的创建，后续文章在说客户端，本次结束。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/678848