设计模式一动态代理模式

欢迎光临我的博客[http://poetize.cn],前端使用Vue2,聊天室使用Vue3,后台使用Spring Boot

1.前言

每个代理类只能为一个接口服务,这样程序开发中必然会产生许多的代理类.
所以我们就会想办法可以通过一个代理类完成全部的代理功能,那么我们就需要用动态代理


2.在Java中要想实现动态代理机制,需要java.lang.reflect.InvocationHandler接口和java.lang.reflect.Proxy类的支持

java.lang.reflect.InvocationHandler接口的定义如下:

//Object proxy:被代理的对象
//Method method:要调用的方法
//Object[] args:方法调用时所需要参数
public interface InvocationHandler {  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
}  

java.lang.reflect.Proxy类的定义如下:

//CLassLoader loader:类的加载器
//Class<?> interfaces:得到全部的接口
//InvocationHandler h:指定动态处理器
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
throws IllegalArgumentException  

注:动态代理类只能代理接口(不支持抽象类),代理类都需要实现InvocationHandler类,实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的,该invoke方法返回的值是被代理接口的一个实现类


3.动态代理实现AOP编程

核心业务接口

public interface Study {
    public void toStudy();
}

核心业务实现

public class Students implements Study {
    @Override
    public void toStudy() {
        System.out.println("i will study");
    }
}

切面接口

public interface Advice {
    public void beforeAdvice();
    public void afterAdvice();
}

切面实现

public class LogAdvice implements Advice {
    @Override
    public void beforeAdvice() {
        System.out.println("到学校");
    }

    @Override
    public void afterAdvice() {
        System.out.println("回家");
    }
}

配置文件

target=AOP.Students
advice=AOP.LogAdvice
factorybean=AOP.ProxyFactoryBean

Bean工厂类(用于生产代理工厂Bean)
关于内省(Introspector)

public class BeanFactory {
    //读取配置文件
    Properties pro = new Properties();

    public BeanFactory(InputStream in) throws IOException {
        pro.load(in);
    }

    //获取工厂Bean
    public Object getBean(String name) throws Exception {
        Object bean = null;
        //得到代理工厂类的实例化bean
        bean = Class.forName(pro.getProperty(name)).newInstance();

        //通过代理工厂类名得到配置文件中被代理的类(只要得到代理工厂,其他都能得到),
        // 并将类实例化(这是代理工厂类的实例化bean的参数)
        Object target = Class.forName(pro.getProperty("target")).newInstance();
        Object advice = Class.forName(pro.getProperty("advice")).newInstance();

        //内省,给工厂Bean传参
        BeanInfo beanInfo = Introspector.getBeanInfo(Class.forName(pro.getProperty(name)));
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor pd : propertyDescriptors) {
            String name1 = pd.getName();
            Method writeMethod = pd.getWriteMethod();
            if ("target".equals(name1)) {
                writeMethod.invoke(bean, target);
            } else if ("advice".equals(name1)) {
                writeMethod.invoke(bean, advice);
            }
        }
        return bean;
    }

}

代理工厂Bean(用于生产代理)

public class ProxyFactoryBean implements InvocationHandler {
    //被代理的对象。Object表示什么对象都可以代理,有别于静态代理
    private Object target;
    private Advice advice;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Advice getAdvice() {
        return advice;
    }

    public void setAdvice(Advice advice) {
        this.advice = advice;
    }

    //CLassLoader loader:类的加载器
    //Class<?> interfaces:得到全部的接口
    //InvocationHandler h:指定动态处理器
    public Object getProxy() {
        Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
        return proxy;
    }

    //Object proxy:被代理的对象  
    //Method method:要调用的方法  
    //Object[] args:方法调用时所需要参数  
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        advice.beforeAdvice();
        Object obj = method.invoke(target, args);
        advice.afterAdvice();
        return obj;
    }
}

测试

public class AOPTest {
    public void test() throws Exception{
        //读取配置文件(相对于src目录)
        InputStream in = Thread.currentThread().
                         getContextClassLoader().
                         getResourceAsStream("AOP/pro.properties");
        //创建bean工厂对象
        BeanFactory beanFactory = new BeanFactory(in);
        //获取代理工厂Bean
        ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) beanFactory.getBean("bean");
        //获取代理
        Study proxy = (Study) proxyFactoryBean.getProxy();
        proxy.toStudy();

    }
}
posted @ 2019-08-04 23:06  LittleDonkey  阅读(270)  评论(0编辑  收藏  举报