聊一聊Spring AOP

   前两天，在给新入职的同事作技术介绍时，讲到spring的AOP。使我又一次认识到，对于AOP，特别是spring AOP的理解，虽然你们都能说上来几句，可是许多人认识并不太全面，甚至能够说是只知其一;不知其二----即便是对于那些已经有过几年开发经验的工程师也是如此。因此，回来以后，我干脆对这块东西作了个肤浅的小结，以便再有相似任务时，直接拿来给你们借鉴。

AOP(Aspect-Oriented Programming)实际上是OOP(Object-Oriented Programing)思想的补充和完善。咱们知道，OOP引进"抽象"、"封装"、"继承"、"多态"等概念,对万事万物进行抽象和封装，来创建一种对象的层次结构，它强调了一种完整事物的自上而下的关系。可是具体细粒度到每一个事物内部的状况，OOP就显得无能为力了。好比日志功能。日志代码每每水平地散布在全部对象层次当中，却与它所散布到的对象的核心功能毫无关系。对于其余不少相似功能，如事务管理、权限控制等也是如此。这致使了大量代码的重复，而不利于各个模块的重用。
   而AOP技术则偏偏相反，它利用一种称为"横切"的技术，可以剖解开封装的对象内部，并将那些影响了多个类而且与具体业务无关的公共行为 封装成一个独立的模块（称为切面）。更重要的是，它又能以巧夺天功的妙手将这些剖开的切面复原，不留痕迹的融入核心业务逻辑中。这样，对于往后横切功能的编辑和重用都可以带来极大的方便。
AOP技术的具体实现，无非也就是经过动态代理技术或者是在程序编译期间进行静态的"织入"方式。下面是这方面技术的几个基本术语：
一、join point（链接点）：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不须要去定义一个join point。
二、point cut（切入点）：本质上是一个捕获链接点的结构。在AOP中，能够定义一个point cut，来捕获相关方法的调用。
三、advice（通知）：是point cut的执行代码，是执行“方面”的具体逻辑。
四、aspect（方面）：point cut和advice结合起来就是aspect，它相似于OOP中定义的一个类，但它表明的更可能是对象间横向的关系。
五、introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的AOP工具又将其称为mixin。

全部AOP技术基本上都是基于以上这些概念实现的。

  太抽象了，仍是赶快上例子吧。下面，我写了一个用spring AOP实现的记录方法调用的日志功能的应用实例：目的是记录 系统登陆功能 的执行状况，技术框架简单采用Spring+Struts。

1.登陆页面：

<form action="login.do" method="post">
username:<input type="text" name="username" /><br>
password:<input type="password" name="password"><br>
<input type="submit" value="login">
</form>

2.表单类：

/**
*
* <p>[描述信息：登录表单类]</p>
*
* @author bruce.yang
* @version 1.0 Created on 2013-8-13 下午2:04:09
*/
public class LoginActionForm extends ActionForm {
private String username;
private String password;
//setter,getter方法
}

3.Action类：

/**
*
* <p>[描述信息：登录Action]</p>
*
* @author bruce.yang
* @version 1.0 Created on 2013-8-13 下午2:04:38
*/
public class LoginAction extends Action {
private ILoginService loginService;
@Override
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
LoginActionForm laf = (LoginActionForm) form;
String username = laf.getUsername();
String password = laf.getPassword();
boolean ret = loginService.login(username, password);
if (ret) {
return mapping.findForward("success");
}
return mapping.findForward("fail");
}
//loginService的setter,getter方法
}

4.service层接口：

public interface ILoginService {
public boolean login(String userName, String password);
}
public interface ILogService {
public void log();
public void logArg(JoinPoint point);
public void logArgAndReturn(JoinPoint point, Object returnObj);
}

5.service层实现类：

/**
*
* <p>[描述信息：登陆Service类]</p>
*
* @author bruce.yang
* @version 1.0 Created on 2013-8-13 下午1:45:32
*/
public class LoginServiceImpl implements ILoginService {
/**
*
* <p>功能实现描述:登陆处理逻辑(这里是假实现)</p>
*
* @see com.bruceyang.login.service.ILoginService#login(java.lang.String, java.lang.String)
* @author: bruce.yang
* @date: Created on 2013-8-13 下午1:45:32
*/
public boolean login(String userName, String password) {
StringBuffer sb=new StringBuffer();
sb.append("Target:").append("login:").append(userName).append(",").append(password);
System.out.println(sb.toString());
return true;
}
}

/**
*
* <p>[描述信息：操做日志记录Service]</p>
*
* @author bruce.yang
* @version 1.0 Created on 2013-8-13 下午1:45:32
*/
public class LogServiceImpl implements ILogService {
/**
*
* <p>功能实现描述:最简单的状况</p>
*
* @see com.bruceyang.login.service.ILogService#log()
* @author: bruce.yang
* @date: Created on 2013-8-13 下午1:46:17
*/
public void log() {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" *******Log*********");
}
/**
*
* <p>功能实现描述:有参无返回值的方法</p>
*
* @see com.bruceyang.login.service.ILogService#logArg(org.aspectj.lang.JoinPoint)
* @author: bruce.yang
* @date: Created on 2013-8-13 下午1:43:43
*/
public void logArg(JoinPoint point) {
StringBuffer sb=new StringBuffer();
//获取链接点所在的目标对象
Object obj=point.getTarget();
//获取链接点的方法签名对象
String method=point.getSignature().getName();
//获取链接点方法运行时的入参列表
Object[] args = point.getArgs();
sb.append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())).append(" ");
sb.append(obj.toString().substring(0,obj.toString().indexOf('@')));
sb.append(".").append(method).append(" ");
sb.append("Args:[");
if (args != null) {
for(int i=0;i<args.length;i++){
Object o=args[i];
sb.append(o);
if(i<args.length-1){
sb.append(",");
}
}
}
sb.append("]");
System.out.println(sb.toString());
}
/**
*
* <p>功能实现描述:有参并有返回值的方法</p>
*
* @see com.bruceyang.login.service.ILogService#logArgAndReturn(org.aspectj.lang.JoinPoint, java.lang.Object)
* @author: bruce.yang
* @date: Created on 2013-8-13 下午1:43:17
*/
public void logArgAndReturn(JoinPoint point, Object returnObj) {
StringBuffer sb=new StringBuffer();
//获取链接点所在的目标对象
Object obj=point.getTarget();
//获取链接点的方法签名对象
String method=point.getSignature().getName();
//获取链接点方法运行时的入参列表
Object[] args = point.getArgs();
sb.append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())).append(" ");
sb.append(obj.toString().substring(0,obj.toString().indexOf('@')));
sb.append(".").append(method).append(" ");
sb.append("Args:[");
if (args != null) {
for(int i=0;i<args.length;i++){
Object o=args[i];
sb.append(o);
if(i<args.length-1){
sb.append(",");
}
}
}
sb.append("]").append(" ");
sb.append("Ret:[").append(returnObj).append("]");
System.out.println(sb.toString());
}
}

6.web.xml：

<!-- spring config -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:config/spring/app*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- struts config -->
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/config/struts/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>debug</param-name>
<param-value>2</param-value>
</init-param>
<init-param>
<param-name>detail</param-name>
<param-value>2</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

7.spring配置信息：

  applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx">
<bean id="logService" class="com.bruceyang.login.service.impl.LogServiceImpl"></bean>
<bean id="loginService" class="com.bruceyang.login.service.impl.LoginServiceImpl"></bean>
<aop:config>
<!-- 切入点 -->
<aop:pointcut
expression="execution(* com.bruceyang.login.service.impl.Login*.*(..))"
id="myPointcut" />
<!-- 切面： 将哪一个对象中的哪一个方法，织入到哪一个切入点 -->
<aop:aspect id="dd" ref="logService">
<!-- 前置通知
<aop:before method="log" pointcut-ref="myPointcut" />
<aop:after method="logArg" pointcut-ref="myPointcut"/>
<aop:after-returning method="logArgAndReturn" returning="returnObj" pointcut-ref="myPointcut"/>
-->
<aop:before method="log" pointcut-ref="myPointcut" />
<aop:after method="logArg" pointcut-ref="myPointcut"/>
<aop:after-returning method="logArgAndReturn" returning="returnObj" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>
</beans>

7.Struts配置信息：

  struts-config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd">
<struts-config>
<form-beans>
<form-bean name="loginActionForm" type="com.bruceyang.login.web.form.LoginActionForm"/>
</form-beans>
<action-mappings>
<action path="/tologin"
forward="/login.jsp"
/>
<action
path="/login"
type="org.springframework.web.struts.DelegatingActionProxy"
name="loginActionForm"
scope="request"
input="/login.jsp">
<forward name="success" path="/success.jsp"/>
<forward name="fail" path="/login.jsp"/>
</action>
</action-mappings>
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/config/struts/action-servlet.xml" />
</plug-in>
</struts-config>

action-servlet.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<import resource="login-action.xml" />
</beans>

login-action.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="/login"
class="com.bruceyang.login.web.action.LoginAction">
<property name="loginService" ref="loginService" />
</bean>
</beans>

附：1.目录结构

       2.运行结果

  其实，spring为咱们提供的事务管理等功能也是基于这个逻辑来实现的。而且咱们还能够用这种方式实现更加复杂多样的AOP编程。以达到把全部所谓的横切关注点分离出来，一劳永逸的加以实现，之后集中精力解决核心关注点的实现。