代理,自己的事情,让其他人代理完成.
比如需要自己买火车票的,但因为有事情,就拜托中介代购火车票.其中中介不仅完成购买火车票,还在购买前或者后,回进行其他操作,如果收取中介费 送票等.
静态代理
public interface Action{
public void doAction();
}
public class ViewAction implement Action{
public void doAction(){
System.out.println("实际需要执行的动作...");
}
}
/**
*代理类,类似于中介,同样需要完成买票的动作,当然也要实现Action接口
*/
public class ProxyAction implement Action{
private ViewAction viewAction;//需要指明对ViewAction进行代理的引用,代理用户完成自己购票动作.
public ProxyAction ( ViewAction viewAction){
this.viewAction = viewAction;对需要执行的代理进入注入
}
public void doAction(){
doBefore();
viewAction.doAction();//执行用户的动作
doAfter();
}
public void doBefore(){
System.out.println("执行前的动作...");
}
public void doAfter(){
System.out.println("执行后的动作...");
}
}
//测试
public class StaticTest{
public static main(String[] args){
//ProxyAction 对ViewAction 进行代理执行
ProxyAction proxyAction = new ProxyAction (new ViewAction ());
proxyAction.doAction();
}
}
这样就完成了一个代理,不过从上面看到,如果我还需要其他的操作,比如还需要送东西给其他人,给别人传递信息等,都不用自己完成,这样就促生了快递,邮递等.
我们如果按照上面的实现,就需要对每一种动作定义一个接口,写一个实现,还有一种代理,对于用户来说,这样就很繁杂了很多了,用户只想让一个人来完成代理这些操作,这样就有了新的需求,实际生活中,比如领导的秘书.
在java世界中,就提供了这样的需求实现,称之为动态代理.
其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。
Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现.
如下，HelloWorld接口定义的业务方法，HelloWorldImpl是HelloWorld接口的实现，HelloWorldHandler是 InvocationHandler接口实现。
代码如下：
//业务接口
public interface HelloWorld{
public void sayHello();
}
//业务接口实现
public class HelloWorldImpl implements HelloWorld{
public void sayHello(){
System.out.println("say hello...");
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class HelloWorldHandler implements InvocationHandler{
private Object originalObj;//要代理的原始对象
public HelloWorldHandler (Object originalObj){
this.originalObj = originalObj;
}
//同上面的比较,都是增加了doBefore和doAfter,不同的是此处代理的原始对象是不确定的,就是动态的,怎么确定是对哪个进行代理了呢?回答是使用了反射,这个结合后面的代码来解释.
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
Object result = null;
doBefore();
result = method.invoke(this.originalObj,args);
doAfter();
return result;
}
public void doBefore(){
System.out.println("执行前的动作...");
}
public void doAfter(){
System.out.println("执行后的动作...");
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
//测试
public class DynamicTest{
public static void main(String args[]){
//1.获取一个业务接口的实现对象
HelloWorld helloWorld = new HelloWorldImpl();//id=19
//2. 获取一个InvocationHandler实现，此处是HelloWorldHandler对象;
InvocationHandler handler = new HelloWorldHandler (helloWorld);//对HelloWorld进行代理
//3.创建动态代理对象;
HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(helloWorld.getClass().getClassLoader(),helloWorld.getClass().getInterfaces(), handler); //此处就是反射的使用,得到一个处理后的HelloWorld
//4.通过动态代理对象调用sayHelloWorld()方法，此时会在原始对象HelloWorldImpl. sayHelloWorld()方法前后输出两句字符串。
proxy.sayHello(); //执行
}
}
如果debug到proxy.sayHello();,可以查看变量信息.
最后的结果就是
执行前的动作...
say hello...
执行后的动作...
