动态代理 AOP

作为一个java小白，学习了发射，学习了静态代理和动态代理

AOP：Aspect Orient Programming；

AOP的原理就是java的动态代理机制;

通过查阅资料，对动态代理有了一定了解，接下来先了解什么是代理.

代理模式设计的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上

静态代理：被代理类去代替代理类去执行接口中的方法;

静态代理的特征：是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。下面是简单的

静态代理小程序:

//接口

public interface ClothFactory {

void clothProduct();

}

//被代理类

public class NiKeFactory implements ClothFactory {

public void clothProduct() {

System.out.println("生产NIKE 鞋子..............");

}

}

public class AddiasFactory implements ClothFactory{

public void clothProduct() {

System.out.println("生产addius鞋子...........");

}

}

//代理类

public class ProxyFactory implements ClothFactory{

private ClothFactory cf;

public ProxyFactory(ClothFactory cf) {

this.cf=cf;

}

public void clothProduct() {

System.out.println("代理开始......");

cf.clothProduct();

System.out.println("代理结束..........");

}

}

//测试代码

public class Test {

public static void main(String[] args) {

ClothFactory addius=new AddiasFactory() ;

ClothFactory add=new ProxyFactory(addius);

add.clothProduct();

ClothFactory nike=new NiKeFactory();

ClothFactory add1=new ProxyFactory(nike);

add1.clothProduct();

}

}

接下来什么是动态代理呢

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。

下面用具体程序来介绍动态代理:

//定义接口

public interface Human {

void info();

void fly();

}

//工具类

public class HumanUtil {

public void methodOne() {

System.out.println("前置增强.......");

}

public void methodTwo() {

System.out.println("后置增强........");

}

}

//MyInvanHander 类

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用

public class MyInvanHander implements InvocationHandler {

public Object object=null;

public void setObject(Object object){

this.object=object;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

HumanUtil hu=new HumanUtil();

hu.methodOne();

method.invoke(object, args);

hu.methodTwo();

return null;//也可以返回object，而不是proxy

}

}

//Proxy类：MyProxy代理类

Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：

public class MyProxy {

public static Object getProxyInstance(Object obj){

MyInvanHander hander=new MyInvanHander();

hander.setObject(obj);

return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),hander);

}

//被代理类

public class SuperMan implements Human {

@Override

public void info() {

System.out.println("I am a superman....");

}

@Override

public void fly() {

System.out.println("I can fly higher....");

}

}

//测试类

public class Test {

public static void main(String[] args) {

SuperMan sm=new SuperMan();

Object obj=MyProxy.getProxyInstance(sm);

Human hm=(Human)obj;

hm.info();

System.out.println("--------------");

hm.fly();

}

}

测试结果：

动态代理的好处是：可以直接其它需要代理的类，调用MyProxy.getProxyInstance()方法,就能实现代理，用起来高效方便

如在测试类加入其他包的代理类测试：

public class Test {

public static void main(String[] args) {

SuperMan sm=new SuperMan();

Object obj=MyProxy.getProxyInstance(sm);

Human hm=(Human)obj;

hm.info();

System.out.println("--------------");

hm.fly();

System.out.println("----------------");

NiKeFactory nf=new NiKeFactory();

Object nfj=MyProxy.getProxyInstance(nf);

ClothFactory cf=(ClothFactory)nfj;

cf.clothProduct();

}

}

这一次的测试结果为：

体现了方便的代理性

以上是自己学反射时对动态代理的理解，欢迎大家交流.........................