Java实现Socket编程中的代理模式
2022-12-287.6k 阅读
1. 代理模式概述
1.1 代理模式的定义
代理模式是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。在代理模式中，代理对象与真实对象实现相同的接口，客户端通过代理对象来访问真实对象，代理对象可以在调用真实对象的方法前后添加一些额外的处理逻辑，比如权限控制、缓存、日志记录等。
1.2 代理模式的角色
- 抽象主题（Subject）：定义了真实主题和代理主题的共同接口，这样在任何使用真实主题的地方都可以使用代理主题。
- 真实主题（RealSubject）：定义了代理对象所代表的真实对象，实现了抽象主题接口。
- 代理主题（Proxy）：持有一个指向真实主题的引用，实现了抽象主题接口，在调用真实主题的方法前后可以添加额外的处理逻辑。
2. Java中的Socket编程基础
2.1 Socket的概念
Socket（套接字）是一种网络编程接口，它允许不同主机上的应用程序进行通信。在Java中，Socket编程主要基于TCP（传输控制协议）和UDP（用户数据报协议）两种协议。TCP是一种面向连接的、可靠的协议，而UDP是一种无连接的、不可靠的协议。在本文中，我们主要关注基于TCP协议的Socket编程。
2.2 Java中的Socket类和ServerSocket类
- Socket类：用于客户端，通过指定服务器的IP地址和端口号来建立与服务器的连接。一旦连接建立，就可以通过Socket对象的输入输出流进行数据的读写。
- ServerSocket类：用于服务器端，监听指定的端口号，等待客户端的连接请求。当有客户端请求连接时，ServerSocket会返回一个新的Socket对象，通过这个Socket对象与客户端进行通信。
2.3 简单的Socket通信示例
以下是一个简单的Java Socket通信示例，包括客户端和服务器端：
// 服务器端代码
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(12345)) {
System.out.println("Server is listening on port 12345");
try (Socket clientSocket = serverSocket.accept()) {
System.out.println("Client connected");
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("Received from client: " + inputLine);
out.println("Message received by server: " + inputLine);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 客户端代码
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 12345)) {
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("Echo from server: " + in.readLine());
}
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 在Java Socket编程中引入代理模式
3.1 为什么在Socket编程中使用代理模式
在实际的网络应用中，可能需要在客户端和服务器之间添加一些中间层来实现一些额外的功能，比如网络访问控制、数据加密、缓存等。代理模式提供了一种优雅的方式来实现这些功能，通过在代理对象中添加相应的处理逻辑，而不影响客户端和服务器的原有代码。
3.2 代理模式在Socket编程中的应用场景
- 网络访问控制：代理服务器可以根据客户端的IP地址、请求的目标服务器等信息来决定是否允许访问。
- 数据加密和解密：在代理服务器中对传输的数据进行加密和解密，保护数据的安全性。
- 缓存：代理服务器可以缓存经常请求的数据，当有相同的请求时，直接从缓存中返回数据，提高响应速度。
4. Java实现Socket编程中的代理模式
4.1 定义抽象主题接口
首先，我们定义一个抽象主题接口，该接口定义了客户端和服务器之间通信的方法。
import java.io.IOException;
public interface SocketCommunication {
void communicate() throws IOException;
}
4.2 实现真实主题（客户端或服务器）
这里以客户端为例，实现真实主题类，该类实现了SocketCommunication接口。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class RealClient implements SocketCommunication {
private final String serverAddress;
private final int serverPort;
public RealClient(String serverAddress, int serverPort) {
this.serverAddress = serverAddress;
this.serverPort = serverPort;
}
@Override
public void communicate() throws IOException {
try (Socket socket = new Socket(serverAddress, serverPort)) {
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("Echo from server: " + in.readLine());
}
}
}
}
4.3 实现代理主题
代理主题类同样实现了SocketCommunication接口，并持有一个真实主题的引用。在communicate方法中，可以在调用真实主题的communicate方法前后添加额外的处理逻辑。
import java.io.IOException;
public class ClientProxy implements SocketCommunication {
private final RealClient realClient;
public ClientProxy(String serverAddress, int serverPort) {
this.realClient = new RealClient(serverAddress, serverPort);
}
@Override
public void communicate() throws IOException {
System.out.println("Before communicating with server");
// 可以在这里添加权限检查、日志记录等逻辑
realClient.communicate();
System.out.println("After communicating with server");
// 可以在这里添加数据处理、资源清理等逻辑
}
}
4.4 使用代理模式进行Socket通信
在客户端的主函数中，使用代理对象来进行通信。
public class ProxyClientApp {
public static void main(String[] args) {
ClientProxy clientProxy = new ClientProxy("localhost", 12345);
try {
clientProxy.communicate();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 实现代理服务器
5.1 代理服务器的原理
代理服务器位于客户端和目标服务器之间，它接收客户端的请求，根据一定的规则进行处理，然后将请求转发给目标服务器，并将目标服务器的响应返回给客户端。代理服务器可以对请求和响应进行修改、过滤、缓存等操作。
5.2 实现一个简单的代理服务器
以下是一个简单的Java代理服务器示例，它监听一个端口，接收客户端的请求，将请求转发给目标服务器，并将目标服务器的响应返回给客户端。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ProxyServer {
private static final String TARGET_SERVER_ADDRESS = "localhost";
private static final int TARGET_SERVER_PORT = 12345;
private static final int PROXY_SERVER_PORT = 54321;
public static void main(String[] args) {
try (ServerSocket proxyServerSocket = new ServerSocket(PROXY_SERVER_PORT)) {
System.out.println("Proxy server is listening on port " + PROXY_SERVER_PORT);
while (true) {
try (Socket clientSocket = proxyServerSocket.accept()) {
System.out.println("Client connected to proxy server");
try (Socket targetServerSocket = new Socket(TARGET_SERVER_ADDRESS, TARGET_SERVER_PORT)) {
BufferedReader clientIn = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter clientOut = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader targetServerIn = new BufferedReader(new InputStreamReader(targetServerSocket.getInputStream()));
PrintWriter targetServerOut = new PrintWriter(targetServerSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = clientIn.readLine()) != null) {
System.out.println("Received from client: " + inputLine);
targetServerOut.println(inputLine);
String response = targetServerIn.readLine();
System.out.println("Received from target server: " + response);
clientOut.println(response);
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
5.3 在代理服务器中添加额外功能
- 日志记录：可以在代理服务器中记录客户端的请求和目标服务器的响应，以便于调试和分析。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
public class LoggingProxyServer {
private static final String TARGET_SERVER_ADDRESS = "localhost";
private static final int TARGET_SERVER_PORT = 12345;
private static final int PROXY_SERVER_PORT = 54321;
public static void main(String[] args) {
try (ServerSocket proxyServerSocket = new ServerSocket(PROXY_SERVER_PORT)) {
System.out.println("Proxy server is listening on port " + PROXY_SERVER_PORT);
while (true) {
try (Socket clientSocket = proxyServerSocket.accept()) {
System.out.println("Client connected to proxy server");
try (Socket targetServerSocket = new Socket(TARGET_SERVER_ADDRESS, TARGET_SERVER_PORT)) {
BufferedReader clientIn = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter clientOut = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader targetServerIn = new BufferedReader(new InputStreamReader(targetServerSocket.getInputStream()));
PrintWriter targetServerOut = new PrintWriter(targetServerSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = clientIn.readLine()) != null) {
Date now = new Date();
System.out.println(now + " - Received from client: " + inputLine);
targetServerOut.println(inputLine);
String response = targetServerIn.readLine();
System.out.println(now + " - Received from target server: " + response);
clientOut.println(response);
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 缓存：可以在代理服务器中缓存目标服务器的响应，当有相同的请求时，直接从缓存中返回响应，提高响应速度。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
public class CachingProxyServer {
private static final String TARGET_SERVER_ADDRESS = "localhost";
private static final int TARGET_SERVER_PORT = 12345;
private static final int PROXY_SERVER_PORT = 54321;
private static final Map<String, String> cache = new HashMap<>();
public static void main(String[] args) {
try (ServerSocket proxyServerSocket = new ServerSocket(PROXY_SERVER_PORT)) {
System.out.println("Proxy server is listening on port " + PROXY_SERVER_PORT);
while (true) {
try (Socket clientSocket = proxyServerSocket.accept()) {
System.out.println("Client connected to proxy server");
try (Socket targetServerSocket = new Socket(TARGET_SERVER_ADDRESS, TARGET_SERVER_PORT)) {
BufferedReader clientIn = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter clientOut = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader targetServerIn = new BufferedReader(new InputStreamReader(targetServerSocket.getInputStream()));
PrintWriter targetServerOut = new PrintWriter(targetServerSocket.getOutputStream(), true);
String inputLine;
while ((inputLine = clientIn.readLine()) != null) {
if (cache.containsKey(inputLine)) {
String cachedResponse = cache.get(inputLine);
System.out.println("Returning cached response: " + cachedResponse);
clientOut.println(cachedResponse);
} else {
targetServerOut.println(inputLine);
String response = targetServerIn.readLine();
cache.put(inputLine, response);
System.out.println("Adding response to cache: " + response);
clientOut.println(response);
}
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
6. 总结代理模式在Socket编程中的优势
- 功能扩展：通过代理模式，可以在不修改客户端和服务器原有代码的情况下，为Socket通信添加各种额外的功能，如权限控制、日志记录、缓存等。
- 灵活性：代理模式使得系统的结构更加灵活，可以根据需要动态地切换代理对象，以实现不同的功能。
- 安全性：在代理服务器中，可以对客户端的请求进行合法性检查和过滤，提高系统的安全性。
通过以上对Java实现Socket编程中代理模式的详细介绍，希望读者能够对代理模式在网络编程中的应用有更深入的理解，并能够在实际项目中灵活运用代理模式来解决各种问题。