1 需求说明
模仿dubbo,消费者和提供者约定接口和协议,消费者远程调用提供者,提供者返回一个字符串,消费者打印提供者返回的数据。底层网络通信使用 Netty 4.X
2 设计说明
1、创建一个接口,定义抽象方法。用于消费者和提供者之间的约定。
2、创建一个提供者,该类需要监听消费者的请求,并按照约定返回数据。
3、创建一个消费者,该类需要透明的调用自已不存在的方法,内部需要使用Netty请求提供者返回数据。
设计图如下:
3 编码
目录结构如下:
public interface HelloService {
String hello(String message);
}
@Slf4j
public class HelloServiceImpl implements HelloService {
private int count = 0;
//当有调用方调用该方法时,就返回一个结果
@Override
public String hello(String message) {
log.info("收到客户端的消息:{}",message);
if(message != null){
return "你好客户端, 我已经收到你的消息 [" + message + "] 第" + (++count) + " 次";
}else {
return "你好客户端, 我已经收到你的消息 ";
}
}
}
@Slf4j
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//获取客户端发的消息,并调用服务
log.info("NettyServerHandler 获取客户端的消息:{}",msg);
//客户端在调用服务器的api 时,我们需要定义一个协议
//比如我们要求 每次发消息是都必须以某个字符串开头 "HelloService#hello#你好"
if(msg.toString().startsWith(NettyClientBootstrap.providerName)) {
String result = new HelloServiceImpl().hello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
ctx.writeAndFlush(result);
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
@Slf4j
public class NettyServer {
public static void startServer(String host,int port){
startServer0(host,port);
}
private static void startServer0(String host,int port){
NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup,workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
pipeline.addLast(new NettyServerHandler());
}
});
ChannelFuture channelFuture = serverBootstrap.bind(host, port).sync();
log.info("服务端已启动");
channelFuture.channel().closeFuture().sync();
}catch (Exception e){
e.printStackTrace();
}finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {
//上下文
private ChannelHandlerContext content;
//返回结果
private String result;
//客户端调用时,传递的参数
private String param;
//与服务器的连接创建后,就会被调用, 被调用的顺序是:1
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
log.info("NettyClientHandlerd 的 channelActive 被调用");
content = ctx;
}
//设置传入的参数,被调用的顺序是:2
void setParam(String param){
this.param = param;
}
//被代理对象调用, 发送数据给服务器,-> wait -> 等待被唤醒(channelRead) -> 返回结果 ;被调用的顺序是3和5
@Override
public synchronized Object call() throws Exception {
log.info("call 第一次被调用");
content.writeAndFlush(param);
//等待channelRead 方法获取到服务器的结果后,唤醒
wait();
log.info("call 第二次被调用");
return result;
}
//收到服务器的数据后,调用这个方法。被调用的顺序是:4
@Override
public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
log.info("NettyClientHandlerd的channelRead被调用");
result = msg.toString();
//唤醒等待的线程
notify();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
@Slf4j
public class NettyClient {
private static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static NettyClientHandler client;
private int count;
//使用代理模式,获取代理对象
public Object getBean(final Class<?> serviceClass,final String providerName){
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class<?>[]{serviceClass},(proxy,method,args) ->{
log.info(",(proxy,method,args) 执行...{},次",(++count));
if(client == null){
initClient();
}
//设置要发给服务器端的信息
//providerName 协议头 args[0] 就是客户端调用api hello(???), 参数
client.setParam(providerName + args[0]);
return executorService.submit(client).get();
});
}
//初始化客户端
private static void initClient(){
client = new NettyClientHandler();
NioEventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY,true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
pipeline.addLast(client);
}
});
bootstrap.connect("127.0.0.1", 8000).sync();
}catch (Exception e){
e.printStackTrace();
}finally {
group.shutdownGracefully();
}
}
}
public class NettyServerBootsrap {
public static void main(String[] args) {
NettyServer.startServer("127.0.0.1",8000);
}
}
@Slf4j
public class NettyClientBootstrap {
//定义协议头
public static final String providerName = "HelloService#hello#";
public static void main(String[] args) throws InterruptedException {
//创建一个消费者
NettyClient client = new NettyClient();
//创建一个代理对象
HelloService service = (HelloService)client.getBean(HelloService.class, providerName);
for (; ; ) {
Thread.sleep(2 * 1000);
String result = service.hello("你好,dubbo");
log.info("调用的结果,res:{}",result);
}
}
}