什么是切面 切面,即非正面,我们用一个示例来解释什么是切面,比如,我们的业务功能是要把数据写入文件中,代码可以是这样的:
public void write(String data){
//写入文件
try{
OutputStream out = new FileOutputStream(new File("..."));
BufferedOutputStream bos = new BufferedOutputStream(out);
PrintStream ps = new PrintStream();
ps.println(data);
ps.close();
}catch(IOException e){//...}
}
现在,需求变化了,要求在写入文件操作时需要计算下此操作一共消耗的时间,我们马上可以想到的是,在方法的开始记录时间,方法的结束也记录时间,再计算两者的时间差,不用可以了吗,所以代码根据需求变化后的改进可能是这样的:
public void write(String data){
long startTime = System.currentTimeMillis(); //记录开始时间
//写入文件
try{
OutputStream out = new FileOutputStream(new File("..."));
BufferedOutputStream bos = new BufferedOutputStream(out);
PrintStream ps = new PrintStream();
ps.println(data);
ps.close();
}catch(IOException e){//...}
long endTime = System.currentTimeMillis();
System.out.println("消耗的时间为:"+(endTime-startTime));
}
从以上代码可以看出,很显然我们是在写入的业务方法中添加了代码来记录消耗的时间,而这三句代码本身是与把数据写入到文件中核心业务代码没多大关系的,但根据需求,又必须在这里出现,我们把这个的代码就称为切面了。需求变化可以要求添加这样的切面代码,也可以在某些时候要求去除这些代码,所以我们要做的是,这样的代码如果可以与核心业务代码分离开,在需要的时候可以动态添加,而不需要的时候,又可以很方便的去除,不管是添加还是去除都不需要求动到核心业务方法中的代码。那要怎么做呢?该动态代理模式上场了。
动态代理模式 通过代理模式,我们可以把这部分切面的代码交给代理类来完成,以达到和核心业务方法的解耦,选择使用动态代理模式,是因为动态代理可以帮助我们动态生成一个代理对象,以做到统一处理。动态代理是 AOP 的核心部分,我在2017新版JAVA 课程的反射与内省章节中充分介绍了动态代理的使用,不懂的可以到扣丁学堂看看,由于我们是讲 AOP,这些就不做详细介绍了。一会看完整示例。
让编程可配置 让编程可配置是目的在于维护,我们应该清楚的知道,把相对固定的东西直接写在代码中,要想修改时就会麻烦很多:改源代码文件——》编译——》打包——》部署——》再重新启动服务器等步骤。这个过程是繁琐的;如果这个时候我们要改的东西只是在配置文件改完直接重启一下服务器就 完成的话,那是多么爽的事情啊,所以,AOP 的另一个核心就是配置文件,在 Spring中是使用 XML 来配置的,这将大大提高维护代码的效率,好了,了解了以上内容后,我们现在来看看代码如何实现。
代码实现 我们的业务接口和业务实现类:
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());
}
}
我们的切面代码接口和实现类(在Spring中理解为通知):
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());
}
}
用于生成代理对象的动态代理代码:
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;
}
}
配置文件和工厂类: bean.properties文件内容:
bean.target=com.vince.aop.IManagerImpl bean.advice=com.vince.aop.LogAdvice bean=com.vince.aop.ProxyFactoryBean
Bean工厂类,主要是用于从配置文件中获取信息后生成用于创建代理的类对象:
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("测试数据");
}
}
AOP使用场景 AOP用来封装横切关注点,具体可以在下面的场景中使用: 权限控制 缓存 错误处理 调试 记录跟踪 持久化 同步 事务 等等。。
最后,小结一下,这个示例使用到了动态代理,工厂模式,properties配置文件,内省等知识点,掌握这个示例,会让你理解Spring的 AOP 容易很多,亲,你学会了吗,还不会?没关系,出门左转,到扣丁学堂找到2017版 JAVA 课程第12章反射与内省中有详细的视频介绍,今天的文章就到这里吧,有问题请留言或讨论。