rpc框架实现（一），服务注册端实现

一。rpc远程过程调用，我的一个操作，是远程方法调用给的结果，这样做增加服务的复用性。

写rpc，要把消息传递给远程，消息包括

既然是方法调用，一个方法的唯一标志是类名，方法名，参数类型，方法参数。netty异步准确的返回结果，给谁的结果呢，这就要传递一个唯一标识ID。

RPC远程调用跟本地调用相似，并对方法进行扩充，这就要用到设计模式，装饰者，代理模式

这里用代理模式。如果想不断扩充功能可用装饰者模式。

服务注册，这里用zookeeper实现。

服务端代码实现：加入依赖

<dependencies>
<dependency>
<groupId>me.anduo</groupId>
<artifactId>rpc-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>

<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
</dependency>

<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
</dependency>

<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
</dependency>

<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
</dependency>

<dependency>
<groupId>org.objenesis</groupId>
<artifactId>objenesis</artifactId>
</dependency>

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
</dependency>
</dependencies>

一，主服务类实现spring容器管理，实现俩接口ApplicationContextAware, InitializingBean

实现了ApplicationContextAware之后，这个类就可以方便获得ApplicationContext中的所有bean。换句话说，就是这个类可以直接获取spring配置文件中，所有有引用到的bean对象。

InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。完成netty服务启动，服务注册。

代码：

public class RpcServer implements ApplicationContextAware, InitializingBean {

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

//server.address=127.0.0.1:8888 netty服务地址
private String serverAddress;
//registry.address=127.0.0.1:2181 注册中心地址
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 {
// 获取所有带有RpcService注解的SpringBean
Map<String, Object> serviceBeanMap = ctx.getBeansWithAnnotation(RpcService.class);
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) {
channel.pipeline().addLast(
/** 将RPC请求进行解码（为了处理请求）*/
new RpcDecoder(RpcRequest.class))
/** 将RPC响应进行编码（为了返回响应）*/
.addLast(new RpcDecoder(RpcResponse.class))
/** 处理RPC请求*/
.addLast(new RpcHandler(handlerMap));
}
}).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();
}
}

}

//netty服务处理类

public class RpcHandler extends SimpleChannelInboundHandler<RpcRequest> {

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();

       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();
   }
}

//实现服务注册

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, event -> {
if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
latch.countDown();
}
});
latch.await();
} catch (IOException | InterruptedException e) {
LOGGER.error("Can't get connection for zookeeper,registryAddress:{}", registryAddress, e);
}
return zk;
}

private void createNode(ZooKeeper zk, String data) {
try {
byte[] bytes = data.getBytes();
String znodePath = Constant.ZK_DATA_PATH;
String[] paths = znodePath.split("/");
String path = "";
for (int i = 1; i < paths.length; i++) {
           path = path +"/"+ paths[i];
           Stat exists = zk.exists(path, null);
           if(exists == null){
               if(i == paths.length-1){
                   zk.create(path, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                   zk.create(path, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                   LOGGER.info("create zookeeper node ({} => {})", path, data);
               }else{
                   zk.create(path, "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                   LOGGER.info("create zookeeper node ({} => {})", path, data);
               }
           }

}
//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 (Exception e) {
LOGGER.error("", e);
}
}
}
//服务入口类

public class RpcBootstrap {
   @SuppressWarnings("resource")
   public static void main(String[] args) {
       new ClassPathXmlApplicationContext("spring-server.xml");
   }
}

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

Class<?> value();
}

// 指定远程接口测试类
@RpcService(HelloService.class)
public class HelloServiceImpl implements HelloService {

   @Override
   public String hello(String name) {
       return "Hello! " + name;
   }

}

public interface HelloService {

String hello(String name);
}

<?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"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
   <context:component-scan base-package="xyz.anduo.rpc" />
   <context:property-placeholder location="classpath:server-config.properties"/>
   
<bean id="serviceRegistry" class="me.anduo.rpc.server.core.ServiceRegistry">
<constructor-arg name="registryAddress" value="${registry.address}"/>
</bean>


<bean id="xyz.anduo.rpc.serverServer" class="me.anduo.rpc.server.core.RpcServer">
<constructor-arg name="serverAddress" value="${server.address}"/>
<constructor-arg name="serviceRegistry" ref="serviceRegistry"/>
</bean>
</beans>

registry.address=127.0.0.1:2181

server.address=127.0.0.1:8000

liuerchong

发布了23 篇原创文章 · 获赞 0 · 访问量 189

私信关注

rpc框架实现（一），服务注册端实现

猜你喜欢