传统Socket编程传递POJO(使用Java自带的序列化方式)

刺骨的言语ヽ痛彻心扉 2022-07-14 15:12 283阅读 0赞

1、Java序列化的工具类

import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    import com.baowei.util.CloseUtils;
    
    public class NativeSerializeTools {
    	/**
    	 * 
    	 * @param s
    	 *            需要序列化的对象
    	 * @return
    	 * @throws IOException
    	 */
    	public static byte[] write(Serializable s) {
    		ObjectOutputStream oos = null;
    		ByteArrayOutputStream arrayOutputStream = null;
    		try {
    			arrayOutputStream = new ByteArrayOutputStream();
    			oos = new ObjectOutputStream(arrayOutputStream);
    			oos.writeObject(s);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			CloseUtils.closeCloseable(oos, arrayOutputStream);
    		}
    		return arrayOutputStream.toByteArray();
    	}
    
    	/**
    	 * 
    	 * @param data
    	 *            对象序列化后的自己数组
    	 * @param clazz
    	 *            对象
    	 * @return
    	 * @throws IOException
    	 * @throws ClassNotFoundException
    	 */
    	public static <T> T read(byte[] data, Class<T> clazz) {
    		ObjectInputStream ois = null;
    		ByteArrayInputStream inputStream = null;
    		Object o = null;
    		try {
    			inputStream = new ByteArrayInputStream(data);
    			ois = new ObjectInputStream(inputStream);
    			o = ois.readObject();
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			CloseUtils.closeCloseable(ois, inputStream);
    		}
    		return (T) o;
    	}
    }

2、对于客户端，请求信息的封装(**因为要使用Java的序列化机制，所以需要实现Serializable接口**)

public class RequestInfo implements Serializable {
    	private String requestInfo;
    	public RequestInfo() {
    	}
    	public RequestInfo(String requestInfo) {
    		super();
    		this.requestInfo = requestInfo;
    	}
    	public String getRequestInfo() {
    		return requestInfo;
    	}
    	public void setRequestInfo(String requestInfo) {
    		this.requestInfo = requestInfo;
    	}
    	@Override
    	public String toString() {
    		return "RequestInfo [requestInfo=" + requestInfo + "]";
    	}
    }

3、对于服务端，响应信息的封装( **因为要使用Java的序列化机制，所以需要实现Serializable接口** )

import java.io.Serializable;
    public class ResponseInfo implements Serializable {
    	private String resposeInfo;
    	public ResponseInfo() {
    	}
    	public ResponseInfo(String resposeInfo) {
    		this.resposeInfo = resposeInfo;
    	}
    	public String getResposeInfo() {
    		return resposeInfo;
    	}
    	public void setResposeInfo(String resposeInfo) {
    		this.resposeInfo = resposeInfo;
    	}
    	@Override
    	public String toString() {
    		return "ResponseInfo [resposeInfo=" + resposeInfo + "]";
    	}
    }

4、客户端代码

4.1  对于获取客户端请求信息的处理

// 客户端向服务端，发送数据
    			// 同时接受，服务端响应的信息
    			while (true) {
    				// 1.接受客户端控制台的输入，并发送给服务端
    				// 以方法的形式抽离出去了
    				Scanner scanner = new Scanner(System.in);
    				String requestInfo = scanner.nextLine();
    				RequestInfo info = new RequestInfo(requestInfo);
    
    				// 使用Java自带的序列化的方式
    				sendDataToServer(out, NativeSerializeTools.write(info));
    
    				// 2.接受服务端响应的数据，并处理
    				// 因为处理，根据不同的业务，处理不同
    				// 所以抽离出去,使用handleResponse(String response)函数处理
    				// 在这里，只是简单的输出打印
    				handleResponse(in);
    			}

4.2  对于响应信息的处理

byte[] data = new byte[2048];
    			int len = input.read(data);
    
    			// 有数据，进行处理
    			if (len > 0) {
    				ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    				byteArrayOutputStream.write(data, 0, len);
    				// 对服务端，返回的数据处理
    				ResponseInfo info = NativeSerializeTools
    						.read(byteArrayOutputStream.toByteArray(),
    								ResponseInfo.class);
    				System.out.println("Client接收到Server发来的数据: "
    						+ info.getResposeInfo());
    			}

4.3  完整的客户端代码

import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.util.Scanner;
    
    import com.baowei.entity.RequestInfo;
    import com.baowei.entity.ResponseInfo;
    import com.baowei.serializable.NativeSerializeTools;
    
    public class Client {
    	private String ADDRESS = null;
    	private int PORT;
    	private Socket socket = null;
    	private InputStream in = null;
    	private OutputStream out = null;
    	public void connect(String address, int port) {
    		try {
    			this.ADDRESS = address;
    			this.PORT = port;
    			socket = new Socket(ADDRESS, PORT);
    			in = socket.getInputStream();
    			out = socket.getOutputStream();
    			// 客户端向服务端，发送数据
    			// 同时接受，服务端响应的信息
    			while (true) {
    				// 1.接受客户端控制台的输入，并发送给服务端
    				// 以方法的形式抽离出去了
    				Scanner scanner = new Scanner(System.in);
    				String requestInfo = scanner.nextLine();
    				RequestInfo info = new RequestInfo(requestInfo);
    
    				// 使用Java自带的序列化的方式
    				sendDataToServer(out, NativeSerializeTools.write(info));
    
    				// 2.接受服务端响应的数据，并处理
    				// 因为处理，根据不同的业务，处理不同
    				// 所以抽离出去,使用handleResponse(String response)函数处理
    				// 在这里，只是简单的输出打印
    				handleResponse(in);
    			}
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	// 客户端，给服务端发送请求数据
    	private static void sendDataToServer(OutputStream out, byte[] requestInfo) {
    		try {
    			out.write(requestInfo);
    			out.flush();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    
    	// 对服务端返回的数据，做处理
    	// 这可以是一个逻辑，所有从上面的代码抽出来
    	// 是的代码，看起来更加的整洁美观
    	private static void handleResponse(InputStream input) {
    		try {
    			byte[] data = new byte[2048];
    			int len = input.read(data);
    
    			// 有数据，进行处理
    			if (len > 0) {
    				ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    				byteArrayOutputStream.write(data, 0, len);
    				// 对服务端，返回的数据处理
    				ResponseInfo info = NativeSerializeTools
    						.read(byteArrayOutputStream.toByteArray(),
    								ResponseInfo.class);
    				System.out.println("Client接收到Server发来的数据: "
    						+ info.getResposeInfo());
    			}
    		} catch (IOException e) {
    			throw new RuntimeException(e);
    		}
    	}
    	// 测试方法
    	public static void main(String[] args) {
    
    		new Client().connect("127.0.0.1", 8338);
    	}
    }

5、服务端代码

import java.net.ServerSocket;
    import java.net.Socket;
    public class Server {
    	public void listener(int port) {
    		ServerSocket server = null;
    		try {
    			server = new ServerSocket(port);
    			System.out.println("server start  port " + port + " ... ");
    			HandlerExecutorPool executorPool = new HandlerExecutorPool(100, 500);
    			// 进行阻塞,用于接收客户端的请求
    			while (true) {
    				Socket socket = server.accept();
    				System.out.println("一个客户端连接上来了");
    				// 利用线程池的线程，执行客户端的任务
    				executorPool.execute(new ServerHandler(socket));
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	// 开启服务器
    	public static void main(String[] args) {
    		new Server().listener(8338);
    	}
    }

6、服务端Handler代码

6.1  对于获取客户端请求信息的处理

byte[] data = new byte[2048];
    			int len = input.read(data);
    			// 有数据，进行处理
    			if (len > 0) {
    				ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    				byteArrayOutputStream.write(data, 0, len);
    				// 获取客户端的请求数据
    				RequestInfo info = NativeSerializeTools.read(
    						byteArrayOutputStream.toByteArray(), RequestInfo.class);
    				System.out.println("Client接收到Server发来的数据: "
    						+ info.getRequestInfo());
    				byte[] resposeInfo = getAnswer(info.getRequestInfo());
    				// 服务端，根据客户端的请求数据，返回的数据
    				sendDataToClient(out, resposeInfo);

6.2  对于响应信息的处理

// 根据用户的请求，获取返回信息
    	// 实际的开发，可以到数据库获取数据
    	private byte[] getAnswer(String question) {
    		String answer = "请输入 who， 或者what， 或者where";
    		if ("who".equals(question)) {
    			answer = "我是莉莉";
    		} else if ("what".equals(question)) {
    			answer = "我是来帮你解闷的";
    		} else if ("where".equals(question)) {
    			answer = "我来自外太空";
    		} else {
    			answer = "请输入 who， 或者what， 或者where";
    		}
    		// 实际开发，可以根据请求信息
    		// 到数据库查询数据，并且返回给客户端
    		System.out.println(answer);
    
    		ResponseInfo info = new ResponseInfo(answer);
    		// 将结果以JSON的方式返回
    		return NativeSerializeTools.write(info);
    	}

6.3  完整的服务端代码

import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import com.baowei.entity.RequestInfo;
    import com.baowei.entity.ResponseInfo;
    import com.baowei.serializable.NativeSerializeTools;
    import com.baowei.util.CloseUtils;
    public class ServerHandler implements Runnable {
    	private Socket socket;
    	private InputStream input;
    	private OutputStream out;
    
    	public ServerHandler(Socket socket) {
    		this.socket = socket;
    	}
    	@Override
    	public void run() {
    		try {
    			// 模拟线程池处理不及时
    			Thread.sleep(1000);
    			System.out.println(Thread.currentThread().getName());
    			input = this.socket.getInputStream();
    			out = this.socket.getOutputStream();
    			// 用于处理客户端的请求，并返回信息给客户端
    			while (true) {
    				handle(input, out);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			// 释放资源
    			CloseUtils.closeCloseable(input, out, socket);
    		}
    	}
    
    	// 用于获取客户端的请求信息
    	// 并将返回信息，发送给客户端
    	private void handle(InputStream input, OutputStream out) {
    		try {
    			byte[] data = new byte[2048];
    			int len = input.read(data);
    
    			// 有数据，进行处理
    			if (len > 0) {
    				ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    				byteArrayOutputStream.write(data, 0, len);
    				// 获取客户端的请求数据
    				RequestInfo info = NativeSerializeTools.read(
    						byteArrayOutputStream.toByteArray(), RequestInfo.class);
    				System.out.println("Client接收到Server发来的数据: "
    						+ info.getRequestInfo());
    				byte[] resposeInfo = getAnswer(info.getRequestInfo());
    				// 服务端，根据客户端的请求数据，返回的数据
    				sendDataToClient(out, resposeInfo);
    			}
    
    		} catch (IOException e) {
    			// e.printStackTrace();
    			// 释放资源
    			CloseUtils.closeCloseable(input, out, socket);
    			return;
    		}
    
    	}
    	// 服务端，用于给客户端发送数据
    	// 也就是将，根据客户端的请求的信息，获取的返回信息。返回给客户端
    	// 客户端，给服务端发送请求数据
    	private static void sendDataToClient(OutputStream out, byte[] responseInfo) {
    		try {
    			out.write(responseInfo);
    			// 服务端写数据给客户端的时候，要执行flush()操作
    			// 不然客户端，可能不会及时的接收到信息
    			out.flush();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	// 根据用户的请求，获取返回信息
    	// 实际的开发，可以到数据库获取数据
    	private byte[] getAnswer(String question) {
    		String answer = "请输入 who， 或者what， 或者where";
    		if ("who".equals(question)) {
    			answer = "我是莉莉";
    		} else if ("what".equals(question)) {
    			answer = "我是来帮你解闷的";
    		} else if ("where".equals(question)) {
    			answer = "我来自外太空";
    		} else {
    			answer = "请输入 who， 或者what， 或者where";
    		}
    		// 实际开发，可以根据请求信息
    		// 到数据库查询数据，并且返回给客户端
    		System.out.println(answer);
    
    		ResponseInfo info = new ResponseInfo(answer);
    		// 将结果以JSON的方式返回
    		return NativeSerializeTools.write(info);
    	}
    }

7、自定义线程池

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class HandlerExecutorPool {
    	private ExecutorService executor;
    
    	/**
    	 * 
    	 * @param maxPoolSize
    	 *            线程池，最大的线程数
    	 * @param queueSize
    	 *            阻塞队列的最大个数
    	 */
    	public HandlerExecutorPool(int maxPoolSize, int queueSize) {
    		this.executor = new ThreadPoolExecutor(Runtime.getRuntime()
    				.availableProcessors(), maxPoolSize, //
    				120L, TimeUnit.SECONDS, //
    				new LinkedBlockingQueue<Runnable>(queueSize));
    	}
    
    	public void execute(Runnable task) {
    		this.executor.execute(task);
    	}
    
    }

8、关闭流的工具类

import java.io.Closeable;
    import java.io.IOException;
    public class CloseUtils {
    	public static void closeCloseable(Closeable... closeables) {
    		for (int i = 0; i < closeables.length; i++) {
    			if (closeables[i] != null) {
    				try {
    					closeables[i].close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }

9、[源码下载][Link 1]

[Link 1]: http://pan.baidu.com/s/1pL30IUJ