java 代理和动态代理

第三种关系成为代理，举一个例子，你需要去某公司问问这个公司的相关业务，那么前台的漂亮妹妹就可以充当这个代理，她帮你询问然后告诉你。

扯点正经的吧。。。。

例如，太空船需要一个控制模块：

//: reusing/SpaceShipControls.java
package reusing; /* Added by Eclipse.py */

public class SpaceShipControls {
void up(int velocity) {}
void down(int velocity) {}
void left(int velocity) {}
void right(int velocity) {}
void forward(int velocity) {}
void back(int velocity) {}
void turboBoost() {}
} ///:~


以下是代理方法：
//: reusing/SpaceShipDelegation.java
package reusing; /* Added by Eclipse.py */

public class SpaceShipDelegation {
private String name;
private SpaceShipControls controls =
new SpaceShipControls();
public SpaceShipDelegation(String name) {
this.name = name;
}
// Delegated methods:
public void back(int velocity) {
controls.back(velocity);
}
public void down(int velocity) {
controls.down(velocity);
}
public void forward(int velocity) {
controls.forward(velocity);
}
public void left(int velocity) {
controls.left(velocity);
}
public void right(int velocity) {
controls.right(velocity);
}
public void turboBoost() {
controls.turboBoost();
}
public void up(int velocity) {
controls.up(velocity);
}
public static void main(String[] args) {
SpaceShipDelegation protector =
new SpaceShipDelegation("NSEA Protector");
protector.forward(100);
}
} ///:~


代理的好处是不暴露你访问的对象，具有安全性。

好了，下面就说动态代理了

通过调用静态方法 Proxy.newProxyInstance()可以创建动态代理，这个方法需要三个参数

1.一个类加载器

2.一个你希望该代理实现的接口列表

3.  InvocationHandler 的实现

还有一个 invoke() 方法，该方法传递进来了代理对象，通常你会执行被代理的对象，通过Method,invoke() 将请求转发给被代理对象，并传入其他的参数。

以下是实际的例子

//: typeinfo/SelectingMethods.java

// Looking for particular methods in a dynamic proxy.
import java.lang.reflect.*;

class MethodSelector implements InvocationHandler {
private Object proxied;
public MethodSelector(Object proxied) {
this.proxied = proxied;
}
public Object
invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(method.getName().equals("interesting"))
System.out.println("Proxy detected the interesting method");
return method.invoke(proxied, args);
}
}

interface SomeMethods {
void boring1();
void boring2();
void interesting(String arg);
void boring3();
}

class Implementation implements SomeMethods {
public void boring1() { System.out.println("boring1"); }
public void boring2() { System.out.println("boring2"); }
public void interesting(String arg) {
System.out.println("interesting " + arg);
}
public void boring3() { System.out.println("boring3"); }
}

class SelectingMethods {
public static void main(String[] args) {
SomeMethods proxy= (SomeMethods)Proxy.newProxyInstance(
SomeMethods.class.getClassLoader(),
new Class[]{ SomeMethods.class },
new MethodSelector(new Implementation()));
proxy.boring1();
proxy.boring2();
proxy.interesting("bonobo");
proxy.boring3();
}
} /* Output:
boring1
boring2
Proxy detected the interesting method
interesting bonobo
boring3
*///:~