Spring之AOP

所谓Aop，即Aspect Oriented Programming，面向方面编程。这个概念听起来可能有点抽象，所以在这里我们先引入Aop中的一些术语并结合它们来对Aop思想做一个整体的解释： 

1.Aspect(切面)：横切性关注点的抽象即为切面。记得有这么个俗语，意思就是一根筷子容易折断，而一捆筷子就不容易折断了，说的是团结的力量。那么，现在，大家想一下，如果我们手里拿着一把刀，要斩断一捆筷子（由十根筷子组成），我们要怎么办呢？答案是明显的，就是横着砍下去！我想应该没有人会选择竖着砍下去的，呵呵。那么，在砍的那个过程中，我们要关注的地方有哪些呢？或者说我们要砍断的筷子有哪几根呢？答案还是那么明显，当然是要把十根筷子都砍断咯。那么，对于这捆筷子中的每一根都可以理解为是一个横切性关注点。由于个人的想象力有限，所以举的例子不免有些牵强。好了，我们继续来解释切面的概念，那么在编程中，横切性关注点是什么呢？实际上，简单的来说，就是程序运行时我们要对哪些方法进行拦截，拦截后要做些什么事（例如可以对部分函数的调用进行日志记录），这些都算是横切性关注点。上面说了切面是横切性关注点的抽象，这里，我们可以结合面向对象的概念来理解。大家都知道的是，类是物体特征的抽象，所以结合这个来理解切面的意思应该会容易一点。 
2.Joinpoint(连接点)：顾名思义，连接点的作用就是可以在上面接一点东西。实际上，Aop中的连接点的意思也差不多，就是那些被我们拦截到的点（Spring中，这些点指的就是方法，因为Spring只支持方法类型的拦截点），那么我们拦截一个方法的目的是什么呢？当然是为了附带做一些事（即执行一些代码）啦，或者说是接入一些执行代码，所以被拦截的方法我们可以称之为接入点。 
3.Pointcut(切点)：切点用于指定或定义希望在程序流中拦截的Joinpoint。切点还包含一个通知（所谓通知，即拦截到Joinpoint后我们所要附带做的事，如方法的调用等等），该通知在连接点被拦截时发生，因此如果在一个调用的特定方法上定义一个切点，那么在调用该方法时，Aop框架将截获该切点，并执行切点所关联的通知。 
4.Advice(通知)：所谓通知，就是拦截到Joinpoint后我们所要做的事情（通常就是执行一些代码）。通知可分为前置通知、后置通知、异常通知、最终通知、环绕通知（对于各种通知的解释，这里不再做详细介绍了）。 
5.Target Object(目标对象)：包含连接点的对象，也称之为被通知或被代理对象。因为Aop是需要通过代理机制来实现的。对于目标对象的方法调用，实际上是通过它的代理对象来进行的，因此可以在代理对象中对调用操作进行拦截，然后执行切点的相关通知。 
6.Aop Proxy(Aop代理)：Aop框架为目标对象创建的代理对象，包含了通知。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。 
7.Weave(织入)：将Aspect运用到Target对象并导致proxy对象创建的这个过程。 
8.Introduction(引入)：添加方法或属性到被通知的类。在不修改任何源代码的情况下，Introduction可以在程序运行期间动态地为类添加一些方法和属性。 

接着，我们结合上面的提到的Aop的这些术语来对Aop做一番解释。我们不妨引入一个需求（或者可称之为Aop思想的动机，即为什么要提出Aop思想）：监控部分重要函数的执行时间，并以短信的方式通知相关人员。那么这个需求该怎么实现呢？或许会有朋友说，这个太简单了，不就是直接在方法体内添加发送短信的代码嘛。但是，如果要监控的函数很多呢？逐个地方手动地进行添加？如果需求突然变更了，要求将发短信改为发邮件，那该怎么办呢？如果要监控的目标函数也要发生改变那又该怎么办呢？所以，将代码写死绝对不会是一个程序设计的好思想，也不会是一个合格的编程人员应该做的。那么，Aop思想将可以用来很好地解决这个问题，它对于该需求的实现过程是这样的： 
（1）将要监控的函数定义为切点,也就是说把要监控的函数当作接入点，并且定义到配置文件中去，这样就我们可以动态地修改切点了。 
（2）为包含接入点的目标对象定义Aop代理（实际上可以只定义一个Aop代理来作为多个目标对象的代理） 
（3）将发送短信的代码封装为一个类的方法（我们称之为通知方法）,并且抽取该类的接口，然后我们在实际编码中使用的是接口，并把具体的通知类定义到配置文件中去，这样有便于我们以后做扩展。 
（4）实现Aop代理的invoke方法，并在invoke中调用接入点方法，且在调用之后接着调用通知的方法(也就是发短信或者发邮件的方法)。 
好了，对于刚才我们引入的需求，运用Aop思想，其大致的实现就是上面几步。那么，当需求变更为“发送邮件”时，我们只需要改变一下配置文件中的通知类就可以了；当要监控的函数需要改变时，我们也只需要改一下配置文件中对于切点的配置就可以了。 
下面，我们来看一下Aop思想的一个简单实现的例子（该例子利用Aop思想完成一件事就是当我们调用UserDao对象的saveUser方法时，系统会进行日志记录）： 
1. 编写IOC容器要用到的配置文件（用来配置bean对象和切点）——beans.xml 
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"> 
<bean id="UserDao" class="AopTest.UserDao"></bean> 
<bean id="LogTool" class="AopTest.LogTool"></bean> 
<aop id="logging" ref="LogTool" pointCut="UserDao.*" method="before"></aop> 
</beans> 

2.编写bean节点配置类，用来封装配置文件中所配置的bean对象的信息——BeanNode.java 
package AopTest; 

/** 
* xml配置文件中配置的bean节点的映射对象 
* @author Administrator 
* 
*/ 
public class BeanNode 
{ 
private String id; 
private String className; 

public BeanNode() 
{ 
super(); 
} 

public BeanNode(String id, String className) 
{ 
this.id=id; 
this.className=className; 
} 

public String getId() { 
return id; 
} 
public void setId(String id) { 
this.id = id; 
} 
public String getClassName() { 
return className; 
} 
public void setClassName(String className) { 
this.className = className; 
} 


} 

3.编写aop节点配置类——AopNode.java 
package AopTest; 

/** 
* xml配置文件中配置的aop节点的映射对象 
* @author Administrator 
* 
*/ 
public class AopNode 
{ 
private String id; 
private String ref; 
private String pointCut; 
private String method; 
public String getId() { 
return id; 
} 
public void setId(String id) { 
this.id = id; 
} 
public String getRef() { 
return ref; 
} 
public void setRef(String ref) { 
this.ref = ref; 
} 
public String getPointCut() { 
return pointCut; 
} 
public void setPointCut(String pointCut) { 
this.pointCut = pointCut; 
} 
public String getMethod() { 
return method; 
} 
public void setMethod(String method) { 
this.method = method; 
} 


} 

4.编写自定义IOC容器，用来管理配置文件中配置的bean对象——IocContainer.java 
package AopTest; 

import org.dom4j.Document; 
import org.dom4j.Element; 
import org.dom4j.XPath; 
import org.dom4j.io.SAXReader; 

/** 
* 自定义Ioc容器 
* @author Administrator 
* 
*/ 
public class IocContainer 
{ 
private static java.util.Map<String,BeanNode> beanMap=new java.util.HashMap<String, BeanNode>(); 
private static java.util.List<AopNode> aopNodes=new java.util.ArrayList<AopNode>(); 


/** 
* 解析配置好的xml文件，读取bean节点对象以及aop节点对象,并添加到队列中 
* @param fileName 
*/ 
private void readXML(String fileName) 
{ 
//创建一个文件xml文件读取器 
SAXReader saxReader=new SAXReader(); 
Document document=null; 

try 
{ 
//取得类的类装载器，通过类装载器，取得类路径下的文件 
java.net.URL xmlPath=this.getClass().getClassLoader().getResource(fileName); 
//读取文件内容 
System.out.println("xmlPath="+xmlPath); 
document=saxReader.read(xmlPath); 
//创建一个map对象 
java.util.Map<String, String> nameSpaceMap=new java.util.HashMap<String,String>(); 
//加入命名空间 
nameSpaceMap.put("nameSpace", "http://www.springframework.org/schema/beans"); 

//创建beans/bean查询路径 
XPath xpath1=document.createXPath("nameSpace:beans/nameSpace:bean"); 
//设置命名空间 
xpath1.setNamespaceURIs(nameSpaceMap); 
//获取文档下所有bean节点 
java.util.List<Element> beans=xpath1.selectNodes(document); 
System.out.println("bean对象的个数为："+beans.size()); 

for(int i=0; i<beans.size(); i++) 
{ 
Element element=beans.get(i); 
//获取bean节点对象的id属性 
String id=element.attributeValue("id"); 
System.out.println("bean对象的id为："+id); 
//获取bean节点对象的className属性 
String className=element.attributeValue("class"); 
//创建bean节点对象 
BeanNode beanNode=new BeanNode(id, className); 
beanMap.put(beanNode.getId(), beanNode);
} 

//创建beans/aop查询路径 
XPath xpath2=document.createXPath("nameSpace:beans/nameSpace:aop"); 
//设置命名空间 
xpath2.setNamespaceURIs(nameSpaceMap); 
//获取文档下所有aop节点 
java.util.List<Element> aops=xpath2.selectNodes(document); 

for(int i=0; i<aops.size(); i++) 
{ 
Element element=aops.get(i); 
//获取aop节点对象的id属性 
String id=element.attributeValue("id"); 
//获取aop节点对象的ref属性 
String ref=element.attributeValue("ref"); 
//获取aop节点对象的pointCut属性 
String pointCut=element.attributeValue("pointCut"); 
//获取aop节点对象的method属性 
String method=element.attributeValue("method"); 

//创建aop节点对象 
AopNode aopNode=new AopNode(); 
aopNode.setId(id); 
aopNode.setRef(ref); 
aopNode.setPointCut(pointCut); 
aopNode.setMethod(method); 
aopNodes.add(aopNode); 
} 

} 


catch(Exception e) 
{ 
e.printStackTrace(); 
} 
} 

/** 
* 获取指定对象的代理对象,可以通过该代理对象执行指定对象的所有方法 
* @param id 
* @return 
* @throws Exception 
*/ 
public  Object getProxyOfBean(String id) throws Exception 
{ 
//解析beans.xml文件 
readXML("AopTest/beans.xml"); 
BeanNode beanNode=beanMap.get(id); 
if(null==beanNode) 
{ 
throw new Exception("没有这个东西！id="+id); 
} 

//得到配置的bean对象,注意,此处调用默认无参构造器 
//通过反射机制实例化指定的bean对象 
Class c=Class.forName(beanNode.getClassName()); 
Object  bean=c.newInstance(); 
//向代理对象传入代理配置参数(即aop节点中配置的参数) 
UserDaoProxy.aopNodes=aopNodes; 
//获取指定bean对象的代理对象 
Object proxy=UserDaoProxy.getProxy(bean); 
return proxy; 

} 

public static BeanNode getBeanNodeById(String id) 
{ 
return beanMap.get(id); 
} 

//获得指定id的bean对象 
public static Object getBean(String id) throws Exception 
{ 
BeanNode beanMapping=beanMap.get(id); 
if(null==beanMapping) 
{ 
throw new Exception("没有这个东西！id="+id); 
} 
//得到配置的bean对象,注意,此处调用默认无参构造器 
Class c=Class.forName(beanMapping.getClassName()); 
Object  bean=c.newInstance();
return bean; 
} 
} 
5.编写目标对象接口——IUserDao.java 
package AopTest; 

/** 
* userDao接口 
* @author Administrator 
* 
*/ 
public interface IUserDao 
{ 
/** 
* 根据用户名和密码，保存用户对象 
* @param userName 
* @param userPwd 
*/ 
void saveUser(String userName, String userPwd); 

/** 
* 根据用户id删除用户对象 
* @param id 
*/ 
void deleteUser(int id); 
} 

6.编写目标对象类（实现目标对象接口类）——UserDao.java 
package AopTest; 

public class UserDao implements IUserDao 
{ 
/** 
* 根据用户名和密码，保存用户对象 
* @param userName 
* @param userPwd 
*/ 
public void saveUser(String userName, String userPwd) 
{ 
System.out.println("保存用户对象成功，用户名："+userName+" 密码："+userPwd); 
} 

/** 
* 根据用户id删除用户对象 
* @param id 
*/ 
public void deleteUser(int id) 
{ 
System.out.println("删除用户对象成功，用户编号："+id); 
} 
} 

7.编写日志工具类接口，用来记录某方法调用的信息——ILogTool.java 
package AopTest; 

/** 
* 日志记录工具接口 
* @author Administrator 
* 
*/ 
public interface ILogTool 
{ 
/** 
* 在方法执行前记录日志 
* @param m: 正在执行的方法 
* @param args: 方法中的参数 
*/ 
void before(java.lang.reflect.Method m, Object[] args); 

/** 
* 在方法执行之后记录日志 
* @param m: 正在执行的方法 
* @param args：方法中的参数 
*/ 
void after(java.lang.reflect.Method m, Object[] args); 
} 

8.编写日志工具实现类——LogTool.java 
package AopTest; 

/** 
* 日志工具实现类 
* @author Administrator 
* 
*/ 
public class LogTool implements ILogTool 
{ 
/** 
* 在方法执行前记录日志 
* @param m: 正在执行的方法 
* @param args: 方法中的参数 
*/ 
public void before(java.lang.reflect.Method m, Object[] args) 
{ 
//获取方法名字 
String methodName=m.getName(); 
//获取传入方法中的参数值 
String paramValue=""; 
for(int i=0; i<args.length; i++) 
{ 
Object param=args[i]; 
paramValue=paramValue+param.toString()+","; 
} 
System.out.println("before execute "+methodName+" method, params:"+paramValue); 
} 

/** 
* 在方法执行之后记录日志 
* @param m: 正在执行的方法 
* @param args：方法中的参数 
*/ 
public void after(java.lang.reflect.Method m, Object[] args) 
{ 
//获取方法名 
String methodName=m.getName(); 
//获取传入方法中的参数值 
String paramValue=null; 
for(int i=0; i<args.length; i++) 
{ 
Object param=args[i]; 
paramValue=" "+param.toString(); 
} 
System.out.println("after execute "+methodName+" params:"+paramValue); 
} 
} 

9.编写目标对象的代理类——UserDaoProxy.java 
package AopTest; 

import java.lang.reflect.Method; 

/** 
* 通用代理类的实现 
* Aop要通过jdk中的“代理”机制来实现 
* 实际上Aop思想的实现就是将包含接入点的目标对象交给其代理对象来管理，客户端通过目标对象的代理对象来调用目标对象提供的接入点方法， 
* 这样我们可以在代理对象中调用接入点方法时做其他一些处理，这里我们称之为通知 
* @author Administrator 
* 
*/ 
public class UserDaoProxy implements java.lang.reflect.InvocationHandler 
{ 
//被切点对象的配置列表，里面是xml中读取的AopXmlMapping对象 
static java.util.List<AopNode> aopNodes; 
//被代理的对象(即目标对象） 
static Object proxiedObj; 

/** 
* 获取指定对象的代理对象 
* @param obj 
* @return 
*/ 
public static Object getProxy(Object obj) 
{ 
return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(), 
obj.getClass().getInterfaces(), 
new UserDaoProxy(obj)); 
} 

private UserDaoProxy(Object obj) 
{ 
this.proxiedObj=obj; 
} 

/** 
* 实现InvocationHandler接口的invoke方法 
* 代理对象被调用时，实际上是执行了该方法 
* 因此那些被代理执行的方法应该写在该方法体内 
*/ 
public Object invoke(Object proxy, Method method, Object[] args) 
throws Throwable 
{ 
Object result=null; 
try 
{ 
ILogTool logTool=null; 
boolean needAop=false; 
for(int i=0; i<aopNodes.size(); i++) 
{ 
//获取aop节点的配置信息 
AopNode aopNode=aopNodes.get(i); 
//获取切入点或称之为连接点（也就是要切入到哪个对象的哪个方法上去） 
String pointCut=aopNode.getPointCut(); 
//获取包含通知方法的对象（我们在aop节点中配置的是LogTool对象） 
String logToolName=aopNode.getRef(); 
//找到日志工具对象——包含通知方法的对象 
logTool=(LogTool)IocContainer.getBean(logToolName); 
int limit=pointCut.indexOf("."); 
//获取目标对象的beanId 
String destPointBeanId=pointCut.substring(0,limit);//匹配beanid部分 

//1.获取连接点（Spring中只支持方法类型的连接点） 
String methodRane=pointCut.substring(limit+1,pointCut.length());//匹配方法部分 
System.out.println("destPointBeanId:  "+destPointBeanId); 
//获取目标对象的节点配置信息 
BeanNode beanNode=IocContainer.getBeanNodeById(destPointBeanId); 
System.out.println("目标对象的类名为： "+beanNode.getClassName()); 
System.out.println("被代理执行的对象的类名为： "+this.proxiedObj.getClass().getName()); 
//找到了要切入的目标对象! 
if(null!=beanNode&&beanNode.getClassName().equals(this.proxiedObj.getClass().getName())){ 
if(methodRane.equals("*"))//被代理的对象的所有方法都要接受切入！ 
{ 
//2.获取连接点方法的名字，然后执行该方法 
if(aopNode.getMethod().equals("before")) 
{ 
//方法前切入（即前置通知） 
//这里的method实际上就是客户端调用的被代理对象的方法 
logTool.before(method, args);//3.执行要切入的方法（即通知） 
//调用切入的目标对象（也就是被代理的对象）的方法（即连接点方法） 
//invoke方法的第一个参数为method方法的拥有者，第二个参数为传入method方法的参数对象 
result = method.invoke(this.proxiedObj, args);//4.通过代理对象执行连接点方法 
needAop=true; 
break; 
} 
else 
{ 
//方法后切入（即后置通知） 
//调用切入的目标对象（也就是被代理的对象）的方法（即连接点方法） 
result = method.invoke(proxy, args); 
logTool.after(method, args);//调用后切入！ 
needAop=true; 
break; 
} 

} 
} 
} 
if(!needAop) 
{ 
result = method.invoke(proxy, args);//调用目标对象（也就是被代理的对象）的方法 
} 
}  
catch (Exception e) 
{ 
e.printStackTrace(); 
throw new RuntimeException("invocation : " + e.getMessage()); 
}  
return result; 
} 
} 

10.编写测试类——Tester.java 
package AopTest; 

public class Tester 
{ 
public static void main(String[] args) 
{ 
try 
{ 
IocContainer ic=new IocContainer(); 
//获取UserDao对象的代理对象 
IUserDao userDao=(IUserDao)ic.getProxyOfBean("UserDao"); 
userDao.saveUser("zzq", "123456"); 
} 
catch(Exception e) 
{ 
e.printStackTrace(); 
} 

} 
} 

11.测试结果如下： 
xmlPath=file:/F:/myeclipse6_workspace/netjava_web_project/WebRoot/WEB-INF/classes/AopTest/beans.xml 
bean对象的个数为：2 
bean对象的id为：UserDao 
bean对象的id为：LogTool 
destPointBeanId:  UserDao 
目标对象的类名为： AopTest.UserDao 
被代理执行的对象的类名为： AopTest.UserDao 
before execute saveUser method, params:zzq,123456, 
保存用户对象成功，用户名：zzq 密码：123456 


最后，想稍微解释一下以上的实现代码，实际上Aop思想的实现主要是依赖于IOC思想以及java中的代理机制。