Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務(二)

接上文【轉】Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務 (二)

整體文件結構

其中(Maven 的多模塊構建)：

SpringMVC_RPC_Client
SpringMVC_RPC_Common
SpringMVC_RPC_Server
SpringMVC_RPC_Service 服務接口工程
SpringMVC_RPC_Service_Impl

服務端設計配置

服務接口工程SpringMVC_RPC_Service :

主要定義服務接口類和服務涉及到的實體類

SpringMVC_RPC_Service工程目錄結構圖

SpringMVC_RPC_Service工程 pom.xml文件：

<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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhihua</groupId>
        <artifactId>SpringMVC_RPC_Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>SpringMVC_RPC_Service</artifactId>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

SpringMVC_RPC_Service工程服務接口IHelloService

package com.zhihua.service;

import java.util.List;

import com.zhihua.entity.User;

public interface IHelloService {

    public String hello(String name);

    public User getUser(String name);

    public List<User> getUsers(int size);

    public User updateUser(User user);
}

SpringMVC_RPC_Service工程User類

package com.zhihua.entity;

import java.util.Date;

import com.alibaba.fastjson.JSON;

public class User {

    private String name;
    private Date birthday;
    private boolean sex;
    public User(String name,Date birthday,boolean sex){
        this.name = name;
        this.birthday = birthday;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public boolean isSex() {
        return sex;
    }
    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public String toString(){
        return JSON.toJSONString(this);
    }
}

工程依賴引用的SpringMVC_RPC_Common工程：

主要放置服務端和客戶端共用的組件，而且這些組件可以被其他服務包共用，所以要抽取出來

SpringMVC_RPC_Common工程目錄結構圖

SpringMVC_RPC_Common工程pom.xml文件

<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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhihua</groupId>
        <artifactId>SpringMVC_RPC_Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>SpringMVC_RPC_Common</artifactId>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!-- Netty -->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.0.24.Final</version>
        </dependency>
        <!-- Protostuff -->
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.0.8</version>
        </dependency>
        <dependency>
            <groupId>com.dyuproject.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.0.8</version>
        </dependency>
        <!-- Objenesis -->
        <dependency>
            <groupId>org.objenesis</groupId>
            <artifactId>objenesis</artifactId>
            <version>2.1</version>
        </dependency>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.0.1.RELEASE</version>
        </dependency>
    </dependencies>
</project>

SpringMVC_RPC_Common工程RpcService註解

package com.zhihua.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.stereotype.Component;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Component // 表明可以被 Spring 掃描
public @interface RpcService {

    Class<?> value();
}

SpringMVC_RPC_Common工程Constant接口

package com.zhihua.common;

/**
 * Constant接口
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public interface Constant {

    int ZK_SESSION_TIMEOUT = 5000;
    //在創建數據節點前，先用zkCli.sh客戶端連接上服務端，查看目前存在的數據節點，
    //把下面的/zookeeper/quota改爲你自己的，/zookeeper/quota是我自己Zookeeper的節點

    String ZK_REGISTRY_PATH = "/zookeeper_quota";
    String ZK_DATA_PATH = ZK_REGISTRY_PATH + "/data";
}

SpringMVC_RPC_Common工程RpcDecoder解碼類

package com.zhihua.common;

import java.util.List;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

/**
 * RpcDecoder解碼類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public class RpcDecoder extends ByteToMessageDecoder{

    private Class<?> genericClass;

    public RpcDecoder(Class<?> genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.readableBytes() < 4) {
            return;
        }
        in.markReaderIndex();
        int dataLength = in.readInt();
        if (dataLength < 0) {
            ctx.close();
        }
        if (in.readableBytes() < dataLength) {
            in.resetReaderIndex();
            return;
        }
        byte[] data = new byte[dataLength];
        in.readBytes(data);

        Object obj = SerializationUtil.deserialize(data, genericClass);
        out.add(obj);
    }

}

SpringMVC_RPC_Common工程RpcEncoder解碼類

package com.zhihua.common;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * RpcEncoder編碼類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
@SuppressWarnings("rawtypes")
public class RpcEncoder extends MessageToByteEncoder{

    private Class<?> genericClass;

    public RpcEncoder(Class<?> genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    public void encode(ChannelHandlerContext ctx, Object in, ByteBuf out) throws Exception {
        if (genericClass.isInstance(in)) {
            byte[] data = SerializationUtil.serialize(in);
            out.writeInt(data.length);
            out.writeBytes(data);
        }
    }

}

SpringMVC_RPC_Common工程RpcRequest請求類

package com.zhihua.common;

/**
 * RpcRequest請求類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public class RpcRequest {

    private String requestId;
    private String className;
    private String methodName;
    private Class<?>[] parameterTypes;
    private Object[] parameters;

    public String getRequestId() {
        return requestId;
    }
    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    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 Object[] getParameters() {
        return parameters;
    }
    public void setParameters(Object[] parameters) {
        this.parameters = parameters;
    }
}

SpringMVC_RPC_Common工程RpcResponse響應類

package com.zhihua.common;

/**
 * RpcResponse響應類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public class RpcResponse {

    private String requestId;
    private Throwable error;
    private Object result;

    public String getRequestId() {
        return requestId;
    }
    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }
    public Throwable getError() {
        return error;
    }
    public void setError(Throwable error) {
        this.error = error;
    }
    public Object getResult() {
        return result;
    }
    public void setResult(Object result) {
        this.result = result;
    }
}

SpringMVC_RPC_Common工程SerializationUtil序列化反序列化類

package com.zhihua.common;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

public class SerializationUtil {

    private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<>();

    private static Objenesis objenesis = new ObjenesisStd(true);

    private SerializationUtil() {
    }

    @SuppressWarnings("unchecked")
    private static <T> Schema<T> getSchema(Class<T> cls) {
        Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(cls);
            if (schema != null) {
                cachedSchema.put(cls, schema);
            }
        }
        return schema;
    }

    @SuppressWarnings("unchecked")
    public static <T> byte[] serialize(T obj) {
        Class<T> cls = (Class<T>) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema<T> schema = getSchema(cls);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }

    public static <T> T deserialize(byte[] data, Class<T> cls) {
        try {
            T message = (T) objenesis.newInstance(cls);
            Schema<T> schema = getSchema(cls);
            ProtostuffIOUtil.mergeFrom(data, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
}

服務接口實現工程SpringMVC_RPC_Service_Impl ：

主要放置SpringMVC_RPC_Service接口的實現類，這個工程會依賴公共RPC服務工程SpringMVC_RPC_Server

SpringMVC_RPC_Service_Impl 工程目錄結構圖

SpringMVC_RPC_Service_Impl 服務實現工程pom.xml

<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">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.zhihua</groupId>
    <artifactId>SpringMVC_RPC_Parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>SpringMVC_RPC_Service_Impl</artifactId>
  <packaging>war</packaging>
  <dependencies>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Server</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.0.1.RELEASE</version>
        </dependency>
        <!-- Servlet核心包 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>
    <build>
        <defaultGoal>compile</defaultGoal>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.2.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat8-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8000</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

SpringMVC_RPC_Service_Impl工程HelloServiceImpl服務實現類

package com.zhihua.service.Impl;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import com.zhihua.annotation.RpcService;
import com.zhihua.entity.User;
import com.zhihua.service.IHelloService;

/**
 * 指定遠程接口 使用RpcService註解定義在服務接口的實現類上
 * 需要對該實現類指定遠程接口，因爲實現類可能會實現多個接口，一定要告訴框架哪個纔是遠程接口。
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
@RpcService(IHelloService.class)
public class HelloServiceImpl implements IHelloService{

    @Override
    public String hello(String name) {
        String result = "hello" + name;
        System.out.println(result);
        return "hello" + name;
    }

    @Override
    public User getUser(String name) {
        User user = new User(name,new Date(),true);
        return user;
    }

    @Override
    public List<User> getUsers(int size) {
        List<User> list = new ArrayList<User>();
        User user = null;
        String name = "foo";
        Date birthday = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(birthday);
        for(int i = 0; i < size; i++){
            cal.add(Calendar.DAY_OF_MONTH, 1);
            user = new User(name, cal.getTime(), i%2==0 ? true : false);
            list.add(user);
        }
        return list;
    }

    @Override
    public User updateUser(User user) {
        user.setName(user.getName()+"--update");
        return user;
    }

}

SpringMVC_RPC_Service_Impl工程 RpcBootstrap 啓動服務器併發布服務

爲了加載 applicationContext.xml 配置文件來發布服務，只需編寫一個引導程序即可：

package com.zhihua.bootstrap;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 運行RpcBootstrap類的main方法即可啓動服務端
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年5月16日]
 */
public class RpcBootstrap {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        try {
            System.out.println("服務器正在啓動！");
            if(new ClassPathXmlApplicationContext("applicationContext.xml")!=null){
                System.out.println("服務器啓動成功！");
            }
        } catch (Exception e) {
            System.out.println("服務器啓動失敗！");
            System.out.println(e.getMessage());
        }          
    }
}

SpringMVC_RPC_Service_Impl工程配置文件config.properties

# ZooKeeper 服務器
registry.address=127.0.0.1:2181

# RPC 服務器
server.address=127.0.0.1:8000
#以上配置表明：連接本地的 ZooKeeper 服務器，並在 8000 端口上發佈 RPC 服務。

SpringMVC_RPC_Service_Impl工程 applicationContext.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <!-- 自動掃描web包 ,將帶有註解的類 納入spring容器管理 -->
    <context:component-scan base-package="com.zhihua.*"/>
    <context:property-placeholder location="classpath:config.properties"/>  
    <context:annotation-config/>           

    <!-- 配置服務註冊組件 -->
    <bean id="serviceRegistry" class="com.zhihua.server.ServiceRegistry">
        <constructor-arg name="registryAddress" value="${registry.address}"/>
    </bean>

    <!-- 配置RPC服務器 -->
    <bean id="rpcServer" class="com.zhihua.server.RpcServer">
        <constructor-arg name="serverAddress" value="${server.address}"/>
        <constructor-arg name="serviceRegistry" ref="serviceRegistry"/>
    </bean>


</beans>

服務的註冊與發現工程 SpringMVC_RPC_Server ：

SpringMVC_RPC_Server 主要是連接Zookeeper實現服務的註冊與發現

SpringMVC_RPC_Server 工程的目錄結構圖

SpringMVC_RPC_Server工程pom.xml

<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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhihua</groupId>
        <artifactId>SpringMVC_RPC_Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>SpringMVC_RPC_Server</artifactId>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!-- ZooKeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>

        <!-- Apache Commons Collections -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>
    </dependencies>
</project>

SpringMVC_RPC_Server工程RpcServer服務啓動類

package com.zhihua.server;

import java.util.HashMap;
import java.util.Map;

import org.apache.commons.collections4.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import com.zhihua.annotation.RpcService;
import com.zhihua.common.RpcDecoder;
import com.zhihua.common.RpcEncoder;
import com.zhihua.common.RpcRequest;
import com.zhihua.common.RpcResponse;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * RpcServer服務啓動類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public class RpcServer implements ApplicationContextAware,InitializingBean{

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

    private String serverAddress;
    private ServiceRegistry serviceRegistry;

    private Map<String, Object> handlerMap = new HashMap<>(); // 存放接口名與服務對象之間的映射關係

    public RpcServer(String serverAddress) {
        this.serverAddress = serverAddress;
    }

    public RpcServer(String serverAddress, ServiceRegistry serviceRegistry) {
        this.serverAddress = serverAddress;
        this.serviceRegistry = serviceRegistry;
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        Map<String, Object> serviceBeanMap = ctx.getBeansWithAnnotation(RpcService.class); // 獲取所有帶有 RpcService 註解的 Spring Bean
        if (MapUtils.isNotEmpty(serviceBeanMap)) {
            for (Object serviceBean : serviceBeanMap.values()) {
                String interfaceName = serviceBean.getClass().getAnnotation(RpcService.class).value().getName();
                handlerMap.put(interfaceName, serviceBean);
            }
        }
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel channel) throws Exception {
                    channel.pipeline()
                    .addLast(new RpcDecoder(RpcRequest.class)) // 將 RPC 請求進行解碼（爲了處理請求）
                    .addLast(new RpcEncoder(RpcResponse.class)) // 將 RPC 響應進行編碼（爲了返回響應）
                    .addLast(new RpcHandler(handlerMap)); // 處理 RPC 請求
                }
            })
            .option(ChannelOption.SO_BACKLOG, 128)
            .childOption(ChannelOption.SO_KEEPALIVE, true);

            String[] array = serverAddress.split(":");
            String host = array[0];
            int port = Integer.parseInt(array[1]);

            ChannelFuture future = bootstrap.bind(host, port).sync();
            LOGGER.debug("server started on port {}", port);

            if (serviceRegistry != null) {
                serviceRegistry.register(serverAddress); // 註冊服務地址
            }

            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

SpringMVC_RPC_Server工程ServiceRegistry服務註冊類

package com.zhihua.server;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.zhihua.common.Constant;

/**
 * 服務註冊類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月27日]
 */
public class ServiceRegistry {

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

    private CountDownLatch latch = new CountDownLatch(1);

    private String registryAddress;

    public ServiceRegistry(String registryAddress) {
        this.registryAddress = registryAddress;
    }

    public void register(String data) {
        if (data != null) {
            ZooKeeper zk = connectServer();
            if (zk != null) {
                createNode(zk, data);
            }
        }
    }

    private ZooKeeper connectServer() {
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(registryAddress, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown();
                    }
                }
            });
            latch.await();
        } catch (IOException | InterruptedException e) {
            LOGGER.error("", e);
        }
        return zk;
    }

    private void createNode(ZooKeeper zk, String data) {
        try {
            byte[] bytes = data.getBytes();
            String path = zk.create(Constant.ZK_DATA_PATH, bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            LOGGER.debug("create zookeeper node ({} => {})", path, data);
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("", e);
        }
    }

}

SpringMVC_RPC_Server工程RpcHandler請求統一處理類

package com.zhihua.server;

import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cglib.reflect.FastClass;
import org.springframework.cglib.reflect.FastMethod;

import com.zhihua.common.RpcRequest;
import com.zhihua.common.RpcResponse;

import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 * RpcHandler請求統一處理類
 * <請替換成功能描述> <br>
 * <請替換成詳細描述>
 * @author caizh
 * @since [1.0.0]
 * @version [1.0.0,2017年3月24日]
 */
public class RpcHandler extends SimpleChannelInboundHandler<RpcRequest> {

    /**
     * 爲了避免使用Java反射帶來的性能的問題，我們可以使用CGLib提供的反射API，如上面用到的FastClass與FastMethod
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(RpcHandler.class);

    private final Map<String, Object> handlerMap;

    public RpcHandler(Map<String, Object> handlerMap) {
        this.handlerMap = handlerMap;
    }

    @Override
    public void channelRead0(final ChannelHandlerContext ctx, RpcRequest request) throws Exception {
        RpcResponse response = new RpcResponse();
        response.setRequestId(request.getRequestId());
        try {
            Object result = handle(request);
            response.setResult(result);
        } catch (Throwable t) {
            response.setError(t);
        }
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    private Object handle(RpcRequest request) throws Throwable {
        String className = request.getClassName();
        Object serviceBean = handlerMap.get(className);

        Class<?> serviceClass = serviceBean.getClass();
        String methodName = request.getMethodName();
        Class<?>[] parameterTypes = request.getParameterTypes();
        Object[] parameters = request.getParameters();

        /*Method method = serviceClass.getMethod(methodName, parameterTypes);
      method.setAccessible(true);
      return method.invoke(serviceBean, parameters);*/

        FastClass serviceFastClass = FastClass.create(serviceClass);
        FastMethod serviceFastMethod = serviceFastClass.getMethod(methodName, parameterTypes);
        return serviceFastMethod.invoke(serviceBean, parameters);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        LOGGER.error("server caught exception", cause);
        ctx.close();
    }
}

至此，服務端代碼編寫完畢，接下來開始編寫客戶端代碼

客戶端工程SpringMVC_RPC_Client：

主要是springMVC實現服務端服務接口的調用測試

SpringMVC_RPC_Client工程目錄結構圖

SpringMVC_RPC_Client工程的pom.xml文件

<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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.zhihua</groupId>
        <artifactId>SpringMVC_RPC_Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>SpringMVC_RPC_Client</artifactId>
    <packaging>war</packaging>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.zhihua</groupId>
            <artifactId>SpringMVC_RPC_Service</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.0.1.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- ZooKeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
        </dependency>

        <!-- CGLib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>

</project>

SpringMVC_RPC_Client工程HelloController類

package com.zhihua.controller;

import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.zhihua.client.RpcProxy;
import com.zhihua.entity.User;
import com.zhihua.service.IHelloService;

@Controller
public class HelloController {

    @Autowired
    private RpcProxy rpcProxy;

    @RequestMapping("/hello")
    public void hello(String name){
        IHelloService service = rpcProxy.create(IHelloService.class);
        String result = service.hello(name);
        System.out.println(result);
    }

    @RequestMapping("/getUser")
    public void getUser(String name){
        IHelloService service = rpcProxy.create(IHelloService.class);
        System.out.println(service.getUser(name).toString());
    }

    @RequestMapping("/getUsers")
    public void getUsers(int size){
        IHelloService service = rpcProxy.create(IHelloService.class);
        List<User> list = service.getUsers(size);
        for(User user : list){
            System.out.println(user.toString());
        }
    }

    @RequestMapping("/updateUser")
    public void updateUser(String name){
        User user = new User(name, new Date(), true);
        IHelloService service = rpcProxy.create(IHelloService.class);
        user = service.updateUser(user);
        System.out.println(user.toString());
    }

    @RequestMapping("/test")
    public void test(){
        System.out.println("測試路徑");
    }
}

SpringMVC_RPC_Client工程代理類RpcProxy

package com.zhihua.client;

import java.lang.reflect.Method;
import java.util.UUID;

import com.zhihua.common.RpcRequest;
import com.zhihua.common.RpcResponse;

import net.sf.cglib.proxy.InvocationHandler;
import net.sf.cglib.proxy.Proxy;

public class RpcProxy {

    private String serverAddress;
    private ServiceDiscovery serviceDiscovery;

    public RpcProxy(String serverAddress) {
        this.serverAddress = serverAddress;
    }

    public RpcProxy(ServiceDiscovery serviceDiscovery) {
        this.serviceDiscovery = serviceDiscovery;
    }

    @SuppressWarnings("unchecked")
    public <T> T create(Class<?> interfaceClass) {
        return (T) Proxy.newProxyInstance(
                interfaceClass.getClassLoader(),
                new Class<?>[]{interfaceClass},
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        RpcRequest request = new RpcRequest(); // 創建並初始化 RPC 請求
                        request.setRequestId(UUID.randomUUID().toString());
                        request.setClassName(method.getDeclaringClass().getName());
                        request.setMethodName(method.getName());
                        request.setParameterTypes(method.getParameterTypes());
                        request.setParameters(args);

                        if (serviceDiscovery != null) {
                            serverAddress = serviceDiscovery.discover(); // 發現服務
                        }

                        String[] array = serverAddress.split(":");
                        String host = array[0];
                        int port = Integer.parseInt(array[1]);

                        RpcClient client = new RpcClient(host, port); // 初始化 RPC 客戶端
                        RpcResponse response = client.send(request); // 通過 RPC 客戶端發送 RPC 請求並獲取 RPC 響應

                        if (response.getError() != null) {
                            throw response.getError();
                        } else {
                            return response.getResult();
                        }
                    }
                }
                );
    }

}

SpringMVC_RPC_Client工程客戶端類RpcClient

package com.zhihua.client;

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

import com.zhihua.common.RpcDecoder;
import com.zhihua.common.RpcEncoder;
import com.zhihua.common.RpcRequest;
import com.zhihua.common.RpcResponse;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class RpcClient extends SimpleChannelInboundHandler<RpcResponse>{

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


    private String host;
    private int port;

    private RpcResponse response;

    private final Object obj = new Object();

    public RpcClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception {
        this.response = response;

        synchronized (obj) {
            obj.notifyAll(); // 收到響應，喚醒線程
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        LOGGER.error("client caught exception", cause);
        ctx.close();
    }

    public RpcResponse send(RpcRequest request) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group).channel(NioSocketChannel.class)
            .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel channel) throws Exception {
                    channel.pipeline()
                    .addLast(new RpcEncoder(RpcRequest.class)) // 將 RPC 請求進行編碼（爲了發送請求）
                    .addLast(new RpcDecoder(RpcResponse.class)) // 將 RPC 響應進行解碼（爲了處理響應）
                    .addLast(RpcClient.this); // 使用 RpcClient 發送 RPC 請求
                }
            })
            .option(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture future = bootstrap.connect(host, port).sync();
            future.channel().writeAndFlush(request).sync();

            synchronized (obj) {
                obj.wait(); // 未收到響應，使線程等待
            }

            if (response != null) {
                future.channel().closeFuture().sync();
            }
            return response;
        } finally {
            group.shutdownGracefully();
        }
    }
}

SpringMVC_RPC_Client工程服務發現類ServiceDiscovery

package com.zhihua.client;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.zhihua.common.Constant;

import io.netty.util.internal.ThreadLocalRandom;

public class ServiceDiscovery {

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

    private CountDownLatch latch = new CountDownLatch(1);

    private volatile List<String> dataList = new ArrayList<>();

    private String registryAddress;

    public ServiceDiscovery(String registryAddress) {
        this.registryAddress = registryAddress;

        ZooKeeper zk = connectServer();
        if (zk != null) {
            watchNode(zk);
        }
    }

    public String discover() {
        String data = null;
        int size = dataList.size();
        if (size > 0) {
            if (size == 1) {
                data = dataList.get(0);
                LOGGER.debug("using only data: {}", data);
            } else {
                data = dataList.get(ThreadLocalRandom.current().nextInt(size));
                LOGGER.debug("using random data: {}", data);
            }
        }
        return data;
    }

    private ZooKeeper connectServer() {
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(registryAddress, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown();
                    }
                }
            });
            latch.await();
        } catch (IOException | InterruptedException e) {
            LOGGER.error("", e);
        }
        return zk;
    }

    private void watchNode(final ZooKeeper zk) {
        try {
            List<String> nodeList = zk.getChildren(Constant.ZK_REGISTRY_PATH, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeChildrenChanged) {
                        watchNode(zk);
                    }
                }
            });
            List<String> dataList = new ArrayList<>();
            for (String node : nodeList) {
                byte[] bytes = zk.getData(Constant.ZK_REGISTRY_PATH + "/" + node, false, null);
                dataList.add(new String(bytes));
            }
            LOGGER.debug("node data: {}", dataList);
            this.dataList = dataList;
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("", e);
        }
    }
}

SpringMVC_RPC_Client工程配置文件config.properties

# ZooKeeper 服務器
registry.address=127.0.0.1:2181

SpringMVC_RPC_Client工程 applicationContext.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <!-- 自動掃描web包 ,將帶有註解的類 納入spring容器管理 -->
    <context:component-scan base-package="com.zhihua.*"/>
    <context:property-placeholder location="classpath:config.properties"/>  
    <context:annotation-config/>

    <!-- 完成請求和註解POJO的映射 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /> 

    <!-- 配置服務發現組件 -->
    <bean id="serviceDiscovery" class="com.zhihua.client.ServiceDiscovery">
        <constructor-arg name="registryAddress" value="${registry.address}"/>
    </bean>

    <!-- 配置 RPC代理 -->
    <bean id="rpcProxy" class="com.zhihua.client.RpcProxy">
        <constructor-arg name="serviceDiscovery" ref="serviceDiscovery"/>
    </bean>

</beans>

至此，客戶端代碼編寫完畢，接下來就是測試了

注意：

因爲該例都是在本地上測試的，所以在測試的時候，一定要確認本地的 ZooKeeper 是打開的，否則實例是運行不成功的
在運行SpringMVC_RPC_Client工程前，要先把其他工程打包，先執行SpringMVC_RPC_Service_Impl工程中的RpcBootstrap 的main方法，啓動服務，然後在tomcat中部署SpringMVC_RPC_Client
說一下我在執行測試過程中碰到的問題：在執行的時候，一直報錯，找不到 IHelloService這個接口，可我已經在pom文件中引用了SpringMVC_RPC_Service工程依賴，引用本身也沒有問題，百度也沒出結果，最後我直接SpringMVC_RPC_Client添加了之前已經打包的SpringMVC_RPC_Service，就不再報錯，測試通過

測試結果：

http://localhost:8090/SpringMVC_RPC_Client/hello?name=aaaaa

helloaaaaa

http://localhost:8090/SpringMVC_RPC_Client/getUsers?size=5

{“birthday”:1495094682365,”name”:”foo”,”sex”:true} {“birthday”:1495181082365,”name”:”foo”,”sex”:false} {“birthday”:1495267482365,”name”:”foo”,”sex”:true} {“birthday”:1495353882365,”name”:”foo”,”sex”:false} {“birthday”:1495440282365,”name”:”foo”,”sex”:true}

Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務(二)

整體文件結構

服務端設計配置

服務接口工程SpringMVC_RPC_Service :

工程依賴引用的SpringMVC_RPC_Common工程：

服務接口實現工程SpringMVC_RPC_Service_Impl ：

服務的註冊與發現工程 SpringMVC_RPC_Server ：

客戶端工程SpringMVC_RPC_Client：

測試結果：

《Python進階》學習筆記

Leetcode 3161. 物塊放置查詢

leetcode 60 排列序列

一個docker容器暴露多個端口

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

wpf附加屬性理解 WPF附加屬性

SQL語句常見優化十大案例

MySQL UNION 操作符、排序、左右聯查

什麼是JVM？

mysql臨時表

sql注入

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結