问题：什么是AOP？
答：AOP基本概念：Aspect-Oriented Programming，面向方面编程的简称，Aspect是一种新的模块化机制。用来描写叙述分散在对象、类或方法中的横切关注点(crosscutting concern)， 从关注点中分离出横切关注点是面向方面程序设计的核心所在。
分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特 定领域问题代码的调用。业务逻辑同特定领域问题的关系通过方面来封装、维护，这样原本分散在整个应用程序中的变动就能够非常好地管理起来。
个人理解：所谓的AOP就是把我们的程序的运行看成是一个方块的面包，然后切成了一片一片的吐司--这些吐司就是我们一个一个的方法。
然后在这些吐司片的前面，后面、甚至是里面来做一些特定条件下发生的特定事情。比方嵌入几个葡萄干、给前面加苹果酱、给后面加草莓酱这种事情。。优势在于你能够在自己的AOP方法中规定一个加苹果酱的理由，满足这个理由的话就能够加苹果酱，而不用在每一个方法中都特定的指出加苹果酱，加草莓酱什么的··个人理解···。
AOP的实现有非常多的方式。我这边使用Spring中自带的aop来做一些业务逻辑的实现。
在Spring中实现aop的方式有两种。各自是通过xml配置和通过注解配置。以下来介绍这两种方式。
在介绍他们之前先看一下项目的结构：
上图中ServiceAspect是我们使用注解的方式来实现AOP的类，InteceptorXML是使用XML来实现AOP的类；TestAop是測试方法；TestServiceImpl；TestService是用来被AOP的动作。（须要明白的是，AOP的动作建议都发生在service层面。
）application-context.xml是我的配置文件。
1.通过注解配置。
我注解AOP的代码例如以下：
package test.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import test.entity.User;
@Component
// 声明这是一个组件
@Aspect
// 声明这是一个切面bean
public class ServiceAspect {
// 配置切入点，该方法无方法体，主要是为了同类中其它方法使用此处配置的切入点 ----见(1)
@Pointcut("execution(* test.service..*.*(..))")
public void aspect() {
}
// 配置前置通知，使用在方法aspect()上注冊的切入点，同一时候接受JoinPoint切入点对象。能够没有该參数 ----见(2)
@Before("aspect()&&args(id)")
public void before(JoinPoint joinPoint, long id) {
System.out.println(id + "------------------");
System.out.println("before-->" + joinPoint);
}
// 配置后置通知，使用在方法aspect()上注冊的切入点----见(3)
@After("aspect()&&args(id)")
public void after(JoinPoint joinPoint, long id) {
System.out.println(id + "after----------------------");
System.out.println("after-->" + joinPoint);
}
// 配置围绕通知----见(4)
@Around("aspect()")
public Object around(JoinPoint joinPoint) {
long start = System.currentTimeMillis();
try {
Object o=((ProceedingJoinPoint) joinPoint).proceed();
User user = (User)o;
System.out.println("-----around======="+user.toString());
long end = System.currentTimeMillis();
System.out.println("around -->" + joinPoint + "\tUse time : "
+ (end - start) + " ms!");
return user;
} catch (Throwable e) {
long end = System.currentTimeMillis();
System.out.println("around __>" + joinPoint + "\tUse time : "
+ (end - start) + " ms with exception : " + e.getMessage());
return null;
}
}
// 配置后置返回通知,使用在方法aspect()上注冊的切入点----见(5)
@AfterReturning(pointcut = "aspect()", returning = "returnVal")
public void afterReturning(JoinPoint joinPoint, Object returnVal) {
System.out.println("afterReturning executed, return result is "
+ returnVal);
}
// 配置抛出异常后通知,使用在方法aspect()上注冊的切入点----见(6)
@AfterThrowing(pointcut = "aspect()", throwing = "ex")
public void afterThrow(JoinPoint joinPoint, Exception ex) {
System.out.println("afterThrow--> " + joinPoint + "\t"
+ ex.getMessage());
}
}
非常多内容在凝视中已经有了。这里说一下几个关键的easy让人不明确的地方。
（1）@Pointcut("execution(* test.service..*.*(..))")就是我们定义的切入点，在括号中面的參数是指定了哪些方法是在考虑切入的范围内的；
* test.service..*.*(..)能够这样来解剖：
第一个* ：表示被拦截的方法能够是随意的返回类型；
test.service:指定了要拦截的包。
..：这两个..表示的是被指定的拦截包test.service中全部的子包中的类的方法都要考虑到拦截的范围中；
*:表示随意的类。
.*:表示随意的方法；
(..):表示随意的方法參数；
总结起来，就是告诉我们这样一个信息：要拦截test.service中全部子包中的全部类的全部方法，这些方法的返回值能够是随意的，參数能够是随意的。
当然，我们也能够特定很多内容。可是格式不要变。比如：
@Pointcut(“execution(* test.service..*.add*(..))”)
那么所要拦截的方法就必须以add来开头了。
切入点的方法中不实现不论什么的操作，作用仅仅是提供给其它的切面来使用。
（2）
@Before("aspect()&&args(id)")中的 aspect()，指定指定切入点的方法。就是我们定义为pointCut的aspect()方法，然后args(id)，我们获取了所拦截的方法的传入的參数中的id；在before方法中我们能够在切入点运行曾经来做一些操作。 当中的joinPoint是切入点的相关信息。
（3）
@After("aspect()&&args(id)")同（2）。仅仅是这是在切入点运行完毕以后来做出一些处理。
（4）
@Around("aspect()")是围绕通知，在围绕通知中我们能切入点的非常多内容进行改动；
当中通过Object o=((ProceedingJoinPoint) joinPoint).proceed();我们就能够让切入点的方法完毕，获得他的执行结果。
然后User user = (User)o;我们把它转换为User对象。假设在return user，之前我们加上user.setName("after aa");就能够改变切入点的执行结果。
这样的操作对于非常多的错误检測以及格式检測是非常实用处的。
（5）
@AfterReturning(pointcut = "aspect()", returning = "returnVal")
这里是切入点有返回结果后做的操作。通过returning的定义我们能获得切入点的返回结果；
（6）
@AfterThrowing(pointcut = "aspect()", throwing = "ex")
这里能够在切入点抛出异常后做一些工作，通过定义throwing我们能获得抛出的异常对象。
相关代码：
application-context.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" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<context:component-scan base-package="test"> <!--开启spring自己定义的包扫描，我定义的为扫描test包下全部内容-->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><!--这里不扫描controller。在mvc中扫描，安全又可靠-->
</context:component-scan>
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy><!--开启凝视方式的spring aop-->
<bean id="userService" class="test.service.impl.UserService"></bean><!--注入userService-->
</beans>UserService
package test.service.impl;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import test.entity.User;
public class UserService {
private final static Log log = LogFactory.getLog(UserService.class);
public User get(long id) {
if (log.isInfoEnabled()) {
log.info("getUser method . . .");
}
User user = new User(1, "test");
return user;
}
public void save(User user) {
if (log.isInfoEnabled()) {
log.info("saveUser method . . .");
}
}
public boolean delete(long id) throws Exception {
if (log.isInfoEnabled()) {
log.info("delete method . . .");
throw new Exception("spring aop ThrowAdvice演示");
}
return false;
}
}
test方法
package demo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.entity.User;
import test.service.impl.UserService;
public class TestAop {
public static void main(String[] args) {
ApplicationContext aContext = new ClassPathXmlApplicationContext("application-context.xml");//载入spring文件
UserService userService = (UserService) aContext.getBean("userService");//获得userservice
User user =userService.get(1L);//调用get方法。
System.out.println(user);
try {
userService.delete(1L);//调用delete方法。
} catch (Exception e) {
System.out.println("Delete user : " + e.getMessage());
}
}
}
測试结果：
2.通过XML来配置
通过xml来配置AOP，操作都在xml文件里完毕
在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" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<!-- <context:component-scan base-package="test">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy> -->
<bean id="userService" class="test.service.impl.UserService"></bean>
<bean id="inteceptorXML" class="test.aop.InteceptorXML"></bean>
<aop:config>
<aop:aspect id="aspectd" ref="inteceptorXML">
<aop:pointcut expression="execution(* test.service..*.*(..))" id="mypointCutMethod"/>
<aop:before method="doAccessCheck" pointcut-ref="mypointCutMethod" />
</aop:aspect>
</aop:config>
</beans>
在xml中我们指定了用来作为拦截器的bean----inteceptorXML，类似的指定了切入点
<aop:aspect id="aspectd" ref="inteceptorXML">指定了拦截器为interceptorXML。
execution(* test.service..*.*(..))，并指定了id为mypointCutMethod。然后定义了
<aop:before method="doAccessCheck" pointcut-ref="mypointCutMethod" />
指定了调用doAccessCheck来做before拦截，其它拦截我没有指定，这里都能够指定的。
inteceptorXml
package test.aop;
import org.aspectj.lang.ProceedingJoinPoint;
public class InteceptorXML {
public void doAccessCheck() {
System.out.println("before advice");
}
public void doWriteLog() {
System.out.println("after advice");
}
public void doWriteErrorLog() {
System.out.println("Exception advice");
}
public Object doAroundMethod(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("enter around advice method.");
Object obj = pjp.proceed();
System.out.println("exit around advice method.");
return obj;
}
}
执行以上測试方法。得到的结果例如以下：
