客户端&服务器访问方式的演进

最新推荐文章于 2020-08-03 11:30:53 发布

feiyuciuxun

最新推荐文章于 2020-08-03 11:30:53 发布

阅读量429

点赞数

分类专栏： java 文章标签：网络 nio netty

本文链接：https://blog.csdn.net/feiyuciuxun/article/details/107051333

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

3、客户端给服务端发送完消息后，服务端再给客户端一个回馈

三、URL编程

一、网络编程基本知识

前言：

端口号与IP地址的组合得出一个网络套接字：Socket，网络编程通常称为socket编程。

1、网络模型：

a.通讯方式：TCP、UDP

i. TCP : 可靠连接，使命必达，速度慢

ii. UDP : 不可靠，速度快

2、 TCP的编程模型

a. BIO / OIO

i. Blocking IO / Old IO

b. NIO（linux支持）

i. New IO : Non-Blocking IO

ii. Selector

iii. ByteBuffer (single pointer)

c. AIO(仅仅windows支持)

i. Asynchronous IO

2、Netty

a. 封装了NIO ByteBuf(read pointer、writer pointer)

第一种方式：BIO/OIO

写一个简单的例子：客户端连接服务器，只写一句话

第一步：创建客户端和服务端，并让客户端连接上服务端

server:

ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(new InetSocketAddress(8899));
System.out.println("hello");
Socket accept = serverSocket.accept();
System.out.println("world");

client:

Socket socket = new Socket("localhost",8899);

解析：

在以上的server端的代码中，运行以后”hello“会输出出来，但是，accept()方法是阻塞的，也就是说，如果客户端没有启动，或者说没有客户端连接到服务端，此时”world不会输出出来“。客户端启动，则”world“就会输出出来。

第二步：

客户端连接上服务端传给服务端一些信息

server:
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(8899));
        System.out.println("hello");
        Socket accept = serverSocket.accept();
        System.out.println("world");
        // 获取输入流
        InputStream is = accept.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String str = br.readLine();
        
        System.out.println(str);
        // 关闭资源
        is.close();
        accept.close();
        serverSocket.close();

client:
        Socket socket = new Socket("localhost",8899);
        OutputStream oos = socket.getOutputStream();
        // 获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(oos));
        bw.write("你好啊，我是Michael");
        bw.newLine();
        bw.flush();
        // 关闭资源
        bw.close();

解析：此时服务端不仅仅会输出”hello“、”world“还会输出客户端传过来的信息：”你好啊，我是Michael“.

此时server中的br.readLine()是一个阻塞方法，即：如果客户端只是连接上，但是没有传过来数据，服务端会在br.readLine()处阻塞。如第三步所示

第三步：

server端的代码不变

client代码如下：

        Socket socket = new Socket("localhost",8899);
        OutputStream oos = socket.getOutputStream();
        // 获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(oos));
        // 下面的代码是等待键盘输入内容，如果不输入内容，下面的代码会进入阻塞状态
        System.in.read();

解析：此时启动客户端，服务端仅仅会输出"hello"、"world"。并进入阻塞状态。

这种情况其实是一种网络攻击，叫拒绝服务攻击，也就是说我连接上你的服务器，但就是什么事也不干，其他正常的连接也连接不上来，这就是一种攻击。

这种模式类似于：一个餐厅开门后只能服务于一个客户，客户吃完饭，餐厅会关门，如果需要对下一个客户提供服务，需要重新开张。

以上模式只能接受一个客户端。如何改进呢：

第一种改进方式：

server:        
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(8899));
        boolean started = true;
        while (started){
            Socket accept = serverSocket.accept();
            // 获取输入流
            InputStream is = accept.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String str = br.readLine();

            System.out.println(str);
            // 关闭资源
            is.close();
            accept.close();
        }
        serverSocket.close();

client
        Socket socket = new Socket("localhost",8899);
        OutputStream oos = socket.getOutputStream();
        // 获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(oos));
        bw.write("你好啊，我是Michael");
        bw.newLine();
        bw.flush();
        bw.close();

解析：启动服务端，重复启动客户端，没启动一起客户端，服务端会收到"你好啊，我是Michael"。这种模式类似于，饭店每次只能允许一个人在里面吃饭，此时其他想要吃饭的客户必须得等上一个客户吃完饭走出去餐厅，才能进去。也就是其他客户端会进入阻塞模式。

第二种改进方式：

这种方式为每一个客户端生成一个线程，当大量客户端同时访问此服务时，由于起的线程太多，服务基本上就挂了

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket socket = new ServerSocket();
        socket.bind(new InetSocketAddress("localhost", 8888));
        boolean started = true;
        while (started) {
            new Thread(()->{
                try {
                    Socket s = socket.accept();
                    BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                    String str = br.readLine();
                    System.out.println(str);
                    br.close();
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();

        }
        socket.close();
    }
}

public class Client {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("localhost", 8888);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bw.write("mashibing");
        bw.newLine();
        bw.flush();
        bw.close();
    }
}

这种方式类似于：每个顾客去餐厅吃饭时，餐厅都找一个属于这个顾客的服务员(也就是线程)去为他服务，不妨碍其他顾客吃饭。而主线程的作用就是为其分配服务员(线程)。

第二种方式：NIO

NIO中使用的是ServerSocketChannel模式，channel就是通道的意思

public class Server2 {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ServerSocket socket = ssc.socket();
        socket.bind(new InetSocketAddress("localhost",8899));
        // 将此通道设置为非阻塞式
        ssc.configureBlocking(false);

        System.out.println("Server started, listening on:" + ssc.getLocalAddress());
        // 启动大管家
        Selector selector = Selector.open();
        // 我让大管家管什么事呢？让大管家负责有连接需要连接过来的服务
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true){
            // 开始轮询，有事情就会处理事情，在轮询时是阻塞状态
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();
            while (it.hasNext()){
                SelectionKey key = it.next();
                it.remove();
                handle(key);
            }
        }
    }

    private static void handle(SelectionKey key) {
        // 客户端连接的情况
        if(key.isAcceptable()){
            try {
                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                // 有客户端进来时单独建立一个新的通道，同时也将此通道设置为非阻塞式
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);
                // 此通道注册一个读数据的通道还是什么不清楚
                sc.register(key.selector(),SelectionKey.OP_READ);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
            }
        }else if(key.isReadable()){
            SocketChannel sc = null;
            try {
                sc = (SocketChannel) key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(512);
                buffer.clear();
                int len = sc.read(buffer);
                if(len!=-1){
                    System.out.println(new String(buffer.array(),0,len));
                }
                ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
                sc.write(bufferToWrite);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(sc!=null){
                    try {
                        sc.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

以上代码是NIO代码，只用了一个线程。Nertty就是对其的封装。NIO使用了ByteBuffer，其底层封装了一个字节数组，和一个指针，记录了读写数据的位置，但是它不好用，也容易出错。而Netty底层使用了ByteBuf，也是一个字节数组，但是其有两个指针分别记录读写数据的位置，并且，Netty可以操作直接内存即零拷贝，不需要经过JDK的内存，直接使用操作系统的内存，少了拷贝数据的过程，增加效率。

此种模型因为是单线程的，当大管家在处理某一张桌子(客户端)的需求时,其他需求都需要排队等待，改进方式如下：

NIO另一种模型：一个大管家+多个服务员(线程)，线程数固定，大管家只负责接客，服务员负责每个客人的业务需求。服务员忙完后回到线程池进入等待状态，有了新的客户再去服务。但是ByteBuffer的问题依然没有解决

Netty:

以下只有服务端代码，没有客户端代码，客户端代码可以使用BIO中的客户端

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 负责接客
        NioEventLoopGroup bossGroups = new NioEventLoopGroup(2);
        // 负责服务
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(4);
        // Server启动辅助类
        ServerBootstrap b = new ServerBootstrap();

        b.group(bossGroups,workerGroup);
        // 异步全双工
        b.channel(NioServerSocketChannel.class);
        // netty 帮我们内部处理accept的过程
        b.childHandler(new MyChildInitializer());
        b.bind(8888).sync();

    }
}
class MyChildInitializer extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        System.out.println("a client connected !");
    }
}

一个完整的Netty例子

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 负责接客
        NioEventLoopGroup boosGroup = new NioEventLoopGroup(2);
        // 负责服务
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(4);
        // server启动辅助类
        ServerBootstrap b = new ServerBootstrap();
        b.group(boosGroup,workerGroup);
        // 指定使用的channel类型：异步全双工
        b.channel(NioServerSocketChannel.class);

        b.childHandler(new MyChildInitializer2());
        ChannelFuture future = b.bind(8899).sync();
        // 优雅的关闭方式
        future.channel().closeFuture().sync();
        boosGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();

    }
}
class MyChildInitializer2 extends ChannelInitializer<SocketChannel> {

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline().addLast(new MyChildHandler2());
    }
}
class MyChildHandler2 extends ChannelInboundHandlerAdapter{

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println(buf.toString());
        ctx.writeAndFlush(msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
    }
}

public class NettyClient {
    public static void main(String[] args) throws InterruptedException, IOException {
        NioEventLoopGroup worker = new NioEventLoopGroup(1);
        Bootstrap bs = new Bootstrap();
        bs.group(worker);
        bs.channel(NioSocketChannel.class);
        bs.handler(new MyChannelInit());
        ChannelFuture future = bs.connect("localhost", 8899).sync();
        // 等待关闭
        future.channel().closeFuture().sync();
        System.out.println("go on");
        worker.shutdownGracefully();
    }
}
class MyChannelInit extends ChannelInitializer<SocketChannel>{

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline().addLast(new MyHandler());
    }
}
class MyHandler extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println(msg.toString());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("mashbing".getBytes());
        ctx.writeAndFlush(buf);
    }
}

详情请看马士兵关于线程与高并发的视频