设计模式一动态代理模式
欢迎光临我的博客[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();
}
}