aop动态代理学习

学习，顺便做个demo，方便理解.

A接口有c方法，类B实现A接口，原本应该是执行B类中的c方法，可现在不这样做； 我声明产生B类的代理类B',由它来冒充B类的“兄弟”并“实现”A接口， 对外界来说B'应该也有c方法，可当真正调用它的时候， 它会去执行与它关联InvocationHandler的invoke()方法， 在这个方法里面你可以做很多事情。这样，这个请求就被“代理”到其它地方去了。

//接口

package proxy;
public interface TargetInterface {
    public void show();
}

//接口实现类
package proxy;
public class Target implements TargetInterface{
    @Override
    public void show(){
       System.out.println("我是目标类");
    }
}
//Handler类     在被代理的方法前后要做的事情，就写在这里了
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvokationHandler implements InvocationHandler{
    private Object target;
    public void setTarget(Object target){
       this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
       System.out.println("进入事务了");//代理加入的功能
       Object result = method.invoke(target, args);
       System.out.println("退出事务了");//代理加入的功能
       return result;
    }
}

//代理类创建工厂   用目标类的接口和classloader，及handler创建了代理对象

package proxy;
import java.lang.reflect.Proxy;
public class MyProxyFactory {
    public static Object getProxy(Object target){
       MyInvokationHandler  handler = new MyInvokationHandler();
       handler.setTarget(target);
       return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }
}

//测试代理

package proxy;
import org.junit.Test;
public class TestProxy {
    @Test
    public void testShow(){
       TargetInterface target = new Target();
       TargetInterface targetProxy = (TargetInterface)MyProxyFactory.getProxy(target);
       targetProxy.show();
    }
}

适用条件：

被代理的对象系统开销很大，或者被代理对象的方法功能不够完善需要增加功能

前提：

代理对象和被代理对象有相同的接口和相同的classloader来加载