RPC,即 Remote Procedure Call(远程过程调用),说得通俗一点就是:调用远程计算机上的服务,就像调用本地服务一样。
RPC 可基于 HTTP 或 TCP 协议,Web Service 就是基于 HTTP 协议的 RPC,它具有良好的跨平台性,但其性能却不如基于 TCP 协议的 RPC。会两方面会直接影响 RPC 的性能,一是传输方式,二是序列化。
众所周知,TCP 是传输层协议,HTTP 是应用层协议,而传输层较应用层更加底层,在数据传输方面,越底层越快,因此,在一般情况下,TCP 一定比 HTTP 快。就序列化而言,Java 提供了默认的序列化方式,但在高并发的情况下,这种方式将会带来一些性能上的瓶颈,于是市面上出现了一系列优秀的序列化框架,比如:Protobuf、Kryo、Hessian、Jackson 等,它们可以取代 Java 默认的序列化,从而提供更高效的性能。
为了支持高并发,传统的阻塞式 IO 显然不太合适,因此我们需要异步的 IO,即 NIO。Java 提供了 NIO 的解决方案,Java 7 也提供了更优秀的 NIO.2 支持,用 Java 实现 NIO 并不是遥不可及的事情,只是需要我们熟悉 NIO 的技术细节。
我们需要将服务部署在分布式环境下的不同节点上,通过服务注册的方式,让客户端来自动发现当前可用的服务,并调用这些服务。这需要一种服务注册表(Service Registry)的组件,让它来注册分布式环境下所有的服务地址(包括:主机名与端口号)。
应用、服务、服务注册表之间的关系见下图:
每台 Server 上可发布多个 Service,这些 Service 共用一个 host 与 port,在分布式环境下会提供 Server 共同对外提供 Service。此外,为防止 Service Registry 出现单点故障,因此需要将其搭建为集群环境。
本文将为您揭晓开发轻量级分布式 RPC 框架的具体过程,该框架基于 TCP 协议,提供了 NIO 特性,提供高效的序列化方式,同时也具备服务注册与发现的能力。
根据以上技术需求,我们可使用如下技术选型:
- Spring:它是最强大的依赖注入框架,也是业界的权威标准。
- Netty:它使 NIO 编程更加容易,屏蔽了 Java 底层的 NIO 细节。
- Protostuff:它基于 Protobuf 序列化框架,面向 POJO,无需编写 .proto 文件。
- ZooKeeper:提供服务注册与发现功能,开发分布式系统的必备选择,同时它也具备天生的集群能力。
相关 Maven 依赖请见最后附录。
第一步:编写服务接口
1
2
3
4
|
public interface HelloService {
String hello(String name);
} |
将该接口放在独立的客户端 jar 包中,以供应用使用。
第二步:编写服务接口的实现类
1
2
3
4
5
6
7
8
|
@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
|
@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
|
< beans ...>
< context:component-scan base-package = "com.xxx.rpc.sample.server" />
< context:property-placeholder location = "classpath:config.properties" />
<!-- 配置服务注册组件 -->
< bean id = "serviceRegistry" class = "com.xxx.rpc.registry.ServiceRegistry" >
< constructor-arg name = "registryAddress" value = "${registry.address}" />
</ bean >
<!-- 配置 RPC 服务器 -->
< bean id = "rpcServer" class = "com.xxx.rpc.server.RpcServer" >
< constructor-arg name = "serverAddress" value = "${server.address}" />
< constructor-arg name = "serviceRegistry" ref = "serviceRegistry" />
</ bean >
</ beans >
|
具体的配置参数在config.properties文件中,内容如下:
1
2
3
4
5
|
# 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
|
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
|
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
|
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
|
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();
}
}
} |
以上代码中,有两个重要的 POJO 需要描述一下,它们分别是RpcRequest与RpcResponse。
使用RpcRequest封装 RPC 请求,代码如下:
1
2
3
4
5
6
7
8
9
10
|
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
|
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
|
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);
}
} |
使用RpcEncoder提供 RPC 编码,只需扩展 Netty 的MessageToByteEncoder抽象类的encode方法即可,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
|
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);
}
}
} |
以上了使用 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
|
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();
}
} |
为了避免使用 Java 反射带来的性能问题,我们可以使用 CGLib 提供的反射 API,如上面用到的FastClass与FastMethod。
第七步:配置客户端
同样使用 Spring 配置文件来配置 RPC 客户端,spring.xml代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
< beans ...>
< context:property-placeholder location = "classpath:config.properties" />
<!-- 配置服务发现组件 -->
< bean id = "serviceDiscovery" class = "com.xxx.rpc.registry.ServiceDiscovery" >
< constructor-arg name = "registryAddress" value = "${registry.address}" />
</ bean >
<!-- 配置 RPC 代理 -->
< bean id = "rpcProxy" class = "com.xxx.rpc.client.RpcProxy" >
< constructor-arg name = "serviceDiscovery" ref = "serviceDiscovery" />
</ bean >
</ beans >
|
其中config.properties提供了具体的配置:
1
2
|
# 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
|
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);
}
}
} |
第九步:实现 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
|
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();
}
}
}
);
}
} |
使用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
|
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();
}
}
} |
第十步:发送 RPC 请求
使用 JUnit 结合 Spring 编写一个单元测试,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@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
|
<!-- JUnit --> < dependency >
< groupId >junit</ groupId >
< artifactId >junit</ artifactId >
< version >4.11</ version >
< scope >test</ scope >
</ dependency >
<!-- SLF4J --> < dependency >
< groupId >org.slf4j</ groupId >
< artifactId >slf4j-log4j12</ artifactId >
< version >1.7.7</ version >
</ dependency >
<!-- Spring --> < dependency >
< groupId >org.springframework</ groupId >
< artifactId >spring-context</ artifactId >
< version >3.2.12.RELEASE</ version >
</ dependency >
< dependency >
< groupId >org.springframework</ groupId >
< artifactId >spring-test</ artifactId >
< version >3.2.12.RELEASE</ version >
< scope >test</ scope >
</ dependency >
<!-- 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 >
<!-- 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 >
<!-- Objenesis --> < dependency >
< groupId >org.objenesis</ groupId >
< artifactId >objenesis</ artifactId >
< version >2.1</ version >
</ dependency >
<!-- CGLib --> < dependency >
< groupId >cglib</ groupId >
< artifactId >cglib</ artifactId >
< version >3.1</ version >
</ dependency >
|
相关推荐
4. **Spring Cloud Netflix Feign**:基于Java的声明式Web服务客户端,与Spring Cloud整合,简化了HTTP客户端的编写。 **源码分析:** 当你查看RPC的源码时,会看到以下关键部分: 1. **服务接口(Service ...
在这个场景中,我们将讨论如何将JSONRPC4J与Spring框架和Maven构建工具整合,以创建一个高效、灵活的远程服务调用系统。 1. **JSONRPC4J简介** JSONRPC4J提供了简单的方式来实现JSON-RPC规范,该规范定义了客户端...
BootNettyRpc是一个专为Spring Boot项目设计的RPC(Remote Procedure Call)框架,它利用了高性能的Netty网络库来实现高效、低延迟的远程调用。Netty是一款基于NIO(非阻塞I/O)的异步事件驱动的网络通信框架,常...
标题 "spring远程调用和xfire aegis 源代码上传" 涉及到的是在Java开发中使用Spring框架进行远程过程调用(RPC)以及整合XFire和Aegis库来实现服务间的通信。这一主题是分布式系统设计中的一个重要组成部分,特别是...
【Spring整合JAVA XMLRPC】是一个重要的IT主题,它涉及到Java应用程序如何通过XML-RPC(远程过程调用)协议与远程服务器进行通信,并结合Spring框架来实现更高效、更灵活的服务集成。XML-RPC是一种轻量级的基于HTTP...
- **架构特点**: 根据业务需求将整个系统拆分成多个子系统(服务),每个子系统负责一部分业务逻辑,并通过RPC远程调用技术实现子系统间的通信。 - **优点**: - 模块间耦合度低,便于单独开发和维护。 - 可以由...
在本教程中,我们将探讨如何基于 Java Spring 框架将一个特定的类的方法对外提供 RESTful 服务并进行调用。首先,我们有一个名为 `Person` 的类,包含姓名 (name)、年龄 (age) 和性别 (gender) 属性,以及对应的 ...
Dubbo是阿里巴巴开源的一款高性能、轻量级的RPC(远程过程调用)框架,它致力于提供高性能和透明化的远程服务调用方案,以及服务治理方案。Dubbo的核心特性包括服务注册与发现、负载均衡、服务治理、监控等,极大地...
SOFA-RPC 是阿里巴巴开源的一款高性能、高可扩展性、企业级的Java远程过程调用(RPC)框架。它的设计目标是简化分布式服务之间的通信,提高系统的解耦性,并提供丰富的功能来支持微服务架构。在本文中,我们将深入...
然后,可以编写一个名为`DubboConsumerAgent`的Java代理类,利用Java的`Instrumentation`接口和`javassist`库动态修改字节码,对`MockClusterInvoker`进行增强,插入埋点逻辑。 ### 2. JDBC调用拦截 虽然在课程描述...
本篇文档详细介绍了如何使用 Apache Dubbo 实现基于 RPC 的服务发布与调用,并简要概述了使用 Java Spring 构建 RESTful 服务以及使用 Apache Axis2 发布 Web 服务的过程。这些技术都是现代微服务架构中的重要组成...
标题中的“基于Java的Spring4GWT.zip”表明这是一个关于使用Java编程语言,结合Spring框架和GWT(Google Web Toolkit)技术的项目压缩包。这个项目可能是一个Web应用程序,利用了Spring的强大功能来管理和协调应用的...
在这个系统中,XML-RPC(远程过程调用)用于跨网络通信,Spring框架提供依赖注入和AOP(面向切面编程)来管理组件和事务,而Hibernate作为ORM(对象关系映射)工具,负责数据库操作。下面将详细介绍这三项技术及其在...
1. **JavaConfig**: 传统的Spring配置多依赖XML文件,而JavaConfig是Spring框架提供的一种使用Java类进行配置的方式。它允许开发者通过编写配置类,以面向对象的方式定义bean和它们的依赖关系,增强了代码的可读性和...
然后,Dubbo被引入作为服务治理框架,它允许服务提供者注册服务到Zookeeper,同时服务消费者从Zookeeper中获取服务提供者的地址,从而实现服务的远程调用。 具体步骤可能包括: 1. **设置SpringBoot项目**:创建...
RPC框架如Dubbo提供了透明化的远程调用体验,使得开发者无需关注底层网络通信细节。 Dubbo是阿里巴巴开源的一款高性能、轻量级的Java服务框架。最初,Dubbo的设计目标是专注于服务之间的RPC调用,通过提供服务注册...
- RPC允许程序在一台计算机上调用另一台计算机上的子程序,使远程调用如同本地调用般简便。 - 实现RPC的关键在于网络通信(通常基于TCP)和数据序列化,以及调用过程的透明性。 2. HTTP与RPC的区别: - HTTP是...
SpringFlex使得后端服务可以方便地与Flex前端交互,提供了强大的数据绑定和远程调用功能。 首先,Spring框架是Java领域的一个轻量级、全面的依赖注入(DI)容器,它管理应用对象的生命周期和配置,同时也支持AOP...
本压缩包“基于java的开发源码-调用远程API规范 XINS.zip”包含的资源,旨在帮助开发者理解和使用XINS来规范地调用远程API。 XINS的核心概念是通过XML文件定义API接口,这些接口描述了服务的功能、参数和预期响应。...