我是靠谱客的博主 时尚火车，最近开发中收集的这篇文章主要介绍netty+zk实现简单的rpc调用（基于传输层） 第一步：编写服务接口 第二步：编写服务接口的实现类 第三步：配置服务端 第四步：启动服务器并发布服务 第五步：实现服务注册 第六步：实现 RPC 服务器 第七步：配置客户端 第八步：实现服务发现 第九步：实现 RPC 代理 第十步：发送 RPC 请求 总结 附录：Maven 依赖，觉得挺不错的，现在分享给大家，希望可以做个参考。
概述
本文将为您揭晓开发轻量级分布式 RPC 框架的具体过程，该框架基于 TCP 协议，提供了 NIO 特性，提供高效的序列化方式，同时也具备服务注册与发现的能力。
根据以上技术需求，我们可使用如下技术选型：
- Spring：它是最强大的依赖注入框架，也是业界的权威标准。
- Netty：它使 NIO 编程更加容易，屏蔽了 Java 底层的 NIO 细节。
- Protostuff：它基于 Protobuf 序列化框架，面向 POJO，无需编写 .proto 文件。
- ZooKeeper：提供服务注册与发现功能，开发分布式系统的必备选择，同时它也具备天生的集群能力。
相关 Maven 依赖请见附录。
第一步：编写服务接口
|
1
2
3
4
5
|
<!-- lang: java -->
public
interface
HelloService {
String hello(String name);
}
|
将该接口放在独立的客户端 jar 包中，以供应用使用。
第二步：编写服务接口的实现类
|
1
2
3
4
5
6
7
8
9
|
<!-- lang: java -->
@RpcService
(HelloService.
class
)
// 指定远程接口
public
class
HelloServiceImpl
implements
HelloService {
@Override
public
String hello(String name) {
return
"Hello! "
+ name;
}
}
|
使用RpcService注解定义在服务接口的实现类上，需要对该实现类指定远程接口，因为实现类可能会实现多个接口，一定要告诉框架哪个才是远程接口。
RpcService代码如下：
|
1
2
3
4
5
6
7
8
|
<!-- lang: java -->
@Target
({ElementType.TYPE})
@Retention
(RetentionPolicy.RUNTIME)
@Component
// 表明可被 Spring 扫描
public
@interface
RpcService {
Class<!--?--> value();
}
|
该注解具备 Spring 的Component注解的特性，可被 Spring 扫描。
该实现类放在服务端 jar 包中，该 jar 包还提供了一些服务端的配置文件与启动服务的引导程序。
第三步：配置服务端
服务端 Spring 配置文件名为spring.xml，内容如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
<!-- lang: xml -->
<beans ...=
""
>
<context:component-scan base-
package
=
"com.xxx.rpc.sample.server"
>
<context:property-placeholder location=
"classpath:config.properties"
>
<!-- 配置服务注册组件 -->
<bean
class
=
"com.xxx.rpc.registry.ServiceRegistry"
id=
"serviceRegistry"
>
<constructor-arg name=
"registryAddress"
value=
"${registry.address}"
>
</constructor-arg></bean>
<!-- 配置 RPC 服务器 -->
<bean
class
=
"com.xxx.rpc.server.RpcServer"
id=
"rpcServer"
>
<constructor-arg name=
"serverAddress"
value=
"${server.address}"
>
<constructor-arg name=
"serviceRegistry"
ref=
"serviceRegistry"
>
</constructor-arg></constructor-arg></bean>
</context:property-placeholder></context:component-scan></beans>
|
具体的配置参数在config.properties文件中，内容如下：
|
1
2
3
4
5
6
|
<!-- lang: java -->
# ZooKeeper 服务器
registry.address=
127.0
.
0.1
:
2181
# RPC 服务器
server.address=
127.0
.
0.1
:
8000
|
以上配置表明：连接本地的 ZooKeeper 服务器，并在 8000 端口上发布 RPC 服务。
第四步：启动服务器并发布服务
为了加载 Spring 配置文件来发布服务，只需编写一个引导程序即可：
|
1
2
3
4
5
6
7
|
<!-- lang: java -->
public
class
RpcBootstrap {
public
static
void
main(String[] args) {
new
ClassPathXmlApplicationContext(
"spring.xml"
);
}
}
|
运行RpcBootstrap类的main方法即可启动服务端，但还有两个重要的组件尚未实现，它们分别是：ServiceRegistry与RpcServer，下文会给出具体实现细节。
第五步：实现服务注册
使用 ZooKeeper 客户端可轻松实现服务注册功能，ServiceRegistry代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
<!-- lang: java -->
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);
}
}
}
|
其中，通过Constant配置了所有的常量：
|
1
2
3
4
5
6
7
8
|
<!-- lang: java -->
public
interface
Constant {
int
ZK_SESSION_TIMEOUT =
5000
;
String ZK_REGISTRY_PATH =
"/registry"
;
String ZK_DATA_PATH = ZK_REGISTRY_PATH +
"/data"
;
}
|
注意：首先需要使用 ZooKeeper 客户端命令行创建/registry永久节点，用于存放所有的服务临时节点。
第六步：实现 RPC 服务器
使用 Netty 可实现一个支持 NIO 的 RPC 服务器，需要使用ServiceRegistry注册服务地址，RpcServer代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
<!-- lang: java -->
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();
}
}
}
</socketchannel></string,></string,>
|
以上代码中，有两个重要的 POJO 需要描述一下，它们分别是RpcRequest与RpcResponse。
使用RpcRequest封装 RPC 请求，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
<!-- lang: java -->
public
class
RpcRequest {
private
String requestId;
private
String className;
private
String methodName;
private
Class<!--?-->[] parameterTypes;
private
Object[] parameters;
// getter/setter...
}
|
使用RpcResponse封装 RPC 响应，代码如下：
|
1
2
3
4
5
6
7
8
9
|
<!-- lang: java -->
public
class
RpcResponse {
private
String requestId;
private
Throwable error;
private
Object result;
// getter/setter...
}
|
使用RpcDecoder提供 RPC 解码，只需扩展 Netty 的ByteToMessageDecoder抽象类的decode方法即可，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
<!-- lang: java -->
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);
}
}</object>
|
使用RpcEncoder提供 RPC 编码，只需扩展 Netty 的MessageToByteEncoder抽象类的encode方法即可，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<!-- lang: java -->
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);
}
}
}
|
编写一个SerializationUtil工具类，使用Protostuff实现序列化：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
<!-- lang: java -->
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);
}
}
}
</t></t></t></t></t></t></t></t></t></t></t></t></
class
<?>
|
以上了使用 Objenesis 来实例化对象，它是比 Java 反射更加强大。
注意：如需要替换其它序列化框架，只需修改SerializationUtil即可。当然，更好的实现方式是提供配置项来决定使用哪种序列化方式。
使用RpcHandler中处理 RPC 请求，只需扩展 Netty 的SimpleChannelInboundHandler抽象类即可，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
<!-- lang: java -->
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();
/*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();
}
}
</string,></string,></rpcrequest>
|
为了避免使用 Java 反射带来的性能问题，我们可以使用 CGLib 提供的反射 API，如上面用到的FastClass与FastMethod。
第七步：配置客户端
同样使用 Spring 配置文件来配置 RPC 客户端，spring.xml代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
<!-- lang: java -->
<beans ...=
""
>
<context:property-placeholder location=
"classpath:config.properties"
>
<!-- 配置服务发现组件 -->
<bean
class
=
"com.xxx.rpc.registry.ServiceDiscovery"
id=
"serviceDiscovery"
>
<constructor-arg name=
"registryAddress"
value=
"${registry.address}"
>
</constructor-arg></bean>
<!-- 配置 RPC 代理 -->
<bean
class
=
"com.xxx.rpc.client.RpcProxy"
id=
"rpcProxy"
>
<constructor-arg name=
"serviceDiscovery"
ref=
"serviceDiscovery"
>
</constructor-arg></bean>
</context:property-placeholder></beans>
|
其中config.properties提供了具体的配置：
|
1
2
3
|
<!-- lang: java -->
# ZooKeeper 服务器
registry.address=
127.0
.
0.1
:
2181
|
第八步：实现服务发现
同样使用 ZooKeeper 实现服务发现功能，见如下代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
<!-- lang: java -->
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);
}
}
}
</string></string></string>
|
第九步：实现 RPC 代理
这里使用 Java 提供的动态代理技术实现 RPC 代理（当然也可以使用 CGLib 来实现），具体代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
<!-- lang: java -->
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() {
@Override
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.isError()) {
throw
response.getError();
}
else
{
return
response.getResult();
}
}
}
);
}
}
</t>
|
使用RpcClient类实现 RPC 客户端，只需扩展 Netty 提供的SimpleChannelInboundHandler抽象类即可，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
<!-- lang: java -->
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();
}
}
}
</socketchannel></rpcresponse>
|
第十步：发送 RPC 请求
使用 JUnit 结合 Spring 编写一个单元测试，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<!-- lang: java -->
@RunWith
(SpringJUnit4ClassRunner.
class
)
@ContextConfiguration
(locations =
"classpath:spring.xml"
)
public
class
HelloServiceTest {
@Autowired
private
RpcProxy rpcProxy;
@Test
public
void
helloTest() {
HelloService helloService = rpcProxy.create(HelloService.
class
);
String result = helloService.hello(
"World"
);
Assert.assertEquals(
"Hello! World"
, result);
}
}
|
运行以上单元测试，如果不出意外的话，您应该会看到绿条。
总结
本文通过 Spring + Netty + Protostuff + ZooKeeper 实现了一个轻量级 RPC 框架，使用 Spring 提供依赖注入与参数配置，使用 Netty 实现 NIO 方式的数据传输，使用 Protostuff 实现对象序列化，使用 ZooKeeper 实现服务注册与发现。使用该框架，可将服务部署到分布式环境中的任意节点上，客户端通过远程接口来调用服务端的具体实现，让服务端与客户端的开发完全分离，为实现大规模分布式应用提供了基础支持。
附录：Maven 依赖
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
<!-- lang: xml -->
<!-- JUnit -->
<dependency>
<groupid>junit</groupid>
junit</artifactid>
<version>
4.11
</version>
<scope>test</scope>
</dependency>
<!-- SLF4J -->
<dependency>
<groupid>org.slf4j</groupid>
slf4j-log4j12</artifactid>
<version>
1.7
.
7
</version>
</dependency>
<!-- Spring -->
<dependency>
<groupid>org.springframework</groupid>
spring-context</artifactid>
<version>
3.2
.
12
.RELEASE</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
spring-test</artifactid>
<version>
3.2
.
12
.RELEASE</version>
<scope>test</scope>
</dependency>
<!-- Netty -->
<dependency>
<groupid>io.netty</groupid>
netty-all</artifactid>
<version>
4.0
.
24
.Final</version>
</dependency>
<!-- Protostuff -->
<dependency>
<groupid>com.dyuproject.protostuff</groupid>
protostuff-core</artifactid>
<version>
1.0
.
8
</version>
</dependency>
<dependency>
<groupid>com.dyuproject.protostuff</groupid>
protostuff-runtime</artifactid>
<version>
1.0
.
8
</version>
</dependency>
<!-- ZooKeeper -->
<dependency>
<groupid>org.apache.zookeeper</groupid>
zookeeper</artifactid>
<version>
3.4
.
6
</version>
</dependency>
<!-- Apache Commons Collections -->
<dependency>
<groupid>org.apache.commons</groupid>
commons-collections4</artifactid>
<version>
4.0
</version>
</dependency>
<!-- Objenesis -->
<dependency>
<groupid>org.objenesis</groupid>
objenesis</artifactid>
<version>
2.1
</version>
</dependency>
<!-- CGLib -->
<dependency>
<groupid>cglib</groupid>
cglib</artifactid>
<version>
3.1
</version>
</dependency>
|
最后
以上就是时尚火车为你收集整理的netty+zk实现简单的rpc调用（基于传输层） 第一步：编写服务接口 第二步：编写服务接口的实现类 第三步：配置服务端 第四步：启动服务器并发布服务 第五步：实现服务注册 第六步：实现 RPC 服务器 第七步：配置客户端 第八步：实现服务发现 第九步：实现 RPC 代理 第十步：发送 RPC 请求 总结 附录：Maven 依赖的全部内容，希望文章能够帮你解决netty+zk实现简单的rpc调用（基于传输层） 第一步：编写服务接口 第二步：编写服务接口的实现类 第三步：配置服务端 第四步：启动服务器并发布服务 第五步：实现服务注册 第六步：实现 RPC 服务器 第七步：配置客户端 第八步：实现服务发现 第九步：实现 RPC 代理 第十步：发送 RPC 请求 总结 附录：Maven 依赖所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复