java 代理端口例子

以下是一个简单的Java代理端口的例子，该代理将任何传入TCP端口的数据转发到另一个指定的TCP端口：

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class PortProxy {

    public static void main(String[] args) throws IOException {
        // 监听的本地端口
        int localPort = 8080;
        // 转发到的远程端口
        int remotePort = 80;
        // 转发到的远程IP地址
        InetAddress remoteAddress = InetAddress.getByName("www.example.com");

        // 创建本地监听套接字
        ServerSocket serverSocket = new ServerSocket(localPort);

        while (true) {
            // 等待客户端连接
            Socket clientSocket = serverSocket.accept();

            // 创建与远程服务器的连接
            Socket remoteSocket = new Socket(remoteAddress, remotePort);

            // 创建并启动数据转发线程
            Thread thread = new Thread(new ProxyThread(clientSocket, remoteSocket));
            thread.start();
        }
    }

    private static class ProxyThread implements Runnable {
        private final Socket clientSocket;
        private final Socket remoteSocket;

        public ProxyThread(Socket clientSocket, Socket remoteSocket) {
            this.clientSocket = clientSocket;
            this.remoteSocket = remoteSocket;
        }

        @Override
        public void run() {
            try {
                // 创建数据转发线程
                Thread thread1 = new Thread(new ForwardThread(clientSocket.getInputStream(), remoteSocket.getOutputStream()));
                thread1.start();
                Thread thread2 = new Thread(new ForwardThread(remoteSocket.getInputStream(), clientSocket.getOutputStream()));
                thread2.start();

                // 等待数据转发线程结束
                thread1.join();
                thread2.join();
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            } finally {
                try {
                    // 关闭套接字
                    clientSocket.close();
                    remoteSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class ForwardThread implements Runnable {
        private final java.io.InputStream input;
        private final java.io.OutputStream output;

        public ForwardThread(java.io.InputStream input, java.io.OutputStream output) {
            this.input = input;
            this.output = output;
        }

        @Override
        public void run() {
            try {
                // 从输入流读取数据并写入输出流
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = input.read(buffer)) != -1) {
                    output.write(buffer, 0, bytesRead);
                    output.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在上面的代码中，`PortProxy`类代表了代理服务器，它监听本地端口`localPort`，并将所有传入的数据转发到远程IP地址`remoteAddress`和端口`remotePort`。每当收到一个连接请求时，它会创建一个新的线程来处理该连接。

`ProxyThread`类代表了一个数据转发线程，它将转发客户端和远程服务器之间的所有数据。它创建两个`ForwardThread`线程，一个用于将客户端数据转发到远程服务器，另一个用于将远程服务器数据转发回客户端。每个`ForwardThread`线程都使用一个输入流和一个输出流来读取和写入数据。

请注意，在实际应用中，代理服务器可能需要进行身份验证、安全检查和流量限制，以确保只有经过授权的用户才能使用它。