初探:理解可配置的AOP框架
补充知识:
1、AOP的概念:Aspect Oriented Programming(面向切面编程)
2、可配置 AOP框架实现
AOP使用场景
AOP用来封装横切关注点,具体可以在下面的场景中使用:
权限
缓存
错误处理
调试
记录跟踪
持久化
同步
事务
等等。。
先写个接口
IManager接口
package com.vince.aop;
/**
* Created by vince on 2017/6/14.
*/
public interface IManager {
public void add(String item);
}
接口的实现类
package com.vince.aop;
import java.util.ArrayList;
/**
* Created by vince on 2017/6/14.
*/
public class IManagerImpl implements IManager {
private ArrayList<String> list = new ArrayList<>();
@Override
public void add(String item) {
//System.out.println("add start "+ System.currentTimeMillis());
list.add(item);
System.out.println(item);
//System.out.println("add end "+ System.currentTimeMillis());
}
}
把这个外围的记录日志的代码 即不是真正的业务代码 只是测试用的类似的
挪到代理里面去完成
就是面向切面编程 AOP
把侧面 切面的东西 挪到代理里面
让真正的业务代码只关注 业务的本身 而不需要关注外围的东西
下面我们自己写一个简洁版的AOP框架
前面的两个是·IManager是核心业务接口
和IManagerImpl核心业务类
先写个接口Advice
有前通知和后后通知方法
package com.vince.aop;
/**
* Created by vince on 2017/6/14.
* 通知
*/
public interface Advice {
public void beforeAdvice();
public void afterAdvice();
}
然后有一个实现类 专门记录日志的一个类
package com.vince.aop;
/**
* Created by vince on 2017/6/14.
* 切面的实现类
*/
public class LogAdvice implements Advice{
@Override
public void beforeAdvice() {
System.out.println("start time:"+System.currentTimeMillis());
}
@Override
public void afterAdvice() {
System.out.println("end time:"+System.currentTimeMillis());
}
}
写配置文件
bean.target=com.vince.aop.IManagerImpl
bean.advice=com.vince.aop.LogAdvice
bean=com.vince.aop.ProxyFactoryBean
实现动态代理 要写一个创建代理的类
实际上就是通过这个创建代理对象的类
把两个毫不相关的类(IManagerImpl和LogAdvice)连接起来
package com.vince.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* Created by vince on 2017/6/14.
*/
public class ProxyFactoryBean implements InvocationHandler {
private Object target;
private Advice advice;
public Object getProxy(){
Object proxy = Proxy.newProxyInstance(target.getClass().getClassLoader()
, target.getClass().getInterfaces()
, this);
return proxy;
}
@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 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;
}
}
还有一个读取配置文件 装配对象 的类 上一个博客写这个类时使用静态代码块实现的
现在换一种 我们使用构造器实现读取配置文件
然后写工厂类实现可配置编程
package com.vince.aop;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* Created by vince on 2017/6/14.
* AOP框架的简单实现
*/
public class BeanFactory {
Properties prop = new Properties();
public BeanFactory(InputStream in){//这样可以不一定非要读一个文件 其他文件 只要传进来流 都可以绑定
try {
prop.load(in);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 获取一个bean实例
* @param name
* @return
*/
public Object getBean(String name){
String className = prop.getProperty(name);
Object bean = null;
try {
//获取ProxyFactoryBean的class对象
Class<?> aClass = Class.forName(className);
bean = aClass.newInstance();//实例化对象
//根据配置文件实例化target和advice对象
Object target = Class.forName(prop.getProperty(name + ".target")).newInstance();
Object advice = Class.forName(prop.getProperty(name + ".advice")).newInstance();
//通过内省实现对 ProxyFactoryBean的属性赋值
BeanInfo beanInfo = Introspector.getBeanInfo(aClass);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for(PropertyDescriptor pd: propertyDescriptors){
String propertyName = pd.getName();
Method writeMethod = pd.getWriteMethod();
if("target".equals(propertyName)){
writeMethod.invoke(bean,target);
}else if("advice".equals(propertyName)){
writeMethod.invoke(bean,advice);
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IntrospectionException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return bean;
}
}
最后来个测试
package com.vince.aop;
import org.junit.Test;
import java.io.InputStream;
/**
* Created by vince on 2017/6/14.
*/
public class AOPTest {
@Test
public void test(){
//1读取配置 文件
InputStream in = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("com/vince/aop/bean.properties");
//2创建Bean的工厂对象
BeanFactory beanFactory = new BeanFactory(in);
//3获取代理对象
ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) beanFactory.getBean("bean");
IManager proxy = (IManager) proxyFactoryBean.getProxy();
proxy.add("我是一只猫");
}
}