反射动态代理与AOP-蒲公英云

反射动态代理与AOP

本文用到的知识点是动态代理和反射的知识，本文属于简单的应用demo，如果不熟悉知识点的盆友可以点击我以前的文章，对于反射的底层实现有想了解的盆友可以点击反射机制以及应用的文章。

本文主要就是用简单的实例讲解动态代理和反射的常用的应用AOP。

简而言之，AOP就是利用动态代理机制在一业务前面切向的加入特定的方法，本demo中

HumanUtil 是要切向加入的。有什么需要探讨的欢迎点击Q我吧相互交流O(∩_∩)O

AOP：Aspect Orient Programming

package myNetDemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import javax.xml.ws.spi.Invoker;
interface Human {
    void info();
    void fly();
}
// 被代理类
class SuperMan implements Human {
    @Override
    public void info() {
        System.out.println("我是超人");
    }
    @Override
    public void fly() {
        // TODO Auto-generated method stub
        System.out.println("我可以飞");
    }
}
class HumanUtil {
    public void method1() {
        System.out.println("===方法一===");
    }
    public void method2() {
        System.out.println("===方法二===");
    }
}
class MyInvocationHandler1 implements InvocationHandler {
    Object obj;// 被代理类对象的声明
    public void setObject(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        HumanUtil hUtil = new HumanUtil();
        hUtil.method1();
        Object returnVal = method.invoke(obj, args);
        hUtil.method2();
        return returnVal;
    }
}
// 动态的创建一个代理类的对象
class myProxy {
    public static Object getProxyInstance(Object obj) {
        MyInvocationHandler1 handler1 = new MyInvocationHandler1();
        handler1.setObject(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), handler1);
    }
}
public class TestAOP {
    public static void main(String[] args) {
        SuperMan man = new SuperMan();// 创建被代理类的对象
        Object obj = myProxy.getProxyInstance(man);// 返回代理类的对象
        Human h = (Human) obj;
        // 通过代理类的对象调用重写的抽象方法
        h.info();
        System.out.println();
        h.fly();
        System.out.println("***************");
        NikeClothFactory nike=new NikeClothFactory();
        Object objj=myProxy.getProxyInstance(nike);
        ClothesFactory clothesFactory=(ClothesFactory)objj;
        clothesFactory.productCloth();
    }
}
package myNetDemo;
//静态代理模式
//接口
interface ClothesFactory {
    void productCloth();
}
// 被代理类
class NikeClothFactory implements ClothesFactory {
    @Override
    public void productCloth() {
        System.out.println("Nike工厂生产衣服");
    }
}
// 代理类
class ProxyFactory implements ClothesFactory {
    ClothesFactory cf;// 虽然声明的是总接口，但实例化时实际传进去的是具体被代理实现类
    // 在构造器内完成初始化
    public ProxyFactory(ClothesFactory cf) {
        this.cf = cf;
    }
    @Override
    public void productCloth() {
        System.out.println("代理类开始执行，收代理费");
        cf.productCloth();// 实际调用的是实际被代理类的实现方法
    }
}
public class TestProductClothes {
    public static void main(String[] args) {
        NikeClothFactory nikeClothFactory = new NikeClothFactory();// 创建被代理类的对象
        ProxyFactory pFactory = new ProxyFactory(nikeClothFactory);// 创建爱你代理类的对象
        pFactory.productCloth();// 实际调用的是被代理类方法
        // 若再有一个接口，还要在于一个接口的实现类（被代理类，目标类），在造一个代理类实现接口
        // 于是想要动态代理
    }
}