nidongla
nidongla

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。

一、前言

购物优惠券 https://m.cqfenfa.com/

　　说实话，写这个玩意儿是我上周刚刚产生的想法，本想写完后把代码挂上来赚点积分也不错。写完后发现这东西值得写一篇文章，授人予鱼不如授人以渔嘛（这句话是这么说的吧），顺便赚点应届学生MM的膜拜那就更妙了。然后再挂一个收款二维码，一个人1块钱，一天10000个人付款，一个月30万，一年360万。。。可了不得了，离一个亿的小目标就差几十年了。

　　不知道博客园对梦话有没有限制，有的话请告知，我会尽快删除上述文字。

　　那么现在回到现实中，这篇博文如果能有>2个评论，我后续会再出一个Netty相关的专栏。否则，就不出了。有人会好奇，为什么把阈值定义成>2呢？不为什么，因为我肯定会先用我媳妇儿的号留个言，然后用自己的号留个言。

　　好了，废话不多说了，后面还有好多事儿呢，洗菜、做饭、刷碗、跪搓衣。。。好了，言归正传吧。

二、最终效果

　　为什么先看最终效果？因为此刻代码已经撸完了。更重要的是我们带着感官的目标去进行后续的分析，可以更好地理解。标题中提到了，整个工程包含三个部分：

1、聊天服务器

　　聊天服务器的职责一句话解释：负责接收所有用户发送的消息，并将消息转发给目标用户。

　　聊天服务器没有任何界面，但是却是IM中最重要的角色，为表达敬意，必须要给它放个效果图：

 

2021-05-11 10:41:40.037  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700900029,"messageType":"99"}
2021-05-11 10:41:50.049  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.n.handler.BussMessageHandler     : 收到消息：{"time":1620700910045,"messageType":"14","sendUserName":"guodegang","recvUserName":"yuqian","sendMessage":"于老师你好"}
2021-05-11 10:41:50.055  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.executor.SendMsgExecutor   : 消息转发成功:{"time":1620700910052,"messageType":"14","sendUserName":"guodegang","recvUserName":"yuqian","sendMessage":"于老师你好"}
2021-05-11 10:41:54.068  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700914064,"messageType":"99"}
2021-05-11 10:41:57.302  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.n.handler.BussMessageHandler     : 收到消息：{"time":1620700917301,"messageType":"14","sendUserName":"yuqian","recvUserName":"guodegang","sendMessage":"郭老师你好"}
2021-05-11 10:41:57.304  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.executor.SendMsgExecutor   : 消息转发成功:{"time":1620700917303,"messageType":"14","sendUserName":"yuqian","recvUserName":"guodegang","sendMessage":"郭老师你好"}
2021-05-11 10:42:05.050  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700925049,"messageType":"99"}
2021-05-11 10:42:12.309  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700932304,"messageType":"99"}
2021-05-11 10:42:20.066  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700940050,"messageType":"99"}
2021-05-11 10:42:27.311  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700947309,"messageType":"99"}
2021-05-11 10:42:35.070  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700955068,"messageType":"99"}
2021-05-11 10:42:42.316  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700962312,"messageType":"99"}
2021-05-11 10:42:50.072  INFO 9392 --- [ntLoopGroup-3-1] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700970071,"messageType":"99"}
2021-05-11 10:42:57.316  INFO 9392 --- [ntLoopGroup-3-2] c.e.o.s.netty.handler.HeartBeatHandler   : server收到心跳包：{"time":1620700977315,"messageType":"99"}

　　从效果图我们看到了一些内容：收到心跳包、收到消息，转发消息，这些内容后面会详细讲解。

2、聊天客户端

　　聊天客户端的职责一句话解释：登陆，给别人发聊天内容，收其它人发给自己的聊天内容。

　　下面为方便演示，我会打开两个客户端，用两个不同用户登陆，然后发消息。

 实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第1张图片

3、Web管理控制台

　　目前只做了一个账户管理，具体看图吧：

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第2张图片

三、需求分析

　　无（见第二章节）。

四、概要设计

1、技术选型

1）聊天服务端

　　聊天服务器与客户端通过TCP协议进行通信，使用长连接、全双工通信模式，基于经典通信框架Netty实现。

　　那么什么是长连接？顾名思义，客户端和服务器连上后，会在这条连接上面反复收发消息，连接不会断开。与长连接对应的当然就是短连接了，短连接每次发消息之前都需要先建立连接，然后发消息，最后断开连接。显然，即时聊天适合使用长连接。

　　那么什么又是全双工？当长连接建立起来后，在这条连接上既有上行的数据，又有下行的数据，这就叫全双工。那么对应的半双工、单工，大家自行百度吧。

2）Web管理控制台

　　Web管理端使用SpringBoot脚手架，前端使用Layuimini（一个基于Layui前端框架封装的前端框架），后端使用SpringMVC+Jpa+Shiro。

3）聊天客户端

　　使用SpringBoot+JavaFX，做了一个极其简陋的客户端，JavaFX是一个开发Java桌面程序的框架，本人也是第一次使用，代码中的写法都是网上查的，这并不是本文的重点，有兴趣的仔细百度吧。

4）SpringBoot

　　以上三个组件，全部以SpringBoot做为脚手架开发。

5）代码构建

　　Maven。

2、数据库设计

　　我们只简单用到一张用户表，比较简单直接贴脚本：

CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` varchar(64) DEFAULT NULL COMMENT '用户名：登陆账号',
  `pass_word` varchar(128) DEFAULT NULL COMMENT '密码',
  `name` varchar(16) DEFAULT NULL COMMENT '昵称',
  `sex` char(1) DEFAULT NULL COMMENT '性别:1-男，2女',
  `status` bit(1) DEFAULT NULL COMMENT '用户状态：1-有效，0-无效',
  `online` bit(1) DEFAULT NULL COMMENT '在线状态：1-在线，0-离线',
  `salt` varchar(128) DEFAULT NULL COMMENT '密码盐值',
  `admin` bit(1) DEFAULT NULL COMMENT '是否管理员（只有管理员才能登录Web端）：1-是，0-否',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

　　这张表都在什么时候用到？

　　1）Web管理端登陆的时候；2）聊天客户端将登陆请求发送到聊天服务端时，聊天服务端进行用户认证；3）聊天客户端的好友列表加载。

3、通信设计

　　本节将会是本文的核心内容之一，主要描述通信报文协议格式、以及通信报文的交互场景。

1）报文协议格式

　　下面这张图应该能说明99%了：

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第3张图片

　　剩下的1%在这里说：

　　a）粘包问题，TCP长连接中，粘包是第一个需要解决的问题。通俗的讲，粘包的意思是消息接收方往往收到的不是“整个”报文，有时候比“整个”多一点，有时候比“整个”少一点，这样就导致接收方无法解析这个报文。那么上图中的头8个字节就为了解决这个问题，接收方根据头8个字节标识的长度来获取到“整个”报文，从而进行正常的业务处理；

　　b）2字节报文类型，为了方便解析报文而设计。根据这两个字节将后面的json转成相应的实体以便进行后续处理；

　　c）变长报文体实际上就是json格式的串，当然，你可以自己设计报文格式，我这里为了方便处理就直接放json了；

　　d）当然，你可以把报文设计的更复杂、更专业，比如加密、加签名等。

2）报文交互场景

　　a）登陆

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第4张图片

　　b）发送消息-成功

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第5张图片

　　c）发送消息-目标客户端不在线

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第6张图片

　　d）发送消息-目标客户端在线，但消息转发失败

实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。_第7张图片

五、编码实现

　　前面说了那么多，现在总得说点有用的。

1、先说说Netty

　　Netty是一个相当优秀的通信框架，大多数的顶级开源框架中都有Netty的身影。具体它有多么优秀，建议大家自行百度，我不如百度说的好。我只从应用方面说说Netty。应用过程中，它最核心的东西叫handler，我们可以简单理解它为消息处理器。收到的消息和出去的消息都会经过一系列的handler加工处理。收到的消息我们叫它入站消息，发出去的消息我们叫它出站消息，因此handler又分为出站handler和入站handler。收到的消息只会被入站handler处理，发出去的消息只会被出站handler处理。

　　举个例子，我们从网络上收到的消息是二进制的字节码，我们的目标是将消息转换成java bean，这样方便我们程序处理，针对这个场景我设计这么几个入站handler：

　　1）将字节转换成String的handler；

　　2）将String转成java bean的handler；

　　3）对java bean进行业务处理的handler。

　　发出去的消息呢，我设计这么几个出站handler：

　　1）java bean 转成String的handler；

　　2）String转成byte的handler。

　　以上是关于handler的说明。

　　接下来再说一下Netty的异步。异步的意思是当你做完一个操作后，不会立马得到操作结果，而是有结果后Netty会通知你。通过下面的一段代码来说明：

channel.writeAndFlush(sendMsgRequest).addListener(new GenericFutureListenersuper Void>>() {
                @Override
                public void operationComplete(Futuresuper Void> future) throws Exception {
                    if (future.isSuccess()){
                        logger.info("消息发送成功:{}",sendMsgRequest);
                    }else {
                        logger.info("消息发送失败:{}",sendMsgRequest);
                    }
                }
            });

　　上面的writeAndFlush操作无法立即返回结果，如果你关注结果，那么为他添加一个listener，有结果后会在listener中响应。

　　到这里，百度上搜到的Netty相关的代码你基本就能看懂了。

2、聊天服务端

　　首先看主入口的代码

public void start(){
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(boss, worker)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)
                .handler(new LoggingHandler(LogLevel.INFO))
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //心跳
                        ch.pipeline().addLast(new IdleStateHandler(25, 20, 0, TimeUnit.SECONDS));
                        //收整包
                        ch.pipeline().addLast(new StringLengthFieldDecoder());
                        //转字符串
                        ch.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8")));
                        //json转对象
                        ch.pipeline().addLast(new JsonDecoder());
                        //心跳
                        ch.pipeline().addLast(new HeartBeatHandler());
                        //实体转json
                        ch.pipeline().addLast(new JsonEncoder());
                        //消息处理
                        ch.pipeline().addLast(bussMessageHandler);
                    }
                });
        try {
            ChannelFuture f = serverBootstrap.bind(port).sync();
            f.channel().closeFuture().sync();
        }catch (InterruptedException e) {
            logger.error("服务启动失败：{}", ExceptionUtils.getStackTrace(e));
        }finally {
            worker.shutdownGracefully();
            boss.shutdownGracefully();
        }
    }

　　代码中除了initChannel方法中的代码，其他代码都是固定写法。那么什么叫固定写法呢？通俗来讲就是可以Ctrl+c、Ctrl+v。

　　下面我们着重看initChannel方法里面的代码。这里面就是上面讲到的各种handler，我们下面挨个讲这些handler都是干啥的。

　　1）IdleStateHandler。这个是Netty内置的一个handler，既是出站handler又是入站handler。它的作用一般是用来实现心跳监测。所谓心跳，就是客户端和服务端建立连接后，服务端要实时监控客户端的健康状态，如果客户端挂了或者hung住了，服务端及时释放相应的资源，以及做出其他处理比如通知运维。所以在我们的场景中，客户端需要定时上报自己的心跳，如果服务端检测到一段时间内没收到客户端上报的心跳，那么及时做出处理，我们这里就是简单的将其连接断开，并修改数据库中相应账户的在线状态。

　　现在开始说IdleStateHandler，第一个参数叫读超时时间，第二个参数叫写超时时间，第三个参数叫读写超时时间，第四个参数时时间单位秒。这个handler表达的意思是当25秒内没读到客户端的消息，或者20秒内没往客户端发消息，就会产生一个超时事件。那么这个超时事件我们该对他做什么处理呢，请看下一条。

　　2）HeartBeatHandler。结合a）一起看，当发生超时事件时，HeartBeatHandler会收到这个事件，并对它做出处理：第一将链接断开；第二讲数据库中相应的账户更新为不在线状态。

public class HeartBeatHandler extends ChannelInboundHandlerAdapter {
    private static Logger logger = LoggerFactory.getLogger(HeartBeatHandler.class);

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent){
            IdleStateEvent event = (IdleStateEvent)evt;
            if (event.state() == IdleState.READER_IDLE) {
                //读超时，应将连接断掉
                InetSocketAddress socketAddress = (InetSocketAddress)ctx.channel().remoteAddress();
                String ip = socketAddress.getAddress().getHostAddress();
                ctx.channel().disconnect();
                logger.info("【{}】连接超时，断开",ip);
                String userName = SessionManager.removeSession(ctx.channel());
                SpringContextUtil.getBean(UserService.class).updateOnlineStatus(userName,Boolean.FALSE);
            }else {
                super.userEventTriggered(ctx, evt);
            }
        }else {
            super.userEventTriggered(ctx, evt);
        }

    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof HeartBeat){
            //收到心跳包，不处理
            logger.info("server收到心跳包：{}",msg);
            return;
        }
        super.channelRead(ctx, msg);
    }
}

　　3）StringLengthFieldDecoder。这是个入站handler，他的作用就是解决上面提到的粘包问题：

public class StringLengthFieldDecoder extends LengthFieldBasedFrameDecoder {
    public StringLengthFieldDecoder() {
        super(10*1024*1024,0,8,0,8);
    }


    @Override
    protected long getUnadjustedFrameLength(ByteBuf buf, int offset, int length, ByteOrder order) {
        buf = buf.order(order);
        byte[] lenByte = new byte[length];
        buf.getBytes(offset, lenByte);
        String lenStr = new String(lenByte);
        Long len =  Long.valueOf(lenStr);
        return len;
    }
}

　　只需要集成Netty提供的LengthFieldBasedFrameDecoder 类，并重写getUnadjustedFrameLength方法即可。

　　首先看构造方法中的5个参数。第一个表示能处理的包的最大长度；第二三个参数应该结合起来理解，表示长度字段从第几位开始，长度的长度是多少，也就是上面报文格式协议中的头8个字节；第四个参数表示长度是否需要校正，举例理解，比如头8个字节解析出来的长度=包体长度+头8个字节的长度，那么这里就需要校正8个字节，我们的协议中长度只包含报文体，因此这个参数填0；最后一个参数，表示接收到的报文是否要跳过一些字节，本例中设置为8，表示跳过头8个字节，因此经过这个handler后，我们收到的数据就只有报文本身了，不再包含8个长度字节了。

　　再看getUnadjustedFrameLength方法，其实就是将头8个字符串型的长度为转换成long型。重写完这个方法后，Netty就知道如何收一个“完整”的数据包了。

　　4）StringDecoder。这个是Netty自带的入站handler，会将字节流以指定的编码解析成String。

　　5）JsonDecoder。是我们自定义的一个入站handler，目的是将json String转换成java bean，以方便后续处理：

public class JsonDecoder extends MessageToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, String o, List list) throws Exception {
        Message msg = MessageEnDeCoder.decode(o);
        list.add(msg);
    }

} 
         
　　这里会调用我们自定义的一个编解码帮助类进行转换：
 
         
 
          
public static Message decode(String message){
        if (StringUtils.isEmpty(message) || message.length() < 2){
            return null;
        }
        String type = message.substring(0,2);
        message = message.substring(2);
        if (type.equals(LoginRequest)){
            return JsonUtil.jsonToObject(message,LoginRequest.class);
        }else if (type.equals(LoginResponse)){
            return JsonUtil.jsonToObject(message,LoginResponse.class);
        }else if (type.equals(LogoutRequest)){
            return JsonUtil.jsonToObject(message,LogoutRequest.class);
        }else if (type.equals(LogoutResponse)){
            return JsonUtil.jsonToObject(message,LogoutResponse.class);
        }else if (type.equals(SendMsgRequest)){
            return JsonUtil.jsonToObject(message,SendMsgRequest.class);
        }else if (type.equals(SendMsgResponse)){
            return JsonUtil.jsonToObject(message,SendMsgResponse.class);
        }else if (type.equals(HeartBeat)){
            return JsonUtil.jsonToObject(message,HeartBeat.class);
        }
        return null;
    }
 
          
　　6）BussMessageHandler。先看这个入站handler，是我们的一个业务处理主入口，他的主要工作就是将消息分发给线程池去处理，另外还负载一个小场景，当客户端主动断开时，需要将相应的账户数据库中状态更新为不在线。
 
          
 
           
public class BussMessageHandler extends ChannelInboundHandlerAdapter {
    private static Logger logger = LoggerFactory.getLogger(BussMessageHandler.class);

    @Autowired
    private TaskDispatcher taskDispatcher;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        logger.info("收到消息：{}",msg);
        if (msg instanceof Message){
            taskDispatcher.submit(ctx.channel(),(Message)msg);
        }
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        //客户端连接断开
        InetSocketAddress socketAddress = (InetSocketAddress)ctx.channel().remoteAddress();
        String ip = socketAddress.getAddress().getHostAddress();
        logger.info("客户端断开：{}",ip);
        String userName = SessionManager.removeSession(ctx.channel());
        SpringContextUtil.getBean(UserService.class).updateOnlineStatus(userName,Boolean.FALSE);
        super.channelInactive(ctx);
    }
}
 
           
　　接下来还差线程池的处理逻辑，也非常简单，就是将任务封装成executor然后交给线程池处理：
 
           
 
            
public class TaskDispatcher {
    private ThreadPoolExecutor threadPool;

    public TaskDispatcher(){
        int corePoolSize = 15;
        int maxPoolSize = 50;
        int keepAliveSeconds = 30;
        int queueCapacity = 1024;
        BlockingQueue queue = new LinkedBlockingQueue<>(queueCapacity);
        this.threadPool = new ThreadPoolExecutor(
                corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
                queue);
    }

    public void submit(Channel channel, Message msg){
        ExecutorBase executor = null;
        String messageType = msg.getMessageType();
        if (messageType.equals(MessageEnDeCoder.LoginRequest)){
            executor = new LoginExecutor(channel,msg);
        }
        if (messageType.equalsIgnoreCase(MessageEnDeCoder.SendMsgRequest)){
            executor = new SendMsgExecutor(channel,msg);
        }
        if (executor != null){
            this.threadPool.submit(executor);
        }
    }
}
 
 
            
　　接下来看一下消息转发executor是怎么做的：
 
            
 
             
public class SendMsgExecutor extends ExecutorBase {
    private static Logger logger = LoggerFactory.getLogger(SendMsgExecutor.class);

    public SendMsgExecutor(Channel channel, Message message) {
        super(channel, message);
    }

    @Override
    public void run() {
        SendMsgResponse response = new SendMsgResponse();
        response.setMessageType(MessageEnDeCoder.SendMsgResponse);
        response.setTime(new Date());
        SendMsgRequest request = (SendMsgRequest)message;
        String recvUserName = request.getRecvUserName();
        String sendContent = request.getSendMessage();
        Channel recvChannel = SessionManager.getSession(recvUserName);
        if (recvChannel != null){
            SendMsgRequest sendMsgRequest = new SendMsgRequest();
            sendMsgRequest.setTime(new Date());
            sendMsgRequest.setMessageType(MessageEnDeCoder.SendMsgRequest);
            sendMsgRequest.setRecvUserName(recvUserName);
            sendMsgRequest.setSendMessage(sendContent);
            sendMsgRequest.setSendUserName(request.getSendUserName());
            recvChannel.writeAndFlush(sendMsgRequest).addListener(new GenericFutureListenersuper Void>>() {
                @Override
                public void operationComplete(Futuresuper Void> future) throws Exception {
                    if (future.isSuccess()){
                        logger.info("消息转发成功:{}",sendMsgRequest);
                        response.setResultCode("0000");
                        response.setResultMessage(String.format("发给用户[%s]消息成功",recvUserName));
                        channel.writeAndFlush(response);
                    }else {
                        logger.error(ExceptionUtils.getStackTrace(future.cause()));
                        logger.info("消息转发失败:{}",sendMsgRequest);
                        response.setResultCode("9999");
                        response.setResultMessage(String.format("发给用户[%s]消息失败",recvUserName));
                        channel.writeAndFlush(response);
                    }
                }
            });
        }else {
            logger.info("用户{}不在线，消息转发失败",recvUserName);
            response.setResultCode("9999");
            response.setResultMessage(String.format("用户[%s]不在线",recvUserName));
            channel.writeAndFlush(response);
        }
    }
}
 
             
　　整体逻辑：一获取要把消息发给那个账号；二获取该账号对应的连接；三在此连接上发送消息；四获取消息发送结果，将结果发给消息“发起者”。
 
             
　　下面是登陆处理的executor：
 
             
 
              
public class LoginExecutor extends ExecutorBase {
    private static Logger logger = LoggerFactory.getLogger(LoginExecutor.class);

    public LoginExecutor(Channel channel, Message message) {
        super(channel, message);
    }
    @Override
    public void run() {
        LoginRequest request = (LoginRequest)message;
        String userName = request.getUserName();
        String password = request.getPassword();
        UserService userService = SpringContextUtil.getBean(UserService.class);
        boolean check = userService.checkLogin(userName,password);
        LoginResponse response = new LoginResponse();
        response.setUserName(userName);
        response.setMessageType(MessageEnDeCoder.LoginResponse);
        response.setTime(new Date());
        response.setResultCode(check?"0000":"9999");
        response.setResultMessage(check?"登陆成功":"登陆失败，用户名或密码错");
        if (check){
            userService.updateOnlineStatus(userName,Boolean.TRUE);
            SessionManager.addSession(userName,channel);
        }
        channel.writeAndFlush(response).addListener(new GenericFutureListenersuper Void>>() {
            @Override
            public void operationComplete(Futuresuper Void> future) throws Exception {
                //登陆失败，断开连接
                if (!check){
                    logger.info("用户{}登陆失败，断开连接",((LoginRequest) message).getUserName());
                    channel.disconnect();
                }
            }
        });
    }
}
 
              
　　登陆逻辑也不复杂，登陆成功则更新用户在线状态，并且无论登陆成功还是失败，都会返一个登陆应答。同时，如果登陆校验失败，在返回应答成功后，需要将链接断开。
 
              
　　7）JsonEncoder。最后看这个唯一的出站handler，服务端发出去的消息都会被出站handler处理，他的职责就是将java bean转成我们之前定义的报文协议格式：
 
              
 
               
public class JsonEncoder extends MessageToByteEncoder {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Message message, ByteBuf byteBuf) throws Exception {
        String msgStr = MessageEnDeCoder.encode(message);
        int length = msgStr.getBytes(Charset.forName("UTF-8")).length;
        String str = String.valueOf(length);
        String lenStr = StringUtils.leftPad(str,8,'0');
        msgStr = lenStr + msgStr;
        byteBuf.writeBytes(msgStr.getBytes("UTF-8"));
    }
}
 
               
　　8）SessionManager。剩下最后一个东西没说，这个是用来保存每个登陆成功账户的链接的，底层是个map，key为用户账户，value为链接：
 
               
 
                
public class SessionManager {
    private static ConcurrentHashMap sessionMap = new ConcurrentHashMap<>();

    public static void addSession(String userName,Channel channel){
        sessionMap.put(userName,channel);
    }

    public static String removeSession(String userName){
        sessionMap.remove(userName);
        return userName;
    }

    public static String removeSession(Channel channel){
        for (String key:sessionMap.keySet()){
            if (channel.id().asLongText().equalsIgnoreCase(sessionMap.get(key).id().asLongText())){
                sessionMap.remove(key);
                return key;
            }
        }
        return null;
    }

    public static Channel getSession(String userName){
        return sessionMap.get(userName);
    }
}
 
                
　　到这里，整个服务端的逻辑就走完了，是不是，很简单呢！
 
                
3、聊天客户端
 
                
　　客户端中界面相关的东西是基于JavaFX框架做的，这个我是第一次用，所以不打算讲这块，怕误导大家。主要还是讲Netty作为客户端是如何跟服务端通信的。
 
                
　　按照惯例，还是先贴出主入口：
 
                
 
                 
public void login(String userName,String password) throws Exception {
        Bootstrap clientBootstrap = new Bootstrap();
        EventLoopGroup clientGroup = new NioEventLoopGroup();
        try {
            clientBootstrap.group(clientGroup)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,10000);
            clientBootstrap.handler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new IdleStateHandler(20, 15, 0, TimeUnit.SECONDS));
                    ch.pipeline().addLast(new StringLengthFieldDecoder());
                    ch.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8")));
                    ch.pipeline().addLast(new JsonDecoder());
                    ch.pipeline().addLast(new JsonEncoder());
                    ch.pipeline().addLast(bussMessageHandler);
                    ch.pipeline().addLast(new HeartBeatHandler());
                }
            });
            ChannelFuture future = clientBootstrap.connect(server,port).sync();
            if (future.isSuccess()){
                channel = (SocketChannel)future.channel();
                LoginRequest request = new LoginRequest();
                request.setTime(new Date());
                request.setUserName(userName);
                request.setPassword(password);
                request.setMessageType(MessageEnDeCoder.LoginRequest);
                channel.writeAndFlush(request).addListener(new GenericFutureListenersuper Void>>() {
                    @Override
                    public void operationComplete(Futuresuper Void> future) throws Exception {
                        if (future.isSuccess()){
                            logger.info("登陆消息发送成功");
                        }else {
                            logger.info("登陆消息发送失败：{}", ExceptionUtils.getStackTrace(future.cause()));
                            Platform.runLater(new Runnable() {
                                @Override
                                public void run() {
                                    LoginController.setLoginResult("网络错误，登陆消息发送失败");
                                }
                            });
                        }
                    }
                });
            }else {
                clientGroup.shutdownGracefully();
                throw new RuntimeException("网络错误");
            }
        }catch (Exception e){
            clientGroup.shutdownGracefully();
            throw new RuntimeException("网络错误");
        }
    }
 
                 
　　对这段代码，我们主要关注这几点：一所有handler的初始化；二connect服务端。
 
                 
　　所有handler中，除了bussMessageHandler是客户端特有的外，其他的handler在服务端章节已经讲过了，不再赘述。
 
                 
　　1）先看连接服务端的操作。首先发起连接，连接成功后发送登陆报文。发起连接需要对成功和失败进行处理。发送登陆报文也需要对成功和失败进行处理。注意，这里的成功失败只是代表当前操作的网络层面的成功失败，这时候并不能获取服务端返回的应答中的业务层面的成功失败，如果不理解这句话，可以翻看前面讲过的“异步”相关内容。
 
                 
　　2）BussMessageHandler。整体流程还是跟服务端一样，将受到的消息扔给线程池处理，我们直接看处理消息的各个executor。
 
                 
　　先看客户端发出登陆请求后，收到登陆应答消息后是怎么处理的（这段代码可以结合1）的内容一起理解）：
 
                 
 
                  
public class LoginRespExecutor extends ExecutorBase {
    private static Logger logger = LoggerFactory.getLogger(LoginRespExecutor.class);

    public LoginRespExecutor(Channel channel, Message message) {
        super(channel, message);
    }

    @Override
    public void run() {
        LoginResponse response = (LoginResponse)message;
        logger.info("登陆结果：{}->{}",response.getResultCode(),response.getResultMessage());
        if (!response.getResultCode().equals("0000")){
            Platform.runLater(new Runnable() {
                @Override
                public void run() {
                    LoginController.setLoginResult("登陆失败，用户名或密码错误");
                }
            });
        }else {
            LoginController.setCurUserName(response.getUserName());
            ClientApplication.getScene().setRoot(SpringContextUtil.getBean(MainView.class).getView());
        }
    }
}
 
                  
　　接下来看客户端是怎么发聊天信息的：
 
                  
 
                   
public void sendMessage(Message message) {
        channel.writeAndFlush(message).addListener(new GenericFutureListenersuper Void>>() {
            @Override
            public void operationComplete(Futuresuper Void> future) throws Exception {
                SendMsgRequest send = (SendMsgRequest)message;
                if (future.isSuccess()){
                    Platform.runLater(new Runnable() {
                        @Override
                        public void run() {
                            MainController.setMessageHistory(String.format("[我]在[%s]发给[%s]的消息[%s]，发送成功",
                                    DateFormatUtils.format(send.getTime(),"yyyy-MM-dd HH:mm:ss"),send.getRecvUserName(),send.getSendMessage()));
                        }
                    });
                }else {
                    Platform.runLater(new Runnable() {
                        @Override
                        public void run() {
                            MainController.setMessageHistory(String.format("[我]在[%s]发给[%s]的消息[%s]，发送失败",
                                    DateFormatUtils.format(send.getTime(),"yyyy-MM-dd HH:mm:ss"),send.getRecvUserName(),send.getSendMessage()));
                        }
                    });
                }
            }
        });
    }
 
                   
　　实际上，到这里通信相关的代码已经贴完了。剩下的都是界面处理相关的代码，不再贴了。
 
                   
　　客户端，是不是，非常简单！
 
                   
4、Web管理端
 
                   
　　Web管理端可以说是更没任何技术含量，就是Shiro登陆认证、列表增删改查。增删改没什么好说的，下面重点说一下Shiro登陆和列表查询。
 
                   
　　1）Shiro登陆
 
                   
　　首先定义一个Realm，至于这是什么概念，自行百度吧，这里并不是本文重点：
 
                   
 
                    
public class UserDbRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        
        UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
        String username = upToken.getUsername();
        String password = "";
        if (upToken.getPassword() != null)
        {
            password = new String(upToken.getPassword());
        }
        // TODO: 2021/5/13 校验用户名密码，不通过则抛认证异常即可 
        ShiroUser user = new ShiroUser();
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, getName());
        return info;
    }
}
 
                    
　　接下来把这个Realm注册成Spring Bean，同时定义过滤链：
 
                    
 
                     
    @Bean
    public Realm realm() {
        UserDbRealm realm = new UserDbRealm();
        realm.setAuthorizationCachingEnabled(true);
        realm.setCacheManager(cacheManager());
        return realm;
    }
    
    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
        chainDefinition.addPathDefinition("/css/**", "anon");
        chainDefinition.addPathDefinition("/img/**", "anon");
        chainDefinition.addPathDefinition("/js/**", "anon");
        chainDefinition.addPathDefinition("/logout", "logout");
        chainDefinition.addPathDefinition("/login", "anon");
        chainDefinition.addPathDefinition("/captchaImage", "anon");
        chainDefinition.addPathDefinition("/**", "authc");
        return chainDefinition;
    }
 
                     
　　到现在为止，Shiro配置好了，下面看如何调起登陆：
 
                     
 
                      
    @PostMapping("/login")
    @ResponseBody
    public Result login(String username, String password, Boolean rememberMe)
    {
        Result ret = new Result<>();
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        Subject subject = SecurityUtils.getSubject();
        try
        {
            subject.login(token);
            return ret;
        }
        catch (AuthenticationException e)
        {
            String msg = "用户或密码错误";
            if (StringUtils.isNotEmpty(e.getMessage()))
            {
                msg = e.getMessage();
            }
            ret.setCode(Result.FAIL);
            ret.setMessage(msg);
            return ret;
        }
    }
 
                      
　　登陆代码就这么愉快的完成了。
 
                      
　　2）列表查询
 
                      
　　查是个很简单的操作，但是却是所有web系统中使用最频繁的操作。因此，做一个通用性的封装，非常有必要。以下代码不做过多讲解，初级工程师到高级工程师，就差这段代码了（手动捂脸）：
 
                      
　　a）Controller
 
                      
 
                       
    @RequestMapping("/query")
    @ResponseBody
    public Result> query(@RequestParam Map params, String sort, String order, Integer pageIndex, Integer pageSize){
        Page page = userService.query(params,sort,order,pageIndex,pageSize);
        Result> ret = new Result<>();
        ret.setData(page);
        return ret;
    }
 
                       
　　b）Service
 
                       
 
                        
    @Autowired
    private UserDao userDao;
    @Autowired
    private QueryService queryService;

    public Page query(Map params, String sort, String order, Integer pageIndex, Integer pageSize){
        return queryService.query(userDao,params,sort,order,pageIndex,pageSize);
    }
 
                        
 
                         
public class QueryService {
    public  com.easy.okim.common.model.Page query(JpaSpecificationExecutor dao, Map filters, String sort, String order, Integer pageIndex, Integer pageSize){
        com.easy.okim.common.model.Page ret = new com.easy.okim.common.model.Page();
        Map params = new HashMap<>();
        if (filters != null){
            filters.remove("sort");
            filters.remove("order");
            filters.remove("pageIndex");
            filters.remove("pageSize");
            for (String key:filters.keySet()){
                Object value = filters.get(key);
                if (value != null && StringUtils.isNotEmpty(value.toString())){
                    params.put(key,value);
                }
            }
        }
        Pageable pageable = null;
        pageIndex = pageIndex - 1;
        if (StringUtils.isEmpty(sort)){
            pageable = PageRequest.of(pageIndex,pageSize);
        }else {
            Sort s = Sort.by(Sort.Direction.ASC,sort);
            if (StringUtils.isNotEmpty(order) && order.equalsIgnoreCase("desc")){
                s = Sort.by(Sort.Direction.DESC,sort);
            }
            pageable = PageRequest.of(pageIndex,pageSize,s);
        }
        Page page = null;
        if (params.size() ==0){
            page = dao.findAll(null,pageable);
        }else {
            Specification specification = new Specification() {
                @Override
                public Predicate toPredicate(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder builder) {
                    List predicates = new ArrayList<>();
                    for (String filter : params.keySet()) {
                        Object value = params.get(filter);
                        if (value == null || StringUtils.isEmpty(value.toString())) {
                            continue;
                        }
                        String field = filter;
                        String operator = "=";
                        String[] arr = filter.split("\|");
                        if (arr.length == 2) {
                            field = arr[0];
                            operator = arr[1];
                        }
                        if (arr.length == 3) {
                            field = arr[0];
                            operator = arr[1];
                            String type = arr[2];
                            if (type.equalsIgnoreCase("boolean")){
                                value = Boolean.parseBoolean(value.toString());
                            }else if (type.equalsIgnoreCase("integer")){
                                value = Integer.parseInt(value.toString());
                            }else if (type.equalsIgnoreCase("long")){
                                value = Long.parseLong(value.toString());
                            }
                        }
                        String[] names = StringUtils.split(field, ".");
                        Path expression = root.get(names[0]);
                        for (int i = 1; i < names.length; i++) {
                            expression = expression.get(names[i]);
                        }
                        // logic operator
                        switch (operator) {
                            case "=":
                                predicates.add(builder.equal(expression, value));
                                break;
                            case "!=":
                                predicates.add(builder.notEqual(expression, value));
                                break;
                            case "like":
                                predicates.add(builder.like(expression, "%" + value + "%"));
                                break;
                            case ">":
                                predicates.add(builder.greaterThan(expression, (Comparable) value));
                                break;
                            case "<":
                                predicates.add(builder.lessThan(expression, (Comparable) value));
                                break;
                            case ">=":
                                predicates.add(builder.greaterThanOrEqualTo(expression, (Comparable) value));
                                break;
                            case "<=":
                                predicates.add(builder.lessThanOrEqualTo(expression, (Comparable) value));
                                break;
                            case "isnull":
                                predicates.add(builder.isNull(expression));
                                break;
                            case "isnotnull":
                                predicates.add(builder.isNotNull(expression));
                                break;
                            case "in":
                                CriteriaBuilder.In in = builder.in(expression);
                                String[] arr1 = StringUtils.split(filter.toString(), ",");
                                for (String e : arr1) {
                                    in.value(e);
                                }
                                predicates.add(in);
                                break;
                        }
                    }

                    // 将所有条件用 and 联合起来
                    if (!predicates.isEmpty()) {
                        return builder.and(predicates.toArray(new Predicate[predicates.size()]));
                    }
                    return builder.conjunction();
                }
            };
            page = dao.findAll(specification,pageable);
        }
        ret.setTotal(page.getTotalElements());
        ret.setRows(page.getContent());
        return ret;
    }
}
 
                         
　　c）Dao
 
                         
 
                          
public interface UserDao extends JpaRepository,JpaSpecificationExecutor {
    //啥都不用写，继承Spring Data Jpa提供的类就行了
}
 
                          
五、结语
 
                          
　　虽然标题起的有些哗众取宠了，但内容也确实都是实实在在的干货，希望本文能对大家有一些帮助，源代码工程不打算贴了，希望你能跟着文章自己手敲一遍。
 
                          
　　开头说的收款二维码，只是说笑，如果你真想付款，请私信我索取收款二维码，金额不设上限的哈哈。
 
                          
　　欢迎阅读，欢迎转载，转载请注明出处，求你了。
 
                         
 
                        
 
                       
 
                      
 
                     
 
                    
 
                   
 
                  
 
                 
 
                
 
               
 
              
 
             
 
            
 
           
 
          
 
         
 
         
        
       
      
     
    
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(实战即时聊天，一文说明白：聊天服务器+聊天客户端+Web管理控制台。)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                                
  • java Illegal overloaded getter method with ambiguous type for propert的解决
                                    zwllxs
javajdk
                                    
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 
 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
    
                                
    • 
                                
  • IT人应当知道的10个行业小内幕
                                    beijingjava
工作互联网
                                    
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 
　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 
　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
    
                                
    • 
                                
  • java 实现自定义链表
                                    CrazyMizzz
java数据结构
                                    
    1.链表结构 
 
  链表是链式的结构 
 
 
2.链表的组成 
 
   链表是由头节点，中间节点和尾节点组成 
 
   节点是由两个部分组成： 
 
      1.数据域 
      2.引用域 
 
 
3.链表的实现 
 
&nbs
    
                                
    • 
                                
  • web项目发布到服务器后图片过一会儿消失
                                    麦田的设计者
struts2上传图片永久保存
                                    
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
    
                                
    • 
                                
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法
                                    IT独行者
CodeIgniterCart框架　
                                    
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： 
$data = array(
               'id'      => 'sku_123ABC',
               'qty'     => 1,
               '
    
                                
    • 
                                
  • linux回收站
                                    _wy_
linux回收站
                                    
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。      后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
    
                                
    • 
                                
  • jquery回到页面顶端
                                    知了ing
htmljquerycss
                                    
    html代码： 
 
<h1 id="anchor">页面标题</h1>
<div id="container">页面内容</div>
<p><a href="#anchor" class="topLink">回到顶端</a><
    
                                
    • 
                                
  • B树、B-树、B+树、B*树
                                    矮蛋蛋
B树
                                    
    原文地址： 
http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html 
B树 
 
       即二叉搜索树： 
 
       1.所有非叶子结点至多拥有两个儿子（Left和Right）； 
 
&nb
    
                                
    • 
                                
  • 数据库连接池
                                    alafqq
数据库连接池
                                    
    http://www.cnblogs.com/xdp-gacl/p/4002804.html 
 
@Anthor:孤傲苍狼 
 
数据库连接池 
 
用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： 
java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
    
                                
    • 
                                
  • java泛型
                                    百合不是茶
java泛型
                                    
    泛型 
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患 
  
泛型的特点：消除强制转换 确保类型安全 向后兼容 
  
简单泛型的定义： 
     泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 
class fan
    
                                
    • 
                                
  • javascript闭包[两个小测试例子]
                                    bijian1013
JavaScriptJavaScript
                                    
    一.程序一 
<script>
var name = "The Window";
var Object_a = {
　　name : "My Object",
　　getNameFunc : function(){
               var that = this;
　　　　return function(){
　　　　
    
                                
    • 
                                
  • 探索JUnit4扩展：假设机制（Assumption）
                                    bijian1013
javaAssumptionJUnit单元测试
                                    
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
    
                                
    • 
                                
  • 【Gson四】范型POJO的反序列化
                                    bit1129
POJO
                                    
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 
String str = new Gson().toJson(data); 
得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO 
  
import com.google.gson.Gson;

import java.
    
                                
    • 
                                
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL
                                    bit1129
Stream
                                    
    几点总结： 
1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 
2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
    
                                
    • 
                                
  • NGINX + LUA实现复杂的控制
                                    ronin47
nginx lua
                                    
    安装lua_nginx_module 模块 
lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty 
Centos和debian的安装就简单了。。 
这里说下freebsd的安装： 
fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4
ma
    
                                
    • 
                                
  • java-递归判断数组是否升序
                                    bylijinnan
java
                                    
    

public class IsAccendListRecursive {

	/*递归判断数组是否升序
	 * if a Integer array is ascending,return true
	 * use recursion
	 */
	
	public static void main(String[] args){
		IsAccendListRecursiv
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline2
                                    bylijinnan
javanetty
                                    
    Netty3的API 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 
里面提到ChannelPipeline的一个“pitfall”： 
如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 
来
    
                                
    • 
                                
  • Java工具之JPS
                                    chinrui
java
                                    
    JPS使用 
  
  
熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
    
                                
    • 
                                
  • window.print分页打印
                                    ctrain
window
                                    
    
function init() {
    var tt = document.getElementById("tt");
    var childNodes = tt.childNodes[0].childNodes;
    var level = 0;
    for (var i = 0; i < childNodes.length; i++) {

    
                                
    • 
                                
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM
                                    daizj
jdkhadoopjps
                                    
    在安装hadoop时，执行JPS出现下面错误 
  
[slave16][email protected]:/tmp/hsperfdata_hdfs# jps 
Error occurred during initialization of VM 
java.lang.Error: Properties init: Could not determine current working
    
                                
    • 
                                
  • PHP开发大型项目的一点经验
                                    dcj3sjt126com
PHP重构
                                    
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
    
                                
    • 
                                
  • android笔记之--向网络发送GET/POST请求参数
                                    dcj3sjt126com
android
                                    
    使用GET方法发送请求 
private static boolean sendGETRequest (String path,

                     Map<String, String> params) throws Exception{

              //发送地http://192.168.100.91:8080/videoServi
    
                                
    • 
                                
  • linux复习笔记 之bash shell (3) 通配符
                                    eksliang
linux 通配符linux通配符
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2104387  
在bash的操作环境中有一个非常有用的功能，那就是通配符。 
下面列出一些常用的通配符，如下表所示    符号 意义   * 万用字符，代表0个到无穷个任意字符   ? 万用字符，代表一定有一个任意字符   [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
    
                                
    • 
                                
  • Android关于短信加密
                                    gqdy365
android
                                    
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）： 
    1、因为Android有短信收发接口，可以调用接口完成短信收发； 
        发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
    
                                
    • 
                                
  • asp.net在网站根目录下创建文件夹
                                    hvt
.netC#hovertreeasp.netWeb Forms
                                    
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： 
string m_keleyiFolderName = Server.MapPath("/hovertree");

if (Directory.Exists(m_keleyiFolderName))
{
//文件夹已经存在
return;
}
else
{
try
{
D
    
                                
    • 
                                
  • 一个合格的程序员应该读过哪些书
                                    justjavac
程序员书籍
                                    
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ 
 
 “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 
 
很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
    
                                
    • 
                                
  • 单实例实践
                                    跑龙套_az
单例
                                    
      
 1、内部类 
public class Singleton {
      private static class SingletonHolder {
             public static Singleton singleton = new Singleton();
      } 
       public Singleton getRes
    
                                
    • 
                                
  • PO VO BEAN 理解
                                    q137681467
VODTOpo
                                    
    PO： 
     全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。 
  
  
BO： 
    全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
    
                                
    • 
                                
  • 战胜惰性，暗自努力
                                    金笛子
努力
                                    
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 
我有个朋友是搞技术的，平时嘻嘻哈哈，以
    
                                
    • 
                                
  • NDK/JNI二维数组多维数组传递
                                    wenzongliang
二维数组jniNDK
                                    
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 
Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata)

{
jint i,j;

int s
    
                                
    •