静默的小猫
静默的小猫

如何使用Socket在客户端实现长连接

​ 长连接貌似是一个很高深莫测的知识，但是只要你做直播、IM、游戏、弹幕里面的任何一种，或者是你的app想要实时的接收某些消息，你就会要接触到长连接技术。本文主要教你如何在客户端如何使用Socket实现长连接。

Socket背景知识

​  要做长连接的话，是不能用http协议来做的，因为http协议已经是应用层协议了，并且http协议是无状态的，而我们要做长连接，肯定是需要在应用层封装自己的业务，所以就需要基于TCP协议来做，而基于TCP协议的话，就要用到Socket了。

Socket是java针对tcp层通信封装的一套网络方案

TCP协议我们知道，是基于ip（或者域名）和端口对指定机器进行的点对点访问，他的连接成功有两个条件，就是对方ip可以到达和端口是开放的

Socket能帮完成TCP三次握手，而应用层的头部信息需要自己去解析，也就是说，自己要制定好协议，并且要去解析byte

Socket使用方式

Socket看上去不是很好用，因为他是基于java.io来实现的，你要直接跟InputStream和OutputStream打交道，也就是直接跟byte[]打交道，所以用起来并不是这么友好。

下面通过一个简单的例子，往一台服务器发\01 \00 \00 \00 \00这一串字节，服务器也返回相同的字节流，上代码

    public void testSocketChannelBlock() throws Exception {

        final SocketChannel channel = SocketChannel.open(address);

        ByteBuffer output = ByteBuffer.allocate(5);

        output.put((byte) 1);

        output.putInt(0);

        output.flip();

        channel.write(output);

        logger.debug("write complete, start read");

        ByteBuffer input = ByteBuffer.allocate(5);

        int readByte = channel.read(input);

        logger.debug("readByte " + readByte);

        input.flip();

        if (readByte == -1) {

            logger.debug("readByte == -1, return!");

            return;

        }

        for (int i = 0; i < readByte; i++) {

            logger.debug("read [" + i + "]:" + input.get());

        }

    }

Selector

我们知道，传统io是阻塞的，也就是说，一个线程只能处理一个io流，也就是一个Socket。有了Selector之后，一个线程就能处理多个SocketChannel。

Selector的原理是，他能接受多个SocketChannel，然后不断的遍历每一个Channel的状态，如果有Channel已经ready了，他就能通过他自身提供的方法，通知到线程，让线程去处理对应的业务。流程图如下：


如何使用Socket在客户端实现长连接_第1张图片

Netty对nio这一套有比较好的封装，里面就涉及到了Selector，

Netty 优点

1.并发高

2.传输快

3.封装好

（1）Netty为什么并发高

Netty是一款基于NIO（Nonblocking I/O，非阻塞IO）开发的网络通信框架，对比于BIO（Blocking I/O，阻塞IO），他的并发性能得到了很大提高，两张图让你了解BIO和NIO的区别：


如何使用Socket在客户端实现长连接_第2张图片


如何使用Socket在客户端实现长连接_第3张图片

从这两图可以看出，NIO的单线程能处理连接的数量比BIO要高出很多，而为什么单线程能处理更多的连接呢？原因就是图二中出现的Selector。

当一个连接建立之后，他有两个步骤要做，第一步是接收完客户端发过来的全部数据，第二步是服务端处理完请求业务之后返回response给客户端。NIO和BIO的区别主要是在第一步。

在BIO中，等待客户端发数据这个过程是阻塞的，这样就造成了一个线程只能处理一个请求的情况，而机器能支持的最大线程数是有限的，这就是为什么BIO不能支持高并发的原因。

而NIO中，当一个Socket建立好之后，Thread并不会阻塞去接受这个Socket，而是将这个请求交给Selector，Selector会不断的去遍历所有的Socket，一旦有一个Socket建立完成，他会通知Thread，然后Thread处理完数据再返回给客户端——这个过程是不阻塞的，这样就能让一个Thread处理更多的请求了。

下面两张图是基于BIO的处理流程和netty的处理流程，辅助你理解两种方式的差别：


如何使用Socket在客户端实现长连接_第4张图片


如何使用Socket在客户端实现长连接_第5张图片

除了BIO和NIO之外，还有一些其他的IO模型，下面这张图就表示了五种IO模型的处理流程：


如何使用Socket在客户端实现长连接_第6张图片

BIO，同步阻塞IO，阻塞整个步骤，如果连接少，他的延迟是最低的，因为一个线程只处理一个连接，适用于少连接且延迟低的场景，比如说数据库连接。

NIO，同步非阻塞IO，阻塞业务处理但不阻塞数据接收，适用于高并发且处理简单的场景，比如聊天软件。

多路复用IO，他的两个步骤处理是分开的，也就是说，一个连接可能他的数据接收是线程a完成的，数据处理是线程b完成的，他比BIO能处理更多请求。

信号驱动IO，这种IO模型主要用在嵌入式开发，不参与讨论。

异步IO，他的数据请求和数据处理都是异步的，数据请求一次返回一次，适用于长连接的业务场景。

（2）Netty为什么传输快

Netty的传输快其实也是依赖了NIO的一个特性——零拷贝。我们知道，Java的内存有堆内存、栈内存和字符串常量池等等，其中堆内存是占用内存空间最大的一块，也是Java对象存放的地方，一般我们的数据如果需要从IO读取到堆内存，中间需要经过Socket缓冲区，也就是说一个数据会被拷贝两次才能到达他的的终点，如果数据量大，就会造成不必要的资源浪费。

Netty针对这种情况，使用了NIO中的另一大特性——零拷贝，当他需要接收数据的时候，他会在堆内存之外开辟一块内存，数据就直接从IO读到了那块内存中去，在netty里面通过ByteBuf可以直接对这些数据进行直接操作，从而加快了传输速度。


如何使用Socket在客户端实现长连接_第7张图片
传统数据拷贝


如何使用Socket在客户端实现长连接_第8张图片
零拷贝

（3）为什么说Netty封装好？

阻塞I/O

public class PlainOioServer {

    public void serve(int port) throws IOException {

        final ServerSocket socket = new ServerSocket(port);    //1

        try {

            for (;;) {

                final Socket clientSocket = socket.accept();    //2

                System.out.println("Accepted connection from " + clientSocket);

                new Thread(new Runnable() {                        //3

                    @Override

                    public void run() {

                        OutputStream out;

                        try {

                            out = clientSocket.getOutputStream();

                            out.write("Hi!\r\n".getBytes(Charset.forName("UTF-8")));                            //4

                            out.flush();

                            clientSocket.close();                //5

                        } catch (IOException e) {

                            e.printStackTrace();

                            try {

                                clientSocket.close();

                            } catch (IOException ex) {

                                // ignore on close

                            }

                        }

                    }

                }).start();                                        //6

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}


非阻塞IO

public class PlainNioServer {

    public void serve(int port) throws IOException {

        ServerSocketChannel serverChannel = ServerSocketChannel.open();

        serverChannel.configureBlocking(false);

        ServerSocket ss = serverChannel.socket();

        InetSocketAddress address = new InetSocketAddress(port);

        ss.bind(address);                                            //1

        Selector selector = Selector.open();                        //2

        serverChannel.register(selector, SelectionKey.OP_ACCEPT);    //3

        final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes());

        for (;;) {

            try {

                selector.select();                                    //4

            } catch (IOException ex) {

                ex.printStackTrace();

                // handle exception

                break;

            }

            Set readyKeys = selector.selectedKeys();    //5

            Iterator iterator = readyKeys.iterator();

            while (iterator.hasNext()) {

                SelectionKey key = iterator.next();

                iterator.remove();

                try {

                    if (key.isAcceptable()) {                //6

                        ServerSocketChannel server =

                                (ServerSocketChannel)key.channel();

                        SocketChannel client = server.accept();

                        client.configureBlocking(false);

                        client.register(selector, SelectionKey.OP_WRITE |

                                SelectionKey.OP_READ, msg.duplicate());    //7

                        System.out.println(

                                "Accepted connection from " + client);

                    }

                    if (key.isWritable()) {                //8

                        SocketChannel client =

                                (SocketChannel)key.channel();

                        ByteBuffer buffer =

                                (ByteBuffer)key.attachment();

                        while (buffer.hasRemaining()) {

                            if (client.write(buffer) == 0) {        //9

                                break;

                            }

                        }

                        client.close();                    //10

                    }

                } catch (IOException ex) {

                    key.cancel();

                    try {

                        key.channel().close();

                    } catch (IOException cex) {

                        // 在关闭时忽略

                    }

                }

            }

        }

    }

}


Netty

public class NettyOioServer {

    public void server(int port) throws Exception {

        final ByteBuf buf = Unpooled.unreleasableBuffer(

                Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));

        EventLoopGroup group = new OioEventLoopGroup();

        try {

            ServerBootstrap b = new ServerBootstrap();        //1

            b.group(group)                                    //2

            .channel(OioServerSocketChannel.class)

            .localAddress(new InetSocketAddress(port))

            .childHandler(new ChannelInitializer() {//3

                @Override

                public void initChannel(SocketChannel ch)

                    throws Exception {

                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {            //4

                        @Override

                        public void channelActive(ChannelHandlerContext ctx) throws Exception {

                            ctx.writeAndFlush(buf.duplicate()).addListener(ChannelFutureListener.CLOSE);//5

                        }

                    });

                }

            });

            ChannelFuture f = b.bind().sync();  //6

            f.channel().closeFuture().sync();

        } finally {

            group.shutdownGracefully().sync();        //7

        }

    }

}


Channel

数据传输流，与channel相关的概念有以下四个，上一张图让你了解netty里面的Channel。


如何使用Socket在客户端实现长连接_第9张图片

Channel，表示一个连接，可以理解为每一个请求，就是一个Channel。

ChannelHandler，核心处理业务就在这里，用于处理业务请求。

ChannelHandlerContext，用于传输业务数据。

ChannelPipeline，用于保存处理过程需要用到的ChannelHandler和ChannelHandlerContext。

ByteBuf

ByteBuf是一个存储字节的容器，最大特点就是使用方便，它既有自己的读索引和写索引，方便你对整段字节缓存进行读写，也支持get/set，方便你对其中每一个字节进行读写，他的数据结构如下图所示：

如何使用Socket在客户端实现长连接_第10张图片
ByteBuf数据结构

Heap Buffer 堆缓冲区

堆缓冲区是ByteBuf最常用的模式，他将数据存储在堆空间。

Direct Buffer 直接缓冲区

直接缓冲区是ByteBuf的另外一种常用模式，他的内存分配都不发生在堆，jdk1.4引入的nio的ByteBuffer类允许jvm通过本地方法调用分配内存，这样做有两个好处

通过免去中间交换的内存拷贝, 提升IO处理速度; 直接缓冲区的内容可以驻留在垃圾回收扫描的堆区以外。

DirectBuffer 在 -XX:MaxDirectMemorySize=xxM大小限制下, 使用 Heap 之外的内存, GC对此”无能为力”,也就意味着规避了在高负载下频繁的GC过程对应用线程的中断影响.

Composite Buffer 复合缓冲区

复合缓冲区相当于多个不同ByteBuf的视图，这是netty提供的，jdk不提供这样的功能。

Codec

Netty中的编码/解码器，通过他你能完成字节与pojo、pojo与pojo的相互转换，从而达到自定义协议的目的。

在Netty里面最有名的就是HttpRequestDecoder和HttpResponseEncoder了。

认识Http请求

在动手写Netty框架之前，我们先要了解http请求的组成，如下图：


如何使用Socket在客户端实现长连接_第11张图片

HTTP Request 第一部分是包含的头信息

HttpContent 里面包含的是数据，可以后续有多个 HttpContent 部分

LastHttpContent 标记是 HTTP request 的结束，同时可能包含头的尾部信息

完整的 HTTP request，由1，2，3组成


如何使用Socket在客户端实现长连接_第12张图片

HTTP response 第一部分是包含的头信息

HttpContent 里面包含的是数据，可以后续有多个 HttpContent 部分

LastHttpContent 标记是 HTTP response 的结束，同时可能包含头的尾部信息

完整的 HTTP response，由1，2，3组成

从request的介绍我们可以看出来，一次http请求并不是通过一次对话完成的，他中间可能有很次的连接。通过上一章我们队netty的了解，每一次对话都会建立一个channel，并且一个ChannelInboundHandler一般是不会同时去处理多个Channel的。

如何在一个Channel里面处理一次完整的Http请求？这就要用到我们上图提到的FullHttpRequest，我们只需要在使用netty处理channel的时候，只处理消息是FullHttpRequest的Channel，这样我们就能在一个ChannelHandler中处理一个完整的Http请求了。

什么是Decoder和Encoder

​  在学习Decoder和Encoder之前，首先要了解他们在具体是个什么东西。在Netty里面，有四个核心概念，这个在第一篇文章提到的，他们的分别是：

Channel，一个客户端与服务器通信的通道

ChannelHandler，业务逻辑处理器，分为ChannelInboundHandler和ChannelOutboundHandler

ChannelInboundHandler，输入数据处理器

ChannelOutboundHandler，输出业务处理器

通常情况下，业务逻辑都是存在于ChannelHandler之中

ChannelPipeline，用于存放ChannelHandler的容器

ChannelContext，通信管道的上下文

他们之间的交流流程如下图：

如何使用Socket在客户端实现长连接_第13张图片
Channel关系图

他们的交互流程是：

事件传递给 ChannelPipeline 的第一个 ChannelHandler

ChannelHandler 通过关联的 ChannelHandlerContext 传递事件给 ChannelPipeline 中的 下一个

ChannelHandler 通过关联的 ChannelHandlerContext 传递事件给 ChannelPipeline 中的 下一个

而我们本文所需要详细讲的Decoder和Encoder，他们分别就是ChannelInboundHandler和ChannelOutboundHandler，分别用于在数据流进来的时候将字节码转换为消息对象和数据流出去的时候将消息对象转换为字节码。

Encoder

​  Encoder最重要的实现类是MessageToByteEncoder，这个类的作用就是将消息实体T从对象转换成byte，写入到ByteBuf，然后再丢给剩下的ChannelOutboundHandler传给客户端，流程图如下：


如何使用Socket在客户端实现长连接_第14张图片
Encoder流程图

encode方法是继承MessageToByteEncoder唯一需要重写的方法，可见其简单程度。也是因为Encoder相比于Decoder更为简单，在这里也不多做赘述，直接上代码：

public class ShortToByteEncoder extends   MessageToByteEncoder {  //1

    @Override

    public void encode(ChannelHandlerContext ctx, Short msg, ByteBuf out)

            throws Exception {

        out.writeShort(msg);  //2

    }

}

Decoder

​  和Encoder一样，decoder就是在服务端收到数据的时候，将字节流转换为实体对象Message。但是和Encoder的处理逻辑不一样，数据传到服务端有可能不是一次请求就能完成的，中间可能需要经过几次数据传输，并且每一次传输传多少数据也是不确定的，所以它有两个重要方法：

decode和decodeLast的不同之处，在于他们的调用时机不同，正如描述所说，decodeLast只有在Channel的生命周期结束之前会调用一次，默认是调用decode方法。

​  同样是ToInteger的解码器，他的代码如下：


public class ToIntegerDecoder extends ByteToMessageDecoder { //1

    @Override

    public void decode(ChannelHandlerContext ctx, ByteBuf in, List out)

            throws Exception {

        if (in.readableBytes() >= 4) {  //2

            out.add(in.readInt());  //3

        }

    }

}

从这段代码可以看出，因为不知道这次请求发过来多少数据，所以每次都要判断byte长度够不够4，如果你的数据长度更长，且不固定的话，这里的逻辑会变得非常复杂。所以在这里介绍另一个我们常用的解码器 ：ReplayingDecoder。

ReplayingDecoder

​  ReplayingDecoder 是 byte-to-message 解码的一种特殊的抽象基类，读取缓冲区的数据之前需要检查缓冲区是否有足够的字节，使用ReplayingDecoder就无需自己检查；若ByteBuf中有足够的字节，则会正常读取；若没有足够的字节则会停止解码。

​  RelayingDecoder在使用的时候需要搞清楚的两个方法是checkpoint(S s)和state()，其中checkpoint的参数S，代表的是ReplayingDecoder所处的状态，一般是枚举类型。RelayingDecoder是一个有状态的Handler，状态表示的是它目前读取到了哪一步，checkpoint(S s)是设置当前的状态，state()是获取当前的状态。

​  在这里我们模拟一个简单的Decoder，假设每个包包含length:int和content:String两个数据，其中length可以为0，代表一个空包，大于0的时候代表content的长度。代码如下：

public class LiveDecoder extends ReplayingDecoder { //1

    public enum LiveState { //2

        LENGTH,

        CONTENT

    }

    private LiveMessage message = new LiveMessage();

    public LiveDecoder() {

        super(LiveState.LENGTH); // 3

    }

    @Override

    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List list) throws Exception {

        switch (state()) { // 4

            case LENGTH:

                int length = byteBuf.readInt();

                if (length > 0) {

                    checkpoint(LiveState.CONTENT); // 5

                } else {

                    list.add(message); // 6

                }

                break;

            case CONTENT:

                byte[] bytes = new byte[message.getLength()];

                byteBuf.readBytes(bytes);

                String content = new String(bytes);

                message.setContent(content);

                list.add(message);

                break;

            default:

                throw new IllegalStateException("invalid state:" + state());

        }

    }

}

继承ReplayingDecoder，泛型LiveState，用来表示当前读取的状态

描述LiveState，有读取长度和读取内容两个状态

初始化的时候设置为读取长度的状态

读取的时候通过state()方法来确定当前处于什么状态

如果读取出来的长度大于0，则设置为读取内容状态，下一次读取的时候则从这个位置开始

读取完成，往结果里面放解析好的数据

​  以上就是ReplayingDecoder的使用方法，他比ByteToMessageDecoder更加灵活，能够通过巧妙的方式来处理复杂的业务逻辑，但是也是因为这个原因，使得ReplayingDecoder带有一定的局限性：

不是所有的标准 ByteBuf 操作都被支持，如果调用一个不支持的操作会抛出 UnreplayableOperationException

ReplayingDecoder 略慢于 ByteToMessageDecoder

所以，如果不引入过多的复杂性 使用 ByteToMessageDecoder 。否则,使用ReplayingDecoder。

MessageToMessage

​  Encoder和Decoder除了能完成Byte和Message的相互转换之外，为了处理复杂的业务逻辑，还能帮助使用者完成Message和Message的相互转换，我们熟悉的Http协议的处理，其中就用到了很多MessageToMessage的派生类。

Netty如何实现长连接

一个简单的长连接demo分为以下几个步骤：


如何使用Socket在客户端实现长连接_第15张图片
长连接流程

1.创建连接（Channel）

2.发心跳包

3.发消息，并通知其他用户

4.一段时间没收到心跳包或者用户主动关闭之后关闭连接

​ 看似简单的步骤，里面有两个技术难点：

1.如何保存已创建的Channel

这里我们是将Channel放在一个Map中，以Channel.hashCode()作为key

其实这样做有一个劣势，就是不适合水平扩展，每个机器都有一个连接数的上线，如果需要实现多用户实时在线，对机器的数量要求会很高，在这里我们不多做讨论，不同的业务场景，设计方案也是不同的，可以在长连接方案和客户端轮询方案中进行选择。

2.如何自动关闭没有心跳的连接

Netty有一个比较好的Feature，就是ScheduledFuture，他可以通过ChannelHandlerContext.executor().schedule()创建，支持延时提交，也支持取消任务，这就给我们心跳包的自动关闭提供了一个很好的实现方案。

开始动手

​  首先，我们需要用一个JavaBean来封装通信的协议内容，在这里我们只需要三个数据就行了：

1.type : byte，表示消息的类型，有心跳类型和内容类型

2.length : int，表示消息的长度

3.content : String，表示消息的内容（心跳包在这里没有内容）

​  然后，因为我们需要将Channel和ScheduledFuture缓存在Map里面，所以需要将两个对象组合成一个JavaBean。

​  接着，需要完成输入输出流的解析和转换，我们需要重写Decoder和Encoder，

服务端:

import io.netty.channel.Channel;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.SimpleChannelInboundHandler;

import io.netty.util.concurrent.ScheduledFuture;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeUnit;

/**

* Created by RoyDeng on 17/7/20.

*/

public class LiveHandler extends SimpleChannelInboundHandler { // 1

    private static Map channelCache = new HashMap<>();

    private Logger logger = LoggerFactory.getLogger(LiveHandler.class);

    @Override

    protected void channelRead0(ChannelHandlerContext ctx, LiveMessage msg) throws Exception {

        Channel channel = ctx.channel();

        final int hashCode = channel.hashCode();

        System.out.println("channel hashCode:" + hashCode + " msg:" + msg + " cache:" + channelCache.size());

        if (!channelCache.containsKey(hashCode)) {

            System.out.println("channelCache.containsKey(hashCode), put key:" + hashCode);

            channel.closeFuture().addListener(future -> {

                System.out.println("channel close, remove key:" + hashCode);

                channelCache.remove(hashCode);

            });

            ScheduledFuture scheduledFuture = ctx.executor().schedule(

                    () -> {

                        System.out.println("schedule runs, close channel:" + hashCode);

                        channel.close();

                    }, 10, TimeUnit.SECONDS);

            channelCache.put(hashCode, new LiveChannelCache(channel, scheduledFuture));

        }

        switch (msg.getType()) {

            case LiveMessage.TYPE_HEART: {

                LiveChannelCache cache = channelCache.get(hashCode);

                ScheduledFuture scheduledFuture = ctx.executor().schedule(

                        () -> channel.close(), 5, TimeUnit.SECONDS);

                cache.getScheduledFuture().cancel(true);

                cache.setScheduledFuture(scheduledFuture);

                ctx.channel().writeAndFlush(msg);

                break;

            }

            case LiveMessage.TYPE_MESSAGE: {

                channelCache.entrySet().stream().forEach(entry -> {

                    Channel otherChannel = entry.getValue().getChannel();

                    otherChannel.writeAndFlush(msg);

                });

                break;

            }

        }

    }

    @Override

    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        logger.debug("channelReadComplete");

        super.channelReadComplete(ctx);

    }

    @Override

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        logger.debug("exceptionCaught");

        if(null != cause) cause.printStackTrace();

        if(null != ctx) ctx.close();

    }

}

2.客户端

package com.dz.test;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.nio.ByteBuffer;

import java.util.Scanner;


public class LongConnection {

    private Logger logger = LoggerFactory.getLogger(LongConnection.class);

    String host = "localhost";

    int port = 8080;

    public void testLongConnection() throws Exception {

        logger.debug("start");

        final Socket socket = new Socket();

        socket.connect(new InetSocketAddress(host, port));

        Scanner scanner = new Scanner(System.in);

        new Thread(() -> {

            while (true) {

                try {

                    byte[] input = new byte[64];

                    int readByte = socket.getInputStream().read(input);

                    logger.debug("readByte " + readByte);

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }).start();

        int code;

        while (true) {

            code = scanner.nextInt();

            logger.debug("input code:" + code);

            if (code == 0) {

                break;

            } else if (code == 1) {

                ByteBuffer byteBuffer = ByteBuffer.allocate(5);

                byteBuffer.put((byte) 1);

                byteBuffer.putInt(0);

                socket.getOutputStream().write(byteBuffer.array());

                logger.debug("write heart finish!");

            } else if (code == 2) {

                byte[] content = ("hello, I'm" + hashCode()).getBytes();

                ByteBuffer byteBuffer = ByteBuffer.allocate(content.length + 5);

                byteBuffer.put((byte) 2);

                byteBuffer.putInt(content.length);

                byteBuffer.put(content);

                socket.getOutputStream().write(byteBuffer.array());

                logger.debug("write content finish!");

            }

        }

        socket.close();

    }

    // 因为Junit不支持用户输入,所以用main的方式来执行用例

    public static void main(String[] args) throws Exception {

        new LongConnection().testLongConn();

    }

}

你可能感兴趣的:(如何使用Socket在客户端实现长连接)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 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<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 30天风格练习-DAY2 黄希夷
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动 李蕾1229
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 那个抄袭的大张伟 猫小努
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
  • 三大师传 beca酱
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • html 周华华 html
    js 1，数组的排列 var arr=[1,4,234,43,52,]; for(var x=0;x<arr.length;x++){    for(var y=x-1;y<arr.length;y++){      if(arr[x]<arr[y]){     &
  • 【Struts2 四】Struts2拦截器 bit1129 struts2拦截器
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。   Struts2中自定义拦截器的步骤是：
  • make:cc 命令未找到解决方法 daizj linux命令未知make cc
    安装rz sz程序时，报下面错误：   [root@slave2 src]# make posix cc   -O -DPOSIX -DMD=2 rz.c -o rz make: cc：命令未找到 make: *** [posix] 错误 127   系统：centos 6.6 环境：虚拟机   错误原因：系统未安装gcc，这个是由于在安
  • Oracle之Job应用 周凡杨 oracle job
    最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。   一：查看相关job信息    1、相关视图  dba_jobs  all_jobs  user_jobs  dba_jobs_running 包含正在运行
  • 多线程机制 朱辉辉33 多线程
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 程序、进程和线程： 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一） 老A不折腾 web报表finereportjava报表报表工具
    FineReport使用中遇到的常见报错及解决办法（一） 这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。   1、address pool is full： 含义：地址池满，连接数超过并发数上
  • mysql rpm安装后没有my.cnf 林鹤霄 没有my.cnf
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题 aigo root
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/   Step 4: Run ADB command from your PC   On the PC, you need install Amazon Fire ADB driver and instal
  • javascript 中var提升的典型实例 alxw4616 JavaScript
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧 myname = 'global'; var fn = function () { console.log(myname); // undefined var myname = 'local'; console.log(myname); // local }; fn() // 上述代码实际上等同于以下代码 m
  • 定时器和获取时间的使用 百合不是茶 时间的转换定时器
    定时器:定时创建任务在游戏设计的时候用的比较多   Timer();定时器 TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。       定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
  • JDK1.5 Queue bijian1013 javathreadjava多线程Queue
    JDK1.5 Queue LinkedList： LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
  • http认证原理和https bijian1013 httphttps
    一.基础介绍         在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。         Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
  • 【Java范型五】范型继承 bit1129 java
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2   package com.tom.lang.generics; public abstract class SuperGenerics<T1, T2> { private T1 t1; private T2 t2; public abstract void doIt(T
  • 【Nginx六】nginx.conf常用指令(Directive) bit1129 Directive
    1. worker_processes    8; 表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行   nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process
  • lua 遍历Header头部 ronin47 lua header 遍历　
    local headers = ngx.req.get_headers()   ngx.say("headers begin", "<br/>")   ngx.say("Host : ", he
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。 bylijinnan java
    import java.util.Arrays; public class MinSumASumB { /** * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序. * * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 * 例如: * int[] a = {100,99,98,1,2,3
  • redis 开窍的石头 redis
    在redis的redis.conf配置文件中找到# requirepass foobared 把它替换成requirepass 12356789 后边的12356789就是你的密码 打开redis客户端输入config get requirepass 返回 redis 127.0.0.1:6379> config get requirepass 1) "require
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？ comsci java语言
          无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情       
  • 安装ubuntu14.04登录后花屏了怎么办 cuiyadll ubuntu
    这个情况，一般属于显卡驱动问题。 可以先尝试安装显卡的官方闭源驱动。 按键盘三个键：CTRL + ALT  +  F1 进入终端，输入用户名和密码登录终端： 安装amd的显卡驱动 sudo  apt-get  install  fglrx 安装nvidia显卡驱动 sudo  ap
  • SSL 与 数字证书 的基本概念和工作原理 darrenzhu 加密ssl证书密钥签名
    SSL 与 数字证书 的基本概念和工作原理 http://www.linuxde.net/2012/03/8301.html SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 http://www.ibm.com/developerworks/cn/webspher
  • Ubuntu设置ip的步骤 dcj3sjt126com ubuntu
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 转载不是错： Ubuntu命令行修改网络配置方法 /etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 1. 以D
  • php包管理工具推荐 dcj3sjt126com PHPComposer
    http://www.phpcomposer.com/   Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。 中文文档  入门指南  下载  安装包列表 Composer 中国镜像
  • Gson使用四（TypeAdapter） eksliang jsongsonGson自定义转换器gsonTypeAdapter
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述        Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例        例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
  • JQM控件之Navbar和Tabs gundumw100 htmlxmlcss
    在JQM中使用导航栏Navbar是简单的。 只需要将data-role="navbar"赋给div即可： <div data-role="navbar"> <ul> <li><a href="#" class="ui-btn-active&qu
  • 利用归并排序算法对大文件进行排序 iwindyforest java归并排序大文件分治法Merge sort
      归并排序算法介绍，请参照Wikipeida zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 基本思想： 大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 低于限制行数的子文件直接排序 两个排序好的子文件归并到父文件 直到最后所有排序好的父文件归并到输入
  • iOS UIWebView URL拦截 啸笑天 UIWebView
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
  • 索引的碎片整理SQL语句 macroli sql
    SET NOCOUNT ON DECLARE @tablename VARCHAR (128) DECLARE @execstr VARCHAR (255) DECLARE @objectid INT DECLARE @indexid INT DECLARE @frag DECIMAL DECLARE @maxfrag DECIMAL --设置最大允许的碎片数量,超过则对索引进行碎片
  • Angularjs同步操作http请求with $promise qiaolevip 每天进步一点点学习永无止境AngularJS纵观千象
    // Define a factory app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) { var deferred = $q.defer(); AccountService.getProfile().then(function(res) {
  • hibernate联合查询问题 sxj19881213 sqlHibernateHQL联合查询
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2）   1 几个常识：  （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。  （2）hql的默认查询策略，在进行联合查询时，会产
  • struts2.xml wuai struts
    <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache