浅谈Java---Socket

       网络上的两个程序通过一个双向的通信连接实现数据的交换，这样连接的一端称为一个socket。socket本质是编程接口(API),对于TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。http是轿车，提供了封装或者显示数据的具体形式；socket是发动机，提供了网络通信的能力。

      建立一个完整的socket(套接字)，需要调用java.net包中的Socket类和ServerSocket类(Socket类和ServerSocket类的工作都是通过SocketImpl类及其子类完成的)，客户端的输出流是服务器端的输入流，服务器端的输出流是客户端的输入流。

通信过程

网络分为应用层，http、ssh、telnet就是属于这一类，建立在传输层的基础上，其实就是定义了各自的编码解码格式，分层如下：

Socket连接

上述通信都要先在传输层有建立连接的基础上才能完成，TCP通过三次握手建立连接：

java Socket客户端与服务端互发消息

实现结构图：

客户端和服务端分别通过两个线程来完成发送消息和接收消息，此前需要等待客户端和服务端建立连接，代码如下：

服务端代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;


/**
 * 聊天室服务端
 * @author soft01
 *
 */

public class Server {
	/*
	 * 运行在服务端的ServerSocket主要有两个作用：
	 * 1：向系统申请服务端口（客户端就是通过这个端口与服务端程序建立连接的）
	 * 2：监听端口，一旦一个客户端建立连接，那么就会自动创建一个Socket与该客户端通讯。
	 */
	private ServerSocket server;
	/*
	 * 该数组用于保存所有ClientHandler对应客户端的输出流，便于这些ClientHandler转发消息
	 */
	//private PrintWriter[] allOut = {};
	private Collection<PrintWriter> allOut = new ArrayList<>();
	
	public Server() {
		try {
			System.out.println("正在启动服务端");
			server = new ServerSocket(8088);
			System.out.println("服务端启动完毕");
			
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public void start() {
		try {
			/*
			 * ServerSocket提供了接受客户端连接的方法：
			 * Socket accept()
			 * 这是一个阻塞方法，调用后服务端开始等待，
			 * 直到一个客户端通过这个端口与服务端建立连接为止，
			 * 这时该方法会返回一个Socket实例，通过这个实例就可以与该客户通讯了。。
			 * 
			 * 多次调用accept方法可以等待多个客户端的连接。
			 */
			while(true) {
			System.out.println("等待客户端连接...");
			Socket socket = server.accept();
			System.out.println("一个客户端连接了");
			ClientHandler handler = new ClientHandler(socket);
			Thread t = new Thread(handler);
			t.start();
			
			//启动一个线程来处理
			
			}
		}catch(Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public static void main(String[] args) {
		Server server = new Server();
		server.start();
	}
	/*
	 * 该线程任务是负责与指定客户端进行交互
	 */
	private class ClientHandler implements Runnable{
		private Socket socket;
		//客户端地址信息
		private String host;
		
		public ClientHandler(Socket socket) {
			this.socket = socket;
			
			//通过socket获取远端计算机地址信息
			InetAddress address = socket.getInetAddress();
			//获取远端计算机地址信息IP的字符串格式
			host = address.getHostAddress();
		}
		public void run() {
			PrintWriter pw = null;
			try {
				/*
				 * 通过Socket获取输入流，可以读取远端计算机发送过来的字节数据。
				 */
				InputStream in = socket.getInputStream();
				InputStreamReader isr = new InputStreamReader(in,"utf-8");
				BufferedReader br = new BufferedReader(isr);
				
				/*
				 * 通过socket获取输出流，以便将消息发送给客户端
				 */
				OutputStream out = socket.getOutputStream();
				OutputStreamWriter osw = new OutputStreamWriter(out);
				BufferedWriter bw = new BufferedWriter(osw);
				 pw = new PrintWriter(bw,true);
				/*
				 * 将当前ClientHandler对应客户端的输出流放入共享数组allOut中，以便其他的ClientHandler
				 * 也可以访问到，从而给这个客户端转发消息
				 */
				 
				 /*
				  * 多个线程（ClientHandler)不能同时对allOut数组扩容添元素，会出现并发安全问题。
				  */
				 synchronized(allOut) {
//					//1     对allOut扩容
//						allOut = Arrays.copyOf(allOut, allOut.length+1);
//						//2     将输出流存入到数组中
//						allOut[allOut.length-1] = pw;
					 allOut.add(pw);
				 }
				
				System.out.println(host+"上线了，当前在线人数："+allOut.size());
				System.out.println("length:"+allOut.size());
				
				
				String message = null;
				while((message = br.readLine())!=null) {//读取一行到换行符位置停止
					System.out.println(host+"说："+message);
					//将消息发送给客户端
					synchronized(allOut) {
					for(PrintWriter o  : allOut) {
					o.println(host+"说："+message);	
					}
				}	
				}
			}catch(Exception e) {
				e.printStackTrace();
			}finally {
				//处理客户端断开连接后的操作
				
				//先将当前客户端输出流从共享数组中删除
				synchronized(allOut) {
//					for (int i = 0; i < allOut.length; i++) {
//						if(allOut[i]==pw) {
//							allOut[i]=allOut[allOut.length-1];
//							allOut=Arrays.copyOf(allOut, allOut.length-1);
//							break;
//					}
//					}
					allOut.remove(pw);
				}
				
				System.out.println(host+"下线了，当前在线人数："+allOut.size());
				try {
					socket.close();
				}catch(IOException e) {
					
				}
			}
			
			
		}
	}
	

}

客户端代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 聊天室客户端
 * @author soft01
 *
 */

public class Client {
	/*
	 * java.net.socket套接字
	 * Socket 封装了TCP连接和通讯的细节，使用它可以通过两条流的读写完成与远端计算机的数据交互。
	 */
	
	private Socket socket;
	/**
	 * 构造方法，用来初始化客户端
	 * @param args
	 */
	Scanner scan = new Scanner(System.in);
	public Client() {
		try {
			/*
			 * 实例化Socket时需要传入两个参数：
			 * 1:服务端计算机的IP地址
			 * 2:服务段应用程序打开的服务端口
			 * 我们通过IP可以找到网络上的服务端计算机，通过端口连接到该机器上的服务端应用程序。
			 * 
			 * 实例化Socket的过程就是连接的过程，若服务器端没有响应这里就会抛出异常。
			 */
			System.out.println("正在连接服务端...");
			socket = new Socket("192.168.1.17",8088);//本机地址，（连接别人需要别人IP地址）
			System.out.println("已连接");
			
		}catch(Exception e) {
			e.printStackTrace();//捕获异常
		}
		
	}
	
	
	/**
	 * 客户端开始工作的方法
	 * @param args
	 */
	public void start() {
		try {
			//启动用于读取服务端发送过来消息的线程
			ServerHandler handler = new ServerHandler();
			Thread t = new Thread(handler);
			t.start();
			/*
			 * Socket提供的方法：
			 * OutputStream getOutputStream()
			 * 获取的字节输出流写出的字节会通过网络发送给远端的计算机
			 */
			OutputStream out = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
			BufferedWriter bw = new BufferedWriter(osw);
			PrintWriter  pw = new PrintWriter(bw,true);
			
		
			
			while(true) {
				
				System.out.println("请输入内容");
				String line = scan.nextLine();
				pw.println(line);
				} 
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	
	
	public static void main(String[] args) {
		Client client = new Client();
		client.start();
		
	}
/*
 * 该线程负责读取服务端发送过来的消息
 */
	private class ServerHandler implements Runnable{
		public void run() {
			try {
				
				//创建输入流读取服务端发送过来的消息
				InputStream in = socket.getInputStream();
				InputStreamReader read = new InputStreamReader(in,"utf-8");
				BufferedReader br = new BufferedReader(read);
				//循环读取服务端发送过来的消息
				String message = null;
				while((message=br.readLine())!=null) {
					System.out.println(message);
				}
				
			}catch(Exception e) {
				
			}
		}
	}
	
	
}

上面是一个实现Java聊天室的简单案例，可以根据自己的需求进行改动！

在接收消息的时候要注意编码格式，个人在用socket与硬件对接时就出现了乱码的情况。此时需要用byte数组去接收数据，根据硬件对应的编码格式进行转码，就可以避免乱码的出现。同时也避免了读一行出现的问题哦

InputStream in = socket.getInputStream();
String message ="";
int len = 0;
byte[] buf = new byte[1];
DataInputStream dis = new DataInputStream(new BufferedInputStream(in));
while(dis.read(buf)!= -1){
	message += bytesToHexString(buf)+" ";
	if(dis.available() == 0){
		log.info(host + "发送的消息为：" + message);
		//接收消息后进行逻辑处理
		}
	}

此处附上byte[]数组转换为16进制的字符串的方法(具体情况根据自己项目的实际情况而定)

 /**
     * byte[]数组转换为16进制的字符串
     *
     * @param bytes 要转换的字节数组
     * @return 转换后的结果
     */
    public static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

另外在此附上socket获取客户端数据自启动的代码

 /*socket获取客户端数据自启动*/
    @Component
    @Order(value = 1)
    public class JDDRunner implements ApplicationRunner {
        @Override
        public void run(ApplicationArguments args) throws Exception {
            new Thread(){
                public void run(){
                    new Server().start();
                }
            }.start();
        }
    }

纸上得来终觉浅，绝知此事要躬行。关于socket的介绍后期用到还会继续完善，希望对看到的小伙伴有所帮助。不喜勿喷！

参考博客：https://blog.csdn.net/zkkzpp258/article/details/80863958