程序一逸
程序一逸

Netty实战篇：基于Netty框架打造一款高性能的IM即时通讯程序

引言

   关于Netty网络框架的内容，前面已经讲了两个章节，但总归来说难以真正掌握，毕竟只是对其中一个个组件进行讲解，很难让诸位将其串起来形成一条线，所以本章中则会结合实战案例，对Netty进行更深层次的学习与掌握，实战案例也并不难，一个非常朴素的IM聊天程序。

原本打算做个多人斗地主，但斗地主需要织入过多的业务逻辑，因此一方面会带来不必要的理解难度，让案例更为复杂化，另一方面代码量也会偏多，所以最终依旧选择实现基本的聊天程序，既简单，又能加深对Netty的理解。

一、基于Netty设计通信协议

   协议，这玩意儿相信大家肯定不陌生了，毕竟在《网络编程》系列的前两章，都在围绕着网络协议展开叙述，再来简单回顾一下协议的概念：网络协议是指一种通信双方都必须遵守的约定，两个不同的端，按照一定的格式对数据进行“编码”，同时按照相同的规则进行“解码”，从而实现两者之间的数据传输与通信。

当自己想要打造一款IM通信程序时，对于消息的封装、拆分也同样需要设计一个协议，通信的两端都必须遵守该协议工作，这也是实现通信程序的前提，但为什么需要通信协议呢？因为TCP/IP中是基于流的方式传输消息，消息与消息之间没有边界，而协议的目的则在于约定消息的样式、边界等。

1.1、Redis通信的RESP协议

   不知大家是否还记得之前在《Redis综述篇》中聊到的RESP客户端协议，这是Redis提供的一种客户端通信协议，如果想要操作Redis，就必须遵守该协议的格式发送数据，但这个协议特别简单，如下：

  • 首先要求所有命令，都以*开头，后面跟着具体的子命令数量，接着用换行符分割。
  • 接着需要先用$符号声明每个子命令的长度，然后再用换行符分割。
  • 最后再拼接上具体的子命令，同样用换行符分割。

这样描述有些令人难懂，那就直接看个案例，例如一条简单set命令，如下：

客户端命令：
    set name ZhuZi

转变为RESP指令：
    *3
    $3
    set
    $4
    name
    $5
    ZhuZi
复制代码

按照Redis的规定，但凡满足RESP协议的客户端，都可以直接连接并操作Redis服务端，这也就意味着咱们可以直接通过Netty来手写一个Redis客户端，代码如下：

// 基于Netty、RESP协议实现的Redis客户端
public class RedisClient {
    // 换行符的ASCII码
    static final byte[] LINE = {13, 10};

    public static void main(String[] args) {
        EventLoopGroup worker = new NioEventLoopGroup();
        Bootstrap client = new Bootstrap();

        try {
            client.group(worker);
            client.channel(NioSocketChannel.class);
            client.handler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel socketChannel)
                                                        throws Exception {
                    ChannelPipeline pipeline = socketChannel.pipeline();

                    pipeline.addLast(new ChannelInboundHandlerAdapter(){

                        // 通道建立成功后调用：向Redis发送一条set命令
                        @Override
                        public void channelActive(ChannelHandlerContext ctx)
                                                            throws Exception {
                            String command = "set name ZhuZi";
                            ByteBuf buffer = respCommand(command);
                            ctx.channel().writeAndFlush(buffer);
                        }

                        // Redis响应数据时触发：打印Redis的响应结果
                        @Override
                        public void channelRead(ChannelHandlerContext ctx,
                                                Object msg) throws Exception {
                            // 接受Redis服务端执行指令后的结果
                            ByteBuf buffer = (ByteBuf) msg;
                            System.out.println(buffer.toString(CharsetUtil.UTF_8));
                        }
                    });
                }
            });

            // 根据IP、端口连接Redis服务端
            client.connect("192.168.12.129", 6379).sync();
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    private static ByteBuf respCommand(String command){
        // 先对传入的命令以空格进行分割
        String[] commands = command.split(" ");
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();

        // 遵循RESP协议：先写入指令的个数
        buffer.writeBytes(("*" + commands.length).getBytes());
        buffer.writeBytes(LINE);

        // 接着分别写入每个指令的长度以及具体值
        for (String s : commands) {
            buffer.writeBytes(("$" + s.length()).getBytes());
            buffer.writeBytes(LINE);
            buffer.writeBytes(s.getBytes());
            buffer.writeBytes(LINE);
        }
        // 把转换成RESP格式的命令返回
        return buffer;
    }
}
复制代码

在上述这个案例中，也仅仅只是通过respCommand()这个方法，对用户输入的指令进行了转换，同时在上面通过Netty，与Redis的地址、端口建立了连接，在连接建立成功后，就会向Redis发送一条转换成RESP指令的set命令，接着等待Redis的响应结果并输出，如下：

+OK
复制代码

因为这是一条写指令，所以当Redis收到执行完成后，最终就会返回一个OK，大家也可直接去Redis中查询，也依旧能够查询到刚刚写入的name这个键值。

1.2、HTTP超文本传输协议

   前面咱们自己针对于Redis的RESP协议，对用户指令进行了封装，然后发往Redis执行，但对于这些常用的协议，Netty早已提供好了现成的处理器，想要使用时无需从头开发，可以直接使用现成的处理器来实现，比如现在咱们可以基于Netty提供的处理器，实现一个简单的HTTP服务器，代码如下：

// 基于Netty提供的处理器实现HTTP服务器
public class HttpServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        ServerBootstrap server = new ServerBootstrap();
        server
            .group(boss,worker)
            .channel(NioServerSocketChannel.class)
            .childHandler(new ChannelInitializer() {
                @Override
                protected void initChannel(NioSocketChannel ch) {
                    ChannelPipeline pipeline = ch.pipeline();

                    // 添加一个Netty提供的HTTP处理器
                    pipeline.addLast(new HttpServerCodec());
                    pipeline.addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx,
                                                Object msg) throws Exception {
                            // 在这里输出一下消息的类型
                            System.out.println("消息类型：" + msg.getClass());
                            super.channelRead(ctx, msg);
                        }
                    });
                    pipeline.addLast(new SimpleChannelInboundHandler() {
                        @Override
                        protected void channelRead0(ChannelHandlerContext ctx,
                                                    HttpRequest msg) throws Exception {
                            System.out.println("客户端的请求路径：" + msg.uri());

                            // 创建一个响应对象，版本号与客户端保持一致，状态码为OK/200
                            DefaultFullHttpResponse response =
                                    new DefaultFullHttpResponse(
                                            msg.protocolVersion(),
                                            HttpResponseStatus.OK);

                            // 构造响应内容
                            byte[] content = "
Hi, ZhuZi!
".getBytes();

                            // 设置响应头：告诉客户端本次响应的数据长度
                            response.headers().setInt(
                                HttpHeaderNames.CONTENT_LENGTH,content.length);
                            // 设置响应主体
                            response.content().writeBytes(content);

                            // 向客户端写入响应数据
                            ctx.writeAndFlush(response);
                        }
                    });
                }
            })
            .bind("127.0.0.1",8888)
            .sync();
    }
}
复制代码

在该案例中，咱们就未曾手动对HTTP的数据包进行拆包处理了，而是在服务端的pipeline上添加了一个HttpServerCodec处理器，这个处理器是Netty官方提供的，其类继承关系如下：

public final class HttpServerCodec 
    extends CombinedChannelDuplexHandler 
    implements SourceCodec {
    // ......
}
复制代码

观察会发现，该类继承自CombinedChannelDuplexHandler这个组合类，它组合了编码器、解码器，这也就意味着HttpServerCodec即可以对客户端的数据做解码，也可以对服务端响应的数据做编码，同时除开添加了这个处理器外，在第二个处理器中打印了一下客户端的消息类型，最后一个处理器中，对客户端的请求做出了响应，其实也就是返回了一句话而已。

此时在浏览器输入http://127.0.0.1:8888/index.html，结果如下：

消息类型：class io.netty.handler.codec.http.DefaultHttpRequest
消息类型：class io.netty.handler.codec.http.LastHttpContent$1
客户端的请求路径：/index.html
复制代码

此时来看结果，客户端的请求会被解析成两个部分，第一个是请求信息，第二个是主体信息，但按理来说浏览器发出的请求，属于GET类型的请求，GET请求是没有请求体信息的，但Netty依旧会解析成两部分~，只不过GET请求的第二部分是空的。

在第三个处理器中，咱们直接向客户端返回了一个h1标签，同时也要记得在响应头里面，加上响应内容的长度信息，否则浏览器的加载圈，会一直不同的转动，毕竟浏览器也不知道内容有多长，就会一直反复加载，尝试等待更多的数据。

1.3、自定义消息传输协议

   Netty除开提供了HTTP协议的处理器外，还提供了DNS、HaProxy、MemCache、MQTT、Protobuf、Redis、SCTP、RTSP.....一系列协议的实现，具体定义位于io.netty.handler.codec这个包下，当然，咱们也可以自己实现自定义协议，按照自己的逻辑对数据进行编解码处理。

很多基于Netty开发的中间件/组件，其内部基本上都开发了专属的通信协议，以此来作为不同节点间通信的基础，所以解下来咱们基于Netty也来自己设计一款通信协议，这也会作为后续实现聊天程序时的基础。

但所谓的协议设计，其实仅仅只需要按照一定约束，实现编码器与解码器即可，发送方在发出数据之前，会经过编码器对数据进行处理，而接收方在收到数据之前，则会由解码器对数据进行处理。

1.3.1、自定义协议的要素

在自定义传输协议时，咱们必然需要考虑几个因素，如下：

  • 魔数：用来第一时间判断是否为自己需要的数据包。
  • 版本号：提高协议的拓展性，方便后续对协议进行升级。
  • 序列化算法：消息正文具体该使用哪种方式进行序列化传输，例如Json、ProtoBuf、JDK...。
  • 消息类型：第一时间判断出当前消息的类型。
  • 消息序号：为了实现双工通信，客户端和服务端之间收/发消息不会相互阻塞。
  • 正文长度：提供给LTC解码器使用，防止解码时出现粘包、半包的现象。
  • 消息正文：本次消息要传输的具体数据。

在设计协议时，一个完整的协议应该涵盖上述所说的几方面，这样才能提供双方通信时的基础，基于上述几个字段，能够在第一时间内判断出：消息是否可用、当前协议版本、消息的具体类型、消息的长度等各类信息，从而给后续处理器使用（自定义的协议规则本身就是一个编解码处理器而已）。

1.3.2、自定义协议实战

前面简单聊到过，所谓的自定义协议就是自己规定消息格式，以及自己实现编/解码器对消息实现封装/拆解，所以这里想要自定义一个消息协议，就只需要满足前面两个条件即可，因此实现如下：

@ChannelHandler.Sharable
public class ChatMessageCodec extends MessageToMessageCodec {

    // 消息出站时会经过的编码方法（将原生消息对象封装成自定义协议的消息格式）
    @Override
    protected void encode(ChannelHandlerContext ctx, Message msg,
                          List list) throws Exception {
        ByteBuf outMsg = ctx.alloc().buffer();
        // 前五个字节作为魔数
        byte[] magicNumber = new byte[]{'Z','h','u','Z','i'};
        outMsg.writeBytes(magicNumber);
        // 一个字节作为版本号
        outMsg.writeByte(1);
        // 一个字节表示序列化方式  0：JDK、1：Json、2：ProtoBuf.....
        outMsg.writeByte(0);
        // 一个字节用于表示消息类型
        outMsg.writeByte(msg.getMessageType());
        // 四个字节表示消息序号
        outMsg.writeInt(msg.getSequenceId());

        // 使用Java-Serializable的方式对消息对象进行序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(msg);
        byte[] msgBytes = bos.toByteArray();

        // 使用四个字节描述消息正文的长度
        outMsg.writeInt(msgBytes.length);
        // 将序列化后的消息对象作为消息正文
        outMsg.writeBytes(msgBytes);

        // 将封装好的数据传递给下一个处理器
        list.add(outMsg);
    }

    // 消息入站时会经过的解码方法（将自定义格式的消息转变为具体的消息对象）
    @Override
    protected void decode(ChannelHandlerContext ctx,
                          ByteBuf inMsg, List list) throws Exception {
        // 读取前五个字节得到魔数
        byte[] magicNumber = new byte[5];
        inMsg.readBytes(magicNumber,0,5);
        // 再读取一个字节得到版本号
        byte version = inMsg.readByte();
        // 再读取一个字节得到序列化方式
        byte serializableType = inMsg.readByte();
        // 再读取一个字节得到消息类型
        byte messageType = inMsg.readByte();
        // 再读取四个字节得到消息序号
        int sequenceId = inMsg.readInt();
        // 再读取四个字节得到消息正文长度
        int messageLength = inMsg.readInt();

        // 再根据正文长度读取序列化后的字节正文数据
        byte[] msgBytes = new byte[messageLength];
        inMsg.readBytes(msgBytes,0,messageLength);

        // 对于读取到的消息正文进行反序列化，最终得到具体的消息对象
        ByteArrayInputStream bis = new ByteArrayInputStream(msgBytes);
        ObjectInputStream ois = new ObjectInputStream(bis);
        Message message = (Message) ois.readObject();

        // 最终把反序列化得到的消息对象传递给后续的处理器
        list.add(message);
    }
}
复制代码 
  
上面自定义的处理器中，继承了MessageToMessageCodec类，主要负责将数据在原生ByteBuf与Message之间进行相互转换，而Message对象是自定义的消息对象，这里暂且无需过多关心。其中主要实现了两个方法：
 
  
     
   
  • encode()：出站时会经过的编码方法，会将原生消息对象按自定义的协议封装成对应的字节数据。
    •  
   
  • decode()：入站时会经过的解码方法，会将协议格式的字节数据，转变为具体的消息对象。
    •  
  
 
  
上述自定义的协议，也就是一定规则的字节数据，每条消息数据的组成如下：
 
  
     
   
  • 魔数：使用第1~5个字节来描述，这个魔数值可以按自己的想法自定义。
    •  
   
  • 版本号：使用第6个字节来描述，不同数字表示不同版本。
    •  
   
  • 序列化算法：使用第7个字节来描述，不同数字表示不同序列化方式。
    •  
   
  • 消息类型：使用第8个字节来描述，不同的消息类型使用不同数字表示。
    •  
   
  • 消息序号：使用第9~12个字节来描述，其实就是一个四字节的整数。
    •  
   
  • 正文长度：使用第13~16个字节来描述，也是一个四字节的整数。
    •  
   
  • 消息正文：长度不固定，根据每次具体发送的数据来决定。
    •  
  
 
  
在其中，为了实现简单，这里的序列化方式，则采用的是JDK默认的Serializable接口方式，但这种方式生成的对象字节较大，实际情况中最好还是选择谷歌的ProtoBuf方式，这种算法属于序列化算法中，性能最佳的一种落地实现。
 
  
 
   
当然，这个自定义的协议是提供给后续的聊天业务使用的，但这种实战型的内容分享，基本上代码量较高，所以大家看起来会有些枯燥，而本文所使用的聊天室案例，是基于《B站-黑马Netty视频教程》二次改良的，因此如若感觉文字描述较为枯燥，可直接点击前面给出的链接，观看P101~P121视频进行学习。
 
  
 
  
最后来观察一下，大家会发现，在咱们定义的这个协议编解码处理器上，存在着一个@ChannelHandler.Sharable注解，这个注解的作用是干吗的呢？其实很简单，用来标识当前处理器是否可在多线程环境下使用，如果带有该注解的处理器，则表示可以在多个通道间共用，因此只需要创建一个即可，反之同理，如果不带有该注解的处理器，则每个通道需要单独创建使用。
 
  
二、基于Netty打造IM聊天程序
 
  
   前面简单过了一下自定义协议后，接着来基于Netty框架上手一个真正的实战项目，那也就是基于Netty打造一款IM即时通讯的聊天程序，这里在实现过程中，仅仅只会给出核心实现，但最后会提供完整代码的Github链接，因此大家重点理解核心即可。
 
  
2.1、IM程序的用户模块
 
  
   聊天、聊天，自然是得先有人，然后才能进行聊天沟通，与QQ、微信类似，如果你想要使用某款聊天程序时，前提都得是先具备一个对应的账户才行，因此在咱们设计IM系统之处，那也需要对应的用户功能实现，但这里为了简单，同样不再结合数据库实现完整的用户模块了，而是基于内存实现用户的管理，如下：
 
  
public interface UserService {
    boolean login(String username, String password);
}
复制代码
 
  
这是用户模块的顶层接口，仅仅只提供了一个登录接口，关于注册、鉴权、等级.....等一系列功能，大家感兴趣的可在后续进行拓展实现，接着来看看该接口的实现类，如下：
 
  
public class UserServiceMemoryImpl implements UserService {
    private Map allUserMap = new ConcurrentHashMap<>();
    
    {
        // 在代码块中对用户列表进行初始化，向其中添加了两个用户信息
        allUserMap.put("ZhuZi", "123");
        allUserMap.put("XiongMao", "123");
    }

    @Override
    public boolean login(String username, String password) {
        String pass = allUserMap.get(username);
        if (pass == null) {
            return false;
        }
        return pass.equals(password);
    }
}
复制代码
 
  
这个实现类并未结合数据库来实现，而是仅仅在程序启动时，通过代码块的方式，加载了ZhuZi、XiongMao两个用户信息并放入内存的Map容器中，这里有兴趣的小伙伴，可自行将Map容器换成数据库的表即可。
 
  
其中实现的login()登录接口尤为简单，仅仅只是判断了一下有没有对应用户，如果有的话则看看密码是否正确，正确返回true，密码错误则返回false，是的，我所写的登录功能就是这么简单，走个简单的过场，哈哈哈~
 
  
2.1.1、服务端、客户端的基础架构
 
  
基本的用户模块有了，但这里还未曾套入具体实现，因此先简单的搭建出服务端、客户端的架构，然后再基于构建好的架构实现基础的用户登录功能，服务端的基础搭建如下：
 
  
public class ChatServer {
    public static void main(String[] args) {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();

        ChatMessageCodec MESSAGE_CODEC = new ChatMessageCodec();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(MESSAGE_CODEC);
                }
            });

            Channel channel = serverBootstrap.bind(8888).sync().channel();
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            System.out.println("服务端出现错误：" + e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}
复制代码
 
  
服务端的代码目前很简单，仅仅只是装载了一个自己的协议编/解码处理器，然后就是一些老步骤，不再过多的重复赘述，接着再来搭建一个简单的客户端，代码实现如下：
 
  
public class ChatClient {
    public static void main(String[] args) {
        NioEventLoopGroup group = new NioEventLoopGroup();

        ChatMessageCodec MESSAGE_CODEC = new ChatMessageCodec();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(group);
            bootstrap.handler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(MESSAGE_CODEC);
                }
            });
            Channel channel = bootstrap.connect("localhost", 8888).sync().channel();
            channel.closeFuture().sync();
        } catch (Exception e) {
            System.out.println("客户端出现错误：" + e);
        } finally {
            group.shutdownGracefully();
        }
    }
}
复制代码
 
  
目前仅仅只是与服务端建立了连接，然后装载了一个自定义的编解码器，到这里就搭建了最基本的服务端、客户端的基础架构，接着来基于它实现简单的登录功能。
 
  
2.1.2、用户登录功能的实现
 
  
对于登录功能，由于需要在服务端与客户端之间传输数据，因此咱们可以设计一个消息对象，但由于后续单聊、群聊都需要发送不同的消息格式，因此先设计出一个父类，如下：
 
  
public abstract class Message implements Serializable {

    private int sequenceId;
    private int messageType;


    @Override
    public String toString() {
        return "Message{" +
                "sequenceId=" + sequenceId +
                ", messageType=" + messageType +
                '}';
    }

    public int getSequenceId() {
        return sequenceId;
    }

    public void setSequenceId(int sequenceId) {
        this.sequenceId = sequenceId;
    }

    public void setMessageType(int messageType) {
        this.messageType = messageType;
    }

    public abstract int getMessageType();

    public static final int LoginRequestMessage = 0;
    public static final int LoginResponseMessage = 1;
    public static final int ChatRequestMessage = 2;
    public static final int ChatResponseMessage = 3;
    public static final int GroupCreateRequestMessage = 4;
    public static final int GroupCreateResponseMessage = 5;
    public static final int GroupJoinRequestMessage = 6;
    public static final int GroupJoinResponseMessage = 7;
    public static final int GroupQuitRequestMessage = 8;
    public static final int GroupQuitResponseMessage = 9;
    public static final int GroupChatRequestMessage = 10;
    public static final int GroupChatResponseMessage = 11;
    public static final int GroupMembersRequestMessage = 12;
    public static final int GroupMembersResponseMessage = 13;
    public static final int PingMessage = 14;
    public static final int PongMessage = 15;
}
复制代码
 
  
在这个消息父类中，定义了多种消息类型的状态码，不同的消息类型对应不同数字，同时其中还设计了一个抽象方法，即getMessageType()，该方法交给具体的子类实现，每个子类返回各自的消息类型，为了方便后续拓展，这里又创建了一个抽象类作为中间类，如下：
 
  
public abstract class AbstractResponseMessage extends Message {
    private boolean success;
    private String reason;

    public AbstractResponseMessage() {
    }

    public AbstractResponseMessage(boolean success, String reason) {
        this.success = success;
        this.reason = reason;
    }

    @Override
    public String toString() {
        return "AbstractResponseMessage{" +
                "success=" + success +
                ", reason='" + reason + '\'' +
                '}';
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }
}
复制代码
 
  
这个类主要是提供给响应时使用的，其中包含了响应状态以及响应信息，接着再设计两个登录时会用到的消息对象，如下：
 
  
public class LoginRequestMessage extends Message {
    private String username;
    private String password;

    public LoginRequestMessage() {
    }

    @Override
    public String toString() {
        return "LoginRequestMessage{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public LoginRequestMessage(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public int getMessageType() {
        return LoginRequestMessage;
    }
}
复制代码
 
  
上述这个消息类，主要是提供给客户端登录时使用，本质上也就是一个涵盖用户名、用户密码的对象而已，同时还有一个用来给服务端响应时的响应类，如下：
 
  
public class LoginResponseMessage extends AbstractResponseMessage {
    public LoginResponseMessage(boolean success, String reason) {
        super(success, reason);
    }

    @Override
    public int getMessageType() {
        return LoginResponseMessage;
    }
}
复制代码
 
  
登录响应类的实现十分简单，由登录状态和登录消息组成，OK，接着来看看登录的具体实现。
 
  
首先在客户端中，再通过pipeline添加一个处理器，如下：
 
  
CountDownLatch WAIT_FOR_LOGIN = new CountDownLatch(1);
AtomicBoolean LOGIN = new AtomicBoolean(false);
AtomicBoolean EXIT = new AtomicBoolean(false);
Scanner scanner = new Scanner(System.in);
        
ch.pipeline().addLast("client handler", new ChannelInboundHandlerAdapter() {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 负责接收用户在控制台的输入，负责向服务器发送各种消息
        new Thread(() -> {
            System.out.println("请输入用户名:");
            String username = scanner.nextLine();
            if(EXIT.get()){
                return;
            }
            System.out.println("请输入密码:");
            String password = scanner.nextLine();
            if(EXIT.get()){
                return;
            }
            // 构造消息对象
            LoginRequestMessage message = new LoginRequestMessage(username, password);
            System.out.println(message);
            // 发送消息
            ctx.writeAndFlush(message);
            System.out.println("等待后续操作...");
            try {
                WAIT_FOR_LOGIN.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 如果登录失败
            if (!LOGIN.get()) {
                ctx.channel().close();
                return;
            }
    }).start();
}
复制代码
 
  
在与服务端建立连接成功之后，就提示用户需要登录，接着接收用户输入的用户名、密码，然后构建出一个LoginRequestMessage消息对象，接着将其发送给服务端，由于前面装载了自定义的协议编解码器，所以消息在出站时，这个Message对象会被序列化成字节码，接着再服务端入站时，又会被反序列化成消息对象，接着来看看服务端的实现，如下：
 
  
@ChannelHandler.Sharable
public class LoginRequestMessageHandler 
            extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, 
                LoginRequestMessage msg) throws Exception {
        String username = msg.getUsername();
        String password = msg.getPassword();
        boolean login = UserServiceFactory.getUserService().login(username, password);
        LoginResponseMessage message;
        if (login) {
            SessionFactory.getSession().bind(ctx.channel(), username);
            message = new LoginResponseMessage(true, "登录成功");
        } else {
            message = new LoginResponseMessage(false, "用户名或密码不正确");
        }
        ctx.writeAndFlush(message);
    }
}
复制代码
 
  
在服务端中，新增了一个处理器类，继承自SimpleChannelInboundHandler这个处理器，其中指定的泛型为LoginRequestMessage，这表示当前处理器只关注这个类型的消息，当出现登录类型的消息时，会进入该处理器并触发内部的channelRead0()方法。
 
  
在该方法中，获取了登录消息中的用户名、密码，接着对其做了基本的登录效验，如果用户名存在并且密码正确，就会返回登录成功，否则会返回登录失败，最终登录后的状态会被封装成一个LoginResponseMessage对象，然后写回客户端的通道中。
 
  
当然，为了该处理器能够成功生效，这里需要将其装载到服务端的pipeline上，如下：
 
  
LoginRequestMessageHandler LOGIN_HANDLER = new LoginRequestMessageHandler();
ch.pipeline().addLast(LOGIN_HANDLER);
复制代码
 
  
装载好登录处理器后，接着分别启动服务端、客户端，测试结果如下：
 
  
Netty实战篇：基于Netty框架打造一款高性能的IM即时通讯程序_第1张图片
 
  

 从图中的效果来看，这里实现了最基本的登录功能，估计有些小伙伴看到这里就有些晕了，但其实非常简单，仅仅只是通过Netty在做数据交互而已，客户端则提供输入用户名、密码的功能，然后将用户输入的名称、密码发送给服务端，服务端提供登录判断的功能，最终根据判断结果再向客户端返回数据罢了。
 
  
2.2、基于Netty实现点对点单聊
 
  
   有了基本的用户登录功能后，接着来看看如何实现点对点的单聊功能呢？首先我定义了一个会话接口，如下：
 
  
public interface Session {
    void bind(Channel channel, String username);
    void unbind(Channel channel);
    Channel getChannel(String username);
}
复制代码
 
  
这个接口中依旧只有三个方法，释义如下：
 
  
     
   
  • bind()：传入一个用户名和Socket通道，让两者之间的产生绑定关系。
    •  
   
  • unbind()：取消一个用户与某个Socket通道的绑定关系。
    •  
   
  • getChannel()：根据一个用户名，获取与其存在绑定关系的通道。
    •  
  
 
  
该接口的实现类如下：
 
  
public class SessionMemoryImpl implements Session {

    private final Map usernameChannelMap = new ConcurrentHashMap<>();
    private final Map channelUsernameMap = new ConcurrentHashMap<>();

    @Override
    public void bind(Channel channel, String username) {
        usernameChannelMap.put(username, channel);
        channelUsernameMap.put(channel, username);
        channelAttributesMap.put(channel, new ConcurrentHashMap<>());
    }

    @Override
    public void unbind(Channel channel) {
        String username = channelUsernameMap.remove(channel);
        usernameChannelMap.remove(username);
        channelAttributesMap.remove(channel);
    }

    @Override
    public Channel getChannel(String username) {
        return usernameChannelMap.get(username);
    }

    @Override
    public String toString() {
        return usernameChannelMap.toString();
    }
}
复制代码
 
  
该实现类最关键的是其中的两个Map容器，usernameChannelMap用来存储所有用户名与Socket通道的绑定关系，而channelUsernameMap则是反过来的顺序，这主要是为了方便，即可以通过用户名获得对应通道，也可以通过通道判断出用户名，实际上一个Map也能搞定，但还是那句话，主要为了简单嘛~
 
  
有了上述这个最简单的会话管理功能后，就要着手实现具体的功能了，其实在前面实现登录功能的时候，就用过这其中的bind()方法，也就是当登录成功之后，就会将当前发送登录消息的通道，与正在登录的用户名产生绑定关系，这样就方便后续实现单聊、群聊的功能。
 
  
2.2.1、定义单聊的消息对象
 
  
与登录时相同，由于需要在服务端和客户端之间实现数据的转发，因此这里也需要两个消息对象，用来作为数据交互的消息格式，如下：
 
  
public class ChatRequestMessage extends Message {
    private String content;
    private String to;
    private String from;

    public ChatRequestMessage() {
    }

    public ChatRequestMessage(String from, String to, String content) {
        this.from = from;
        this.to = to;
        this.content = content;
    }
    // 省略Get/Setting、toString()方法.....
}
复制代码
 
  
上述这个类，是提供给客户端用来发送消息数据的，其中主要包含了三个值，聊天的消息内容、发送人与接收人，因为这里是需要实现一个IM聊天程序，所以并不是客户端与服务端进行数据交互，而是客户端与客户端之间进行数据交互，服务端仅仅只提供消息转发的功能，接着再构建一个消息类，如下：
 
  
public class ChatResponseMessage extends AbstractResponseMessage {

    private String from;
    private String content;

    @Override
    public String toString() {
        return "ChatResponseMessage{" +
                "from='" + from + '\'' +
                ", content='" + content + '\'' +
                '}';
    }

    public ChatResponseMessage(boolean success, String reason) {
        super(success, reason);
    }

    public ChatResponseMessage(String from, String content) {
        this.from = from;
        this.content = content;
    }

    @Override
    public int getMessageType() {
        return ChatResponseMessage;
    }
    // 省略Get/Setting、toString()方法.....
}
复制代码
 
  
这个类是提供给服务端用来转发的，当服务端收到一个聊天消息后，因为聊天消息中包含了接收人，所以可以先根据接收人的用户名，找到对应的客户端通道，然后再封装成一个响应消息，转发给对应的客户端即可，下面来做具体实现。
 
  
2.2.2、实现点对点单聊功能
 
  
由于聊天功能是提供给客户端使用的，所以当一个客户端登录成功之后，应该暴露给用户一个操作菜单，所以直接在原本客户端的channelActive()方法中，登录成功之后继续加代码即可，代码如下：
 
  
while (true) {
    System.out.println("==================================");
    System.out.println("\t1、发送单聊消息");
    System.out.println("\t2、发送群聊消息");
    System.out.println("\t3、创建一个群聊");
    System.out.println("\t4、获取群聊成员");
    System.out.println("\t5、加入一个群聊");
    System.out.println("\t6、退出一个群聊");
    System.out.println("\t7、退出聊天系统");
    System.out.println("==================================");
    String command = scanner.nextLine();
}
复制代码
 
  
首先会开启一个死循环，然后不断接收用户的操作，接着使用switch语法来对具体的菜单功能进行实现，先实现单聊功能，如下：
 
  
switch (command){
    case "1":
        System.out.print("请选择你要发送消息给谁：");
        String toUserName = scanner.nextLine();
        System.out.print("请输入你要发送的消息内容：");
        String content = scanner.nextLine();
        ctx.writeAndFlush(new ChatRequestMessage(username, toUserName, content));
        break;
}
复制代码
 
  
如果用户选择了单聊，接着会提示用户选择要发送消息给谁，这里也就是让用户输入对方的用户名，实际上如果有界面的话，这一步是并不需要用户自己输入的，而是提供窗口让用户点击，比如QQ、微信一样，想要给某个人发送消息时，只需要点击“他”的头像私聊即可。
 
  
等用户选择了聊天目标，并且输入了消息内容后，接着会构建一个ChatRequestMessage消息对象，然后会发送给服务端，但这里先不看服务端的实现，客户端这边还需要重写一个方法，如下：
 
  
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    System.out.println("收到消息：" + msg);
    if ((msg instanceof LoginResponseMessage)) {
        LoginResponseMessage response = (LoginResponseMessage) msg;
        if (response.isSuccess()) {
            // 如果登录成功
            LOGIN.set(true);
        }
        // 唤醒 system in 线程
        WAIT_FOR_LOGIN.countDown();
    }
}
复制代码
 
  
前面的逻辑是在channelActive()方法中完成的，也就是连接建立成功后，就会让用户登录，接着登录成功之后会给用户一个菜单栏，提供给用户进行操作，但前面的逻辑中一直没有对服务端响应的消息进行处理，因此channelRead()方法中会对服务端响应的数据进行处理。
 
  
channelRead()方法会在有数据可读时被触发，所以当服务端响应数据时，首先会判断一下：目前服务端响应的是不是登录消息，如果是的话，则需要根据登录的结果来唤醒前面channelActive()方法中的线程。如果目前服务端响应的不是登录消息，这也就意味着客户端前面已经登录成功了，所以接着会直接打印一下收到的数据。
 
  
OK，有了上述客户端的代码实现后，接着再来服务端多创建一个处理器，如下：
 
  
@ChannelHandler.Sharable
public class ChatRequestMessageHandler 
            extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx,
                    ChatRequestMessage msg) throws Exception {
        String to = msg.getTo();
        Channel channel = SessionFactory.getSession().getChannel(to);
        // 在线
        if (channel != null) {
            channel.writeAndFlush(new ChatResponseMessage(
                        msg.getFrom(), msg.getContent()));
        }
        // 不在线
        else {
            ctx.writeAndFlush(new ChatResponseMessage(
                        false, "对方用户不存在或者不在线"));
        }
    }
}
复制代码
 
  
这里依旧通过继承SimpleChannelInboundHandler类的形式，来特别关注ChatRequestMessage单聊类型的消息，如果目前服务端收到的是单聊消息，则会进入触发该处理器的channelRead0()方法，该处理器内部的逻辑也并不复杂，首先根据单聊消息的接收人，去找一下与之对应的通道：
 
  
     
   
  • 如果根据用户名查到了通道，表示接收人目前是登录在线状态。
    •  
   
  • 反之，如果无法根据用户名找到通道，表示对应的用户不存在或者没有登录。
    •  
  
 
  
接着会根据上面的查询结果，进行对应的结果返回：
 
  
     
   
  • 如果在线：把要发送的单聊消息，直接写入至找到的通道中。
    •  
   
  • 如果不在线：向发送单聊消息的客户端，返回用户不存在或用户不在线。
    •  
  
 
  
有了这个处理器之后，接着还需要把该处理器装载到服务端上，如下：
 
  
ChatRequestMessageHandler CHAT_HANDLER = new ChatRequestMessageHandler();
ch.pipeline().addLast(CHAT_HANDLER);
复制代码
 
  
装载好单聊处理器后，接着分别启动一个服务端、两个客户端，测试结果如下：
 
  
Netty实战篇：基于Netty框架打造一款高性能的IM即时通讯程序_第2张图片
 
  

 从测试结果中可以明显看出效果，其中的单聊功能的确已经实现，可以实现A→B用户之间的单聊功能，两者之间借助服务器转发，可以实现两人私聊的功能。
 
  
2.3、基于Netty打造多人聊天室
 
  
   前面实现了两个用户之间的私聊功能，接着再来实现一个多人聊天室的功能，毕竟像QQ、微信、钉钉....等任何通讯软件，都支持多人建立群聊的功能，但多人聊天室的功能，实现之前还需要先完成建群的功能，毕竟如果群都没建立，自然无法向某个群内发送数据。
 
  
实现拉群也好，群聊也罢，其实现步骤依旧和前面相同，如下：
 
  
     
   
  • ①先定义对应的消息对象。
    •  
   
  • ②实现客户端发送对应消息数据的功能。
    •  
   
  • ③再写一个服务端的群聊处理器，然后装载到服务端上。
    •  
  
 
  
2.3.1、定义拉群的消息体
 
  
首先来定义两个拉群时用的消息体，如下：
 
  
public class GroupCreateRequestMessage extends Message {
    private String groupName;
    private Set members;

    public GroupCreateRequestMessage(String groupName, Set members) {
        this.groupName = groupName;
        this.members = members;
    }

    @Override
    public int getMessageType() {
        return GroupCreateRequestMessage;
    }
    
    // 省略其他Get/Settings、toString()方法.....
}
复制代码
 
  
上述这个消息体是提供给客户端使用的，其中主要存在两个成员，也就是群名称与群成员列表，存放所有群成员的容器选用了Set集合，因为Set集合具备不可重复性，因此可以有效的避免同一用户多次进群，接着再来看看服务端响应时用的消息体，如下：
 
  
public class GroupCreateResponseMessage extends AbstractResponseMessage {
    public GroupCreateResponseMessage(boolean success, String reason) {
        super(success, reason);
    }

    @Override
    public int getMessageType() {
        return GroupCreateResponseMessage;
    }
}
复制代码
 
  
这个消息体的实现尤为简单，仅仅只是给客户端返回了拉群状态以及拉群的附加信息。
 
  
2.3.2、定义群聊会话管理
 
  
前面单聊有单聊的会话管理机制，而实现多人群聊时，依旧需要有群聊的会话管理机制，首先封装了一个群聊实体类，如下：
 
  
public class Group {
    // 聊天室名称
    private String name;
    // 聊天室成员
    private Set members;

    public static final Group EMPTY_GROUP = new Group("empty", Collections.emptySet());

    public Group(String name, Set members) {
        this.name = name;
        this.members = members;
    }

    // 省略其他Get/Settings、toString()方法.....
}
复制代码
 
  
接着定义了一个群聊会话的顶级接口，如下：
 
  
public interface GroupSession {
    // 创建一个群聊
    Group createGroup(String name, Set members);
    // 加入某个群聊
    Group joinMember(String name, String member);
    // 移除群聊中的某个成员
    Group removeMember(String name, String member);
    // 解散一个群聊
    Group removeGroup(String name);
    // 获取一个群聊的成员列表
    Set getMembers(String name);
    // 获取一个群聊所有在线用户的Channel通道
    List getMembersChannel(String name);
}
复制代码
 
  
上述接口中，提供了几个接口方法，其实也主要是群聊系统中的一些日常操作，如创群、加群、踢人、解散群、查看群成员....等功能，接着来看看该接口的实现者，如下：
 
  
public class GroupSessionMemoryImpl implements GroupSession {
    private final Map groupMap = new ConcurrentHashMap<>();

    @Override
    public Group createGroup(String name, Set members) {
        Group group = new Group(name, members);
        return groupMap.putIfAbsent(name, group);
    }

    @Override
    public Group joinMember(String name, String member) {
        return groupMap.computeIfPresent(name, (key, value) -> {
            value.getMembers().add(member);
            return value;
        });
    }

    @Override
    public Group removeMember(String name, String member) {
        return groupMap.computeIfPresent(name, (key, value) -> {
            value.getMembers().remove(member);
            return value;
        });
    }

    @Override
    public Group removeGroup(String name) {
        return groupMap.remove(name);
    }

    @Override
    public Set getMembers(String name) {
        return groupMap.getOrDefault(name, Group.EMPTY_GROUP).getMembers();
    }

    @Override
    public List getMembersChannel(String name) {
        return getMembers(name).stream()
                .map(member -> SessionFactory.getSession().getChannel(member))
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }
}
复制代码
 
  
这个实现类没啥好说的，重点记住里面有个Map容器即可，这个容器主要负责存储所有群名称与Group群聊对象的关系，后续可以通过群聊名称，在这个容器中找到一个对应群聊对象。同时为了方便后续调用这些接口，还提供了一个工具类，如下：
 
  
public abstract class GroupSessionFactory {
    private static GroupSession session = new GroupSessionMemoryImpl();

    public static GroupSession getGroupSession() {
        return session;
    }
}
复制代码
 
  
很简单，仅仅只实例化了一个群聊会话管理的实现类，因为这里没有结合Spring来实现，所以并不能依靠IOC技术来自动管理Bean，因此咱们需要手动创建出一个实例，以供于后续使用。
 
  
2.3.3、实现拉群功能
 
  
前面客户端的功能菜单中，3对应着拉群功能，所以咱们需要对3做具体的功能实现，逻辑如下：
 
  
case "3":
    System.out.print("请输入你要创建的群聊昵称：");
    String newGroupName = scanner.nextLine();
    System.out.print("请选择你要邀请的群成员（不同成员用、分割）：");
    String members = scanner.nextLine();
    Set memberSet = new HashSet<>(Arrays.asList(members.split("、")));
    memberSet.add(username); // 加入自己
    ctx.writeAndFlush(new GroupCreateRequestMessage(newGroupName, memberSet));
    break;
复制代码
 
  
在该分支实现中，首先会要求用户输入一个群聊昵称，接着需要输入需要拉入群聊的用户名称，多个用户之间使用、分割，接着会把用户输入的群成员以及自己，全部放入到一个Set集合中，最终组装成一个拉群消息体，发送给服务端处理，服务端的处理器如下：
 
  
@ChannelHandler.Sharable
public class GroupCreateRequestMessageHandler 
        extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, 
                GroupCreateRequestMessage msg) throws Exception {
        String groupName = msg.getGroupName();
        Set members = msg.getMembers();
        // 群管理器
        GroupSession groupSession = GroupSessionFactory.getGroupSession();
        Group group = groupSession.createGroup(groupName, members);
        if (group == null) {
            // 发生成功消息
            ctx.writeAndFlush(new GroupCreateResponseMessage(true, 
                                groupName + "创建成功"));
            // 发送拉群消息
            List channels = groupSession.getMembersChannel(groupName);
            for (Channel channel : channels) {
                channel.writeAndFlush(new GroupCreateResponseMessage(
                                    true, "您已被拉入" + groupName));
            }
        } else {
            ctx.writeAndFlush(new GroupCreateResponseMessage(
                                false, groupName + "已经存在"));
        }
    }
}
复制代码
 
  
这里依旧继承了SimpleChannelInboundHandler类，只关心拉群的消息，当客户端出现拉群消息时，首先会获取用户输入的群昵称和群成员，接着通过前面提供的创群接口，尝试创建一个群聊，如果群聊已经存在，则会创建失败，反之则会创建成功，在创建群聊成功的情况下，会给所有的群成员发送一条“你已被拉入[XXX]”的消息。
 
  
最后，同样需要将该处理器装载到服务端上，如下：
 
  
GroupCreateRequestMessageHandler GROUP_CREATE_HANDLER = 
                    new GroupCreateRequestMessageHandler();
ch.pipeline().addLast(GROUP_CREATE_HANDLER);
复制代码
 
  
最后分别启动一个服务端、两个客户端进行效果测试，如下：
 
  
Netty实战篇：基于Netty框架打造一款高性能的IM即时通讯程序_第3张图片
 
  

 从上图的测试结果来看，的确实现了咱们的拉群效果，一个用户拉群之后，被邀请的成员都会收到来自于服务端的拉群提醒，这也就为后续群聊功能奠定了基础。
 
  
2.3.4、定义群聊的消息体
 
  
这里就不重复赘述了，还是之前的套路，定义一个客户端用的消息体，如下：
 
  
public class GroupChatRequestMessage extends Message {
    private String content;
    private String groupName;
    private String from;

    public GroupChatRequestMessage(String from, String groupName, String content) {
        this.content = content;
        this.groupName = groupName;
        this.from = from;
    }

    @Override
    public int getMessageType() {
        return GroupChatRequestMessage;
    }
    // 省略其他Get/Settings、toString()方法.....
}    
复制代码
 
  
这个是客户端用来发送群聊消息的消息体，其中存在三个成员，发送人、群聊昵称、消息内容，通过这三个成员，可以描述清楚任何一条群聊记录，接着来看看服务端响应时用的消息体，如下：
 
  
public class GroupChatResponseMessage extends AbstractResponseMessage {
    private String from;
    private String content;

    public GroupChatResponseMessage(boolean success, String reason) {
        super(success, reason);
    }

    public GroupChatResponseMessage(String from, String content) {
        this.from = from;
        this.content = content;
    }
    @Override
    public int getMessageType() {
        return GroupChatResponseMessage;
    }
    // 省略其他Get/Settings、toString()方法.....
}
复制代码
 
  
在这个消息体中，就省去了群聊昵称这个成员，因为这个消息体的用处，主要是给服务端转发给客户端时使用的，因此不需要群聊昵称，当然，要也可以，我这里就直接省去了。
 
  
2.3.5、实现群聊功能
 
  
依旧先来做客户端的实现，实现了客户端之后再去完成服务端的实现，客户端实现如下：
 
  
case "2":
    System.out.print("请选择你要发送消息的群聊：");
    String groupName = scanner.nextLine();
    System.out.print("请输入你要发送的消息内容：");
    String groupContent = scanner.nextLine();
    ctx.writeAndFlush(new GroupChatRequestMessage(username, groupName, groupContent));
    break;
复制代码
 
  
因为发送群聊消息对应着之前菜单中的2，所以这里对该分支进行实现，当用户选择发送群聊消息时，首先会让用户自己先选择一个群聊，接着输入要发送的消息内容，接着组装成一个群聊消息对象，发送给服务端处理，服务端的实现如下：
 
  
@ChannelHandler.Sharable
public class GroupChatRequestMessageHandler 
        extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx,
                GroupChatRequestMessage msg) throws Exception {
        List channels = GroupSessionFactory.getGroupSession()
                .getMembersChannel(msg.getGroupName());

        for (Channel channel : channels) {
            channel.writeAndFlush(new GroupChatResponseMessage(
                            msg.getFrom(), msg.getContent()));
        }
    }
}
复制代码
 
  
这里依旧定义了一个处理器，关于原因就不再重复啰嗦了，服务端对于群聊消息的实现额外简单，也就是先根据用户选择的群昵称，找到该群所有的群成员，然后依次遍历成员列表，获取对应的Socket通道，转发消息即可。
 
  
接着将该处理器装载到服务端pipeline上，然后分别启动一个服务端、两个客户端，进行效果测试，如下：
 
  
Netty实战篇：基于Netty框架打造一款高性能的IM即时通讯程序_第4张图片
 
  

 效果如上图的注释，基于上述的代码测试，效果确实达到了咱们需要的群聊效果~
 
  
2.3.6、聊天室的其他功能实现
 
  
到这里为止，实现了最基本的建群、群聊的功能，但对于踢人、加群、解散群....等一系列群聊功能还未曾实现，但我这里就不继续重复了，毕竟还是那个套路：
 
  
     
   
  • ①定义对应功能的消息体。
    •  
   
  • ②客户端向服务端发送对应格式的消息。
    •  
   
  • ③服务端编写处理器，对特定的消息进行处理。
    •  
  
 
  
所以大家感兴趣的情况下，可以根据上述步骤继续进行实现，实现的过程没有任何难度，重点就是时间问题罢了。
 
  
三、Netty实战篇总结
 
  
   看到这里，其实Netty实战篇的内容也就大致结束了，个人对于实战篇的内容并不怎么满意，因为与最初设想的实现存在很大偏差，这是由于近期工作、生活状态不对，所以内容输出也没那么夯实，对于这篇中的完整代码实现，也包括前面两篇中的一些代码实现，这里给出完整的GitHub链接：>>>戳我访问<<<，大家感兴趣可以自行Down下去玩玩。
 
  
 
  

 原文链接：https://juejin.cn/post/7182845662126407737
 来源：稀土掘金
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,网络,redis)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 2023-04-17|篮球女孩
                        长一木

                        
    1小学抑或初中阶段，在课外书了解到她的故事。“篮球女孩”。当时佩服她的顽强，也对生命多了一丝敬畏。今天刚好在公众号看到，长大后的“篮球女孩”。佩服之余又满是心疼。网络侵删祝那素未蒙面的女孩，未来一切顺遂。
    
                    
    • 
                    
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
                        落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
                        
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）
                        算法大师
华为od面试python算法前端
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 《在战“疫”中成长致敬生活》观后感
                        梅子刘的刀

                        
    （作者：周晨）今天上午，我看了“我是接班人”网络大课堂《在战役中成长致敬生活》。有很多人拿出自己攒下的钱，默默地捐给了武汉，有几千块钱的、有几万块钱的，也有十几万块钱的。连小朋友也把自己的压岁钱捐给了武汉。有名环卫工人把自己五年的积蓄全部捐给了武汉。有名外卖小哥为医护人员买鞋子送吃的。还有已经治愈出院的新型肺炎病人捐了400毫升的血浆。还有位叫大树的叔叔，虽然他没有钱，但是他地里有蔬菜，捐了几大卡
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 中原焦点团队网络初中级30期阴丽丽坚持分享第三百八十八次2022.10.18分享 约练次数（74） 咨询师（6） 来访者（53） 观察者（15）
                        阴丽丽

                        
    今天是忙碌的一天，一早起来，总想着找点把事情弄完，可总也弄不完。就这样弄着吧！孩子的事，自己的事都在那里搁置着，不想做，有点欧！今天总体还不错，只是在下午起床时走神了俩小时，也算是给自己的放松吧！今日难得1.儿子乖巧、听话，努力配合，一天下来也是忙忙碌碌，这真的很难得！2.儿子今天录的视频被班主任认可，这真的很难得3.我今天早上做核酸时，自己把教案整了一下，这真的很难得
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • 多子女家庭问题
                        3e5c5362403c

                        
    杨宁宁焦点解决网络初17中19坚持分享589天（2021.3.20）本周约练我1次，总计166次，读书打卡第256天案例督导收获：【家有老大篇】被爱与高期待下的独舞家里的第一个孩子往往集万千宠爱于一身。爸爸妈妈、爷爷奶奶、姥姥姥爷的目光都聚焦在他的身上。在这种光环下长大的孩子，就如小皇帝一般，衣来伸手、饭来张口。拥有爱的同时，也意味着拥有了更高的被期待，父母会花血本给你报各种各样的早教班，给你买各
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • 父母教育孩子的方式，将影响孩子一生
                        树英教育

                        
    为什么有些孩子总是充满自信与快乐？独立、有主见又坚强？而有些孩子却自卑、胆怯，软弱又过度依赖父母？为什么有些孩子总是健康、阳光又富于创造力？而有些孩子却悲观、孤僻又思想空乏？一个孩子的行为取决于孩子的思想，思想取决于环境和自己的认知，认知取决于教育。父母是孩子人生中的第一位教育者，父母养育孩子的方式，将决定他们人生的高度，影响他们的一生。网络图，侵权即删优秀的父母就像园丁，既要浇水施肥，又要修剪杂
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图
                        RaidenQ
python华为leetcode算法力扣广度优先无向图
                        
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
    
                    
    • 
                    
  • 戴容容 中原焦点团队.网络初级第33期,坚持分享第19天 2022年3月9日
                        TessDai

                        
    《每个人眼中的世界都是不同的》“一千个人眼里有一千个哈姆雷特”世界是多元的,每个人都有自己的道理,人人按照自己的理解去看待这个世界的人和物.我们如此,其他人也是如此.因此,任何事情,我们要放下自己以为的真理,去理解他人认为的真理,只有同频方能共振.孩子在慢慢长大的过程中慢慢学会独立,甚至对抗.尤其当孩子处于青春期的时候,他们开始有很多自己独立的想法,和一些特立独行的做法,家长常常会觉得不可思议,觉
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通
                        学习3人组
大数据大数据
                        
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                                
  • sql统计相同项个数并按名次显示
                                    朱辉辉33
javaoracle
                                    
    现在有如下这样一个表： 
A表 
ID Name time 
------------------------------ 
0001 aaa 2006-11-18 
0002 ccc 2006-11-18 
0003 eee 2006-11-18 
0004 aaa 2006-11-18 
0005 eee 2006-11-18 
0004 aaa 2006-11-18 
0002 ccc 20
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列-目录
                                    白糖_
JQuery Mobile
                                    
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。 
  
从现在起，往后一段时间，我打算
    
                                
    • 
                                
  • 如何给线程池命名
                                    daysinsun
线程池
                                    
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下： 
    
public class Named
    
                                
    • 
                                
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
                                    周凡杨
html解析errorreadyState
                                    
      
错误：  IE   中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"      
  
  
现象：  同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    
                                
    • 
                                
  • java上传
                                    g21121
java
                                    
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 
下面是servlet的代码： 
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    
                                
    • 
                                
  • SpringMVC配置学习
                                    510888780
springmvc
                                    
    spring MVC配置详解 
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 
 
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    
                                
    • 
                                
  • spring mvc-jfreeChart 柱图(1)
                                    布衣凌宇
jfreechart
                                    
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 
第二步：配置web.xml; 
web.xml代码如下 
<servlet> 
    <servlet-name>jfreechart</servlet-nam
    
                                
    • 
                                
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    
                                
    • 
                                
  • java 线程池使用 Runnable&Callable&Future
                                    antlove
javathreadRunnablecallablefuture
                                    
    1. 创建线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 
  
2. 执行一次线程，调用Runnable接口实现 
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    
                                
    • 
                                
  • XML语法元素结构的总结
                                    百合不是茶
xml树结构
                                    
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    
                                
    • 
                                
  • 改变eclipse编码格式
                                    bijian1013
eclipse编码格式
                                    
    1.改变整个工作空间的编码格式 
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。 
        Eclipse->window->preferences->General->workspace-
    
                                
    • 
                                
  • javascript中return的设计缺陷
                                    bijian1013
JavaScriptAngularJS
                                    
    代码1： 
<script>
var gisService = (function(window) 
{ 

    return
    {
        name:function ()
        {
            alert(1);
        }
    };

})(this);

gisService.name();
&l
    
                                
    • 
                                
  • 【持久化框架MyBatis3八】Spring集成MyBatis3
                                    bit1129
Mybatis3
                                    
    pom.xml配置 
Maven的pom中主要包括： 
 
 MyBatis 
 MyBatis-Spring 
 Spring 
 MySQL-Connector-Java 
 Druid 
 applicationContext.xml配置     
<?xml version="1.0" encoding="UTF-8"?>
&
    
                                
    • 
                                
  • java web项目启动时自动加载自定义properties文件
                                    bitray
javaWeb监听器相对路径
                                    
    创建一个类 
public class ContextInitListener implements ServletContextListener 
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 
 
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 
 

    <listener>
        <des
    
                                
    • 
                                
  • 用nginx区分文件大小做出不同响应
                                    ronin47

                                    
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    
                                
    • 
                                
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Random;

public class ContinuousPoker {

    /**
     * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
     * 2-10为数字本身，A为1，J为1
    
                                
    • 
                                
  • 翟鸿燊老师语录
                                    ccii
翟鸿燊
                                    
    一、国学应用智慧TAT之亮剑精神A 
1. 角色就是人格 
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。 
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    
                                
    • 
                                
  • [光速与宇宙]进行光速飞行的一些问题
                                    comsci
问题
                                    
     
 
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家 
    仅仅是猜想。。。未经官方证实 
 
 
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    
                                
    • 
                                
  • oracle undo解析
                                    cwqcwqmax9
oracle
                                    
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 
 
Undo是干嘛用的？         &nb
    
                                
    • 
                                
  • java中各种集合的详细介绍
                                    dashuaifu
java集合
                                    
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    
                                
    • 
                                
  • 卸载windows服务的方法
                                    dcj3sjt126com
windowsservice
                                    
    卸载Windows服务的方法 
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    
                                
    • 
                                
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
                                    dcj3sjt126com
iosxcode
                                    
           
      
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html 
Excerpt: 
 
 You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    
                                
    • 
                                
  • 2014之C++学习笔记（一）
                                    Etwo
C++EtwoEtwoiterator迭代器
                                    
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    
                                
    • 
                                
  • js跨越获取数据问题记录
                                    haifengwuch
jsonpjsonAjax
                                    
    js的跨越问题，普通的ajax无法获取服务器返回的值。 
 
  第一种解决方案，通过getson，后台配合方式，实现。 
Java后台代码： 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException { 
String ca
    
                                
    • 
                                
  • 蓝色jQuery导航条
                                    ini
JavaScripthtmljqueryWebhtml5
                                    
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    
                                
    • 
                                
  • linux部署jdk,tomcat,mysql
                                    kerryg
jdktomcatlinuxmysql
                                    
    1、安装java环境jdk: 
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。 
   1.1）、卸载： 
     （rpm -qa :查询已经安装哪些软件包； 
       rmp -q 软件包：查询指定包是否已
    
                                
    • 
                                
  • DOMContentLoaded VS onload VS onreadystatechange
                                    mutongwu
jqueryjs
                                    
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 
 
2. onload是最早支持的事件，要求所有资源加载完毕触发。 
 
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    
                                
    • 
                                
  • sql批量插入数据
                                    qifeifei
批量插入
                                    
    hi， 
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。 
   
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    
                                
    • 
                                
  • log4j打印日志文件 如何实现相对路径到 项目工程下
                                    thinkfreer
Weblog4j应用服务器日志
                                    
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 
 
 
需求： 
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    
                                
    • 
                                
  • linux下mysql-5.6.23.tar.gz安装与配置
                                    笑我痴狂
mysqllinuxunix
                                    
    1.卸载系统默认的mysql 
 
[root@localhost ~]# rpm -qa | grep mysql 
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    
                                
    •