Netty SpringBoot 的整合

Netty与Spring Boot的整合

​ 最近有朋友向我询问一些Netty与SpringBoot整合的相关问题,这里,我就总结了一下基本整合流程,也就是说,这篇文章 ,默认大家是对netty与Spring,SpringMVC的整合是没有什么问题的。现在,就进入正题吧。

Server端:

总的来说,服务端还是比较简单的,自己一共写了三个核心类。分别是

  • NettyServerListener:服务启动监听器
  • ServerChannelHandlerAdapter:通道适配器,主要用于多线程共享
  • RequestDispatcher:请求分排器

下面开始集成过程:

  1. 在pom.xml中添加以下依赖

    <dependency>
     <groupId>io.netty</groupId>
     <artifactId>netty-all</artifactId>
     <version>5.0.0.Alpha2</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>
  2. 让SpringBoot的启动类实现CommandLineRunner接口并重写run方法,比如我的启动类是CloudApplication.java

    @SpringBootApplication
    public class CloudApplication implements CommandLineRunner {
    
       public static void main(String[] args) {
           SpringApplication.run(CloudApplication.class, args);
       }
    
       @Override
       public void run(String... strings) {
       }
    }
  3. 创建类NettyServerListener.java

    // 读取yml的一个配置类
    import com.edu.hart.modules.constant.NettyConfig;
    // Netty连接信息配置类
    import com.edu.hart.modules.constant.NettyConstant;
    // 
    import com.edu.hart.rpc.util.ObjectCodec;
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelPipeline;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
    import io.netty.handler.codec.LengthFieldPrepender;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PreDestroy;
    import javax.annotation.Resource;
    
    /**
    * 服务启动监听器
    *
    * @author 叶云轩
    */
    @Component
    public class NettyServerListener {
       /**
        * NettyServerListener 日志输出器
        *
        * @author 叶云轩 create by 2017/10/31 18:05
        */
       private static final Logger LOGGER = LoggerFactory.getLogger(NettyServerListener.class);
       /**
        * 创建bootstrap
        */
       ServerBootstrap serverBootstrap = new ServerBootstrap();
       /**
        * BOSS
        */
       EventLoopGroup boss = new NioEventLoopGroup();
       /**
        * Worker
        */
       EventLoopGroup work = new NioEventLoopGroup();
       /**
        * 通道适配器
        */
       @Resource
       private ServerChannelHandlerAdapter channelHandlerAdapter;
       /**
        * NETT服务器配置类
        */
       @Resource
       private NettyConfig nettyConfig;
    
       /**
        * 关闭服务器方法
        */
       @PreDestroy
       public void close() {
           LOGGER.info("关闭服务器....");
           //优雅退出
           boss.shutdownGracefully();
           work.shutdownGracefully();
       }
    
       /**
        * 开启及服务线程
        */
       public void start() {
           // 从配置文件中(application.yml)获取服务端监听端口号
           int port = nettyConfig.getPort();
           serverBootstrap.group(boss, work)
                   .channel(NioServerSocketChannel.class)
                   .option(ChannelOption.SO_BACKLOG, 100)
                   .handler(new LoggingHandler(LogLevel.INFO));
           try {
               //设置事件处理
               serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                   @Override
                   protected void initChannel(SocketChannel ch) throws Exception {
                       ChannelPipeline pipeline = ch.pipeline();
                       pipeline.addLast(new LengthFieldBasedFrameDecoder(nettyConfig.getMaxFrameLength()
                               , 0, 2, 0, 2));
                       pipeline.addLast(new LengthFieldPrepender(2));
                       pipeline.addLast(new ObjectCodec());
    
                       pipeline.addLast(channelHandlerAdapter);
                   }
               });
               LOGGER.info("netty服务器在[{}]端口启动监听", port);
               ChannelFuture f = serverBootstrap.bind(port).sync();
               f.channel().closeFuture().sync();
           } catch (InterruptedException e) {
               LOGGER.info("[出现异常] 释放资源");
               boss.shutdownGracefully();
               work.shutdownGracefully();
           }
       }
    }
  4. 创建类ServerChannelHandlerAdapter.java - 通道适配器

    // 记录调用方法的元信息的类
    import com.edu.hart.rpc.entity.MethodInvokeMeta;
    import io.netty.channel.ChannelHandler.Sharable;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    
    /**
    * 多线程共享
    */
    @Component
    @Sharable
    public class ServerChannelHandlerAdapter extends ChannelHandlerAdapter {
      /**
        * 日志处理
        */
       private Logger logger = LoggerFactory.getLogger(ServerChannelHandlerAdapter.class);
    /**
        * 注入请求分排器
        */
       @Resource
       private RequestDispatcher dispatcher;
    
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
           cause.printStackTrace();
           ctx.close();
       }
    
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) {
           MethodInvokeMeta invokeMeta = (MethodInvokeMeta) msg;
           // 屏蔽toString()方法
           if (invokeMeta.getMethodName().endsWith("toString()")
                   && !"class java.lang.String".equals(invokeMeta.getReturnType().toString()))
               logger.info("客户端传入参数 :{},返回值:{}",
                       invokeMeta.getArgs(), invokeMeta.getReturnType());
           dispatcher.dispatcher(ctx, invokeMeta);
       }
    }
  5. RequestDispatcher.java

    // 封装的返回信息枚举类
    import com.edu.hart.modules.communicate.ResponseCodeEnum;
    // 封装的返回信息实体类
    import com.edu.hart.modules.communicate.ResponseResult;
    // 封装的连接常量类
    import com.edu.hart.modules.constant.NettyConstant;
    // 记录元方法信息的实体类
    import com.edu.hart.rpc.entity.MethodInvokeMeta;
    // 对于返回值为空的一个处理
    import com.edu.hart.rpc.entity.NullWritable;
    // 封装的返回信息实体工具类
    import com.edu.hart.rpc.util.ResponseResultUtil;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelFutureListener;
    import io.netty.channel.ChannelHandlerContext;
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
    * 请求分排器
    */
    @Component
    public class RequestDispatcher implements ApplicationContextAware {
       private ExecutorService executorService = Executors.newFixedThreadPool(NettyConstant.getMaxThreads());
       private ApplicationContext app;
    
       /**
        * 发送
        *
        * @param ctx
        * @param invokeMeta
        */
       public void dispatcher(final ChannelHandlerContext ctx, final MethodInvokeMeta invokeMeta) {
           executorService.submit(() -> {
               ChannelFuture f = null;
               try {
                   Class<?> interfaceClass = invokeMeta.getInterfaceClass();
                   String name = invokeMeta.getMethodName();
                   Object[] args = invokeMeta.getArgs();
                   Class<?>[] parameterTypes = invokeMeta.getParameterTypes();
                   Object targetObject = app.getBean(interfaceClass);
                   Method method = targetObject.getClass().getMethod(name, parameterTypes);
                   Object obj = method.invoke(targetObject, args);
                   if (obj == null) {
                       f = ctx.writeAndFlush(NullWritable.nullWritable());
                   } else {
                       f = ctx.writeAndFlush(obj);
                   }
                   f.addListener(ChannelFutureListener.CLOSE);
               } catch (Exception e) {
                   ResponseResult error = ResponseResultUtil.error(ResponseCodeEnum.SERVER_ERROR);
                   f = ctx.writeAndFlush(error);
               } finally {
                   f.addListener(ChannelFutureListener.CLOSE);
               }
           });
       }
    
       /**
        * 加载当前application.xml
        *
        * @param ctx
        * @throws BeansException
        */
       public void setApplicationContext(ApplicationContext ctx) throws BeansException {
           this.app = ctx;
       }
    }
  6. application.yml文件中对于netty的一个配置

    netty:
     port: 11111
  7. NettyConfig.java

    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    /**
    * 读取yml配置文件中的信息
    * Created by 叶云轩 on 2017/10/31 - 18:38
    * Concat tdg_yyx@foxmail.com
    */
    @Component
    @ConfigurationProperties(prefix = "netty")
    public class NettyConfig {
    
       private int port;
    
       public int getPort() {
           return port;
       }
    
       public void setPort(int port) {
           this.port = port;
       }
    }
  8. NettyConstanct.java

    import org.springframework.stereotype.Component;
    
    /**
    * Netty服务器常量
    * Created by 叶云轩 on 2017/10/31 - 17:47
    * Concat tdg_yyx@foxmail.com
    */
    @Component
    public class NettyConstant {
    
       /**
        * 最大线程量
        */
       private static final int MAX_THREADS = 1024;
       /**
        * 数据包最大长度
        */
       private static final int MAX_FRAME_LENGTH = 65535;
    
       public static int getMaxFrameLength() {
           return MAX_FRAME_LENGTH;
       }
    
       public static int getMaxThreads() {
           return MAX_THREADS;
       }
    }

    至此,netty服务端算是与SpringBoot整合成功。那么看一下启动情况吧。

    spring-boot netty集成启动

Client端:

Client我感觉要比Server端要麻烦一点。这里还是先给出核心类吧。

  • NettyClient : netty客户端
  • ClientChannelHandlerAdapter : 客户端通道适配器
  • CustomChannelInitalizer:自定义通道初始化工具
  • RPCProxyFactoryBean:RPC通信代理工厂

在Client端里。SpringBoot的启动类要继承SpringBootServletInitializer这个类,并覆盖SpringApplicationBuilder方法

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
public class OaApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication.run(OaApplication.class, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(OaApplication.class);
    }
}
  1. NettyClient.java

    // 记录元方法信息的实体类
    import com.edu.hart.rpc.entity.MethodInvokeMeta;
    import io.netty.bootstrap.Bootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.nio.NioSocketChannel;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.management.MBeanServer;
    
    /**
    * 客户端发送类
    * Created by 叶云轩 on 2017/6/16-16:58
    * Concat tdg_yyx@foxmail.com
    */
    public class NettyClient {
    
       private Logger logger = LoggerFactory.getLogger(MBeanServer.class);
       private Bootstrap bootstrap;
       private EventLoopGroup worker;
       private int port;
       private String url;
       private int MAX_RETRY_TIMES = 10;
    
       public NettyClient(String url, int port) {
           this.url = url;
           this.port = port;
           bootstrap = new Bootstrap();
           worker = new NioEventLoopGroup();
           bootstrap.group(worker);
           bootstrap.channel(NioSocketChannel.class);
       }
    
       public void close() {
           logger.info("关闭资源");
           worker.shutdownGracefully();
       }
    
       public Object remoteCall(final MethodInvokeMeta cmd, int retry) {
           try {
               CustomChannelInitializerClient customChannelInitializer = new CustomChannelInitializerClient(cmd);
               bootstrap.handler(customChannelInitializer);
               ChannelFuture sync = bootstrap.connect(url, port).sync();
               sync.channel().closeFuture().sync();
               Object response = customChannelInitializer.getResponse();
               return response;
           } catch (InterruptedException e) {
               retry++;
               if (retry > MAX_RETRY_TIMES) {
                   throw new RuntimeException("调用Wrong");
               } else {
                   try {
                       Thread.sleep(100);
                   } catch (InterruptedException e1) {
                       e1.printStackTrace();
                   }
                   logger.info("第{}次尝试....失败", retry);
                   return remoteCall(cmd, retry);
               }
           }
       }
    }
  2. ClientChannelHandlerAdapter.java

    import com.edu.hart.rpc.entity.MethodInvokeMeta;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
    * Created by 叶云轩 on 2017/6/16-17:03
    * Concat tdg_yyx@foxmail.com
    */
    public class ClientChannelHandlerAdapter extends ChannelHandlerAdapter {
       private Logger logger = LoggerFactory.getLogger(ClientChannelHandlerAdapter.class);
       private MethodInvokeMeta methodInvokeMeta;
       private CustomChannelInitializerClient channelInitializerClient;
    
       public ClientChannelHandlerAdapter(MethodInvokeMeta methodInvokeMeta, CustomChannelInitializerClient channelInitializerClient) {
           this.methodInvokeMeta = methodInvokeMeta;
           this.channelInitializerClient = channelInitializerClient;
       }
    
       @Override
       public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
           logger.info("客户端出异常了,异常信息:{}", cause.getMessage());
           cause.printStackTrace();
           ctx.close();
       }
    
       @Override
       public void channelActive(ChannelHandlerContext ctx) throws Exception {
           if (methodInvokeMeta.getMethodName().endsWith("toString") && !"class java.lang.String".equals(methodInvokeMeta.getReturnType().toString()))
               logger.info("客户端发送信息参数:{},信息返回值类型:{}", methodInvokeMeta.getArgs(), methodInvokeMeta.getReturnType());
           ctx.writeAndFlush(methodInvokeMeta);
    
       }
    
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
           channelInitializerClient.setResponse(msg);
       }
    }
  3. CustomChannelInitializerClient.java

    import com.edu.hart.rpc.entity.MethodInvokeMeta;
    import com.edu.hart.rpc.entity.NullWritable;
    import com.edu.hart.rpc.util.ObjectCodec;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelPipeline;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
    import io.netty.handler.codec.LengthFieldPrepender;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;

     

/**

Created by 叶云轩 on 2017/6/16-15:01
Concat tdg_yyx@foxmail.com
*/
public class CustomChannelInitializerClient extends ChannelInitializer {   
private Logger logger = LoggerFactory.getLogger(CustomChannelInitializerClient.class);

   private MethodInvokeMeta methodInvokeMeta;

   private Object response;

   public CustomChannelInitializerClient(MethodInvokeMeta methodInvokeMeta) {
       if (!"toString".equals(methodInvokeMeta.getMethodName())) {
           logger.info("[CustomChannelInitializerClient] 调用方法名:{},入参:{},参数类型:{},返回值类型{}"
                   , methodInvokeMeta.getMethodName()
                   , methodInvokeMeta.getArgs()
                   , methodInvokeMeta.getParameterTypes()
                   , methodInvokeMeta.getReturnType());
       }
       this.methodInvokeMeta = methodInvokeMeta;
   }

   public Object getResponse() {
       if (response instanceof NullWritable) {
           return null;
       }
       return response;
   }

   public void setResponse(Object response) {
       this.response = response;
   }

   @Override
   protected void initChannel(SocketChannel ch) {
       ChannelPipeline pipeline = ch.pipeline();
       pipeline.addLast(new LengthFieldPrepender(2));
       pipeline.addLast(new LengthFieldBasedFrameDecoder(1024 * 1024, 0, 2, 0, 2));
       pipeline.addLast(new ObjectCodec());
       pipeline.addLast(new ClientChannelHandlerAdapter(methodInvokeMeta, this));
   }
}

 

4. RPCProxyFactoryBean.java

   ```java
   import com.edu.hart.rpc.entity.MethodInvokeMeta;
   import com.edu.hart.rpc.util.WrapMethodUtils;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.config.AbstractFactoryBean;

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;

   /**
    * Created by 叶云轩 on 2017/6/16-17:16
    * Concat tdg_yyx@foxmail.com
    */
   public class RPCProxyFactoryBean extends AbstractFactoryBean<Object> implements InvocationHandler {
       private Logger logger = LoggerFactory.getLogger(RPCProxyFactoryBean.class);

       private Class interfaceClass;

       private NettyClient nettyClient;

       @Override
       public Class<?> getObjectType() {
           return interfaceClass;
       }

       @Override
       protected Object createInstance() throws Exception {
           logger.info("[代理工厂] 初始化代理Bean : {}", interfaceClass);
           return Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, this);
       }

       @Override
       public Object invoke(Object proxy, Method method, Object[] args) {
           final MethodInvokeMeta methodInvokeMeta = WrapMethodUtils.readMethod(interfaceClass, method, args);
           if (!methodInvokeMeta.getMethodName().equals("toString")) {
               logger.info("[invoke] 调用接口{},调用方法名:{},入参:{},参数类型:{},返回值类型{}",
                       methodInvokeMeta.getInterfaceClass(), methodInvokeMeta.getMethodName()
                       , methodInvokeMeta.getArgs(), methodInvokeMeta.getParameterTypes(), methodInvokeMeta.getReturnType());
           }
           return nettyClient.remoteCall(methodInvokeMeta, 0);
       }

       public void setInterfaceClass(Class interfaceClass) {
           this.interfaceClass = interfaceClass;
       }

       public void setNettyClient(NettyClient nettyClient) {
           this.nettyClient = nettyClient;
       }
   }

至此,netty-client与SpringBoot的集成了算完毕了。同样 ,在netty-client中也要加入相应的依赖

不过上面server与client使用了一些公共的类和工具。下面也给列举中出来。

MethodInvokeMeta.java

   import org.springframework.stereotype.Component;

   import java.io.Serializable;

   /**
    * 记录调用方法的元信息
    * Created by 叶云轩 on 2017/6/7-15:41
    * Concat tdg_yyx@foxmail.com
    */
   @Component
   public class MethodInvokeMeta implements Serializable {

       private static final long serialVersionUID = 8379109667714148890L;
       //接口
       private Class<?> interfaceClass;
       //方法名
       private String methodName;
       //参数
       private Object[] args;
       //返回值类型
       private Class<?> returnType;
       //参数类型
       private Class<?>[] parameterTypes;

       public Object[] getArgs() {
           return args;
       }

       public void setArgs(Object[] args) {
           this.args = args;
       }

       public Class<?> getInterfaceClass() {
           return interfaceClass;
       }

       public void setInterfaceClass(Class<?> interfaceClass) {
           this.interfaceClass = interfaceClass;
       }

       public String getMethodName() {
           return methodName;
       }

       public void setMethodName(String methodName) {
           this.methodName = methodName;
       }

       public Class[] getParameterTypes() {
           return parameterTypes;
       }

       public void setParameterTypes(Class<?>[] parameterTypes) {
           this.parameterTypes = parameterTypes;
       }

       public Class getReturnType() {
           return returnType;
       }

       public void setReturnType(Class returnType) {
           this.returnType = returnType;
       }
   }

NullWritable.java

   import java.io.Serializable;

   /**
    * 服务器可能返回空的处理
    * Created by 叶云轩 on 2017/6/16-16:46
    * Concat tdg_yyx@foxmail.com
    */
   public class NullWritable implements Serializable {

       private static final long serialVersionUID = -8191640400484155111L;
       private static NullWritable instance = new NullWritable();

       private NullWritable() {
       }

       public static NullWritable nullWritable() {
           return instance;
       }
   }

ObjectCodec.java

   import io.netty.buffer.ByteBuf;
   import io.netty.buffer.Unpooled;
   import io.netty.channel.ChannelHandlerContext;
   import io.netty.handler.codec.MessageToMessageCodec;

   import java.util.List;

   public class ObjectCodec extends MessageToMessageCodec<ByteBuf, Object> {

       @Override
       protected void encode(ChannelHandlerContext ctx, Object msg, List<Object> out) {
           byte[] data = ObjectSerializerUtils.serilizer(msg);
           ByteBuf buf = Unpooled.buffer();
           buf.writeBytes(data);
           out.add(buf);
       }

       @Override
       protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) {
           byte[] bytes = new byte[msg.readableBytes()];
           msg.readBytes(bytes);
           Object deSerilizer = ObjectSerializerUtils.deSerilizer(bytes);
           out.add(deSerilizer);
       }

   }

ObjectSerializerUtils.java

   package com.edu.hart.rpc.util;

   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;

   import java.io.*;

   /**
    * 对象序列化工具
    */
   public class ObjectSerializerUtils {

       private static final Logger logger = LoggerFactory.getLogger(ObjectSerializerUtils.class);

       /**
        * 反序列化
        *
        * @param data
        * @return
        */
       public static Object deSerilizer(byte[] data) {
           if (data != null && data.length > 0) {
               try {
                   ByteArrayInputStream bis = new ByteArrayInputStream(data);
                   ObjectInputStream ois = new ObjectInputStream(bis);
                   return ois.readObject();
               } catch (Exception e) {
                   logger.info("[异常信息] {}", e.getMessage());
                   e.printStackTrace();
               }
               return null;
           } else {
               logger.info("[反序列化] 入参为空");
               return null;
           }
       }

       /**
        * 序列化对象
        *
        * @param obj
        * @return
        */
       public static byte[] serilizer(Object obj) {
           if (obj != null) {
               try {
                   ByteArrayOutputStream bos = new ByteArrayOutputStream();
                   ObjectOutputStream oos = new ObjectOutputStream(bos);
                   oos.writeObject(obj);
                   oos.flush();
                   oos.close();
                   return bos.toByteArray();
               } catch (IOException e) {
                   e.printStackTrace();
               }
               return null;
           } else {
               return null;
           }
       }
   }

下面主要是用于Client端的:

NettyBeanSacnner.java

   import com.edu.hart.rpc.client.RPCProxyFactoryBean;
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
   import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
   import org.springframework.beans.factory.support.BeanDefinitionBuilder;
   import org.springframework.beans.factory.support.DefaultListableBeanFactory;

   import java.util.List;

   /**
    * 动态加载代理bean到Spring bean工厂
    */
   public class NettyBeanScanner implements BeanFactoryPostProcessor {

       private DefaultListableBeanFactory beanFactory;

       private String basePackage;

       private String clientName;

       public NettyBeanScanner(String basePackage, String clientName) {
           this.basePackage = basePackage;
           this.clientName = clientName;
       }


       /**
        * 注册Bean到Spring的bean工厂
        */
       public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
           this.beanFactory = (DefaultListableBeanFactory) beanFactory;
           // 加载远程服务的接口
           List<String> resolverClass = PackageClassUtils.resolver(basePackage);
           for (String clazz : resolverClass) {
               String simpleName;
               if (clazz.lastIndexOf('.') != -1) {
                   simpleName = clazz.substring(clazz.lastIndexOf('.') + 1);
               } else {
                   simpleName = clazz;
               }
               BeanDefinitionBuilder gd = BeanDefinitionBuilder.genericBeanDefinition(RPCProxyFactoryBean.class);
               gd.addPropertyValue("interfaceClass", clazz);
               gd.addPropertyReference("nettyClient", clientName);
               this.beanFactory.registerBeanDefinition(simpleName, gd.getRawBeanDefinition());
           }
       }
   }

PackageClassUtils.java

这个类要说一下,主要是用来加载Server对应的接口的。因为在Client中RPC接口没有实现类,所以要自己将这些接口加载到Spring工厂里面。但是现在有个问题就是需要使用

SpringBoot中application.yml

   basePackage: com.edu.hart.rpc.service.login;com.edu.hart.rpc.service.employee;com.edu.hart.rpc.service.authorization;
  • 这样的方式来加载,使用通配符的时候会加载不到,这个问题我还没有解决。
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;

   import java.io.File;
   import java.util.ArrayList;
   import java.util.List;

   /**
    * 字节文件加载
    */
   public class PackageClassUtils {

       private final static Logger LOGGER = LoggerFactory.getLogger(PackageClassUtils.class);

       /**
        * 解析包参数
        *
        * @param basePackage 包名
        * @return 包名字符串集合
        */
       public static List<String> resolver(String basePackage) {
           //以";"分割开多个包名
           String[] splitFHs = basePackage.split(";");
           List<String> classStrs = new ArrayList<>();
           //s: com.yyx.util.*
           for (String s : splitFHs) {
               LOGGER.info("[加载类目录] {}", s);
               //路径中是否存在".*" com.yyx.util.*
               boolean contains = s.contains(".*");
               if (contains) {
                   //截断星号  com.yyx.util
                   String filePathStr = s.substring(0, s.lastIndexOf(".*"));
                   //组装路径 com/yyx/util
                   String filePath = filePathStr.replaceAll("\\.", "/");
                   //获取路径 xxx/classes/com/yyx/util
                   File file = new File(PackageClassUtils.class.getResource("/").getPath() + "/" + filePath);
                   //获取目录下获取文件
                   getAllFile(filePathStr, file, classStrs);
               } else {
                   String filePath = s.replaceAll("\\.", "/");
                   File file = new File(PackageClassUtils.class.getResource("/").getPath() + "/" + filePath);
                   classStrs = getClassReferenceList(classStrs, file, s);
               }
           }
           return classStrs;
       }

       /**
        * 添加全限定类名到集合
        *
        * @param classStrs 集合
        * @return 类名集合
        */
       private static List<String> getClassReferenceList(List<String> classStrs, File file, String s) {
           File[] listFiles = file.listFiles();
           if (listFiles != null && listFiles.length != 0) {
               for (File file2 : listFiles) {
                   if (file2.isFile()) {
                       String name = file2.getName();
                       String fileName = s + "." + name.substring(0, name.lastIndexOf('.'));
                       LOGGER.info("[加载完成] 类文件:{}", fileName);
                       classStrs.add(fileName);
                   }
               }
           }
           return classStrs;
       }


       /**
        * 获取一个目录下的所有文件
        *
        * @param s
        * @param file
        * @param classStrs
        */
       private static void getAllFile(String s, File file, List<String> classStrs) {
           if (file.isDirectory()) {
               File[] files = file.listFiles();
               if (files != null)
                   for (File file1 : files) {
                       getAllFile(s, file1, classStrs);
                   }
           } else {
               String path = file.getPath();
               String cleanPath = path.replaceAll("/", ".");
               String fileName = cleanPath.substring(cleanPath.indexOf(s), cleanPath.length());
               LOGGER.info("[加载完成] 类文件:{}", fileName);
               classStrs.add(fileName);
           }
       }
   }

RemoteMethodInvokeUtil.java

   import com.edu.hart.rpc.entity.MethodInvokeMeta;
   import org.springframework.beans.BeansException;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.ApplicationContextAware;

   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;

   /**
    * 消息处理类
    * Created by 叶云轩 on 2017/6/7-15:49
    * Concat tdg_yyx@foxmail.com
    */
   public class RemoteMethodInvokeUtil implements ApplicationContextAware {

       private ApplicationContext applicationContext;

       public Object processMethod(MethodInvokeMeta methodInvokeMeta) throws InvocationTargetException, IllegalAccessException {
           Class interfaceClass = methodInvokeMeta.getInterfaceClass();
           Object bean = applicationContext.getBean(interfaceClass);
           Method[] declaredMethods = interfaceClass.getDeclaredMethods();
           Method method = null;
           for (Method declaredMethod : declaredMethods) {
               if (methodInvokeMeta.getMethodName().equals(declaredMethod.getName())) {
                   method = declaredMethod;
               }
           }
           Object invoke = method.invoke(bean, methodInvokeMeta.getArgs());
           return invoke;
       }

       @Override
       public void setApplicationContext(ApplicationContext app) throws BeansException {
           applicationContext = app;
       }
   }

WrapMethodUtils.java


下面的这些类我也会用在与前台通信时使用:

ResponseEnum.java

ResponseResult.java

import java.io.Serializable;

/**
 * 数据返回实体封装
 * <p>
 * Created by 叶云轩 on 2017/6/13-11:38
 * Concat tdg_yyx@foxmail.com
 *
 * @param <T> 通用变量
 */
public class ResponseResult<T> implements Serializable {


    private static final long serialVersionUID = -3411174924856108156L;
    /**
     * 服务器响应码
     */
    private Integer code;
    /**
     * 服务器响应说明
     */
    private String msg;
    /**
     * 服务器响应数据
     */
    private T data;

    public ResponseResult() {

    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ResponseResult<?> that = (ResponseResult<?>) o;

        return (code != null ? code.equals(that.code) : that.code == null) && (msg != null ? msg.equals(that.msg) : that.msg == null) && (data != null ? data.equals(that.data) : that.data == null);
    }

    public Integer getCode() {

        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public int hashCode() {
        int result = code != null ? code.hashCode() : 0;
        result = 31 * result
                + (msg != null ? msg.hashCode() : 0);
        result = 31 * result + (data != null ? data.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "ResponseResult{"
                + "code="
                + code
                + ", msg='"
                + msg
                + '\''
                + ", data="
                + data
                + '}';
    }
}

ResponseResultUtil.java

import com.edu.hart.modules.communicate.ResponseCodeEnum;
import com.edu.hart.modules.communicate.ResponseResult;

/**
 * 返回结果工具类
 * Created by 叶云轩 on 2017/5/29-10:37
 * Concat tdg_yyx@foxmail.com
 */
public class ResponseResultUtil {

    /**
     * 请求失败返回的数据结构
     *
     * @param responseCodeEnum 返回信息枚举类
     * @return 结果集
     */
    public static ResponseResult error(ResponseCodeEnum responseCodeEnum) {
        ResponseResult ResponseResult = new ResponseResult();
        ResponseResult.setMsg(responseCodeEnum.getMsg());
        ResponseResult.setCode(responseCodeEnum.getCode());
        ResponseResult.setData(null);
        return ResponseResult;
    }

    /**
     * 没有结果集的返回数据结构
     *
     * @return 结果集
     */
    public static ResponseResult success() {
        return success(null);
    }

    /**
     * 成功返回数据结构
     *
     * @param o 返回数据对象
     * @return 返回结果集
     */
    public static ResponseResult success(Object o) {
        ResponseResult responseResult = new ResponseResult();
        responseResult.setMsg(ResponseCodeEnum.REQUEST_SUCCESS.getMsg());
        responseResult.setCode(ResponseCodeEnum.REQUEST_SUCCESS.getCode());
        responseResult.setData(o);
        return responseResult;
    }

    /**
     * 判断是否成功
     *
     * @param responseResult 请求结果
     * @return 判断结果
     */
    public static boolean judgementSuccess(ResponseResult responseResult) {
        return responseResult.getCode().equals(ResponseCodeEnum.REQUEST_SUCCESS.getCode());
    }
}

来,我们测试一下远程通信:

  1. Client调用Server的一个接口。可以看到在hart-oa项目中,RPCEmployeeService没有任何实现类,控制台中打印了方法的调用 以及入参信息

Client调用Server的一个接口

  1. Server断点监听到远程调用,CloudApplication项目为Server端,我们可以看到接收到来自hart-oa的一个请求,参数一致。在CloudApplication中进行相应的处理后,返回到Client(hart-oa)

Server断点监听到远程调用

  1. 返回信息到Client,可以看到我们(hart-oa)收到了来自CloudApplication的响应,结果是我们封装好的ResponseResult.

返回信息到Client

作者:叶云轩

原文:https://blog.csdn.net/yuanzhenwei521/article/details/79194275

展开阅读全文

没有更多推荐了,返回首页