《跟闪电侠学Netty》阅读笔记 - 聊天系统实现

引言

本部分整合聊天系统有关的章节，内容主要是介绍关键功能的实现逻辑，建议读者先看看作者的博客项目，切换到不同分支看看各个细节功能如何实现。

篇幅有限，这里仅仅记录一些个人学习过程的重点部分。

思维导图

https://www.mubu.com/doc/1dunN_7Luzl

项目代码

作者的仓库代码地址：https://github.com/lightningMan/flash-netty5

通信协议设计和自定义编解码实现

什么是通信协议？

基于TCP通信均为二进制协议，底层都是通过字节进行传输的，在通信协议当中规定数据传输的每一个字节含义。

通信过程

  1. 客户端转换数据为二进制。
  2. 网络传输给服务端。
  3. 服务端根据协议规则读取二进制数据。
  4. 服务端处理数据返回响应结果给客户端。

聊天系统的通信协议数据对象设计

在聊天系统当中通信协议的设计如下。

4字节魔数

比如Java的字节码CafeBabe，用于快速识别是否自定义协议，也可以方便快速提取数据。

public static final int MAGIC_NUMBER = 0x12345678;

1 字节版本号

类似TCP的IPV4、IPV6。

/**  
 * 协议版本  
 */  
@JSONField(deserialize = false, serialize = false)  
private Byte version = 1;

1 字节序列化算法

使用1个字节来标识算法。

/**  
 * 序列化算法定义  
 */  
public interface SerializerAlgorithm {  
    /**  
     * json 序列化  
     */  
    byte JSON = 1;  
}

1 字节指令

一个字节最多表示256种指令。注意在设计上指令和版本号进行绑定关联，实现不同版本之间的指令兼容，提高程序的健壮性。

@Data  
public abstract class Packet {  
    /**  
     * 协议版本  
     */  
    @JSONField(deserialize = false, serialize = false)  
    private Byte version = 1;  
  
  
    @JSONField(serialize = false)  
    public abstract Byte getCommand();  
}

4字节数据长度

数据长度是必要的，主要用于字节流这种连续不断的数据形式进行切割。

byteBuf.writeInt(bytes.length);
int 基本数据类型在Java中默认占4个字节，这4个字节用来存储字节数组的长度。

N字节数据

数据部分。

如何实现JAVA对象二进制互相转化？

所谓互转对应了网络 Socket IO 的input/output中的数据转化部分，实体数据转为字节流这个过程我们通常叫做编码，反之则是解码。

无论是编码还是解码，都是依赖Netty自定义的 MessageToMessageCodec实现的，聊天系统的编码和解码工作都是依赖 PacketCodecHandler 完成的。

@ChannelHandler.Sharable  
public class PacketCodecHandler extends MessageToMessageCodec {  
    public static final PacketCodecHandler INSTANCE = new PacketCodecHandler();  
  
    private PacketCodecHandler() {  
  
    }  
  
    @Override  
    protected void decode(ChannelHandlerContext ctx, ByteBuf byteBuf, List out) {  
        out.add(PacketCodec.INSTANCE.decode(byteBuf));  
    }  
  
    @Override  
    protected void encode(ChannelHandlerContext ctx, Packet packet, List out) {  
        ByteBuf byteBuf = ctx.channel().alloc().ioBuffer();  
        PacketCodec.INSTANCE.encode(byteBuf, packet);  
        out.add(byteBuf);  
    }  
} 
 
自定义逻辑处理器，在 Netty Server 中需要注册到 pipeline 当中。
 
 
public static void main(String[] args) {  
    NioEventLoopGroup boosGroup = new NioEventLoopGroup();  
    NioEventLoopGroup workerGroup = new NioEventLoopGroup();  
  
    final ServerBootstrap serverBootstrap = new ServerBootstrap();  
    serverBootstrap  
            .group(boosGroup, workerGroup)  
            .channel(NioServerSocketChannel.class)  
            .option(ChannelOption.SO_BACKLOG, 1024)  
            .childOption(ChannelOption.SO_KEEPALIVE, true)  
            .childOption(ChannelOption.TCP_NODELAY, true)  
            .childHandler(new ChannelInitializer() {  
                protected void initChannel(NioSocketChannel ch) {  
                    //......
                    ch.pipeline().addLast(PacketCodecHandler.INSTANCE); 
                    // ......
                }  
            });  
  
  
    bind(serverBootstrap, PORT);  
}
 
 
这里解释下为什么PacketCodecHandler要被注解标记为“Sharable”，因为编码和解码可能在多个handler中用到，为了提高效率，这里通过共享减少实例的创建。
 
 

   这个优化方式在原书后面的章节会提到 
 
 
 
带着疑问我们再看看@ChannelHandler.Sharable这个注解的源码解释。
 
 

   Indicates that the same instance of the annotated ChannelHandler can be added to one or more ChannelPipelines multiple times without a race condition. 
 
 
 
If this annotation is not specified, you have to create a new handler instance every time you add it to a pipeline because it has unshared state such as member variables.
This annotation is provided for documentation purpose, just like the JCIP annotations 

 
 
上面的内容翻译过来就是：
 
 
被注解的Sharable的同一个ChannelHandler实例，可以被多次添加到一个或多个ChannelPipeline中，并且可以确保不会出现（多线程）竞争情况。
 
 
如果没有指定这个注解，那么每次创建新的 Channel 都需要使用新的 Handler 实例。
 
 
注意在如果存在不共享变量或者状态，如有动态的成员变量，就不能用这个注解。简单来说@ChannelHandler.Sharable实现了Netty中的"Bean"单例和共享。
 
 
实战部分
 
 
数据编码过程（思路）
 
 
下面是数据编码的基本编写思路。
 
 
     
  
  1. 添加编码器。
    2.  
 
 
 
ch.pipeline().addLast(new PacketEncoder());
 
 
     
  
  1. 往ByteBuf逐个写字段，实现编码过程。
    2.  
 
 
 
public class PacketEncoder extends MessageToByteEncoder {  
  
    @Override  
    protected void encode(ChannelHandlerContext ctx, Packet packet, ByteBuf out) {  
        PacketCodec.INSTANCE.encode(out, packet);  
    }  
}
 
 
     
  
  1. 完整的自定义协议：PacketCodec#encode。
    2.  
 
 
 
public void encode(ByteBuf byteBuf, Packet packet) {  
    // 1. 序列化 java 对象  
    byte[] bytes = Serializer.DEFAULT.serialize(packet);  
  
    // 2. 实际编码过程  
    byteBuf.writeInt(MAGIC_NUMBER);  
    byteBuf.writeByte(packet.getVersion());  
    byteBuf.writeByte(Serializer.DEFAULT.getSerializerAlgorithm());  
    byteBuf.writeByte(packet.getCommand());  
    byteBuf.writeInt(bytes.length);  
    byteBuf.writeBytes(bytes);  
}
 
 
解码数据过程（思路）
 
 
下面是数据解码的基本编写思路：
 
 
     
  
  1. 在handler当中添加自定义逻辑处理器。
    2.  
 
 
 
.handler(new ChannelInitializer() {  
    @Override  
    public void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new PacketDecoder());
    }  
});
 
 
     
  
  1. 定义解码逻辑处理器。
    2.  
 
 
 
public class PacketDecoder extends MessageToMessageDecoder {  
  
    @Override  
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) {  
        out.add(PacketCodec.INSTANCE.decode(in));  
    }  
}
 
 
具体的解码过程：
 
 
     
  
  • 跳过魔数。
    •  
  
  • 跳过协议版本号 。
    •  
  
  • 读取序列化算法。
    •  
  
  • 读取指令，数据包，算法标识等自定义协议的基本内容。
    •  
  
  • 根据数据长度。
    •  
  
  • 取出数据。
    •  
 
 
 
PacketCodec#decode
 
 
public Packet decode(ByteBuf byteBuf) {  
    // 跳过 magic number    byteBuf.skipBytes(4);  
  
    // 跳过版本号  
    byteBuf.skipBytes(1);  
  
    // 序列化算法  
    byte serializeAlgorithm = byteBuf.readByte();  
  
    // 指令  
    byte command = byteBuf.readByte();  
  
    // 数据包长度  
    int length = byteBuf.readInt();  
  
    byte[] bytes = new byte[length];  
    byteBuf.readBytes(bytes);  
  
    Class requestType = getRequestType(command);  
    Serializer serializer = getSerializer(serializeAlgorithm);  
  
    if (requestType != null && serializer != null) {  
        return serializer.deserialize(requestType, bytes);  
    }  
  
    return null;  
}
 
 
思考
 
 
JSON序列化方式之外其他序列化方式如何实现？
 
 
Java原生序列化
 
 
     
  
  • 类实现 Serializable 接口
    •  
  
  • 具体底层由ObjectOutputStream和ObjectInputStream实现
    •  
 
 
 
Hessian
 
 
     
  
  • Hessian 是动态类型、二进制、紧凑的，并且可跨语言移植的一种序列化框架
    •  
  
  • Hessian 协议要比 JDK、JSON 更加紧凑，性能上要比 JDK、JSON 序列化高效很多，而且生成的字节数也更小
    •  
 
 
 
Protobuf
 
 
     
  
  • 谷歌实现的混合语言数据标准
    •  
  
  • 轻便、高效的结构化数据存储格式
    •  
  
  • 支持 Java、Python、C++、Go 等语言
    •  
  
  • 要求定义 IDL（Interface description language），并且使用对应语言的IDL生成序列化工具类
    •  
 
 
 
Thrift
 
 
     
  
  • Facebook于2007年开发的跨语言的rpc服框架
    •  
  
  • 通过Thrift的编译环境生成各种语言类型的接口文件
    •  
 
 
 
序列化和编码都是JAVA对象封装二进制过程，两者的联系和区别
 
 
总结起来就是一句话：序列化是目标，编码是方法。网上有一张图非常直观的展示了两者的区别。
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第1张图片
 
 
两者的联系和区别
 
 
编码：信息从一种形式或格式转换为另一种形式的过程，目的是方便传输协议通信。
 
 
序列化：“序列化”其实本身也是“信息从一种形式或格式转换为另一种形式的过程”，只不过这个表现形式直观具体，序列化也常常用于表达一个对象的状态。
 
 
聊天系统的Netty细节优化
 
 
优化部分是聊天系统的精髓，也是使用Netty实践非常有价值的指导和参考。
 
 
1. 使用共享Handler
 
 
问题分析
 
 
在旧版本代码中，每个新连接每次通过 ChannelInitializer 调用，会造成9个指令对象都被new一遍操作，连接过多会造成大量对象创建影响系统性能。
 
 
我们仔细观察可以发现，其实很多处理器内部是没有任何 "状态"的，对于无状态的业务处理器就可以使用单例模式封装。
 
 
serverBootstrap
                .childHandler(new ChannelInitializer() {
                    protected void initChannel(NioSocketChannel ch) {
                        ch.pipeline().addLast(new Spliter());
                        ch.pipeline().addLast(new PacketDecoder());
                        ch.pipeline().addLast(new LoginRequestHandler());
                        ch.pipeline().addLast(new AuthHandler());
                        ch.pipeline().addLast(new MessageRequestHandler());
                        ch.pipeline().addLast(new CreateGroupRequestHandler());
                        ch.pipeline().addLast(new JoinGroupRequestHandler());
                        ch.pipeline().addLast(new QuitGroupRequestHandler());
                        ch.pipeline().addLast(new ListGroupMembersRequestHandler());
                        ch.pipeline().addLast(new GroupMessageRequestHandler());
                        ch.pipeline().addLast(new LogoutRequestHandler());
                        ch.pipeline().addLast(new PacketEncoder());
                    }
                });

 
 
优化手段
 
 
     
  
  • 通过加入注解 @ChannelHandler.Shareble，表示这个 handler 是支持多个 channel 共享的，否则会报错。
    •  
  
  • 发布静态 final 的不可变对象来实现单例，编译器优化。
    •  
  
  • 最后还可以压缩Handler，把编码和解码过程放到一个公用的Handler处理（比如请求指令分发解析处理）。
    •  
 
 
 
注意事项
 
 
     
  
  • 并不是所有的Handler都可以单例
    •  
  
  • Spliter 不是单例的，因为它需要对每个数据做拆包处理。
    •  
 
 
 
2. 缩短事件传播路径
 
 
问题分析
 
 
     
  
  • 首先，指令的decode必须要在最前面，因为涉及后面的命令解析。
    •  
  
  • 如果把每个命令decode之后再传播到每个命令事件，但是对应的事件又不做任何处理，那么会浪费很多次多余的命令判断。
    •  
 
 
 
优化手段
 
 
根本目的是缩短事件传播链条，让事件传播链尽可能短，优化手段实际上也很简单，那就是 使用统一Handler。
 
 
通常的做法如下：
 
 
     
  
  1. 该Handler只做判断，不做任何状态存储，使用单例优化。
    2.  
 
 
 
public static final IMHandler INSTANCE = new IMHandler();
 
 
     
  
  1. 聊天系统中利用HashMap存储所有的命令处理Handler。
    2.  
 
 
 

   这里个人顺带指定下HashMap初始化容量，小小优化一下。 
 
 
 
private IMHandler() {  
    handlerMap = new HashMap<>(7);  
  
    handlerMap.put(MESSAGE_REQUEST, MessageRequestHandler.INSTANCE);  
    handlerMap.put(CREATE_GROUP_REQUEST, CreateGroupRequestHandler.INSTANCE);  
    handlerMap.put(JOIN_GROUP_REQUEST, JoinGroupRequestHandler.INSTANCE);  
    handlerMap.put(QUIT_GROUP_REQUEST, QuitGroupRequestHandler.INSTANCE);  
    handlerMap.put(LIST_GROUP_MEMBERS_REQUEST, ListGroupMembersRequestHandler.INSTANCE);  
    handlerMap.put(GROUP_MESSAGE_REQUEST, GroupMessageRequestHandler.INSTANCE);  
    handlerMap.put(LOGOUT_REQUEST, LogoutRequestHandler.INSTANCE);  
}
 
 
     
  
  1. 回调channelRead0 实际上就是委托给map中的元素对应的指令处理器处理。
    2.  
 
 
 
@Override  
protected void channelRead0(ChannelHandlerContext ctx, Packet packet) throws Exception {  
    handlerMap.get(packet.getCommand()).channelRead(ctx, packet);  
}
 
 
通过一个统一的处理器包括多个静态单例处理器，有效减少JVM内存开销，单例也可以减少对象实例化的开销。
 
 
3. 事件传播源调整
 
 
关键点
 
 
如果你的 outBound 类型的 handler 较多，在写数据的时候能用 ctx.writeAndFlush() 就用这个方法， 不要用 ctx.channel().writeAndFlush()。
 
 
原因
 
 
究其原因是ctx.writeAndFlush() 会绕过所有不需要处理的其他Outbound类型。
 
 
ctx.writeAndFlush() 是从 pipeline 链中的当前节点开始往前找到第一个 outBound 类型向前传播的，如果这个对象不需要其他outBound的handler处理就可以用这个方法。
 
 
我们可以通过下面这个图理解：
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第2张图片
 
 
而ctx.channel().writeAndFlush() 表现则不同，它是从 pipeline 链中的最后一个 outBound 类型的 handler 开始，把对象往前进行传播，从图中就可以看到， outBound 的处理器越多，调用链路就越长，可能产生越多“无用”操作。
 
 
当然如果确定后面的 outBound 都需要进行处理，那么就可以用这个方法。
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第3张图片
 
 
相关问题
 
 
     
  
  • writeAndFlush为什么可以缩短事件传播路径？
    •  
  
  • 它是如何实现OutBound类型的事件传播缩短的?
    •  
 
 
 
4. 减少阻塞主线程的操作【重要】
 
 
Netty中容易被忽视的一点，却是非常重要的概念，那就是 一个Channel的其中一个Handler阻塞，会导致所有其他绑定的Channel一起被拖慢。
 
 
只要有一个 channel 的一个 handler 中的 channelRead0() 方法阻塞了 NIO 线程，最终都会拖慢绑定在该 NIO 线程上的其他所有的 channel，而不是只影响当前的Channel。
 
 

   为什么会这样？源码之下无问题，但是本文不涉及源码解读，读者可以自己留下问题仔细思考一下。 
 
 
 
为了更好理解，这里再举个代码的例子。
 
 
List channelList = 已有数据可读的 channel
for (Channel channel in channelist) {
   for (ChannelHandler handler in channel.pipeline()) {
       handler.channelRead0();
   }   
}
 
 
比如，上面的操作中，如果for循环某次出现卡顿，这不仅仅拖慢一个客户端，而是拖慢所有客户端。
 
 
解决这个问题的方式是，由于Netty进行客户端处理的时候本身已经被设计为非阻塞模式了，大部分情况需要开发者自行使用 业务线程池 开启新的线程防止”卡顿“。
 
 

   需要注意，引入业务线程池会增加系统复杂度，也会增加线上调试难度。 
 
 
 
5. 如何准确统计时长？
 
 
错误做法：在线程的头尾加入时间差计算得出执行时长结果。
 
 
正确做法：使用writeAndFlush+addListener 的方式判断 futrue.isDone 之后才计算 。
 
 
原因：writeAndFlush 在非NIO线程中它是一个异步操作，其他操作由第一个任务队列异步执行。 
 
 
关键点：writeAndFlush 真正执行完成才算是完成处理，监听它完成处理的回调动作才能算出较为准确执行时长。
 
 
优化小结
 
 
     
  
  • 如果Handler多例但是无状态，完全可以改为单例模式 。
    •  
  
  • 尽可能减少Handler的臃肿，防止调用链路过长。
    •  
  
  • 一个耗时操作不只影响单个Channel，所以建议Handler的耗时操作要交给业务线程池开启新线程处理防止”卡顿“，但是需要注意和线程绑定的相关参数处理问题。
    •  
  
  • 耗时统计，writeAndFlush属于异步任务，使用JDK的Future.isDone()方法判断真正的结束时间才是正解。
    •  
 
 
 
实现登录
 
 
处理流程图
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第4张图片
 
 
实现思路
 
 
     
  
  • 目标客户端和服务端分别启动Netty服务。
    •  
  
  • 客户端发送登录请求指令，服务端解码之后根据传输结果校验，根据校验结果构建登录请求响应指令 LoginResponsePacket。
    •  
  
  • 通过ctx.writeAndFlush(loginResponsePacket); 回送响应结果给客户端。
     
   
       
    
    • 登录校验成功，通过SessionUtil添加session信息
      •  
   
    •  
  
  • 客户端登录成功之后，构建请求指令对象，设置参数，通过Netty发送到服务端 。
    •  
  
  • 服务端收到请求进行验证，并且构建相对应的响应指令结果对象。
    •  
 
 
 
实现步骤
 
 
下面是大致的实现步骤：
 
 
     
  
  1. 添加 LoginRequestHandler 登录逻辑处理器在Server端。
    2.  
 
 
 
ch.pipeline().addLast(LoginRequestHandler.INSTANCE);
 
 
  
@ChannelHandler.Sharable  
public class LoginRequestHandler extends SimpleChannelInboundHandler {  
  
    public static final LoginRequestHandler INSTANCE = new LoginRequestHandler();  
  
    protected LoginRequestHandler() {  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, LoginRequestPacket loginRequestPacket) {  
        LoginResponsePacket loginResponsePacket = new LoginResponsePacket();  
        loginResponsePacket.setVersion(loginRequestPacket.getVersion());  
        loginResponsePacket.setUserName(loginRequestPacket.getUserName());  
  
        if (valid(loginRequestPacket)) {  
            loginResponsePacket.setSuccess(true);  
            String userId = IDUtil.randomId();  
            loginResponsePacket.setUserId(userId);  
            System.out.println("[" + loginRequestPacket.getUserName() + "]登录成功");  
            SessionUtil.bindSession(new Session(userId, loginRequestPacket.getUserName()), ctx.channel());  
        } else {  
            loginResponsePacket.setReason("账号密码校验失败");  
            loginResponsePacket.setSuccess(false);  
            System.out.println(new Date() + ": 登录失败!");  
        }  
  
        // 登录响应  
        ctx.writeAndFlush(loginResponsePacket);  
    }  
  
    private boolean valid(LoginRequestPacket loginRequestPacket) {  
        return true;  
    }  
  
    @Override  
    public void channelInactive(ChannelHandlerContext ctx) {  
        SessionUtil.unBindSession(ctx.channel());  
    }  
}
 
 
     
  
  1. 在客户端同样添加Handler也就是LoginResponseHandler，LoginResponseHandler的处理逻辑如下。
    2.  
 
 
 
ch.pipeline().addLast(LoginResponseHandler.INSTANCE);
 
 
public class LoginResponseHandler extends SimpleChannelInboundHandler {  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, LoginResponsePacket loginResponsePacket) {  
        String userId = loginResponsePacket.getUserId();  
        String userName = loginResponsePacket.getUserName();  
  
        if (loginResponsePacket.isSuccess()) {  
            System.out.println("[" + userName + "]登录成功，userId 为: " + loginResponsePacket.getUserId());  
            SessionUtil.bindSession(new Session(userId, userName), ctx.channel());  
        } else {  
            System.out.println("[" + userName + "]登录失败，原因：" + loginResponsePacket.getReason());  
        }  
    }  
  
    @Override  
    public void channelInactive(ChannelHandlerContext ctx) {  
        System.out.println("客户端连接被关闭!");  
    }  
}
 
 
如何把失败或者成功标识绑定在客户端连接？ 服务端如何高效判定客户端重新登录？
 
 
在聊天系统中实现比较简单，服务端高效判断的方法是利用ConcurrentHashMap，Map当中存储用户的ID，如果登录成功则存储到此Map中，服务端也只需要判断Map元素确认是否登录。
 
 
private static final Map userIdChannelMap = new ConcurrentHashMap<>();
 
 
热插拔客户端是否登录验证
 
 
校验是否登录的逻辑封装到工具类当中，实现比较简单。
 
 
SessionUtil
 
 
public static boolean hasLogin(Channel channel) {  
  
    return getSession(channel) != null;  
}  
  
public static Session getSession(Channel channel) {  
  
    return channel.attr(Attributes.SESSION).get();  
}

// AttributeKey SESSION = AttributeKey.newInstance("session");
 
 
AuthHandler
 
 
实现热插拔的思路是判断是否登录，统一通过该调用链条完成，AuthHandler本身作为单独处理器封装判断登录校验逻辑。
 
 
@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (!SessionUtil.hasLogin(ctx.channel())) {
        ctx.channel().close();    
    } else {
        ctx.pipeline().remove(this);        
        super.channelRead(ctx, msg);    
    }
}
 
 
实现双端收发消息
 
 
客户端处理
 
 
客户端成功登录之后，下一步是实现客户端和服务端互相发送数据。客户端收消息处理器如下：
 
 
// 收消息处理器  
ch.pipeline().addLast(new MessageResponseHandler());
 
 
MessageResponseHandler
 
 
public class MessageResponseHandler extends SimpleChannelInboundHandler {  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, MessageResponsePacket messageResponsePacket) {  
        String fromUserId = messageResponsePacket.getFromUserId();  
        String fromUserName = messageResponsePacket.getFromUserName();  
        System.out.println(fromUserId + ":" + fromUserName + " -> " + messageResponsePacket  
                .getMessage());  
    }  
}
 
 
服务端处理
 
 
因为是通用组件，服务端这里封装到 IMHandler 通用组件当中。
 
 
handlerMap.put(MESSAGE_REQUEST, MessageRequestHandler.INSTANCE);
 
 
MessageRequestHandler
 
 
@ChannelHandler.Sharable  
public class MessageRequestHandler extends SimpleChannelInboundHandler {  
    public static final MessageRequestHandler INSTANCE = new MessageRequestHandler();  
  
    private MessageRequestHandler() {  
  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, MessageRequestPacket messageRequestPacket) {  
        long begin = System.currentTimeMillis();  
  
  
        // 1.拿到消息发送方的会话信息  
        Session session = SessionUtil.getSession(ctx.channel());  
  
        // 2.通过消息发送方的会话信息构造要发送的消息  
        MessageResponsePacket messageResponsePacket = new MessageResponsePacket();  
        messageResponsePacket.setFromUserId(session.getUserId());  
        messageResponsePacket.setFromUserName(session.getUserName());  
        messageResponsePacket.setMessage(messageRequestPacket.getMessage());  
  
        // 3.拿到消息接收方的 channel        Channel toUserChannel = SessionUtil.getChannel(messageRequestPacket.getToUserId());  
  
        // 4.将消息发送给消息接收方  
        if (toUserChannel != null && SessionUtil.hasLogin(toUserChannel)) {  
            toUserChannel.writeAndFlush(messageResponsePacket).addListener(future -> {  
                if (future.isDone()) {  
  
                }  
  
            });  
        } else {  
            System.err.println("[" + session.getUserId() + "] 不在线，发送失败!");  
  
        }  
    }  
}
 
 
小结
 
 
实现双端收发消息小结：
 
 
     
  
  1. 定义收发消息Java对象，对于消息进行收发。
    2.  
  
  2. Channel 的 attr 的方法可以给Channel绑定属性并设置某些状态，内部实际也是通过Map维护的，不需要用户外部自己在自定义去维护。
    3.  
  
  3. 如何在控制台当中获取消息并且发送到服务端。
    4.  
  
  4. 服务端回传消息给客户端。
    5.  
 
 
 
ChannelPipleline 和 ChannelHandler 概念
 
 
本部分是补充部分。主要介绍 Pipeline 和ChannelHanlder构成和一些基础概念。
 
 
ChannelPipleline 和 ChannelHandler 构成图
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第5张图片
 
 
理解这幅图之前，需要先理解Channel这个概念。
 
 
Channel 概念理解
 
 
一个客户端连接对应一个Channel，这个Channel可以类比BIO当中的传统概念Socket套接字。
 
 

   A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind. 
 
 
 
一个网络套接字的节点或一个能够进行（网络）I/O操作的组件，如读、写、连接和绑定。
 
 
ChannelPipeline
 
 
源码对于 ChannelPipeline 的定义如下：
 
 

   A list of ChannelHandlers which handles or intercepts inbound events and outbound operations of a Channel. ChannelPipeline implements an advanced form of the Intercepting Filter pattern to give a user full control over how an event is handled and how the ChannelHandlers in a pipeline interact with each other. 
 
 
 
源码中还有一个直观的设计图。
 
 
下图描述了I/O事件在ChannelPipeline中是如何被ChannelHandlers处理的。
 
 
一个I/O事件由ChannelInboundHandler 或 ChannelOutboundHandler 处理，并通过调用 ChannelHandlerContext 中定义的事件传播方法，比如ChannelHandlerContext.fireChannelRead(Object)和ChannelHandlerContext.write(Object)，转发给其最接近的处理程序。
 
 
《跟闪电侠学Netty》阅读笔记 - 聊天系统实现_第6张图片
 
 
ChannelPipeline 的核心如下：
 
 
     
  
  • 处理或拦截一个Channel的入站事件和出站操作的链表。
    •  
  
  • 通过责任链模式的设计，可以完全自定义处理逻辑和ChannelHandler之间互相通信的逻辑。
    •  
 
 
 
ChannelContext
 
 
ChannelHandler与Channel和ChannelPipeline之间的映射关系，由ChannelHandlerContext进⾏维护。
 
 

   Enables a ChannelHandler to interact with its ChannelPipeline and other handlers. 
 
 
 
（ChannelContext）使得ChannelHandler能够与它的ChannelPipeline和其他处理程序互动。
 
 
     
  
  • ChannelContext可以获取整个Channel的信息。
    •  
  
  • 获取所有的上下文。
    •  
  
  • 逻辑处理器ChannelHandler定义处理逻辑。
    •  
 
 
 
ChannelHanlder
 
 
ChannelHanlder 包含两种理解。
 
 
第一种理解：可以理解为Socket连接，客户端和服务端连接的时候会创建一个channel。 负责基本的IO操作，例如：bind()、connect()、read()、write()。 
 
 
第二种理解：Netty的Channel接口所提供的API，大大减少了Socket类复杂性。
 
 
因为Channel连接过程中存在双端 input/output，所以 ChannelHandler 也分类为 ChannelInboundHandler 和 ChannelOutboundHandler。
 
 
ChannelInboundHandler
 
 
     
  
  • 读取的逻辑抽象 。
    •  
  
  • channelRead 是最重要的方法 。
    •  
  
  • 配合ByteBuf使用进行buf.read推进读指针移动 。
    •  
 
 
 
ChannelOutboundHandler
 
 
     
  
  • 对应写出的逻辑抽象 。
    •  
  
  • 核心方法是 write，writeAndFlush 。
    •  
 
 
 
适配器
 
 
在使用过程中还存在对应的适配器。
 
 
     
  
  • ChannelOutboundHandlerAdapter（注意处理顺序和添加addLast的顺序相反）
    •  
  
  • ChannelInboundHandlerAdapter
    •  
 
 
 
客户端和服务端的 SimpleChannelInboundHandler/ChannelInboundHandlerAdapter 简化
 
 
整个聊天系统大部分的指令判断逻辑是重复的，下面介绍如何通过 SImpleChannelInboundHandler/ChannelInboundHandlerAdapter 简化指令的处理逻辑。
 
 
 ChannelInboundHandlerAdapter which allows to explicit only handle a specific type of messages. For example here is an implementation which only handle String messages. 
 
 
 
ChannelInboundHandlerAdapter 允许明确地只处理特定类型的消息。而SimpleChannelInboundHandler提供了一个模板，作用是把处理逻辑不变的内容写好在 channelRead(ctx,msg) 中，并且在里面调用 channelRead0 ，这样处理之后就可以通过抽象方法实现传递到子类中去进行传播。
 
 
区别
 
 
SimpleChannelInboundHandler和ChannelInboundHandlerAdapter这两个类使用上不太好区分，下面再补充介绍一下如何正确对待使用两者。
 
 
ChannelInboundHandlerAdapter 需要覆盖的方法是channelRead，特点是不会自动释放消息，需要调用ctx.fireChannelRead(msg) 向后续链条处理器传递消息，也就是需要手动通过责任链的方式传递给下位处理器。
​
SimpleChannelInboundHandler 是 ChannelInboundHandlerAdapter 的子类，做了额外的处理，会自动释放消息。如果还需要继续传递消息，此时需调用一次 ReferenceCountUtil.retain(msg)。
 
 
需注意SimpleChannelInboundHandler也要调用ctx.fireChannelRead(msg)来触发链条中下一处理器处理。
 
 
ChannelInboundHandlerAdapter通常用于处于链条中间的某些环节对数据进行处理，如数据验证，需要将消息继续传递。
​
SimpleChannelInboundHandler则比较适合链条最后一个环节，该环节处理完后，后续不再需要该消息，因此可以自动释放。
 
 
应用
 
 
在聊天系统中统一处理的Handler继承了SimpleChannelInboundHandler，重写channelRead0方法，主要对于解码之后的操作指令和通用Map进行匹配，如果匹配则分发到具体的逻辑处理器。
 
 
IMHandler 的公用Handler实现非常简单直观。
 
 
@ChannelHandler.Sharable  
public class IMHandler extends SimpleChannelInboundHandler {  
    public static final IMHandler INSTANCE = new IMHandler();  
  
    private Map> handlerMap;  
  
    private IMHandler() {  
        handlerMap = new HashMap<>(7);  
  
        handlerMap.put(MESSAGE_REQUEST, MessageRequestHandler.INSTANCE);  
        handlerMap.put(CREATE_GROUP_REQUEST, CreateGroupRequestHandler.INSTANCE);  
        handlerMap.put(JOIN_GROUP_REQUEST, JoinGroupRequestHandler.INSTANCE);  
        handlerMap.put(QUIT_GROUP_REQUEST, QuitGroupRequestHandler.INSTANCE);  
        handlerMap.put(LIST_GROUP_MEMBERS_REQUEST, ListGroupMembersRequestHandler.INSTANCE);  
        handlerMap.put(GROUP_MESSAGE_REQUEST, GroupMessageRequestHandler.INSTANCE);  
        handlerMap.put(LOGOUT_REQUEST, LogoutRequestHandler.INSTANCE);  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, Packet packet) throws Exception {  
        handlerMap.get(packet.getCommand()).channelRead(ctx, packet);  
    }  
}
 
 
客户端和服务端单聊
 
 
目标
 
 
     
  
  • 输入用户名，服务端随机分配ID，这里省去通过账号和密码注册过程 。
    •  
  
  • 多个客户端登录，用 userId 空格 消息的方式单聊。
    •  
 
 
 
实现过程
 
 
     
  
  1. 使用工具类把UserId和Channel绑定为Session。
     
   
       
    
    •  Session的信息包含用户ID以及名称 ，后续可以扩展更多的字段。
      •  
   
    2.  
  
  2. 使用SessionUtil工具类操作Session，通过Session贮存当前会话信息。
     
   
       
    
    • 注意建议用ConcurrentHashMap
      •  
    
    • ConcurrentHashMap为userId -> Channel的映射Map。
      •  
    
    • 用户登录，需要把Session塞入Map。
      •  
    
    • 当用户断开Channel连接退出，需要移除Session信息。
      •  
   
    3.  
  
  3. 服务端接受消息并且转发（这里Netty类似转发手机信号的基站）
     
   
       
    
    • 获取会话信息。
      •  
    
    • 构造发给客户端的对象MessageResponse 。
      •  
    
    • 消息接收方标识获取对应Channel。
      •  
    
    • 如果目标用户登录则发送消息，如果对方不在线，则控制台打印警告信息。
      •  
   
    4.  
 
 
 
部分实现代码如下：
 
 
MessageResponseHandler
 
 
public class MessageResponseHandler extends SimpleChannelInboundHandler {  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, MessageResponsePacket messageResponsePacket) {  
        String fromUserId = messageResponsePacket.getFromUserId();  
        String fromUserName = messageResponsePacket.getFromUserName();  
        System.out.println(fromUserId + ":" + fromUserName + " -> " + messageResponsePacket  
                .getMessage());  
    }  
}
 
 
MessageRequestHandler
 
 
@ChannelHandler.Sharable  
public class MessageRequestHandler extends SimpleChannelInboundHandler {  
    public static final MessageRequestHandler INSTANCE = new MessageRequestHandler();  
  
    private MessageRequestHandler() {  
  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, MessageRequestPacket messageRequestPacket) {  
        long begin = System.currentTimeMillis();  
  
  
        // 1.拿到消息发送方的会话信息  
        Session session = SessionUtil.getSession(ctx.channel());  
  
        // 2.通过消息发送方的会话信息构造要发送的消息  
        MessageResponsePacket messageResponsePacket = new MessageResponsePacket();  
        messageResponsePacket.setFromUserId(session.getUserId());  
        messageResponsePacket.setFromUserName(session.getUserName());  
        messageResponsePacket.setMessage(messageRequestPacket.getMessage());  
  
        // 3.拿到消息接收方的 channel        Channel toUserChannel = SessionUtil.getChannel(messageRequestPacket.getToUserId());  
  
        // 4.将消息发送给消息接收方  
        if (toUserChannel != null && SessionUtil.hasLogin(toUserChannel)) {  
            toUserChannel.writeAndFlush(messageResponsePacket).addListener(future -> {  
                if (future.isDone()) {  
  
                }  
  
            });  
        } else {  
            System.err.println("[" + session.getUserId() + "] 不在线，发送失败!");  
  
        }  
    }  
}
 
 
群聊发起和通知
 
 
下面两个小节围绕群聊实现介绍。
 
 
群聊和单聊实现类似，都是通过标识获取Channel，为了方面多个成员管理，设计 ChannelGroup 完成Channel 的批量操作。
 
 
预期效果
 
 
     
  
  1. 三位用户依次登录。
    2.  
  
  2. 控制台输入 createGroup 指令，提示创建群聊需要 userId 列表，之后以英文逗号分隔userId。
    3.  
  
  3. 群聊创建成功之后，所有群聊成员收到加入成功消息。
    4.  
 
 
 
创建群聊实现
 
 
主要逻辑如下：
 
 
     
  
  1. 创建一个 channel 分组。
    2.  
  
  2. 筛选出待加入群聊的用户的 channel 和 userName。
    3.  
  
  3. 创建群聊创建结果的响应。
    4.  
  
  4. 给每个客户端发送拉群通知。
    5.  
  
  5. 保存群组相关的信息。
    6.  
 
 
 
存储群的相关信息利用了ConcurrentHashMap实现，和Session的会话信息存储方式类似。ChannelGroup对象负责封装多个Channel的信息，模拟群聊中的“群”。
 
 
  
@ChannelHandler.Sharable  
public class CreateGroupRequestHandler extends SimpleChannelInboundHandler {  
    public static final CreateGroupRequestHandler INSTANCE = new CreateGroupRequestHandler();  
  
    private CreateGroupRequestHandler() {  
  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, CreateGroupRequestPacket createGroupRequestPacket) {  
        List userIdList = createGroupRequestPacket.getUserIdList();  
  
        List userNameList = new ArrayList<>();  
        // 1. 创建一个 channel 分组  
        ChannelGroup channelGroup = new DefaultChannelGroup(ctx.executor());  
  
        // 2. 筛选出待加入群聊的用户的 channel 和 userName        for (String userId : userIdList) {  
            Channel channel = SessionUtil.getChannel(userId);  
            if (channel != null) {  
                channelGroup.add(channel);  
                userNameList.add(SessionUtil.getSession(channel).getUserName());  
            }  
        }  
  
        // 3. 创建群聊创建结果的响应  
        String groupId = IDUtil.randomId();  
        CreateGroupResponsePacket createGroupResponsePacket = new CreateGroupResponsePacket();  
        createGroupResponsePacket.setSuccess(true);  
        createGroupResponsePacket.setGroupId(groupId);  
        createGroupResponsePacket.setUserNameList(userNameList);  
  
        // 4. 给每个客户端发送拉群通知  
        channelGroup.writeAndFlush(createGroupResponsePacket);  
  
        System.out.print("群创建成功，id 为 " + createGroupResponsePacket.getGroupId() + ", ");  
        System.out.println("群里面有：" + createGroupResponsePacket.getUserNameList());  
  
        // 5. 保存群组相关的信息  
        SessionUtil.bindChannelGroup(groupId, channelGroup);  
    }  
}
 
 
客户端收到消息处理逻辑为简单打印创建群聊成功的信息，代码很简单这里不再贴代码。
 
 
群聊成员管理实现
 
 
设计流程和实现思路
 
 
设计流程
 
 
     
  
  1. 加入群聊，控制台输出创建成功消息。
    2.  
  
  2. 控制台输入 joinGroup 之后输入群ID，加入群聊，控制台显示加入群成功。
    3.  
  
  3. 控制台输入 listGroupMembers 然后输入群ID，展示群成员。
    4.  
  
  4. quitGroup 输入群ID，进行退群
    5.  
  
  5. 控制台输入 joinGroup 之后输入群ID显示对应成员不在，则退群成功。
    6.  
 
 
 
实现思路
 
 
     
  
  1. 在控制台中加入群加入的命令处理器。
    2.  
  
  2. 服务端处理群聊请求。
    3.  
  
  3. 客户端处理加群响应.
    4.  
  
  4. 群聊退出实现。
    5.  
 
 
 
在控制台中加入群加入的命令处理器
 
 
JoinGroupConsoleCommand
 
 
public class JoinGroupConsoleCommand implements ConsoleCommand {  
    @Override  
    public void exec(Scanner scanner, Channel channel) {  
        JoinGroupRequestPacket joinGroupRequestPacket = new JoinGroupRequestPacket();  
  
        System.out.print("输入 groupId，加入群聊：");  
        String groupId = scanner.next();  
  
        joinGroupRequestPacket.setGroupId(groupId);  
        channel.writeAndFlush(joinGroupRequestPacket);  
    }  
}
 
 
服务端处理群聊请求
 
 
服务端处理群聊请求：
 
 
     
  
  1. 构建Channel，把处在同一个分组的Channel放到一个List当中存储 。
    2.  
  
  2. 如果群聊构建成功，则构建创建成功响应结果 。
    3.  
 
 
 
@ChannelHandler.Sharable  
public class JoinGroupRequestHandler extends SimpleChannelInboundHandler {  
    public static final JoinGroupRequestHandler INSTANCE = new JoinGroupRequestHandler();  
  
    private JoinGroupRequestHandler() {  
  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, JoinGroupRequestPacket requestPacket) {  
        // 1. 获取群对应的 channelGroup，然后将当前用户的 channel 添加进去  
        String groupId = requestPacket.getGroupId();  
        ChannelGroup channelGroup = SessionUtil.getChannelGroup(groupId);  
        channelGroup.add(ctx.channel());  
  
        // 2. 构造加群响应发送给客户端  
        JoinGroupResponsePacket responsePacket = new JoinGroupResponsePacket();  
  
        responsePacket.setSuccess(true);  
        responsePacket.setGroupId(groupId);  
        ctx.writeAndFlush(responsePacket);  
    }  
}
 
 
客户端处理加群响应
 
 
简单打印加群的响应消息。
 
 
public class JoinGroupResponseHandler extends SimpleChannelInboundHandler {  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, JoinGroupResponsePacket responsePacket) {  
        if (responsePacket.isSuccess()) {  
            System.out.println("加入群[" + responsePacket.getGroupId() + "]成功!");  
        } else {  
            System.err.println("加入群[" + responsePacket.getGroupId() + "]失败，原因为：" + responsePacket.getReason());  
        }  
    }  
}
 
 
群聊退出实现
 
 
群聊退出主要是获取群对应的 channelGroup，然后将当前用户的 channel 移除，之后构建退群的响应信息回传客户端即可。
 
 
QuitGroupRequestHandler
 
 
@ChannelHandler.Sharable  
public class QuitGroupRequestHandler extends SimpleChannelInboundHandler {  
    public static final QuitGroupRequestHandler INSTANCE = new QuitGroupRequestHandler();  
  
    private QuitGroupRequestHandler() {  
  
    }  
  
    @Override  
    protected void channelRead0(ChannelHandlerContext ctx, QuitGroupRequestPacket requestPacket) {  
        // 1. 获取群对应的 channelGroup，然后将当前用户的 channel 移除  
        String groupId = requestPacket.getGroupId();  
        ChannelGroup channelGroup = SessionUtil.getChannelGroup(groupId);  
        channelGroup.remove(ctx.channel());  
  
        // 2. 构造退群响应发送给客户端  
        QuitGroupResponsePacket responsePacket = new QuitGroupResponsePacket();  
  
        responsePacket.setGroupId(requestPacket.getGroupId());  
        responsePacket.setSuccess(true);  
        ctx.writeAndFlush(responsePacket);  
  
    }  
}
 
 
心跳检测
 
 
网络问题
 
 
假死
 
 
从TCP层面来看，服务端断开连接，需要收到4次握手包或者RST包才算真正断开连接，如果中途应用程序并没有捕获到，此时依然会认为这条连接存在的。
 
 
假死引发问题
 
 
     
  
  • 客户端发送数据超时无响应，影响体验。
    •  
  
  • 浪费CPU和内存资源，性能下滑。
    •  
 
 
 
假死原因
 
 
     
  
  • 公网丢包，网络抖动 。
    •  
  
  • 应用程序阻塞无法读写 。
    •  
  
  • 客户端或者服务端设别故障，网卡，机房故障。
    •  
 
 
 
为了解决上面的问题，通常会使用心跳检测机制，定期检测每个Channel连接是否存活。
 
 
服务端心跳检测实现
 
 
     
  
  1. 通过IdleStateHandler自带Handler实现
    2.  
  
  2. 继承类，然后开启定时任务。
    3.  
  
  3. 如果发现假死，则Handler回调channelIdle 方法判断，根据最后一个收到心跳的间隔判定是否需要移除Handler。
    4.  
 
 
 
客户端预判和防御假死
 
 
     
  
  1. 新建Handler。
    2.  
  
  2. 开启定时线程。
    3.  
  
  3. 组装心跳包。
    4.  
  
  4. 发送心跳。
    5.  
  
  5. 服务端接受和识别传来Handler心跳包，刷新内部维护的心跳信息，之后回送收到心跳包消息即可。
    6.  
 
 
 
注意事项
 
 
     
  
  • 心跳检测Handler插入到整个Pipeline最前面，因为如果连接本已经断开，那么此时再进行后续处理均无意义。
    •  
  
  • 假死不一定“死”，防止服务端误判，客户端也需要措施防止假死和预判假死，这就是客户端预判的含义。
    •  
 
 
 
思考
 
 
     
  
  1. IdleHandler 可否单例？
    2.  
  
  2. 断开链接之后重新连接登录。
    3.  
 
 
 
下面是答案：
 
 
IdleHandler 可否单例？
 
 
答案是不能。因为它并不是无状态的，并且每个Channel都有各自的连接状态。
 
 
断开链接之后重新连接登录
 
 
通过额外的线程定时轮循所有的连接的活跃性，如果发现其中有规定时间内假死连接，则尝试执行重连。
 
 
写在最后
 
 
熟悉聊天系统对于后续的源码分析十分有意义，建议读者掌握吃透各种Netty的基础用法，项目的整体构建比较简单入门，个人在笔记中仅仅将重点部分挑选并做了梳理。
 
 
文章参考
 
 
https://juejin.cn/book/m/6844733738119593991/section/6844733738291576840?suid=2040300414187416
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(nettynetty入门)

        

            

                
    
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    
                    
    • 
                    
  • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    
                    
    • 
                    
  • 2019考研 | 西交大软件工程
                        笔者阿蓉

                        
    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
    
                    
    • 
                    
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信
                        z755924843
ESP32开发快速入门服务器网络运维
                        
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
    
                    
    • 
                    
  • Armv8.3 体系结构扩展--原文版
                        代码改变世界ctw
ARM-TEE-Androidarmv8嵌入式arm架构安全架构芯片TrustzoneSecureboot
                        
    快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
    
                    
    • 
                    
  • Python入门之Lesson2:Python基础语法
                        小熊同学哦
Python入门课程python开发语言算法数据结构青少年编程
                        
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
    
                    
    • 
                    
  • 摄影小白，怎么才能拍出高大上产品图片？
                        是波妞唉

                        
    很多人以为文案只要会码字，会排版就OK了！说实话，没接触到这一行的时候，我的想法更简单，以为只要会写字就行！可是真做了文案才发现，码字只是入门级的基本功。一篇文章离不开排版、配图，说起来很简单！从头做到尾你就会发现，写文章用两个小时，找合适的配图居然要花掉半天的时间，甚至更久！图片能找到合适的就不怕，还有找不到的，比如产品图，只能亲自拍。拿着摆弄了半天，就是拍不出想要的效果，光线不好、搭出来丑破天
    
                    
    • 
                    
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码）
                        mmz1207
c++csp
                        
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
    
                    
    • 
                    
  • Vue( ElementUI入门、vue-cli安装)
                        m0_l5z
elementuivue.js
                        
    一.ElementUI入门目录：1.ElementUI入门1.1ElementUI简介1.2Vue+ElementUI安装1.3开发示例2.搭建nodejs环境2.1nodejs介绍2.2npm是什么2.3nodejs环境搭建2.3.1下载2.3.2解压2.3.3配置环境变量2.3.4配置npm全局模块路径和cache默认安装位置2.3.5修改npm镜像提高下载速度2.3.6验证安装结果3.运行n
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 入门MySQL——查询语法练习
                        K_un

                        
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
    
                    
    • 
                    
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    
                    
    • 
                    
  • 2023最详细的Python安装教程（Windows版本）
                        程序员林哥
Pythonpythonwindows开发语言
                        
    python安装是学习pyhon第一步，很多刚入门小白不清楚如何安装python，今天我来带大家完成python安装与配置，跟着我一步步来，很简单，你肯定能完成。第一部分：python安装（一）准备工作1、下载和安装python(认准官方网站)当然你不想去下载的话也可以分享给你，还有入门学习教程，点击下方卡片跳转进群领取（二）开始安装对于Windows操作系统，可以下载“executableins
    
                    
    • 
                    
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】
                        汉子萌萌哒
CCFnoi算法数据结构c++
                        
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
    
                    
    • 
                    
  • 现金贷“租系统”产业崛起：租金3000，本金10万，一月回本
                        Dayon

                        
    最近，地下现金贷的全面崛起，已成了不可阻挡的趋势。大量民间资本开始涌入，民间高利贷、炒房团、土豪的钱，都裹挟其中。而地下现金贷的入门门槛正在不断降低，一条新的产业链开始崛起：租现金贷系统。现在，只需要10万本金，花3000元租个系统，两个人的团队，一个月就能回本。大量的小本金玩家进场了，为了急速获利，他们甚至将利率调到1600%以上。业内人士称，真实的现金贷用户，现在大概只有200多万。整个行业几
    
                    
    • 
                    
  • 【树一线性代数】005入门
                        Owlet_woodBird
算法
                        
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
    
                    
    • 
                    
  • 如何自学软件编程？零基础自学编程入门指南
                        _pangzi

                        
    前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
    
                    
    • 
                    
  • Linux CTF逆向入门
                        蚁景网络安全
linux运维CTF
                        
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
    
                    
    • 
                    
  • python简单好玩的编程代码,python有哪些好玩的代码
                        2301_81900439
pygamepython开发语言
                        
    大家好，小编来为大家解答以下问题，20行python代码的入门级小游戏，python有什么好玩的代码嘛，今天让我们一起来看看吧！哈喽铁子们表弟最近在学Python，总是跟我抱怨很枯燥无味，其实，他有没有认真想过，可能是自己学习姿势不对？比方说，可以通过打游戏来学编程！今天给大家分享100个Python小游戏，一定要收藏！1、简易飞机大战飞机大战相信大家都玩过吧，非常简单有意思的游戏，咱们通过Pyt
    
                    
    • 
                    
  • 思考成长
                        丁昆朋

                        
    这篇文章是加紧赶出来“应付”日更，一方面不想要再晚睡了；另一方面不想失去日更达人的称号，只能坐下来匆忙写下一点文字。既然标题是成长，先来总结一下这段时间的收获：1、整理箱子站着可以看电脑，坐着反而是一种享受，减少了坐着腰酸背痛的现象；2、使用讯飞输入法大大增加自己的输出量；3、Anaconda+“pythontutor.com"+Google算是简单入门python；4、英语的阅读文章能力、听力提
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15）
                        知识分享小能手
大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
                        
    1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
    
                    
    • 
                    
  • 【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（二十八）
                        向往风的男子
k8s学习kubernetes容器
                        
    本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
    
                    
    • 
                    
  • Nginx从入门到实践(三)
                        听你讲故事啊

                        
    动静分离动静分离是将网站静态资源（JavaScript，CSS，img等文件）与后台应用分开部署，提高用户访问静态代码的速度，降低对后台应用访问。动静分离的一种做法是将静态资源部署在nginx上，后台项目部署到应用服务器上，根据一定规则静态资源的请求全部请求nginx服务器，达到动静分离的目标。rewrite规则Rewrite规则常见正则表达式Rewrite主要的功能就是实现URL的重写，Ngin
    
                    
    • 
                    
  • 【Python基础】Python迭代器与生成器（两种强大工具）
                        姑苏老陈
Python编程入门python开发语言python迭代器与生成器
                        
    本文收录于《Python编程入门》专栏，从零基础开始，分享一些Python编程基础知识，欢迎关注，谢谢！文章目录一、前言二、迭代器2.1创建迭代器2.2自定义迭代器2.3处理大型文件三、生成器四、生成器表达式五、实际应用案例5.1数据库查询5.2网络数据流处理六、总结一、前言在Python中，迭代器与生成器是两种非常强大的工具，它们可以帮助我们有效地处理大量数据，特别是在需要逐个访问元素的情况下。
    
                    
    • 
                                
  • 插入表主键冲突做更新
                                    a-john

                                    
    有以下场景： 
用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 
问题： 
如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 
解决： 
mysql中提供了一个sql语
    
                                
    • 
                                
  • Android xml资源文件中@、@android:type、@*、？、@+含义和区别
                                    Cb123456
@+@?@*
                                    
    一.@代表引用资源 
1.引用自定义资源。格式：@[package:]type/name 
android：text="@string/hello" 
  
2.引用系统资源。格式：@android:type/name 
    android:textColor="@android:color/opaque_red"
    
                                
    • 
                                
  • 数据结构的基本介绍
                                    天子之骄
数据结构散列表树、图线性结构价格标签
                                    
    数据结构的基本介绍 
数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。 
  
经典的数据结构大致如下： 
  
一：线性数据结构 
(1)：列表 
a
    
                                
    • 
                                
  • 通过二维码开放平台的API快速生成二维码
                                    一炮送你回车库
api
                                    
     现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。 
       html代码如下:(二维码将生成在这div下)    
?       1      
 &nbs
    
                                
    • 
                                
  • ImageIO读取一张图片改变大小
                                    3213213333332132
javaIOimageBufferedImage
                                    
    
package com.demo;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/**
 * @Description 读取一张图片改变大小
 * @author FuJianyon
    
                                
    • 
                                
  • myeclipse集成svn（一针见血）
                                    7454103
eclipseSVNMyEclipse
                                    
                                     &n
    
                                
    • 
                                
  • 装箱与拆箱----autoboxing和unboxing
                                    darkranger
J2SE
                                    
    4.2　自动装箱和拆箱 
 
基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 
 
4.2.1　autoboxing和unboxing 
 
在Java中，所有要处理的东西几乎都是对象(Object)
    
                                
    • 
                                
  • ajax传统的方式制作ajax
                                    aijuans
Ajax
                                    
    //这是前台的代码 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
    
                                
    • 
                                
  • 只用jre的eclipse是怎么编译java源文件的？
                                    avords
javaeclipsejdktomcat
                                    
    eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ 
&nb
    
                                
    • 
                                
  • 前端模块化
                                    bee1314
模块化
                                    
    背景：   前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。       JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
    
                                
    • 
                                
  • 处理百万级以上的数据处理
                                    bijian1013
oraclesql数据库大数据查询
                                    
    一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。 
        2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
    
                                
    • 
                                
  • mac 卸载 java 1.7 或更高版本
                                    征客丶
javaOS
                                    
    卸载 java 1.7 或更高 
sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 
成功执行此命令后，还可以执行 java 与 javac 命令 
 
sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 
成功执行此命令后，还可以执行 java 
    
                                
    • 
                                
  • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析
                                    bit1129
Stream
                                    
    第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 
第二部，Spark Streaming读取Kafka中的数据，进行实时分析 
  
本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 
1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
    
                                
    • 
                                
  • Erlang vs TNSDL
                                    bookjovi
erlang
                                    
      
    TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
    
                                
    • 
                                
  • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个
                                    ljy325
企业应用
                                    
    　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 
 
相关新闻： 
（1）IT行业成五大疾病重灾区：过劳死平均37.9岁 

    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-原型模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * Effective Java 建议使用copy constructor or copy factory来代替clone()方法：
 * 1.public Product copy(Product p){}
 * 2.publi
    
                                
    • 
                                
  • 配置管理---svn工具之权限配置
                                    chenyu19891124
SVN
                                    
    今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 
安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 
pepos 
   component 
   webapps 
在conf里面的auth里赋予的权限配置为 
[groups]
    
                                
    • 
                                
  • 浅谈程序员的数学修养
                                    comsci
设计模式编程算法面试招聘
                                    
             
                        浅谈程序员的数学修养 
    
                                
    • 
                                
  • 批量执行 bulk collect与forall用法
                                    daizj
oraclesqlbulk collectforall
                                    
    BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 
FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。 
    有关FORALL语句的用法请参考：批量SQL之 F
    
                                
    • 
                                
  • Linux下使用rsync最快速删除海量文件的方法
                                    dongwei_6688
OS
                                    
    1、先安装rsync：yum install rsync 
2、建立一个空的文件夹：mkdir /tmp/test 
3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。 

    
                                
    • 
                                
  • Yii CModel中rules验证规格
                                    dcj3sjt126com
rulesyiivalidate
                                    
    Yii cValidator主要用法分析：  
 yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError 
 
    
                                
    • 
                                
  • 基于vagrant的redis主从实验
                                    dcj3sjt126com
vagrant
                                    
    平台: Mac 
工具: Vagrant 
系统: Centos6.5 
实验目的: Redis主从 
  
实现思路 
制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box 
  
制作sentos6.5+redis的box 
  
mkdir vagrant_redis 
cd vagrant_
    
                                
    • 
                                
  • Memcached(二)、Centos安装Memcached服务器
                                    frank1234
centosmemcached
                                    
    一、安装gcc 
rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 
 
开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]：

建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码......


rpm -ivh kernel-head
    
                                
    • 
                                
  • Remove Duplicates from Sorted List
                                    hcx2013
remove
                                    
    Given a sorted linked list, delete all duplicates such that each element appear only once. 
For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
    
                                
    • 
                                
  • Spring4新特性——JSR310日期时间API的支持
                                    jinnianshilongnian
spring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • 浅谈enum与单例设计模式
                                    247687009
java单例
                                    
    在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构
造器，导出静态成员变量，以便调用者访问。

第一种 
package singleton;

public class Singleton {
        //导出全局成员
        public final static Singleton INSTANCE = new S
    
                                
    • 
                                
  • 使用switch条件语句需要注意的几点
                                    openwrt
cbreakswitch
                                    
    1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 
 
int main()
{
    int n = 1;
    switch(n) {
    case 1:
        printf("--1--\n");
    default:
        printf("defa
    
                                
    • 
                                
  • 配置Spring Mybatis JUnit测试环境的应用上下文
                                    schnell18
springmybatisJUnit
                                    
    Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 
 
 单元测试的app context不支持从外部properties文件注入属性 
 @Value注解不能解析带通配符的路径字符串 
 
解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 
第二个问题的具体实例是： 
   
    
                                
    • 
                                
  • Java 定时任务总结一
                                    tuoni
javaspringtimerquartztimertask
                                    
     Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
    
                                
    • 
                                
  • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法
                                    yangshangchuan
rank相似度计算文本相似度词袋模型余弦相似度
                                    
    本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。 
  
最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下： 
    1、注册多个账号（一般10个以上）。 
    2、从多个账号中选择一个账号，发表1-2篇博文
    
                                
    •