Java语法基础学习DayTwenty（反射机制续）

一、Java动态代理

1.代理设计模式的原理

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

2.静态代理

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

3.动态代理

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

4.代码示例

　　静态代理代码：

//静态代理模式
//接口
interface ClothFactory{
    void productCloth();
}
//被代理类
class NikeClothProduct implements ClothFactory{
    @Override
    public void productCloth(){
        System.out.println("Nike工厂生产一批衣服");
    }
}
//静态代理类
class ProxyFactory implements ClothFactory{
    ClothFactory cf;
    ////创建代理类的对象时，实际传入一个被代理类的对象
    public ProxyFactory(ClothFactory cf){
        this.cf = cf;
    }
    @Override
    public void productCloth(){
        System.out.println("代理类开始执行，收代理费$1000");
        cf.productCloth();
    }
}
public class TestClothProduct{
    public static void main(String[] args){
        NikeClothProduct nike = new NikeClothProduct();//创建被代理类对象
        ProxyFactory proxy = new ProxyFactory(nike);//创建代理类对象
        proxy.productCloth();//代理类开始执行，收代理费$1000
                             //Nike工厂生产一批衣服
    }
}

　　动态代理代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//动态代理的使用，体会反射是动态语言的关键
//接口
interface Subject {
    void action();
}

// 被代理类
class RealSubject implements Subject {
    public void action() {
        System.out.println("我是被代理类，记得要执行我哦！么么哒~~");
    }
}

class MyInvocationHandler implements InvocationHandler {
    Object obj;// 被代理类的对象的声明

    // blind()作用：①给被代理类的对象实例化②返回一个代理类的对象
    public Object blind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
    //当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //method方法的返回值时returnVal
        Object returnVal = method.invoke(obj, args);
        return returnVal;
    }
}

public class Test{
    public static void main(String[] args) throws Exception{
        //1.被代理类的对象
        RealSubject real = new RealSubject();
        //2.创建一个实现了InvacationHandler接口的类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        //3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象。
        Object obj = handler.blind(real);
        Subject sub = (Subject)obj;//此时sub就是代理类的对象

        sub.action();//转到对InvacationHandler接口的实现类的invoke()方法的调用

        //再举一例
        NikeClothProduct nike = new NikeClothProduct();
        ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//proxyCloth即为代理类的对象
        proxyCloth.productCloth();
    }
}

二、动态代理与AOP（Aspect Orient Programming）

1.概述　　

　　使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。

　　这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。

2.代码示例

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//接口
interface Human {
    void info();

    void fly();
}

// 被代理类
class SuperMan implements Human {
    public void info() {
        System.out.println("我是超人！我怕谁！");
    }

    public void fly() {
        System.out.println("I believe I can fly!");
    }
}
//通用方法的类
class HumanUtil {
    public void method1() {
        System.out.println("=======通用方法一=======");
    }

    public void method2() {
        System.out.println("=======通用方法二=======");
    }
}

class MyInvocationHandler 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 h = new HumanUtil();
        h.method1();
        Object returnVal = method.invoke(obj,args);
        h.method2();
        return returnVal;
    }
}
class MyProxy{
    //动态的创建一个代理类的对象
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.setObject(obj);

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

public class Test{
    public static void main(String[] args) throws Exception{
        SuperMan man = new SuperMan();//创建一个被代理类的对象
        Object obj = MyProxy.getProxyInstance(man);//返回一个代理类的对象
        Human hu = (Human)obj;
        hu.info();//通过代理类的对象调用重写的抽象方法
        //=======通用方法一=======
        //我是超人！我怕谁！
        //=======通用方法二=======
        System.out.println();
        hu.fly();
        //=======通用方法一=======
        //I believe I can fly!
        //=======通用方法二=======

        //再举一例
        NikeClothProduct nike = new NikeClothProduct();
        ClothFactory proxyCloth = (ClothFactory)MyProxy.getProxyInstance(nike);
        proxyCloth.productCloth();
        //=======通用方法一=======
        //Nike工厂生产一批衣服
        //=======通用方法二=======
    }
}