1. 套接字介绍

套接字是介于传输层(TCP/UDP)和应用层(HTTP/FTP)之间的一个抽象，被应用程序调用;

在java环境中套接字编程主要使用TCP/IP协议，但是套接字支持的协议族远不止这些；

在java套接字编程中有Socket和ServerSocket两个核心类，ServerSocket位于服务器端监听连接，Socket位于客户端发起连接，服务器端监听到连接后也会产生一个Socket实例来完成与对端Socket的通信，并且服务器端的Socket和客户端的Socket没有任何区别，也就是说进程间通信需要一对套接字完成；

2. API介绍

Socket和ServerSocket是java提供网络编程的门面接口，实际上都是通过SocketImpl及子类完成的；

2.1 重要类关系图

2.2 重要类介绍

1. InetAddress

InetAddress是java对IP地址的封装，包括IP设备的名称、ip地址，有Inet4Address和Inet6Address两个子类；

没有公开的构造方法，只能通过公开的静态方法实例化对象

方法介绍

1）getByName：实例化一个InetAddress对象，getByName的参数可以是ip地址字符串，也可以是主机名

2）anyLocalAddress：实例化一个表示任何本地地址的网络地址，通常是0.0.0.0

3）getHostAddress一般通过InetAddress的获取主机ip地址串，通过获取主机名

4）getHostName

2. SocketAddress/InetSocketAddress

套接字地址，用来表示一个套接字在网络中的位置；

SocketAddress不依赖任何协议的套接字地址；

InetSocketAddress表示一个IP套接字地址，由套接字地址的 IP地址(InetAddress)、主机名和端口号组成

3. ServerSocket

服务器套接字，在服务器端用于监听网络传入

构造方法

1）ServerSocket()：创建一个不绑定任何ip和端口的服务器套接字

创建一个SocksSocketImpl赋值给ServerSocket的SocketImpl，并把自己赋值给SocketImpl的ServerSocket

2）ServerSocket(port, backlog, InetAddress)：用指定的端口、连接大小、ip地址创建一个服务器套接字

同无参构造，创建SocksSocketImpl并相互赋值

根据port和InetAddress创建套接字地址InetSocketAddress（InetAddress, port），如果InetAddress为null则通过InetAddress的anyLocalAddress实例化一个IP地址，如果port不合法则抛出异常；

通过调用bind(SocketAddress, backlog)将服务器套接字和套接字地址进行绑定；

backlog说明https://blog.csdn.net/oyueyang1/article/details/80451535

方法介绍

1）bind(SocketAddress, backlog)：将服务器套接字和套接字地址进行绑定，tcp accept队列大小为backlog

如果SocketAddress为null则新建一个InetSocketAddress(InetAddress.anyLocalAddress, 0),0表示让系统随机分配端口号

实际上通过SocketImpl的bind(InetAddress, port)绑定的，SocketImpl是在构造函数中创建并绑定到当前类的

有参构造方法在构造过程都进行了bind操作，所以此方法一般与无参构造方法同时使用

2）isBound、getInetAddress、getLocalPort、getLocalSocketAddress查询bind方法的绑定信息

3）accept：阻塞式的监听到此服务器套接字连接，监听到连接后会创建一个Socket套接字，服务端和客户端各有一个Socket，2个套接字可以完成不同进程间通信；

4）implAccept(Socket)：为保护方法，当我们自定义ServerSocket需要复写accept方法时，需要新建一个Socket然后通过implAccept加工，accept的阻塞其实是阻塞在implAccept的加工过程

5）getChannel：获取ServerSocketChannel通道

6）close/isClose：关闭套接字/判断套接字是否已关闭

关闭服务器套接字后，阻塞在accept的线程会抛出SocketException；

ServerSocketChannel通道关闭；

注意：没有直接方法判断对端套接字是否关闭

7）getSoTimeout/setSoTimeout：设置accept的阻塞时间，0时表示无穷大，如果超时抛出SocketTimeOutException；

间接调用SocketImple的getOption(capId)/setOption(capId,Object), capId为SO_TIMEOUT(SocketOption中定义)；

8）setSocketFactory(SocketImplFactory)：设置套接字实现工厂

构造方法中会创建一个SocketImpl，默认是创建SocksSocketImpl，如果已设置SocketImplFactory则会调用工厂方法创建一个

4. Socket

套接字或客户端套接字，不同进程通信的端点，服务器端会有n多个客户端套接字

构造方法

1）Socket()：创建一个不绑定任何套接字地址，不连接任务服务器套接字的套接字

创建一个SocksSocketImpl赋值给Socket的SocketImpl，并把自己赋值给SocketImpl的Socket, 同ServerSocket的无参构造方法

2）Socket(SocketAddress serverAddress, SocketAddress localAddress, boolean stream)：创建套接并绑定和连接到指定套接字地址

绑定到本地套接字地址localAddress，连接的服务器套接字地址为serverAddress；

如果localAddress为null则内核随机选择一个本地ip地址和端口进行绑定；

stream表示流套接字（tcp），负责数据包datagram套接字（udp，每个包有大小限制）

3）Socket(InetAddress server, int serverPort, InetAddress local, int localPort)：创建套接并绑定和连接到指定套接字地址

将server和serverPort封装成服务器套接字SocketAddress，local和localPort封装成客户端套接字SocketAddress，然后调用Socket(SocketAddress, SocketAddress, stream)创建流式套接字

4）Socket(String host, int port)：

将host和port封装成服务器端套接字地址SocketAddress；

本地SocketAddress为null则，本地端口随机，任意一本机ip；

调用Socket（SocketAddress， SocketAddress， stream）创建流式Socket；

方法介绍

1）connect(SocketAddress)/connect(SocketAddress, timeout)：连接到套接字地址指定的服务器套接字

有参数构造方法中都会调用connect方法，所以此方法一般与无参构造方法同时使用

2）bind(SocketAddress) ：将套接字和套接字地址进行绑定

如果已绑定则异常；

如果没有绑定在connect方法中会进行绑定，所以如果要调用bind方法需要在connect前调用；

3）getInetAddress()/getPort()/getRemoteSocketAddress()：获取对端套接字的IP地址、端口号、套接字地址，没有连接则返回null

4）getLocalAddress()/getLocalPort()/getLocalSocketAddress()：获此套接字的IP地址、端口号、套接字地址

5）getChannel()：返回此套接字的SocketChannel通道

6）getInputStream()：返回套接字的输入流

如果连接正常，inputstream的read会一直阻塞；

关闭输入流会关闭对应的套接字；

当Socket底层的连接中断时，套接字已缓存的字节可以通过read读取，如果已经消耗了所有缓存的字节，read操作会抛出IOException，套接字上没有任何缓存字节，并且套接字没有关闭调用 available返回0

7）getOutputStream()：返回套接字的输出流

关闭输出流会关闭对应的套接字

8）setSoTimeout(timeout)：Socket关联的InputStream的read操作默认是阻塞的，如果设置超时值，read操作超时引发SocketTimeoutException

实际上通过SocketImpl的setOption(optId)实现， optId为SO_TIMEOUT（SocketOptions中定义）

9）close：关闭套接字

阻塞于当前套接字的IO操作会抛出SocketException;

关闭后不能重新连接和重新绑定（已建立的连接不能用），只能通过新建；

会关闭此套接字的输入输出流；

关闭关联的通道；

10）shutdownInput：丢弃发送到输入流的所有字节，读取内容返回EOF

11）shutdownOutput：禁用输出流，以前发送的字节都会被底层发送，如果关闭后执行写入会抛出IOException

12）isBound/isClose/isConnect/isInputShutdown/isOutputSHutdown：用于判断相应的操作是否结束

13）setSocketImplFactory：设置套接字实现的工厂，构造方法默认会创建一个SocksSocketImpl，如果指定工厂会通过工厂创建

3. 实例

工具类：SocketUtil

1 1 import java.net.InetSocketAddress;
2 2 import java.net.SocketAddress;
3 3 
4 4 /**
5 5  * 工具类
6 6  */
7 7 public class SocketUtil {
8 8 
9 9     /**
1010      * 解析套接字地址中的ip和端口
1111      */
1212     public static String getSocketAddress(SocketAddress socketAddress) {
1313 
1414         if (socketAddress instanceof InetSocketAddress) {
1515             InetSocketAddress inetSocketAddress = ((InetSocketAddress) socketAddress);
1616             int port = inetSocketAddress.getPort();
1717             String hostName = inetSocketAddress.getHostName();
1818             return String.format("%s:%s", hostName, port);
1919         }
2020 
2121         return null;
2222     }
2323 }

View Code

服务器类：DemoTcpServer

1 1 import java.io.*;
2 2 import java.net.*;
3 3 import java.util.*;
4 4 import java.util.concurrent.ExecutorService;
5 5 import java.util.concurrent.Executors;
6 6 
7 7 /**
8 8  * 群聊服务器：启动服务器套接字，监听并处理连接
9 9  */
1010 public class DemoTcpServer {
1111 
1212     static final List<Socket> ONLINE_SOCKET = new ArrayList();
1313 
1414     public static void main(String[] args) throws IOException {
1515 
1616         // 创建服务器套接字，并绑定到本机的41440端口监听
1717         ServerSocket serverSocket = new ServerSocket(41440, 50, InetAddress.getByName("192.168.1.101"));
1818         System.out.println("服务器started...");
1919 
2020         // 创建线程池用于处理已连接的socket
2121         ExecutorService executorService = Executors.newFixedThreadPool(10);
2222         while (true) {
2323             // 等待socket接入，有连接接入后会创建一个Socket与对端Socket通信，此Socket地址ip为本机、端口随机
2424             Socket socket = serverSocket.accept();
2525             String socketAddress = SocketUtil.getSocketAddress(socket.getRemoteSocketAddress());
2626             System.out.println(socketAddress + " 上线了...");
2727             // 加入到在线的socket列表，用于群发消息
2828             ONLINE_SOCKET.add(socket);
2929             // 单独起一个线程监听消息，可以改成nio的Selectors实现
3030             executorService.submit(new SocketHandler(socket));
3131         }
3232     }
3333 }
3434 
3535 /**
3636  * 处理Socket的任务
3737  */
3838 class SocketHandler implements Runnable {
3939 
4040     private Socket socket;
4141 
4242     public SocketHandler(Socket socket) {
4343         this.socket = socket;
4444     }
4545 
4646     @Override
4747     public void run() {
4848         try {
4949             String clientFlag = SocketUtil.getSocketAddress(this.socket.getRemoteSocketAddress());
5050             byte[] input = new byte[1024];
5151             // 循环监听消息
5252             while (true) {
5353                 // 阻塞式读取消息
5454                 int read = this.socket.getInputStream().read(input);
5555                 // 服务器记录发送的所有消息
5656                 System.out.println(clientFlag + " " + new String(input, 0, read, "utf-8"));
5757                 // 群发消息
5858                 sendMsg(this.socket, clientFlag, new String(input, 0, read, "utf-8"));
5959             }
6060         } catch (IOException e) {
6161             System.out.println(SocketUtil.getSocketAddress(socket.getRemoteSocketAddress()) + "下线...");
6262             DemoTcpServer.ONLINE_SOCKET.remove(socket);
6363         }
6464     }
6565 
6666     /**
6767      * 群发消息
6868      */
6969     private void sendMsg(Socket ignoreSocket, String clientFlag, String msg) {
7070 
7171         Iterator<Socket> iterator = DemoTcpServer.ONLINE_SOCKET.iterator();
7272         while (iterator.hasNext()) {
7373 
7474             Socket currentSocket = iterator.next();
7575 
7676             // 不需要向此Socket对端发送消息，只有一个客户端时需要注解此判断
7777             if (currentSocket.equals(ignoreSocket)) {
7878                 continue;
7979             }
8080 
8181             // 发送消息到客户端
8282             try {
8383                 currentSocket.getOutputStream().write((clientFlag + System.lineSeparator() + msg).getBytes("utf-8"));
8484             } catch (Exception e) {
8585                 System.out.println(SocketUtil.getSocketAddress(currentSocket.getRemoteSocketAddress()) + "下线...");
8686                 iterator.remove();
8787             }
8888         }
8989     }
9090 }

View Code

客户端类：

1 1 import java.io.IOException;
2 2 import java.net.InetSocketAddress;
3 3 import java.net.Socket;
4 4 import java.util.Scanner;
5 5 
6 6 /**
7 7  * 客户端
8 8  */
9 9 public class DemoTcpClient {
1010     public static void main(String[] args) throws Exception {
1111 
1212         //以下3步可以通过有参构造方法一次指定
1313         // 创建客户端socket
1414         Socket socket = new Socket();
1515         // 绑定到本地的ip和端口号
1616         socket.bind(new InetSocketAddress("192.168.1.101", 41441));
1717         // 连接到远程的套接字服务器
1818         socket.connect(new InetSocketAddress("192.168.1.101", 41440), 0);
1919         System.out.println("已上线...");
2020 
2121         // 新启动线程用于回显消息
2222         new Thread(() -> {
2323             try {
2424                 byte[] input = new byte[1024];
2525                 while (true) {
2626                     int read = socket.getInputStream().read(input);
2727                     System.out.println(new String(input, 0, read, "utf-8"));
2828                 }
2929             } catch (IOException e) {
3030                 e.printStackTrace();
3131             }
3232         }).start();
3333 
3434         //处理输入
3535         Scanner scanner = new Scanner(System.in);
3636         while (scanner.hasNext()) {
3737             socket.getOutputStream().write(scanner.nextLine().getBytes("utf-8"));
3838             socket.getOutputStream().flush();
3939         }
4040     }
4141 }

View Code

参考文献：

1. https://droidyue.com/blog/2015/03/08/sockets-programming-in-java/
　　2. https://my.oschina.net/leejun2005/blog/104955
　　3. https://www.cnblogs.com/w-wfy/p/6415840.html

Java Socket

1. 套接字介绍

2. API介绍

2.2 重要类介绍

3. 实例

评论区

相关推荐