fix : Modify some comments and code structure

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/client/Client.java

@@ -44,6 +44,8 @@ import java.io.Closeable;
  *
  * <b>The client implements Closeable and supports automatic shutdown, However, you can manually
  * disable it when you want to use it</b>
+ *
+ * @since 1.5.1
  */
 public interface Client extends Closeable {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/client/ClientConnection.java

@@ -23,6 +23,8 @@ import cn.hippo4j.rpc.model.Response;
 
 /**
  * Applicable to client connections<br>
+ *
+ * @since 1.5.1
  */
 public interface ClientConnection extends Connection {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/client/NettyClientConnection.java

@@ -42,6 +42,8 @@ import java.util.concurrent.locks.LockSupport;
 
 /**
  * Client implemented using netty
+ *
+ * @since 1.5.1
  */
 @Slf4j
 public class NettyClientConnection implements ClientConnection {

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/client/RPCClient.java

@@ -25,6 +25,8 @@ import java.io.IOException;
 /**
  * The client, which provides a closing mechanism, maintains a persistent connection if not closed<br>
  * Delegate the method to the {@link ClientConnection} for implementation
+ *
+ * @since 1.5.1
  */
 public class RPCClient implements Client {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/coder/CompactObjectOutputStream.java

@@ -24,6 +24,8 @@ import java.io.OutputStream;
 
 /**
  * object OutputStream
+ *
+ * @since 1.5.1
  */
 public class CompactObjectOutputStream extends ObjectOutputStream {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/coder/NettyEncoder.java

@@ -29,6 +29,8 @@ import java.io.Serializable;
 /**
  * this is a encoder, For custom gluing and unpacking<br>
  * {@link io.netty.handler.codec.serialization.ObjectEncoder}
+ *
+ * @since 1.5.1
  */
 public class NettyEncoder extends MessageToByteEncoder<Serializable> {
 

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

@@ -25,6 +25,8 @@ import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * the registration center for Client and Server
+ *
+ * @since 1.5.1
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class ClassRegistry {

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

@@ -27,6 +27,8 @@ import java.util.ServiceLoader;
  * You simply create an instance of a class based on its name and specific type.
  * Load through the ServiceLoader first. If the load fails, load directly through the instantiation.
  * If it is an interface, throw an exception. This is not elegant implementation
+ *
+ * @since 1.5.1
  */
 public class DefaultInstance implements Instance {
 

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

@@ -22,6 +22,8 @@ import java.net.InetSocketAddress;
 /**
  * The adaptation layer of different service centers is used to know
  * the host of different services through the registration center
+ *
+ * @since 1.5.1
  */
 public interface DiscoveryAdapter {
 

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

@@ -19,6 +19,8 @@ package cn.hippo4j.rpc.discovery;
 
 /**
  * Instance interface to get an instance
+ *
+ * @since 1.5.1
  */
 public interface Instance {
 

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

@@ -19,6 +19,8 @@ package cn.hippo4j.rpc.discovery;
 
 /**
  * Gets the top-level interface of the instance port
+ *
+ * @since 1.5.1
  */
 @FunctionalInterface
 public interface ServerPort {

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

@@ -21,6 +21,8 @@ import cn.hippo4j.common.config.ApplicationContextHolder;
 
 /**
  * Adapter Spring, The requested object is managed by spring
+ *
+ * @since 1.5.1
  */
 public class SpringContextInstance implements Instance {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/exception/CoderException.java

@@ -20,6 +20,8 @@ package cn.hippo4j.rpc.exception;
 /**
  * During decoding and encoding, if an exception occurs, an exception of type {@link CoderException} is thrown,
  * which is not different from a {@link RuntimeException}, but is more explicit about the type of exception
+ *
+ * @since 1.5.1
  */
 public class CoderException extends RuntimeException {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/exception/ConnectionException.java

@@ -21,6 +21,8 @@ package cn.hippo4j.rpc.exception;
  * If an exception occurs during the connection between the server and the client, an exception of type
  * {@link ConnectionException} is thrown, which is not different from {@link RuntimeException}, but is more explicit
  * about the type of exception
+ *
+ * @since 1.5.1
  */
 public class ConnectionException extends RuntimeException {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/exception/TimeOutException.java

@@ -20,6 +20,8 @@ package cn.hippo4j.rpc.exception;
 /**
  * If there is a timeout between the server and the client, you will get a {@link TimeOutException},
  * which is not different from {@link RuntimeException}, but it will be more explicit about the type of exception, right
+ *
+ * @since 1.5.1
  */
 public class TimeOutException extends RuntimeException {
 

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

@@ -26,6 +26,8 @@ import java.util.stream.Collectors;
 
 /**
  * Processor manager for ChannelHandler in netty
+ *
+ * @since 1.5.1
  */
 public abstract class AbstractNettyHandlerManager implements HandlerManager<ChannelHandler> {
 

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

@@ -28,6 +28,8 @@ import java.util.Optional;
 
 /**
  * the abstract base of {@link ConnectHandler} and {@link ChannelInboundHandlerAdapter}
+ *
+ * @since 1.5.1
  */
 public abstract class AbstractNettyTakeHandler extends ChannelInboundHandlerAdapter implements ConnectHandler {
 

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

@@ -25,6 +25,7 @@ import cn.hippo4j.rpc.model.Response;
  * must be specified, such as serialization and parsing, requesting and receiving
  * requests, and so on<br>
  *
+ * @since 1.5.1
  */
 public interface ConnectHandler {
 

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

@@ -26,6 +26,8 @@ import java.io.Closeable;
  * operations that should be done in the connection. It is more like integrating the
  * connection and the connection channel together, so creating {@link Connection} is
  * very resource intensive, for which caching is recommended
+ *
+ * @since 1.5.1
  */
 public interface Connection extends Closeable {
 

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

@@ -25,6 +25,8 @@ import lombok.Getter;
 /**
  * Manage the Handler used in the processing.<br>
  * The Handler must be able to exist multiple times and be invoked once in a single execution
+ *
+ * @since 1.5.1
  */
 public interface HandlerManager<T> {
 

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

@@ -32,6 +32,8 @@ import java.util.List;
 
 /**
  * Processing by the client connection pool handler to clean the buffer and define new connection properties
+ *
+ * @since 1.5.1
  */
 @Slf4j
 public class NettyClientPoolHandler extends AbstractNettyHandlerManager implements ChannelPoolHandler {

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

@@ -24,6 +24,8 @@ import io.netty.channel.ChannelHandlerContext;
 
 /**
  * Interconnect with the netty mediation layer
+ *
+ * @since 1.5.1
  */
 @ChannelHandler.Sharable
 public class NettyClientTakeHandler extends AbstractNettyTakeHandler implements ConnectHandler {

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

@@ -35,6 +35,8 @@ import java.util.List;
 
 /**
  * netty adaptation layer
+ *
+ * @since 1.5.1
  */
 @ChannelHandler.Sharable
 public class NettyServerTakeHandler extends AbstractNettyTakeHandler implements ConnectHandler {

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

@@ -25,6 +25,8 @@ import java.util.Objects;
 /**
  * default request<br>
  * Use the fully qualified name key of the interface and override equals and hashCode
+ *
+ * @since 1.5.1
  */
 public final class DefaultRequest implements Request {
 

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

@@ -25,6 +25,8 @@ import java.util.Objects;
 /**
  * default request<br>
  * Use the fully qualified name key of the interface and override equals and hashCode
+ *
+ * @since 1.5.1
  */
 public class DefaultResponse implements Response {
 

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

@@ -21,6 +21,8 @@ import java.io.Serializable;
 
 /**
  * request
+ *
+ * @since 1.5.1
  */
 public interface Request extends Serializable {
 

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

@@ -21,6 +21,8 @@ import java.io.Serializable;
 
 /**
  * Response
+ *
+ * @since 1.5.1
  */
 public interface Response extends Serializable {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/process/ActivePostProcess.java

@@ -22,6 +22,8 @@ import cn.hippo4j.rpc.model.Response;
 
 /**
  * Callback while the connection is in progress
+ *
+ * @since 1.5.1
  */
 public interface ActivePostProcess {
 

hippo4j-rpc/src/main/java/cn/hippo4j/rpc/process/ActiveProcessChain.java

@@ -30,6 +30,7 @@ import java.util.List;
  * reference resources: spring HandlerExecutionChain
  *
  * @see ActivePostProcess
+ * @since 1.5.1
  */
 @Slf4j
 public final class ActiveProcessChain {

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

@@ -37,6 +37,8 @@ import java.util.List;
 
 /**
  * adapter to the netty server
+ *
+ * @since 1.5.1
  */
 @Slf4j
 public class NettyServerConnection extends AbstractNettyHandlerManager implements ServerConnection {

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

@@ -25,6 +25,8 @@ import java.util.concurrent.CompletableFuture;
 
 /**
  * Server Implementation
+ *
+ * @since 1.5.1
  */
 public class RPCServer implements Server {
 

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

@@ -21,6 +21,8 @@ import java.io.Closeable;
 
 /**
  * the service for RPC, Explain the role of the service in the request
+ *
+ * @since 1.5.1
  */
 public interface Server extends Closeable {
 

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

@@ -22,6 +22,8 @@ import cn.hippo4j.rpc.handler.Connection;
 
 /**
  * This applies to server-side connections
+ *
+ * @since 1.5.1
  */
 public interface ServerConnection extends Connection {
 

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

@@ -54,6 +54,7 @@ import java.util.Optional;
  *     <li>{@link DisposableBean}</li>
  * </ul>
  *
+ * @since 1.5.1
  * @deprecated With {@link cn.hippo4j.config.service.ThreadPoolAdapterService} structure, FactoryBean is not the best choice
  */
 @Deprecated

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

@@ -52,6 +52,7 @@ import java.util.concurrent.ConcurrentHashMap;
  * @see cn.hippo4j.rpc.client.NettyClientConnection
  * @see NettyServerSupport
  * @see ClientFactoryBean
+ * @since 1.5.1
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class NettyClientSupport {

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

@@ -35,6 +35,8 @@ import java.util.concurrent.TimeUnit;
 
 /**
  * This parameter applies only to the connection pool of netty
+ *
+ * @since 1.5.1
  */
 @Slf4j
 public class NettyConnectPool {

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

@@ -31,6 +31,8 @@ import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * To avoid creating multiple connection pools for the same host:port, save all connection pools of the client
+ *
+ * @since 1.5.1
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class NettyConnectPoolHolder {

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

@@ -36,6 +36,8 @@ import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Add a proxy for the request, {@link Proxy} and {@link InvocationHandler}
+ *
+ * @since 1.5.1
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public class NettyProxyCenter {

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

@@ -40,6 +40,7 @@ import java.util.List;
  * @see RPCServer
  * @see NettyServerConnection
  * @see NettyClientSupport
+ * @since 1.5.1
  */
 public class NettyServerSupport implements Server {
 

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

@@ -31,6 +31,8 @@ import java.util.concurrent.locks.LockSupport;
  * The unique remote call can be determined by the key of request and
  * response, and the result of the call is stored in the secondary cache,
  * which is convenient for the client to use at any time.
+ *
+ * @since 1.5.1
  */
 @Slf4j
 @NoArgsConstructor(access = AccessLevel.PRIVATE)