// Purpose. Proxy design pattern
// 1. Create a "wrapper" for a remote, or expensive, or sensitive target
// 2. Encapsulate the complexity/overhead of the target in the wrapper
// 3. The client deals with the wrapper
// 4. The wrapper delegates to the target
// 5. To support plug-compatibility of wrapper and target, create an interface

import java.io.*; import java.net.*;

interface SocketInterface { // 5. To support plug-compatibility
String readLine(); // between the wrapper and the
void writeLine( String str ); // target, create an interface
void dispose(); }

public class ProxyDemo {
public static void main( String[] args ) {
SocketInterface socket = new SocketProxy( "127.0.0.1", 8189,
args[0].equals("first") ? true : false ); // 3. The client deals
String str = null; // with the wrapper
boolean skip = true;
while (true) {
if (args[0].equals("second") && skip) skip = ! skip;
else {
str = socket.readLine();
System.out.println( "Receive - " + str ); // java ProxyDemo first
if (str.equals("quit")) break; // Receive - 123 456
} // Send ---- 234 567
System.out.print( "Send ---- " ); // Receive - 345 678
str = Read.aString(); //
socket.writeLine( str ); // java ProxyDemo second
if (str.equals("quit")) break; // Send ---- 123 456
} // Receive - 234 567
socket.dispose(); // Send ---- 345 678
} }

class SocketProxy implements SocketInterface { // 1. Create a "wrapper" for a
private Socket socket; // remote, or expensive, or
private BufferedReader in; // sensitive target
private PrintWriter out;

public SocketProxy( String host, int port, boolean wait ) {
try {
if (wait) {
ServerSocket server = new ServerSocket( port );
socket = server.accept(); // 2. Encapsulate the complexi-
} else // ty/overhead of the target
socket = new Socket( host, port ); // in the wrapper
in = new BufferedReader( new InputStreamReader(
socket.getInputStream()));
out = new PrintWriter( socket.getOutputStream(), true );
} catch( IOException e ) { e.printStackTrace(); }
}
public String readLine() {
String str = null;
try { str = in.readLine();
} catch( IOException e ) { e.printStackTrace(); }
return str;
}
public void writeLine( String str ) {
out.println( str ); // 4. The wrapper delegates to the target
}
public void dispose() {
try { socket.close();
} catch( IOException e ) { e.printStackTrace(); }
} }