fix : add server support for better use server

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/discovery/ServerPort.java

@@ -18,13 +18,15 @@
 package cn.hippo4j.rpc.discovery;
 
 /**
- *
+ * Gets the top-level interface of the instance port
  */
+@FunctionalInterface
 public interface ServerPort {
 
     /**
+     * Gets the listening or exposed port
      *
-     * @return
+     * @return port
      */
     int getPort();
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/handler/AbstractNettyClientPoolHandler.java

@@ -33,40 +33,40 @@ import java.util.List;
  * Processing by the client connection pool handler to clean the buffer and define new connection properties
  */
 @Slf4j
-public class NettyClientPoolHandler extends NettyHandlerManager implements ChannelPoolHandler {
+public class AbstractNettyClientPoolHandler extends AbstractNettyHandlerManager implements ChannelPoolHandler {
 
-    public NettyClientPoolHandler(List<ChannelHandler> handlers) {
+    public AbstractNettyClientPoolHandler(List<ChannelHandler> handlers) {
         super(handlers);
     }
 
-    public NettyClientPoolHandler(ChannelHandler... handlers) {
+    public AbstractNettyClientPoolHandler(ChannelHandler... handlers) {
         super(handlers);
     }
 
-    public NettyClientPoolHandler() {
+    public AbstractNettyClientPoolHandler() {
         super();
     }
 
     @Override
-    public NettyClientPoolHandler addLast(String name, ChannelHandler handler) {
+    public AbstractNettyClientPoolHandler addLast(String name, ChannelHandler handler) {
         super.addLast(name, handler);
         return this;
     }
 
     @Override
-    public NettyClientPoolHandler addFirst(String name, ChannelHandler handler) {
+    public AbstractNettyClientPoolHandler addFirst(String name, ChannelHandler handler) {
         super.addFirst(name, handler);
         return this;
     }
 
     @Override
-    public NettyClientPoolHandler addLast(ChannelHandler handler) {
+    public AbstractNettyClientPoolHandler addLast(ChannelHandler handler) {
         super.addLast(handler);
         return this;
     }
 
     @Override
-    public NettyClientPoolHandler addFirst(ChannelHandler handler) {
+    public AbstractNettyClientPoolHandler addFirst(ChannelHandler handler) {
         super.addFirst(handler);
         return this;
     }

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/handler/AbstractNettyHandlerManager.java

@@ -27,7 +27,7 @@ import java.util.stream.Collectors;
 /**
  * Processor manager for ChannelHandler in netty
  */
-public abstract class NettyHandlerManager implements HandlerManager<ChannelHandler> {
+public abstract class AbstractNettyHandlerManager implements HandlerManager<ChannelHandler> {
 
     protected final List<HandlerEntity<ChannelHandler>> handlerEntities;
 
@@ -35,7 +35,7 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
 
     AtomicLong lastIndex = new AtomicLong(0);
 
-    protected NettyHandlerManager(List<ChannelHandler> handlerEntities) {
+    protected AbstractNettyHandlerManager(List<ChannelHandler> handlerEntities) {
         Assert.notNull(handlerEntities);
         this.handlerEntities = handlerEntities.stream()
                 .filter(Objects::nonNull)
@@ -43,11 +43,11 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
                 .collect(Collectors.toList());
     }
 
-    protected NettyHandlerManager(ChannelHandler... handlerEntities) {
+    protected AbstractNettyHandlerManager(ChannelHandler... handlerEntities) {
         this(handlerEntities != null ? Arrays.asList(handlerEntities) : Collections.emptyList());
     }
 
-    protected NettyHandlerManager() {
+    protected AbstractNettyHandlerManager() {
         this.handlerEntities = new LinkedList<>();
     }
 
@@ -63,7 +63,7 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
      * @param handler handler
      * @return NettyHandlerManager
      */
-    public NettyHandlerManager addLast(String name, ChannelHandler handler) {
+    public AbstractNettyHandlerManager addLast(String name, ChannelHandler handler) {
         Assert.notNull(handler);
         this.handlerEntities.add(getHandlerEntity(lastIndex.getAndIncrement(), handler, name));
         return this;
@@ -76,7 +76,7 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
      * @param handler handler
      * @return NettyHandlerManager
      */
-    public NettyHandlerManager addFirst(String name, ChannelHandler handler) {
+    public AbstractNettyHandlerManager addFirst(String name, ChannelHandler handler) {
         Assert.notNull(handler);
         this.handlerEntities.add(getHandlerEntity(firstIndex.getAndIncrement(), handler, name));
         return this;
@@ -88,7 +88,7 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
      * @param handler handler
      * @return NettyHandlerManager
      */
-    public NettyHandlerManager addLast(ChannelHandler handler) {
+    public AbstractNettyHandlerManager addLast(ChannelHandler handler) {
         Assert.notNull(handler);
         this.handlerEntities.add(getHandlerEntity(lastIndex.getAndIncrement(), handler, null));
         return this;
@@ -100,7 +100,7 @@ public abstract class NettyHandlerManager implements HandlerManager<ChannelHandl
      * @param handler handler
      * @return NettyHandlerManager
      */
-    public NettyHandlerManager addFirst(ChannelHandler handler) {
+    public AbstractNettyHandlerManager addFirst(ChannelHandler handler) {
         Assert.notNull(handler);
         this.handlerEntities.add(getHandlerEntity(firstIndex.getAndDecrement(), handler, null));
         return this;

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/model/DefaultResponse.java

@@ -117,6 +117,8 @@ public class DefaultResponse implements Response {
     private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
         s.defaultReadObject();
         // Deserialization obj
+        if (!isErr()){
             this.obj = s.readObject();
         }
+    }
 }

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/model/Response.java

@@ -50,7 +50,8 @@ public interface Response extends Serializable {
     String getErrMsg();
 
     /**
-     * Whether the current request has an error
+     * Whether the current request has an error, <br>
+     * If it is true then it cannot be retrieved from obj
      */
     boolean isErr();
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/server/AbstractNettyServerConnection.java

@@ -21,7 +21,7 @@ import cn.hippo4j.common.toolkit.Assert;
 import cn.hippo4j.rpc.coder.NettyDecoder;
 import cn.hippo4j.rpc.coder.NettyEncoder;
 import cn.hippo4j.rpc.discovery.ServerPort;
-import cn.hippo4j.rpc.handler.NettyHandlerManager;
+import cn.hippo4j.rpc.handler.AbstractNettyHandlerManager;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.*;
 import io.netty.channel.nio.NioEventLoopGroup;
@@ -38,7 +38,7 @@ import java.util.List;
  * adapter to the netty server
  */
 @Slf4j
-public class NettyServerConnection extends NettyHandlerManager implements ServerConnection {
+public class AbstractNettyServerConnection extends AbstractNettyHandlerManager implements ServerConnection {
 
     ServerPort port;
     EventLoopGroup leader;
@@ -47,7 +47,7 @@ public class NettyServerConnection extends NettyHandlerManager implements Server
     ChannelFuture future;
     Channel channel;
 
-    public NettyServerConnection(EventLoopGroup leader, EventLoopGroup worker, List<ChannelHandler> handlers) {
+    public AbstractNettyServerConnection(EventLoopGroup leader, EventLoopGroup worker, List<ChannelHandler> handlers) {
         super(handlers);
         Assert.notNull(leader);
         Assert.notNull(worker);
@@ -55,15 +55,15 @@ public class NettyServerConnection extends NettyHandlerManager implements Server
         this.worker = worker;
     }
 
-    public NettyServerConnection(EventLoopGroup leader, EventLoopGroup worker, ChannelHandler... handlers) {
+    public AbstractNettyServerConnection(EventLoopGroup leader, EventLoopGroup worker, ChannelHandler... handlers) {
         this(leader, worker, (handlers != null ? Arrays.asList(handlers) : Collections.emptyList()));
     }
 
-    public NettyServerConnection(ChannelHandler... handlers) {
+    public AbstractNettyServerConnection(ChannelHandler... handlers) {
         this(handlers != null ? Arrays.asList(handlers) : Collections.emptyList());
     }
 
-    public NettyServerConnection(List<ChannelHandler> handlers) {
+    public AbstractNettyServerConnection(List<ChannelHandler> handlers) {
         this(new NioEventLoopGroup(), new NioEventLoopGroup(), handlers);
     }
 
@@ -118,25 +118,25 @@ public class NettyServerConnection extends NettyHandlerManager implements Server
     }
 
     @Override
-    public NettyServerConnection addLast(String name, ChannelHandler handler) {
+    public AbstractNettyServerConnection addLast(String name, ChannelHandler handler) {
         super.addLast(name, handler);
         return this;
     }
 
     @Override
-    public NettyServerConnection addFirst(String name, ChannelHandler handler) {
+    public AbstractNettyServerConnection addFirst(String name, ChannelHandler handler) {
         super.addFirst(name, handler);
         return this;
     }
 
     @Override
-    public NettyServerConnection addLast(ChannelHandler handler) {
+    public AbstractNettyServerConnection addLast(ChannelHandler handler) {
         super.addLast(handler);
         return this;
     }
 
     @Override
-    public NettyServerConnection addFirst(ChannelHandler handler) {
+    public AbstractNettyServerConnection addFirst(ChannelHandler handler) {
         super.addFirst(handler);
         return this;
     }

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/server/RPCServer.java

@@ -29,7 +29,7 @@ public class RPCServer implements Server {
     ServerPort port;
     ServerConnection serverConnection;
 
-    public RPCServer(ServerPort port, ServerConnection serverConnection) {
+    public RPCServer(ServerConnection serverConnection, ServerPort port) {
         this.port = port;
         this.serverConnection = serverConnection;
     }

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/support/NettyProxyCenter.java

@@ -19,7 +19,9 @@ package cn.hippo4j.rpc.support;
 
 import cn.hippo4j.common.toolkit.IdUtil;
 import cn.hippo4j.common.web.exception.IllegalException;
+import cn.hippo4j.rpc.client.Client;
 import cn.hippo4j.rpc.client.NettyClientConnection;
+import cn.hippo4j.rpc.client.RPCClient;
 import cn.hippo4j.rpc.discovery.ServerPort;
 import cn.hippo4j.rpc.model.DefaultRequest;
 import cn.hippo4j.rpc.model.Request;
@@ -54,11 +56,12 @@ public class NettyProxyCenter {
      */
     public static <T> T getProxy(Class<T> cls, String host, ServerPort port, ChannelPoolHandler handler) {
         NettyClientConnection connection = new NettyClientConnection(host, port, handler);
-        return getProxy(connection, cls, host, port);
+        Client rpcClient = new RPCClient(connection);
+        return getProxy(rpcClient, cls, host, port);
     }
 
     @SuppressWarnings("unchecked")
-    public static <T> T getProxy(NettyClientConnection connection, Class<T> cls, String host, ServerPort port) {
+    public static <T> T getProxy(Client client, Class<T> cls, String host, ServerPort port) {
         boolean b = cls.isInterface();
         if (!b) {
             throw new IllegalException(cls.getName() + "is not a Interface");
@@ -76,7 +79,7 @@ public class NettyProxyCenter {
                     String key = host + port + clsName + methodName + IdUtil.simpleUUID();
                     Class<?>[] parameterTypes = method.getParameterTypes();
                     Request request = new DefaultRequest(key, clsName, methodName, parameterTypes, args);
-                    Response response = connection.connect(request);
+                    Response response = client.connection(request);
                     if (response == null) {
                         return null;
                     }

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/support/NettyServerSupport.java

@@ -22,7 +22,7 @@ import cn.hippo4j.rpc.discovery.DefaultInstance;
 import cn.hippo4j.rpc.discovery.ServerPort;
 import cn.hippo4j.rpc.handler.HandlerManager;
 import cn.hippo4j.rpc.handler.NettyServerTakeHandler;
-import cn.hippo4j.rpc.server.NettyServerConnection;
+import cn.hippo4j.rpc.server.AbstractNettyServerConnection;
 import cn.hippo4j.rpc.server.RPCServer;
 import cn.hippo4j.rpc.server.Server;
 import io.netty.channel.ChannelHandler;
@@ -59,11 +59,11 @@ public class NettyServerSupport implements Server {
     Server server;
 
     public NettyServerSupport(ServerPort serverPort, Class<?>... classes) {
-        this(serverPort, new NettyServerConnection(), classes);
+        this(serverPort, new AbstractNettyServerConnection(), classes);
     }
 
     public NettyServerSupport(ServerPort serverPort, List<Class<?>> classes) {
-        this(serverPort, new NettyServerConnection(), classes);
+        this(serverPort, new AbstractNettyServerConnection(), classes);
     }
 
     public NettyServerSupport(ServerPort serverPort, HandlerManager<ChannelHandler> handlerManager, Class<?>... classes) {
@@ -86,14 +86,14 @@ public class NettyServerSupport implements Server {
         // Register the interface that can be invoked
         classes.stream().filter(Class::isInterface)
                 .forEach(cls -> ClassRegistry.put(cls.getName(), cls));
-        NettyServerConnection connection = (handlerManager instanceof NettyServerConnection)
+        AbstractNettyServerConnection connection = (handlerManager instanceof AbstractNettyServerConnection)
-                ? (NettyServerConnection) handlerManager
+                ? (AbstractNettyServerConnection) handlerManager
-                : new NettyServerConnection();
+                : new AbstractNettyServerConnection();
         // Assign a default handler if no handler exists
         if (connection.isEmpty()) {
             connection.addLast(new NettyServerTakeHandler(new DefaultInstance()));
         }
-        server = new RPCServer(serverPort, connection);
+        server = new RPCServer(connection, serverPort);
     }
 
     @Override