前言

上一篇讲了netty的一个入门的demo；项目上我也把数据处理做好了，就要开始存数据库了；我用的mybatis框架，如果单独使用还是觉得比较麻烦，所以就用了springboot+mybatis+netty；本篇主要讲netty与springboot的整合，以及我在这个过程中遇到的问题，又是怎么去解决的；

正文

我在做springboot与netty整合的时候在谷歌，百度找了无数文章，都没有一篇是自己想要的，也达不到自己所想的目的；

代码

1. 新建一个springboot项目，在pom文件中添加netty依赖：

        <dependency>

			<groupId>io.netty</groupId>

			<artifactId>netty-all</artifactId>

			<version>5.0.0.Alpha1</version>

		</dependency>

2.新建netty服务

其实可以复制上一篇文章的netty的三个服务类，做一些稍微的修改就行了；这里为了方便演示,且修都是改好了的，就直接贴出来了；

DiscardServer类：

@Component

public class DiscardServer {

    @Resource

    private ChildChannelHandler childChannelHandler;

    public void run(int port) throws Exception {

        EventLoopGroup bossGroup = new NioEventLoopGroup();

        EventLoopGroup workerGroup = new NioEventLoopGroup();

        System.out.println("准备运行端口：" + port);

        try {

            ServerBootstrap bootstrap = new ServerBootstrap();

            bootstrap.group(bossGroup, workerGroup)

                    .channel(NioServerSocketChannel.class)

                    .option(ChannelOption.SO_BACKLOG, 128)

                    .childHandler(childChannelHandler);

            //绑定端口，同步等待成功

            ChannelFuture f = bootstrap.bind(port).sync();

            //等待服务监听端口关闭

            f.channel().closeFuture().sync();

        } finally {

            //退出，释放线程资源

            workerGroup.shutdownGracefully();

            bossGroup.shutdownGracefully();

        }

    }

}

ChildChannelHandler类

@Component

public class ChildChannelHandler extends ChannelInitializer<SocketChannel> {

    @Resource

    private DiscardServerHandler discardServerHandler;

    public void initChannel(SocketChannel socketChannel) throws Exception {

        socketChannel.pipeline().addLast(discardServerHandler);

    }

}

3.DiscardServerHandler类

特别注意DiscardServerHandler类上需要加@Sharable注解，如果不加的话会报错；

@Component

@Sharable

public class DiscardServerHandler extends ChannelHandlerAdapter {

    @Resource

    private BaseService baseService;

    @Override

    public void channelRead(ChannelHandlerContext ctx, Object msg) {

        try {

            ByteBuf in = (ByteBuf) msg;

            System.out.println("传输内容是");

            System.out.println(in.toString(CharsetUtil.UTF_8));

            //这里调用service服务

            baseService.test();

        }  finally {

            ReferenceCountUtil.release(msg);

        }

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        // 出现异常就关闭

        cause.printStackTrace();

        ctx.close();

    }

}

3.netty调用所需的服务类

1.BaseService接口

public interface BaseService {

    /**

     * 测试接口

     */

    void test();

}

2.接口实现类BaseServiceImpl：

@Service

public class BaseServiceImpl implements BaseService {

    @Override

    public void test() {

        System.out.println("调用service服务");

    }

}

4 springboot启动类

由于main方法是静态方法，netty服务启动类不是静态类，在main方法里面需要用new的方式启动；
也可以将netty服务启动类改为静态类，然后调用其他非静态的类时就得用new方法来构造其他类了；

我也百度到了几篇文章说实现CommandLineRunner接口，所以我用了springboot启动类实现CommandLineRunner接口的run方法，然后在run方法里启动netty服务

@SpringBootApplication

public class DemoApplication implements CommandLineRunner {

	@Resource

	private DiscardServer discardServer;

	public static void main(String[] args) {

		SpringApplication.run(DemoApplication.class, args);

	}

	@Override

	public void run(String... args) throws Exception {

		discardServer.run(8080);

	}

}

5.测试

写一个能发送数据的socket就可以了；

发送的数据为：

public static void main(String[] args){

        try {

            Socket socket=new Socket("localhost",8080);

            OutputStream outputStream = socket.getOutputStream();

            PrintWriter printWriter=new PrintWriter(outputStream);

            printWriter.write("$tmb00035ET3318/08/22 11:5804029.94,027.25,20.00,20.00$");

            printWriter.flush();

            socket.shutdownOutput();

            socket.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

我的测试结果：

传输内容是

$tmb00035ET3318/08/22 11:5804029.94,027.25,20.00,20.00$

aaaaa

到这里，netty与springboot的整合就完成了；

我在整合过程中遇到的问题

我使用springboot结合netty的流程

springboot启动类中启动netty启动类(DiscardServer)，netty启动类（DiscardServer）再调用初始化channel类（ChildChannelHandler），然后初始化channel类再调用（DiscardServerHandler）类；然后DiscardServerHandler类再调用service服务；如下示例图：

aaarticlea/png;base64,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" alt="avatar">

问题：

springboot启动类我并没有实现CommandLineRunner接口，直接在main方法通过new的方式启动netty服务
我实现了CommandLineRunner接口，但是我在run方法中用的new的方式启动的netty服务或者我在run方法使用注入的方式启动netty，但是在其他某个地方调用另一个类使用了new的方式；
DiscardServerHandler类上为标记@Sharable类，会报错误；

以上总结起来的问题就是我在springboot整合netty的过程中有其中一处的调用其他类时使用的方式是new构造的，这样虽然springboot能启动，netty也能启动，但是netty服务中使用new构造的那个类中无法依赖注入，会报空指针异常；

举个栗子：在图中的过程中，我在ChildChannelHandler类中通过new的方式调用DiscardServerHandler类，其他的过程都是使用注入的方式调用，就会出现上边的问题；

在遇到空指针的时候，我把spring托管的bean打印了出来，所有的类都在spring的托管中，但是就是无法注入，我也一直没有明白怎么回事，最后用了一个极端的方法，就是在调用服务时，获取spring的上下文，然后再根据名字来获取bean，你谷歌或百度：非托管类调用spring托管类，就能找到很多文章了；虽然用这个方式能解决上述的问题，但总是不好的；

最后的解决办法：所以类之间的调用都使用spring的依赖注入，别用new的方式来调用或者静态方法的方式调用

总结

既然项目中用到了spring，那么类与类之间的调用就用依赖注入，不然会报空指针的问题（就是非托管对象调用spring托管对象）；这也算是一个常识性的问题了，只是自己现在才遇到这样的问题，还是要踩坑才能遇涨记性啊；这些问题困扰了我两三天，还是要有经验的人带，如果有经验的人带的话，说不几分钟就搞定了；

netty的文章到这里就告一段落了，接下来就是赶项目了；哈哈；

GitHub项目地址：

秒客网

springboot整合netty（二）

前言

正文

代码