netty+websocket集成以后,handler层无法注入service

使用springboot+netty+websocket时,在handler层无法进行业务层的service注入,解决办法:

1、编写一个SpringBeanUtils类

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringBeansUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringBeansUtils.applicationContext = applicationContext;
    }

    public static Object getBean(String name) {
        return SpringBeansUtils.applicationContext.getBean(name);

    }

    public static <T> T getBean(Class<T> clazz) {
        return SpringBeansUtils.applicationContext.getBean(clazz);
    }
}

2、在handler层使用时,通过如下方法获得service:

MgtService mgtService = (MgtService)SpringBeansUtils.getBean("mgtServiceImpl");

特别要注意的是:后面getBean()的时候需要写实现类的类名,而不是接口的。
    

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
首先,需要在pom.xml文件中添加Netty和Spring Boot的依赖: ```xml <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.43.Final</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 然后,创建一个WebSocket客户端类,继承自 `ChannelInboundHandlerAdapter`,实现WebSocket协议相关的方法: ```java @Component public class WebSocketClient extends ChannelInboundHandlerAdapter { private WebSocketClientHandshaker handshaker; private ChannelPromise handshakeFuture; @Autowired private WebSocketClientHandler handler; public void connect(String url) throws Exception { URI uri = new URI(url); String scheme = uri.getScheme() == null ? "ws" : uri.getScheme(); String host = uri.getHost() == null ? "127.0.0.1" : uri.getHost(); int port = uri.getPort(); if (port == -1) { if ("ws".equalsIgnoreCase(scheme)) { port = 80; } else if ("wss".equalsIgnoreCase(scheme)) { port = 443; } } if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) { throw new IllegalArgumentException("Unsupported scheme: " + scheme); } final WebSocketClientHandler handler = this.handler; EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap(); bootstrap.group(group) .option(ChannelOption.SO_KEEPALIVE, true) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); if ("wss".equalsIgnoreCase(scheme)) { SslContext sslContext = SslContextBuilder.forClient().build(); pipeline.addLast(sslContext.newHandler(ch.alloc(), host, port)); } pipeline.addLast(new HttpClientCodec(), new HttpObjectAggregator(8192), WebSocketClientCompressionHandler.INSTANCE, handler); } }); Channel channel = bootstrap.connect(uri.getHost(), port).sync().channel(); handshaker = WebSocketClientHandshakerFactory.newHandshaker( uri, WebSocketVersion.V13, null, true, new DefaultHttpHeaders()); handshakeFuture = channel.newPromise(); handler.setHandshakeFuture(handshakeFuture); channel.writeAndFlush(new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, uri.getRawPath())) .addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) { if (future.isSuccess()) { handshaker.handshake(future.channel()); } else { handshakeFuture.setFailure(future.cause()); } } }); handshakeFuture.sync(); channel.closeFuture().sync(); } finally { group.shutdownGracefully(); } } @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { handler.setCtx(ctx); handshaker.handshake(ctx.channel()); } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { System.out.println("WebSocket Client disconnected!"); handler.setCtx(null); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { Channel ch = ctx.channel(); if (!handshaker.isHandshakeComplete()) { try { handshaker.finishHandshake(ch, (FullHttpResponse) msg); System.out.println("WebSocket Client connected!"); handshakeFuture.setSuccess(); } catch (WebSocketHandshakeException e) { System.out.println("WebSocket Client failed to connect"); handshakeFuture.setFailure(e); } return; } if (msg instanceof FullHttpResponse) { FullHttpResponse response = (FullHttpResponse) msg; throw new IllegalStateException( "Unexpected FullHttpResponse (getStatus=" + response.status() + ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')'); } WebSocketFrame frame = (WebSocketFrame) msg; if (frame instanceof TextWebSocketFrame) { TextWebSocketFrame textFrame = (TextWebSocketFrame) frame; System.out.println("WebSocket Client received message: " + textFrame.text()); } else if (frame instanceof PongWebSocketFrame) { System.out.println("WebSocket Client received pong"); } else if (frame instanceof CloseWebSocketFrame) { System.out.println("WebSocket Client received closing"); ch.close(); } } } ``` 在这个类中,我们注入了一个 `WebSocketClientHandler` 的实例,它也是一个 `ChannelInboundHandlerAdapter`,用于处理WebSocket消息。在 `connect()` 方法中,我们使用Netty创建了一个Bootstrap实例,并设置了一些参数,然后连接到WebSocket服务器。在连接成功后,进行了握手操作,以确保连接正常建立。 下面是 `WebSocketClientHandler` 的实现: ```java @Component public class WebSocketClientHandler extends ChannelInboundHandlerAdapter { private ChannelHandlerContext ctx; private ChannelPromise handshakeFuture; public void setCtx(ChannelHandlerContext ctx) { this.ctx = ctx; } public void setHandshakeFuture(ChannelPromise handshakeFuture) { this.handshakeFuture = handshakeFuture; } @Override public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception { if (evt == WebSocketClientProtocolHandler.ClientHandshakeStateEvent.HANDSHAKE_COMPLETE) { handshakeFuture.setSuccess(); } else { super.userEventTriggered(ctx, evt); } } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // Handle WebSocket message } // Other methods } ``` 在这个类中,我们重写了 `channelRead()` 方法,用于处理WebSocket消息。我们也保存了当前的 `ChannelHandlerContext` 和握手操作的 `ChannelPromise`,以便在连接成功后进行操作。 最后,在Spring Boot的主类中,可以通过注入 `WebSocketClient` 的方式来启动WebSocket客户端: ```java @SpringBootApplication public class Application { @Autowired private WebSocketClient webSocketClient; public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args); } @EventListener(ApplicationReadyEvent.class) public void connect() throws Exception { webSocketClient.connect("ws://localhost:8080/websocket"); } } ``` 在 `connect()` 方法中,我们调用了 `WebSocketClient` 的 `connect()` 方法,来连接到WebSocket服务器。注意,这个方法是阻塞的,直到连接关闭或连接失败。 这样,我们就成功地使用Netty和Spring Boot实现了一个WebSocket客户端,并且可以将其注入到Spring Boot的Bean容器中,以方便管理和使用。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值