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;
}
}
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 + "]";
}
}
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.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);
}
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);
}
}
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.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);
}
}
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);
}
}
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();
}
}
}
}
}
123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
