java socket 服务器_Java Socket 常用的几种服务器模型

目前常见的服务器模型主要有三种：阻塞服务器，并发服务器以及异步服务器。三种形式各有利弊，下面介绍一下。

第一种阻塞式服务器是最好实现的服务器，也是问题最多的服务器，上一篇文章中的示例代码就是典型的阻塞式服务器。客户端发送到服务器的请求，服务器会进行排队，依次处理请求。前一个请求没有处理完成，服务器不会处理后面的请求。这种服务器很容易进行攻击，只需要向服务器发送一个处理时间很长的请求，就会将其他的请求堵在门外，导致其他请求无法得到处理，所以，这种服务器更多的是作为理论模型，实际应用并不多。

第二种是并发式服务器，这种服务器处理请求时，每接收到一个请求，就启动一个线程处理该请求，这种模式的服务器，好处是不会出现阻塞式服务器请求被拥堵的情况，但是也是存在问题的，服务器启动线程是有一定的开销的，请求数量不多的时候，服务器启动线程没有问题，但是请求过多时，将会导致服务器的资源耗尽。所以，会存在一种方式——建立线程池来处理请求，每当请求到来时，向线程池申请线程进行处理，这样，线程池开放多少线程是固定的，不会导致系统资源耗尽，但是依然会有一些问题，当线程池被占用满时，还是有可能出现请求被阻塞的情况，所以这种方式是一种折中的方式。但是，对于并发请求不是很多的场景来说， 使用这种方式是完全可以的。

第三种方式是异步服务器，使用该种方式，一般要借助于系统的异步IO机制，如select或poll，这种方式，当一个请求到达时，我们可以先将请求注册，当有数据可以读取时，会得到通知，这时候我们处理请求，这样，服务器进程没有必要阻塞处理，也不会存在很大的系统开销，因此，目前对于并发量要求比较高的服务器，一般都是采用这种方式。

阻塞式服务器

这里的示例是服务器将字符串转换为大写并追加_OK，由于TCP传输数据是流模式，没有数据边界，服务器端只有拿到终结符，才认为一个请求发送完成，否则会一直等待读取(除非设置超时)。首先给出服务端的代码：

package com.tzSocket.server;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

/**

* create by tz on 2018-08-02

*/

public class ToUpperTCPBlockServer {

//服务器IP

public static final String SERVER_IP = "127.0.0.1";

//服务器端口号

public static final int SERVER_PORT = 10016;

//请求终结字符串

public static final char REQUEST_END_CHAR = '#';

/***

* 启动服务器

* @param serverPort 服务器监听的端口号，

* @param serverIP 服务器ip无需指定，系统自动分配

*/

public void startServer(String serverIP, int serverPort) {

//创建服务器地址对象

InetAddress serverAddr;

try {

serverAddr = InetAddress.getByName(serverIP);

} catch (UnknownHostException e) {

e.printStackTrace();

return;

}

//Java提供了ServerSocket作为服务器

//这里使用了Java的自动关闭的语法，很好用

try(ServerSocket serverSocket = new ServerSocket(SERVER_PORT, 5, serverAddr)) {

while (true) {

StringBuilder recvStrBuilder = new StringBuilder();

//有客户端向服务器发起tcp连接时，accept会返回一个Socket

//该Socket的対端就是客户端的Socket

//具体过程可以查看TCP三次握手过程

try (Socket connection = serverSocket.accept()) {

InputStream in = connection.getInputStream();

//读取客户端的请求字符串，请求字符串以#终结

for (int c = in.read(); c != REQUEST_END_CHAR; c = in.read()) {

recvStrBuilder.append((char)c);

}

recvStrBuilder.append("_ok");

recvStrBuilder.append('#');

String recvStr = recvStrBuilder.toString();

//向客户端写出处理后的字符串

OutputStream out = connection.getOutputStream();

out.write(recvStr.toUpperCase().getBytes());

}

}

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

ToUpperTCPBlockServer server = new ToUpperTCPBlockServer();

server.startServer(SERVER_IP,SERVER_PORT);

}

}

下面是客户端代码：

package com.tzSocket.client;

import com.tzSocket.server.ToUpperTCPBlockServer;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

/**

* create by tz on 2018-08-02

*/

public class ToUpperTCPClient {

//客户端使用的TCP Socket

private Socket clientSocket;

public String toUpperRemote(String serverIp, int serverPort, String str) {

StringBuilder recvStrBuilder = new StringBuilder();

try {

//创建连接服务器的Socket

clientSocket = new Socket(serverIp, serverPort);

//写出请求字符串

OutputStream out = clientSocket.getOutputStream();

out.write(str.getBytes());

//读取服务器响应

InputStream in = clientSocket.getInputStream();

for (int c = in.read(); c != '#'; c = in.read()) {

recvStrBuilder.append((char)c);

}

} catch (IOException e) {

e.printStackTrace();

}finally {

try {

if (clientSocket != null) {

clientSocket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

return recvStrBuilder.toString();

}

public static void main(String[] args) {

ToUpperTCPClient client = new ToUpperTCPClient();

String recvStr = client.toUpperRemote(ToUpperTCPBlockServer.SERVER_IP, ToUpperTCPBlockServer.SERVER_PORT,

"tzTCPSocket" + ToUpperTCPBlockServer.REQUEST_END_CHAR);

System.out.println("收到:" + recvStr);

}

}

返回结果是：

收到:TZTCPSOCKET_OK

并发服务器

并发服务器是基于Executor线程池，与阻塞式服务器相比，具有更好的并发现，多客户端访问更加高效。

并发服务器的服务端示例如下：

package com.tzSocket.server;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

/**

* create by tz on 2018-08-02

*/

public class ToUpperTCPThreadServer {

//服务器IP

public static final String SERVER_IP = "127.0.0.1";

//服务器端口号

public static final int SERVER_PORT = 10005;

//请求终结字符串

public static final char REQUEST_END_CHAR = '#';

/***

* 启动服务器

* @param 服务器监听的端口号，服务器ip无需指定，系统自动分配

*/

public void startServer(String serverIP, int serverPort) {

//创建服务器地址对象

InetAddress serverAddr = null;

try {

serverAddr = InetAddress.getByName(serverIP);

} catch (UnknownHostException e) {

e.printStackTrace();

}

//Java提供了ServerSocket作为服务器

//这里使用了Java的自动关闭的语法，很好用

try(ServerSocket serverSocket = new ServerSocket(SERVER_PORT, 5, serverAddr)) {

Executor executor = Executors.newFixedThreadPool(100);

while (true) {

StringBuilder recvStrBuilder = new StringBuilder();

try {

//有客户端向服务器发起tcp连接时，accept会返回一个Socket

//该Socket的対端就是客户端的Socket

//具体过程可以查看TCP三次握手过程

Socket connection = serverSocket.accept();

//利用线程池，启动线程

executor.execute(new Runnable() {

@Override

public void run() {

//使用局部引用，防止connection被回收

Socket conn = connection;

try{

InputStream in = conn.getInputStream();

//读取客户端的请求字符串，请求字符串以#终结

for (int c = in.read(); c != REQUEST_END_CHAR; c = in.read()) {

recvStrBuilder.append((char)c);

}

recvStrBuilder.append("_isOK");

recvStrBuilder.append('#');

String recvStr = recvStrBuilder.toString();

//向客户端写出处理后的字符串

OutputStream out = conn.getOutputStream();

out.write(recvStr.toUpperCase().getBytes());

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (conn != null) {

conn.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

});

} catch (IOException e) {

e.printStackTrace();

}

}

}catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

ToUpperTCPThreadServer server = new ToUpperTCPThreadServer();

server.startServer(SERVER_IP, SERVER_PORT);

}

}

与阻塞式服务器相比并发服务器差别仅在于当accept返回socket后，启动线程处理，这里使用了Excutor，基于线程池进行处理。另外注意在Runnable的run方法中，使用一个局部对象引用connection，防止被JVM回收。

客户端只需做修改即可：

package com.tzSocket.client;

import com.tzSocket.server.ToUpperTCPBlockServer;

import com.tzSocket.server.ToUpperTCPThreadServer;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

/**

* create by tz on 2018-08-03

*/

public class ToUpperTCPClient {

//客户端使用的TCP Socket

private Socket clientSocket;

public String toUpperRemote(String serverIp, int serverPort, String str) {

StringBuilder recvStrBuilder = new StringBuilder();

try {

//创建连接服务器的Socket

clientSocket = new Socket(serverIp, serverPort);

//写出请求字符串

OutputStream out = clientSocket.getOutputStream();

out.write(str.getBytes());

//读取服务器响应

InputStream in = clientSocket.getInputStream();

for (int c = in.read(); c != '#'; c = in.read()) {

recvStrBuilder.append((char) c);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (clientSocket != null) {

clientSocket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

return recvStrBuilder.toString();

}

public static void main(String[] args) {

ToUpperTCPClient client = new ToUpperTCPClient();

//只需修改服务端端口即可

String recvStr = client.toUpperRemote(ToUpperTCPThreadServer.SERVER_IP, ToUpperTCPThreadServer.SERVER_PORT,

"tzTCPSocket" + ToUpperTCPBlockServer.REQUEST_END_CHAR);

System.out.println("收到:" + recvStr);

}

}

测试结果如下：

收到:TZTCPSOCKET_ISOK

异步服务器

最后一种服务器模式，如果开发异步服务器，需要使用Java的NIO才可以，所以，会发现代码中很多使用的类，与之前的不同了，下面是服务端示例代码：

package com.tzSocket.server;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.ServerSocketChannel;

import java.nio.channels.SocketChannel;

import java.util.Iterator;

/**

* create by tz on 2018-08-03

*/

public class ToUpperTCPNonBlockServer {

//服务器IP

public static final String SERVER_IP = "127.0.0.1";

//服务器端口号

public static final int SERVER_PORT = 10005;

//请求终结字符串

public static final char REQUEST_END_CHAR = '#';

public void startServer(String serverIP, int serverPort) throws IOException {

//使用NIO需要用到ServerSocketChannel

//其中包含一个ServerSocket对象

ServerSocketChannel serviceChannel = ServerSocketChannel.open();

//创建地址对象

InetSocketAddress localAddr = new InetSocketAddress(serverIP, serverPort);

//服务器绑定地址

serviceChannel.bind(localAddr);

//设置为非阻塞

serviceChannel.configureBlocking(false);

//注册到selector，会调用ServerSocket的accept

//我们用selector监听accept能否返回

//当调用accept可以返回时，会得到通知

//注意，是可以返回，还需要调用accept

Selector selector = Selector.open();

serviceChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {

//调用select，阻塞在这里，直到有注册的channel满足条件

selector.select();

//如果走到这里，有符合条件的channel

//可以通过selector.selectedKeys().iterator()拿到符合条件的迭代器

Iterator keys = selector.selectedKeys().iterator();

//处理满足条件的keys

while (keys.hasNext()) {

//取出一个key并移除

SelectionKey key = keys.next();

keys.remove();

try{

if (key.isAcceptable()) {

//有accept可以返回

//取得可以操作的channel

ServerSocketChannel server = (ServerSocketChannel) key.channel();

//调用accept完成三次握手，返回与客户端可以通信的channel

SocketChannel channel = server.accept();

//将该channel置非阻塞

channel.configureBlocking(false);

//注册进selector，当可读或可写时将得到通知，select返回

channel.register(selector, SelectionKey.OP_READ);

} else if (key.isReadable()) {

//有channel可读,取出可读的channel

SocketChannel channel = (SocketChannel) key.channel();

//创建读取缓冲区,一次读取1024字节

ByteBuffer buffer = ByteBuffer.allocate(1024);

channel.read(buffer);

//锁住缓冲区，缓冲区使用的大小将固定

buffer.flip();

//附加上buffer，供写出使用

key.attach(buffer);

key.interestOps(SelectionKey.OP_WRITE);

} else if (key.isWritable()) {

//有channel可写,取出可写的channel

SocketChannel channel = (SocketChannel) key.channel();

//取出可读时设置的缓冲区

ByteBuffer buffer = (ByteBuffer) key.attachment();

//将缓冲区指针移动到缓冲区开始位置

buffer.rewind();

//读取为String

String recv = new String(buffer.array());

//清空缓冲区

buffer.clear();

buffer.flip();

//写回数据

byte[] sendBytes = recv.toUpperCase().getBytes();

channel.write(ByteBuffer.wrap(sendBytes));

//变为等待读

key.interestOps(SelectionKey.OP_READ);

}

} catch (IOException e) {

key.cancel();

key.channel().close();

}

}

}

}

public static void main(String[] args) {

ToUpperTCPNonBlockServer server = new ToUpperTCPNonBlockServer();

try {

server.startServer(SERVER_IP, SERVER_PORT);

} catch (IOException e) {

e.printStackTrace();

}

}

}

客户端代码如下：

package com.tzSocket.client;

import com.tzSocket.server.ToUpperTCPNonBlockServer;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

/**

* create by tz on 2018-08-02

*/

public class ToUpperTCPClient {

//客户端使用的TCP Socket

private Socket clientSocket;

public String toUpperRemote(String serverIp, int serverPort, String str) {

StringBuilder recvStrBuilder = new StringBuilder();

try {

//创建连接服务器的Socket

clientSocket = new Socket(serverIp, serverPort);

//写出请求字符串

OutputStream out = clientSocket.getOutputStream();

out.write(str.getBytes());

//读取服务器响应

InputStream in = clientSocket.getInputStream();

for (int c = in.read(); c != '#'; c = in.read()) {

recvStrBuilder.append((char) c);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (clientSocket != null) {

clientSocket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

return recvStrBuilder.toString();

}

public static void main(String[] args) {

ToUpperTCPClient client = new ToUpperTCPClient();

String recvStr = client.toUpperRemote(ToUpperTCPNonBlockServer.SERVER_IP, ToUpperTCPNonBlockServer.SERVER_PORT,

"tzTCPSocket" + ToUpperTCPNonBlockServer.REQUEST_END_CHAR);

System.out.println("收到:" + recvStr);

}

}

结果如下：

收到:TZTCPSOCKET

可以看到，新的服务器使用了ServerSocketChannel以及SocketChannel，而不再是之前ServerSocket以及Socket，异步服务器的好处在于，服务器没有工作可做的时候，会等在select调用上，不会占用系统资源，而当不同的条件满足时，又可以第一时间被唤醒，执行相应的操作，所以无论从资源的利用上，还是从响应的及时性上都优于前两种。另外，如果write和read的时间比较长，处理也可以放到线程中处理，这样就结合了并发服务器的优势。