首页 / NETTY / springboot+netty搭建客户端与服务端1（服务端）

springboot+netty搭建客户端与服务端1（服务端）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了springboot+netty搭建客户端与服务端1（服务端），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10800字，纯文字阅读大概需要16分钟。

内容图文

1.搭建服务端

启动类

在springboot中利用netty替换tomcat，关闭tomcat与banner。添加扫描注解

import com.jd.wl.sim.annotation.EventProcess;
import org.springframework.boot.Banner;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(includeFilters = @ComponentScan.Filter(EventProcess.class))

public class NettyServerApplication {

	public static void main(String[] args) {
		SpringApplicationBuilder app = new SpringApplicationBuilder(NettyServerApplication.class);
		app.web(WebApplicationType.NONE);
		app.bannerMode(Banner.Mode.OFF);
		app.run(args);
	}
}

在控制类中写的注解

package com.jd.wl.sim.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EventProcess {
    String name() default "";
}

配置文件

netty.server.port=8080
netty.server.host=127.0.0.1
spring.application.name=netty-server

netty服务搭建

package com.jd.wl.sim.configuration;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;

@Configuration
public class NettyServer implements ApplicationListener<ApplicationStartedEvent> {
    private static final Logger LOGGER = LoggerFactory.getLogger(NettyServer.class);
    @Value("${netty.server.port}")
    private int port;
    @Value("${netty.server.host}")
    private String host;
    @Autowired
    private ServerInializer serverInializer;

    @Override
    public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
        ServerBootstrap bootstrap = new ServerBootstrap();
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            bootstrap.group(bossGroup, workerGroup);
            bootstrap.channel(NioServerSocketChannel.class);
            bootstrap.childOption(ChannelOption.TCP_NODELAY, true);
            bootstrap.childOption(ChannelOption.SO_REUSEADDR, true);
            bootstrap.childOption(ChannelOption.SO_KEEPALIVE, false);
            bootstrap.childOption(ChannelOption.SO_RCVBUF, 2048);
            bootstrap.childOption(ChannelOption.SO_SNDBUF, 2048);
            bootstrap.handler(new LoggingHandler(LogLevel.INFO));
            bootstrap.childHandler(serverInializer);
            ChannelFuture channelFuture = bootstrap.bind(host, port).sync();
            String logBanner = "\n\n" +
                    "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n" +
                    "                   Netty Server started on port {}.                                  \n" +
                    "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n";
            LOGGER.info(logBanner, port);
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            LOGGER.info("Netty Server Start Shutdown ............");
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

添加服务器端初始化初始化器

package com.jd.wl.sim.configuration;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * 服务器端初始化初始化器
 *
 * @author hanhuide
 * @date 2021/04/14
 */
@Component
public class ServerInializer extends ChannelInitializer<SocketChannel> {
    @Autowired
    private ServerHandler serverHandler;

    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new ObjectEncoder());//编码器
        pipeline.addLast(new ObjectDecoder(ClassResolvers.cacheDisabled(null)));//解码器
        pipeline.addLast(serverHandler);
    }
}

添加服务端处理程序

package com.jd.wl.sim.configuration;

import com.jd.wl.sim.IFunctionHandler;
import com.jd.wl.sim.annotation.EventProcess;
import com.jd.wl.sim.exception.IllegalPathDuplicatedException;
import com.jd.wl.sim.model.Event;
import com.jd.wl.sim.util.ChannelMap;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.socket.SocketChannel;
import io.netty.util.ReferenceCountUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服务器处理程序
 *
 * @author hanhuide
 * @date 2021/04/14
 */
@ChannelHandler.Sharable
@Component
public class ServerHandler extends SimpleChannelInboundHandler<Event> implements ApplicationContextAware {
    private static final Logger LOGGER = LoggerFactory.getLogger(ServerHandler.class);
    private ConcurrentHashMap<String, IFunctionHandler> functionHandlerMap = new ConcurrentHashMap<>();
    private ExecutorService executor = Executors.newCachedThreadPool(runnable -> {
        Thread thread = Executors.defaultThreadFactory().newThread(runnable);
        thread.setName("NettyServerHandler-" + thread.getName());
        return thread;
    });

    @Override
    protected void messageReceived(ChannelHandlerContext ctx, Event event) throws Exception {
//        handlingEvents(ctx, event);
//        Thread.sleep(2000);
        executor.execute(() -> handlingEvents(ctx, event));
    }

    private void handlingEvents(ChannelHandlerContext ctx, Event event) {
        IFunctionHandler handler = functionHandlerMap.get("hello");
        SocketChannel ch = ChannelMap.randomChannel();
        LOGGER.info(event.toString());
        handler.execute(event, null).forEach(e -> {
//            LOGGER.info(e.toString());
            ch.writeAndFlush(e);
        });
        ReferenceCountUtil.release(event);
    }

    /**
     * 通道关闭
     *
     * @param ctx ctx
     * @throws Exception 异常
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        //channel失效，从Map中移除
        ChannelMap.remove((SocketChannel) ctx.channel());
        LOGGER.info("{}：客户端下线", ctx.channel().remoteAddress());
    }

    /**
     * 通道畅通
     *
     * @param ctx ctx
     * @throws Exception 异常
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ChannelMap.add((SocketChannel) ctx.channel());
        LOGGER.info("{}：客户端上线", ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> handlers = applicationContext.getBeansWithAnnotation(EventProcess.class);
        for (Map.Entry<String, Object> entry : handlers.entrySet()) {
            Object handler = entry.getValue();
            String name = handler.getClass().getAnnotation(EventProcess.class).name();
            if (functionHandlerMap.containsKey(name)) {
                LOGGER.error("IFunctionHandler has duplicated :{}", name, new IllegalPathDuplicatedException());
                System.exit(0);
            }
            functionHandlerMap.put(name, (IFunctionHandler) handler);
        }
    }
}

netty中传递参数的基类为Event

package com.jd.wl.sim.model;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Reprsent a simulation event
 *
 * @author: Yu Wang
 * @date: 2021-03-29 14:46
 **/
@Data
public class Event implements Serializable {
    public Event(String type) {
        Type = type;
    }

    String name;
    String Type;
    String shareResource;
    Date occurTime = null;
    Date processTime = null;
}

在服务断使用到的工具类

package com.jd.wl.sim.util;

import io.netty.channel.Channel;
import io.netty.channel.ChannelId;
import io.netty.channel.socket.SocketChannel;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class ChannelMap {
    private static Map<String, SocketChannel> channelMap = new ConcurrentHashMap<String, SocketChannel>();

    public static String add(SocketChannel socketChannel) {
        ChannelId channelId = socketChannel.id();
        String idStr = channelId.asLongText();
        channelMap.put(idStr, socketChannel);
        return idStr;
    }

    public static Channel get(String clientId) {
        return channelMap.get(clientId);
    }

    public static void remove(SocketChannel socketChannel) {
        ChannelId channelId = socketChannel.id();
        String idStr = channelId.asLongText();
        channelMap.remove(idStr);
    }

    public static SocketChannel randomChannel() {
        Collection<SocketChannel> values = channelMap.values();
        int ran2 = (int) (Math.random() * (values.size()));
        int i = 0;
        for (SocketChannel channel : values) {
            if (i == ran2) return channel;
            i++;
        }
        return null;
    }

    public static int getSize() {
        return channelMap.size();
    }

    public static Set<String> getKeys() {
        return channelMap.keySet();
    }

    public static void main(String[] args) {
        int ran2 = (int) (Math.random() * (2));
        System.out.println(ran2);
    }
}

测试类接口

package com.jd.wl.sim;

import com.jd.wl.sim.model.Event;
import com.jd.wl.sim.model.HttpRequest;
import com.jd.wl.sim.resources.SimResources;
import io.netty.util.Attribute;

import javax.xml.ws.Response;
import java.util.List;

public interface IFunctionHandler {
    List<Event> execute(Event event, Attribute<SimResources> resourcesAttribute);
}

package com.jd.wl.sim.controller;

import com.jd.wl.sim.IFunctionHandler;
import com.jd.wl.sim.annotation.EventProcess;
import com.jd.wl.sim.model.Event;
import com.jd.wl.sim.resources.SimResources;
import io.netty.util.Attribute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

@EventProcess(name = "hello")
public class HelloController implements IFunctionHandler {
    private static final Logger LOGGER = LoggerFactory.getLogger(HelloController.class);

    @Override
    public List<Event> execute(Event event, Attribute<SimResources> attribute) {
        List<Event> list = new ArrayList<>();
        if ("main".equals(event.getType())) {
            event.setName("起床");
            Calendar calendar = Calendar.getInstance();
            calendar.set(2021, 4, 25, 6, 00, 00);
            event.setProcessTime(calendar.getTime());
            list.add(event);
        } else {

            list.add(event);
        }
        return list;
    }
}

内容总结

以上是互联网集市为您收集整理的springboot+netty搭建客户端与服务端1（服务端）全部内容，希望文章能够帮你解决springboot+netty搭建客户端与服务端1（服务端）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/997934.html

来源：【匿名】

【上一篇】1. 彤哥说netty系列之开篇（有个问卷调查）【下一篇】一起学Netty（九）之LengthFieldBasedFrameDecoder

更多 ►

【springboot+netty搭建客户端与服务端1（服务端）】教程文章相关的互联网学习教程文章

Netty实现客户端和服务端通信简单例子【代码】

Netty是建立在NIO基础之上，Netty在NIO之上又提供了更高层次的抽象。在Netty里面，Accept连接可以使用单独的线程池去处理，读写操作又是另外的线程池来处理。Accept连接和读写操作也可以使用同一个线程池来进行处理。而请求处理逻辑既可以使用单独的线程池进行处理，也可以跟放在读写线程一块处理。线程池中的每一个线程都是NIO线程。用户可以根据实际情况进行组装，构造出满足系统需求的并发模型。Netty提供了内置的常用编解码器，...

Netty实现服务端客户端长连接通讯及心跳检测

摘要: 通过netty实现服务端与客户端的长连接通讯，及心跳检测通过netty实现服务端与客户端的长连接通讯，及心跳检测。基本思路：netty服务端通过一个Map保存所有连接上来的客户端SocketChannel,客户端的Id作为Map的key。每次服务器端如果要向某个客户端发送消息，只需根据ClientId取出对应的SocketChannel,往里面写入message即可。心跳检测通过IdleEvent事件，定时向服务端放送Ping消息，检测SocketChannel是否终断。...

Netty源码(十二)之服务端向客户端写数据的过程【代码】【图】

前面的几篇博客大致的介绍整个Netty核心的代码，以及启动的流程，服务端的读取流程，以及常用的解码器的源码。至此Netty的源码还剩一个服务端向客户端写数据的流程。今天我们就来介绍一下服务端向客户端写的流程。写的方式有以下两种，具体代码如下： ctx.writeAndFlush(""); ctx.channel().writeAndFlush("");这两种方式的区别具体如下图所示：可以看到我们如果执行ctx.writeAndFlush("");方法后，当前的handler后面所有handler都...

Netty通过WebSocket编程实现服务器和客户端长连接【代码】【图】

服务器端 public class MyServer {public static void main(String[] args) throws Exception {NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);NioEventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).handler(new LoggingHandler(LogLevel.INFO)) //在bossGrou...

【Netty之旅四】你一定看得懂的Netty客户端启动源码分析！

【Netty之旅四】你一定看得懂的Netty客户端启动源码分析！前言前面小飞已经讲解了NIO和Netty服务端启动，这一讲是Client的启动过程。源码系列的文章依旧还是遵循大白话+画图的风格来讲解，本文Netty源码及以后的文章版本都基于：4.1.22.Final本篇是以NettyClient启动为切入点，带大家一步步进入Netty源码的世界。Client启动流程揭秘1、探秘的入口：netty-client demo这里用netty-exmaple中的EchoClient来作为例子：public final cl...

netty socket简单实现客服聊天功能详细讲解(含安卓用户端，java客户端，java后台程序)【代码】【图】

依照上一篇：https://blog.csdn.net/qq_41966009/article/details/104441452依次按照对应功能写出对应详解。 1.用户端和服务端分别与后台服务器(java后台)通信 1.1用户端(安卓用户端)与后台服务器（java后台）通信首先创建一个ChatApplication类，主要实现以下功能，方便在MainActivity使用SocketIO.Options options = new IO.Options(); // private SocketIoprivate Socket mSocket;private Socket mSocket;{try {options.rec...

java – 使用双向SSL Handake设置Netty(客户端和服务器证书)【代码】

我现在正尝试使用双向SSL握手设置Netty,其中客户端和服务器都提供并验证证书. 这似乎没有在SslHandler中实现.有没有人这样做？我想它会进入SslHandler.handshake操作并被委托给javax.net.ssl.SSLEngine？任何提示/提示/预先存在的实现？谢谢！ ANSWER(stackoverflow不会让我以正常的方式发布它)我发现如果我在设置我的SslHandler之前在SSLEngine对象上设置了needClientAuth标志,那就解决了这个问题！解决方法:这是解决方案,基于n...

java – netty文件传输客户端

我是netty的新手,并用netty示例学习它.现在我想通过发送文件路径从服务器获取文件.此文件是视频,而不是文本文件. 我的客户代码：服务器代码来自github：https://github.com/netty/netty/tree/4.0/example/src/main/java/io/netty/example/file 我尝试了3天但失败了.我如何从服务器接收分块文件？解决方法:我知道您在客户端请求中将路径发送到服务器.所以你在服务器中有一个处理程序来捕获这个路径.在此处理程序中,打开/读取文件以获...

springboot+netty搭建客户端与服务端1（服务端）【代码】

1.搭建服务端启动类在springboot中利用netty替换tomcat，关闭tomcat与banner。添加扫描注解 import com.jd.wl.sim.annotation.EventProcess; import org.springframework.boot.Banner; import org.springframework.boot.WebApplicationType; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.context.an...

Netty+Spring Boot仿微信全栈开发高性能后台及客户端

download:Netty+Spring Boot仿微信全栈开发高性能后台及客户课程将仿微信开发一个App，其中涉及 Netty的websocket开发、SpringBoot开发、MUI与H5Plus（H5+）以及Nginx+FastDFS分布式文件系统搭建与使用等。学完后你也能开发出一个高水平的App，并且发布上线。适合人群初中级java开发，有基础的大学应届生技术储备要求Java基础，了解 html、css、js前端基础，了解linux、spring、springmvc、MyBatis，mysql/mariadb或者其他关系...

Netty Chunk,HttpPost客户端附件上传，服务端解析上传附件【代码】

1.服务端返回Chunk 声明，笔者使用的是netty3,netty 3,语法大同小异，主要学习一个思想 1.RestServer.java@Overridepublic void run() {ExecutorService boss = null;ExecutorService worker = null;NioServerSocketChannelFactory nioServerSocketChannelFactory = null;ServerBootstrap bootstrap = null;try {boss = Executors.newCachedThreadPool();worker = Executors.newCachedThreadPool();nioServerSocketChannelFactory ...

Netty客户端发起连接过程注意点【代码】【图】

使用Netty创建客户端的时候, 和创建服务端类似, 也需要经过创建-初始化-注册这三步, 最后一步也最重要就是连接操作, io.netty.bootstrap.Bootstrap#connect(java.net.SocketAddress) 创建就是创建NioSocketChannel, 同时也会创建unsafe,pipeline,config等. 还会设置一个感兴趣的SelectionKey.OP_READ 读事件属性, 此时也仅仅是把OP_READ保存到一个属性上. 初始化就是给channel设置一些option和attribute. 注册就是将channel注册到对...

首页 / NETTY / springboot+netty搭建客户端与服务端1（服务端）

springboot+netty搭建客户端与服务端1（服务端）

内容导读

内容图文

内容总结

内容备注

内容手机端

【springboot+netty搭建客户端与服务端1（服务端）】教程文章相关的互联网学习教程文章

SPRINGBOOT - 相关标签

NETTY - 相关标签

服务端 - 相关标签

NETTY - 最新教程

NETTY - 最热教程