spring+netty服务器搭建

最新推荐文章于 2024-03-08 21:06:30 发布
最新推荐文章于 2024-03-08 21:06:30 发布
阅读量725 收藏 4
点赞数
分类专栏： netty 文章标签： netty

转载自： https://blog.csdn.net/u012930316/article/details/73743305

 

游戏一般是长连接，自定义协议，不用http协议，BIO,NIO,AIO这些我就不说了，自己查资料

我现在用spring+netty搭起简单的游戏服

思路：1自定义协议和协议包；2spring+netty整合；3半包粘包处理，心跳机制等；4请求分发（目前自己搞的都是单例模式）

下个是测试用的，结构如下

 

 

首先自定义包头

Header.java

 

  1. package com.test.netty.message;

/**

* Header.java

* 自定义协议包头

* @author janehuang

* @version 1.0

*/

public class Header {

private byte tag;

/* 编码*/

private byte encode;

/*加密*/

private byte encrypt;

/*其他字段*/

private byte extend1;

/*其他2*/

private byte extend2;

/*会话id*/

private String sessionid;

/*包的长度*/

private int length = 1024;

/*命令*/

private int cammand;

public Header() {

}

public Header(String sessionid) {

this.encode = 0;

this.encrypt = 0;

this.sessionid = sessionid;

}

public Header(byte tag, byte encode, byte encrypt, byte extend1, byte extend2, String sessionid, int length, int cammand) {

this.tag = tag;

this.encode = encode;

this.encrypt = encrypt;

this.extend1 = extend1;

this.extend2 = extend2;

this.sessionid = sessionid;

this.length = length;

this.cammand = cammand;

}

@Override

public String toString() {

return "header [tag=" + tag + "encode=" + encode + ",encrypt=" + encrypt + ",extend1=" + extend1 + ",extend2=" + extend2 + ",sessionid=" + sessionid + ",length=" + length + ",cammand="

+ cammand + "]";

}

public byte getTag() {

return tag;

}

public void setTag(byte tag) {

this.tag = tag;

}

public byte getEncode() {

return encode;

}

public void setEncode(byte encode) {

this.encode = encode;

}

public byte getEncrypt() {

return encrypt;

}

public void setEncrypt(byte encrypt) {

this.encrypt = encrypt;

}

public byte getExtend1() {

return extend1;

}

public void setExtend1(byte extend1) {

this.extend1 = extend1;

}

public byte getExtend2() {

return extend2;

}

public void setExtend2(byte extend2) {

this.extend2 = extend2;

}

public String getSessionid() {

return sessionid;

}

public void setSessionid(String sessionid) {

this.sessionid = sessionid;

}

public int getLength() {

return length;

}

public void setLength(int length) {

this.length = length;

}

public int getCammand() {

return cammand;

}

public void setCammand(int cammand) {

this.cammand = cammand;

}

}

     

  2.  

  3.  

包体，我简单处理用字符串转字节码，一般好多游戏用probuf系列化成二进制

 

Message.java

 

  1. package com.test.netty.message;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.UnsupportedEncodingException;

import com.test.netty.decoder.MessageDecoder;

/**

* Message.java

*

* @author janehuang

* @version 1.0

*/

public class Message {

private Header header;

private String data;

public Header getHeader() {

return header;

}

public void setHeader(Header header) {

this.header = header;

}

public String getData() {

return data;

}

public void setData(String data) {

this.data = data;

}

public Message(Header header) {

this.header = header;

}

public Message(Header header, String data) {

this.header = header;

this.data = data;

}

public byte[] toByte() {

ByteArrayOutputStream out = new ByteArrayOutputStream();

out.write(MessageDecoder.PACKAGE_TAG);

out.write(header.getEncode());

out.write(header.getEncrypt());

out.write(header.getExtend1());

out.write(header.getExtend2());

byte[] bb = new byte[32];

byte[] bb2 = header.getSessionid().getBytes();

for (int i = 0; i < bb2.length; i++) {

bb[i] = bb2[i];

}

try {

out.write(bb);

byte[] bbb = data.getBytes("UTF-8");

out.write(intToBytes2(bbb.length));

out.write(intToBytes2(header.getCammand()));

out.write(bbb);

out.write('\n');

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return out.toByteArray();

}

public static byte[] intToByte(int newint) {

byte[] intbyte = new byte[4];

intbyte[3] = (byte) ((newint >> 24) & 0xFF);

intbyte[2] = (byte) ((newint >> 16) & 0xFF);

intbyte[1] = (byte) ((newint >> 8) & 0xFF);

intbyte[0] = (byte) (newint & 0xFF);

return intbyte;

}

public static int bytesToInt(byte[] src, int offset) {

int value;

value = (int) ((src[offset] & 0xFF) | ((src[offset + 1] & 0xFF) << 8) | ((src[offset + 2] & 0xFF) << 16) | ((src[offset + 3] & 0xFF) << 24));

return value;

}

public static byte[] intToBytes2(int value) {

byte[] src = new byte[4];

src[0] = (byte) ((value >> 24) & 0xFF);

src[1] = (byte) ((value >> 16) & 0xFF);

src[2] = (byte) ((value >> 8) & 0xFF);

src[3] = (byte) (value & 0xFF);

return src;

}

public static void main(String[] args) {

ByteBuf heapBuffer = Unpooled.buffer(8);

System.out.println(heapBuffer);

ByteArrayOutputStream out = new ByteArrayOutputStream();

try {

out.write(intToBytes2(1));

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

byte[] data = out.toByteArray();

heapBuffer.writeBytes(data);

System.out.println(heapBuffer);

int a = heapBuffer.readInt();

System.out.println(a);

}

}

     

解码器

 

MessageDecoder.java

 

package com.test.netty.decoder;  
  
import io.netty.buffer.ByteBuf;  
import io.netty.channel.ChannelHandlerContext;  
import io.netty.handler.codec.ByteToMessageDecoder;  
import io.netty.handler.codec.CorruptedFrameException;  
  
import java.util.List;  
  
import com.test.netty.message.Header;  
import com.test.netty.message.Message;  
  
  
  
/** 
 * HeaderDecoder.java 
 *  
 * @author janehuang 
 * @version 1.0 
 */  
public class MessageDecoder extends ByteToMessageDecoder {  
    /**包长度志头**/  
    public static final int HEAD_LENGHT = 45;  
    /**标志头**/  
    public static final byte PACKAGE_TAG = 0x01;  
    @Override  
    protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {  
        buffer.markReaderIndex();  
        if (buffer.readableBytes() < HEAD_LENGHT) {  
            throw new CorruptedFrameException("包长度问题");  
        }  
        byte tag = buffer.readByte();  
        if (tag != PACKAGE_TAG) {  
            throw new CorruptedFrameException("标志错误");  
        }  
        byte encode = buffer.readByte();  
        byte encrypt = buffer.readByte();  
        byte extend1 = buffer.readByte();  
        byte extend2 = buffer.readByte();  
        byte sessionByte[] = new byte[32];  
        buffer.readBytes(sessionByte);  
        String sessionid = new String(sessionByte,"UTF-8");  
        int length = buffer.readInt();  
        int cammand=buffer.readInt();  
        Header header = new Header(tag,encode, encrypt, extend1, extend2, sessionid, length, cammand);  
        byte[] data=new byte[length];  
        buffer.readBytes(data);  
        Message message = new Message(header,new String(data,"UTF-8"));  
        out.add(message);  
    }  
}  



 

 

编码器

MessageEncoder.java

 

package com.test.netty.encoder;  
  
  
  
import com.test.netty.decoder.MessageDecoder;  
import com.test.netty.message.Header;  
import com.test.netty.message.Message;  
  
import io.netty.buffer.ByteBuf;  
import io.netty.channel.ChannelHandlerContext;  
import io.netty.handler.codec.MessageToByteEncoder;  
  
  
/** 
 * MessageEncoder.java 
 *  
 * @author janehuang 
 * @version 1.0  
 */  
public class MessageEncoder extends MessageToByteEncoder<Message> {  
  
    @Override  
    protected void encode(ChannelHandlerContext ctx, Message msg, ByteBuf out) throws Exception {  
            Header header = msg.getHeader();  
            out.writeByte(MessageDecoder.PACKAGE_TAG);  
            out.writeByte(header.getEncode());  
            out.writeByte(header.getEncrypt());  
            out.writeByte(header.getExtend1());  
            out.writeByte(header.getExtend2());  
            out.writeBytes(header.getSessionid().getBytes());  
            out.writeInt(header.getLength());  
            out.writeInt(header.getCammand());  
            out.writeBytes(msg.getData().getBytes("UTF-8"));  
    }  
  
}  

服务器

 

TimeServer.java

 

package com.test.netty.server;  
  
  
import org.springframework.stereotype.Component;  
  
  
import io.netty.bootstrap.ServerBootstrap;  
import io.netty.buffer.ByteBuf;  
import io.netty.buffer.Unpooled;  
import io.netty.channel.ChannelFuture;  
import io.netty.channel.ChannelInitializer;  
import io.netty.channel.ChannelOption;  
import io.netty.channel.EventLoopGroup;  
import io.netty.channel.nio.NioEventLoopGroup;  
import io.netty.channel.socket.SocketChannel;  
import io.netty.channel.socket.nio.NioServerSocketChannel;  
import io.netty.handler.codec.LineBasedFrameDecoder;  
  
  
import com.test.netty.decoder.MessageDecoder;  
import com.test.netty.encoder.MessageEncoder;  
import com.test.netty.handler.ServerHandler;  
  
  
/** 
 * ChatServer.java 
 *  
 * @author janehuang 
 * @version 1.0 
 */  
  
  
@Component  
public class TimeServer {  
  
    private int port=88888;  
  
  
    public void run() throws InterruptedException {  
        EventLoopGroup bossGroup = new NioEventLoopGroup();  
        EventLoopGroup workerGroup = new NioEventLoopGroup();  
        ByteBuf heapBuffer = Unpooled.buffer(8);  
        heapBuffer.writeBytes("\r".getBytes());  
        try {  
            ServerBootstrap b = new ServerBootstrap(); // (2)  
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // (3)  
                    .childHandler(new ChannelInitializer<SocketChannel>() { // (4)  
                                @Override  
                                public void initChannel(SocketChannel ch) throws Exception {  
                                    ch.pipeline().addLast("encoder", new MessageEncoder()).addLast("decoder", new MessageDecoder()).addFirst(new LineBasedFrameDecoder(65535))  
                                            .addLast(new ServerHandler());  
                                }  
                            }).option(ChannelOption.SO_BACKLOG, 1024) // (5)  
                    .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)  
            ChannelFuture f = b.bind(port).sync(); // (7)  
            f.channel().closeFuture().sync();  
        } finally {  
            workerGroup.shutdownGracefully();  
            bossGroup.shutdownGracefully();  
        }  
    }  
      
    public void start(int port) throws InterruptedException{  
      this.port=port;  
      this.run();  
    }  
  
}  



处理器并分发

 

ServerHandler.java

 

package com.test.netty.handler;  
  
import io.netty.channel.ChannelHandlerAdapter;  
import io.netty.channel.ChannelHandlerContext;  
  
import com.test.netty.invote.ActionMapUtil;  
import com.test.netty.message.Header;  
import com.test.netty.message.Message;  
  
/** 
 *  
 * @author janehuang 
 * 
 */  
public class ServerHandler extends ChannelHandlerAdapter {  
      
  
  
    @Override  
    public void channelActive(ChannelHandlerContext ctx) throws Exception {  
        String content="我收到连接";  
        Header header=new Header((byte)0, (byte)1, (byte)1, (byte)1, (byte)0, "713f17ca614361fb257dc6741332caf2",content.getBytes("UTF-8").length, 1);  
        Message message=new Message(header,content);  
        ctx.writeAndFlush(message);  
          
    }  
  
    @Override  
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {  
        cause.printStackTrace();  
        ctx.close();  
    }  
  
    @Override  
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {  
         Message m = (Message) msg; // (1)  
           
        /* 请求分发*/  
        ActionMapUtil.invote(header.getCammand(),ctx, m);  
    }  
      
      
}  


分发工具类

 

ActionMapUtil.java

 

package com.test.netty.invote;  
  
import java.lang.reflect.Method;  
import java.util.HashMap;  
import java.util.Map;  
  
public class ActionMapUtil {  
  
    private static Map<Integer, Action> map = new HashMap<Integer, Action>();  
  
    public static Object invote(Integer key, Object... args) throws Exception {  
        Action action = map.get(key);  
        if (action != null) {  
            Method method = action.getMethod();  
            try {  
                return method.invoke(action.getObject(), args);  
            } catch (Exception e) {  
                throw e;  
            }  
        }  
        return null;  
    }  
  
    public static void put(Integer key, Action action) {  
        map.put(key, action);  
    }  
  
}  


为分发创建的对象

 

Action.java

 

package com.test.netty.invote;  
  
import java.lang.reflect.Method;  
  
public class Action {  
      
    private Method method;  
      
    private Object object;  
  
    public Method getMethod() {  
        return method;  
    }  
  
    public void setMethod(Method method) {  
        this.method = method;  
    }  
  
    public Object getObject() {  
        return object;  
    }  
  
    public void setObject(Object object) {  
        this.object = object;  
    }  
      
  
}  

自定义注解，类似springmvc 里面的@Controller
 

 

NettyController.java

 

package com.test.netty.core;  
  
import java.lang.annotation.Documented;  
import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
import org.springframework.stereotype.Component;  
  
@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.TYPE)  
@Documented  
@Component  
public @interface NettyController {  
      
        
}  


类型spring mvc里面的@ReqestMapping

 

ActionMap.java

 

package com.test.netty.core;  
  
import java.lang.annotation.Documented;  
import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.METHOD)  
@Documented  
public @interface ActionMap {  
      
      int key();  
        
}  

加了这些注解是为了spring初始化bean后把这些对象存到容器,此bean需要在spring配置，spring bean 实例化后会调用

 

ActionBeanPostProcessor.java

 

package com.test.netty.core;  
  
import java.lang.reflect.Method;  
  
import org.springframework.beans.BeansException;  
import org.springframework.beans.factory.config.BeanPostProcessor;  
  
import com.test.netty.invote.Action;  
import com.test.netty.invote.ActionMapUtil;  
  
public class ActionBeanPostProcessor implements BeanPostProcessor  {  
  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        return bean;  
    }  
  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        Method[] methods=bean.getClass().getMethods();  
        for (Method method : methods) {  
            ActionMap actionMap=method.getAnnotation(ActionMap.class);  
            if(actionMap!=null){  
                Action action=new Action();  
                action.setMethod(method);  
                action.setObject(bean);  
                ActionMapUtil.put(actionMap.key(), action);  
            }  
        }  
        return bean;  
    }  
  
}  


controller实例

 

UserController.java

 

package com.test.netty.controller;  
  
import io.netty.channel.ChannelHandlerContext;  
  
import org.springframework.beans.factory.annotation.Autowired;  
  
import com.test.model.UserModel;  
import com.test.netty.core.ActionMap;  
import com.test.netty.core.NettyController;  
import com.test.netty.message.Message;  
import com.test.service.UserService;  
  
  
  
@NettyController()  
public class UserAction {  
      
      
    @Autowired  
    private UserService userService;  
      
      
    @ActionMap(key=1)  
    public String login(ChannelHandlerContext ct,Message message){  
        UserModel userModel=this.userService.findByMasterUserId(1000001);  
        System.out.println(String.format("用户昵称:%s;密码%d;传人内容%s", userModel.getNickname(),userModel.getId(),message.getData()));  
        return userModel.getNickname();  
    }  
  
}  



applicationContext.xml配置文件记得加入这个

 

<bean class="com.test.netty.core.ActionBeanPostProcessor"/>  

 

 

测试代码

 

package test;  
  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
  
import com.test.netty.server.TimeServer;  
  
public class Test {  
  
      
    public static void main(String[] args) {  
          ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");    
          TimeServer timeServer=  ac.getBean(TimeServer.class);  
          try {  
            timeServer.start(8888);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
            
    }  
      
      
}  


测试开关端

 

package test;  
  
import java.io.IOException;  
import java.io.OutputStream;  
import java.net.Socket;  
import java.util.Scanner;  
  
import com.test.netty.message.Header;  
import com.test.netty.message.Message;  
  
public class ClientTest {  
  
    public static void main(String[] args) {  
        try {  
            // 连接到服务器  
            Socket socket = new Socket("127.0.0.1", 8888);  
  
            try {  
                // 向服务器端发送信息的DataOutputStream  
                OutputStream out = socket.getOutputStream();  
                // 装饰标准输入流，用于从控制台输入  
                Scanner scanner = new Scanner(System.in);  
                while (true) {  
                    String send = scanner.nextLine();  
                    System.out.println("客户端：" + send);  
                    byte[] by = send.getBytes("UTF-8");  
                    Header header = new Header((byte) 1, (byte) 1, (byte) 1, (byte) 1, (byte) 1, "713f17ca614361fb257dc6741332caf2", by.length, 1);  
                    Message message = new Message(header, send);  
                    out.write(message.toByte());  
                    out.flush();  
                    // 把从控制台得到的信息传送给服务器  
                    // out.writeUTF("客户端：" + send);  
                    // 读取来自服务器的信息  
                }  
  
            } finally {  
                socket.close();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  


测试结果，ok了

_我要早睡晚起
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring+netty服务器搭建的方法
08-28
本篇文章主要介绍了spring+netty服务器搭建的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码
03-31
Java整合springboot2.3+modbusTcp协议+netty高性能物联网服务源码 ...5、完全支持Modbus TCP 4种部署模式: TCP服务器master,TCP客户端slave,TCP服务器slave,TCP客户端master。 本人QQ412961810，有问题可以帮忙解答
Spring和Netty整合详解
feiyangtianyao的专栏
05-28 2万+
Spring和Netty整合详解 本篇主要介绍netty如何跟Spring配合，其实真的很没必要将netty和Spring牵扯在一起，我们完全可以用netty做出一个spring的；然而在《Spring环境下使用Netty写Socket和Http详解》一篇中，因为没怎么用到Spring，遭到部分网友质疑，因此这一篇着重介绍如何跟Spring做配合。 官方主页 Spring Netty 一、概述 N...
认真啃透，带你玩转网络开发框架中的Spring——Netty
老男孩的架构路
11-03 739
Netty是一款异步的事件驱动的网络应用程序框架，支持快速开发可维护的高性能的面向协议的服务器和客户端。Netty主要是对java 的 nio包进行的封装。
Spring Boot与Netty的完美结合：打造高性能网络通信
里查叔叔
03-08 2485
本文介绍了如何在Spring Boot项目中添加Netty依赖、编写Netty服务端和客户端代码，并将Netty的启动和关闭整合到Spring Boot的生命周期中。一旦你整合了Netty到你的Spring Boot应用中，并实现了必要的业务逻辑处理器，你就可以构建并运行你的应用来测试Netty服务了。此外，Netty还提供了丰富的编解码器、处理器和工具类，大大简化了网络编程的复杂性。要在Spring Boot项目中集成Netty，我们需要添加Netty的依赖，并编写Netty的服务端和客户端代码。
springboot整合netty的步骤
Wyangcsdb的博客
11-07 1223
springboot整合netty框架 　Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。 那么如何和springboot这个比较流行的框架进行整合呢？Netty与SpringBoot的整合，我想无非就是要整合几个地方 让netty跟springboot生命周期保持一致，同生共死 让netty能用上ioc
Spring - Netty原理剖析
迦南的专栏
02-09 626
1. Netty简介 Netty是一个高性能、异步事件驱动的NIO框架，基于JAVA NIO提供的API实现。它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。 作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty的NIO框架构建。 2. Netty线程模
Spring Boot + Netty 实现温湿度采集的展示
05-24
Spring Boot + Netty 实现温湿度采集的展示，压缩包为软件平台
Springboot+netty实现的流媒体服务（可用于直播点播）
04-28
介绍：Springboot、netty实现的http-flv、websocket-flv流媒体服务（可用于直播点播），支持rtsp、h264、h265等、rtmp等多种源，h5纯js播放（不依赖flash），不需要依赖nginx等第三方，低延迟（支持识别h264、aac...
ClusterDeviceControlPlatform：Java＆Vue.js全栈“放置设备管理云平台『放置部分』』，使用Spring Boot，Netty搭建TCP服务器与上万设备的通信，基于JavaFX的GUI应用程序模拟上万台设备的行为，初步对服务器进行压力测试
01-30
充分利用设备管理云平台「Java，SPA，Spring Boot 2.0，Netty，Vue.js 2.0，Element 2.0」项目描述Java＆Vue.js全栈项目，大规模扩展设备管理云平台，由以下几部分组成： Java前端服务器，基于Vue.js的Web前端“ SPA...
netty4与spring集成
06-11
netty4与spring集成；客户端服务端代码实现。netty4与spring集成。
netty+spring（整合实战）
架构师尼恩
11-08 4935
Netty Spring （整合） 疯狂创客圈 死磕Netty 系列之 11 【 博客园 总入口 】 主要介绍的是SpringBoot整合Netty。在使用Netty之前，建议先了解Netty的基本原理，请参阅疯狂创客圈。 这里仅仅是使用Netty的第一步，这里介绍一个最简单的Demo——EchoServer，也就是回写服务器。就是无论客户端发啥字符串到服务器端，服务器端接收字符串后直接回写...
Spring Boot框架整合Netty并自定义返回报文协议
weixin_43831884的博客
08-23 1462
通过spring boot框架整合netty，实现自定义报文协议的客户端服务端消息传输
Spring架构篇--2.7 远程通信基础--使用Netty
拽着尾巴的鱼儿的博客
06-05 591
Netty的设计目标是提供一个可嵌入、高性能、灵活、易于使用的网络编程框架，支持多种传输协议，如TCP、UDP、HTTP、WebSocket等，并且提供了丰富的功能，如SSL/TLS支持、压缩、编解码、流量控制、负载均衡、连接管理等。其中，Channel是网络通信的载体，EventLoop是异步事件驱动的核心，ChannelFuture是异步操作的结果，ChannelHandler是处理网络事件的组件，Bootstrap则是启动Netty应用程序的入口点。Netty的优点在于其高性能、可扩展性和灵活性。
Java常用框架（三）SpringBoot及Netty
folyh
02-23 2647
Java常用框架（三）SpringBoot及Netty
在SpringBoot项目中使用Netty创建服务端
咘噜biu的博客
12-14 1745
在SpringBoot项目中使用Netty创建服务端
SpringBoot使用netty
热门推荐
阿靖的博客
06-29 3万+
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP...
springboot+netty
最新发布
04-11
5. 启动Spring Boot应用，Netty服务器开始监听指定端口，并处理请求。 通过结合Spring Boot和Netty，可以快速搭建高性能的网络应用程序，并且可以利用Spring Boot的优势进行配置和管理。同时，Netty提供了丰富的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值