AOP(Aspect Oriented Programming),是面向切面编程的技术。AOP基于IOC基础，是对OOP的有益补充。

AOP将应用系统拆分为个部分：核心业务逻辑及横向的通用逻辑，也就是所谓的切面。

举例：所有大中型应用都要涉及到的持久化管理、事务管理、权限管理、日志管理和调试管理等。使用AOP技术可以让开发人员只专注核心业务，而通用逻辑则使用AOP技术进行横向切入，由专人去处理这些通用逻辑，会使得任务简单明了，提高开发和调试的效率。

Target：目标类

Joinpoint：连接点是指所有可能织入通知的方法理论上大部分方法都是连接点

Pointcut：切入点，已经被增强的方法

Advice：通知，增强的方法

Aspect：切面，通知所在的类就叫切面。

Weaving：织入，将通知应用到目标对象来创建新的代理对象的过程。

 通知的类型： 前置通知 后置通知 返回通知 异常通知 环绕通知

各类通知的执行顺序： 前置通知 2.执行目标方法 3.执行后置通知 4.返回通知||异常通知

前置通知，后置通知，返回通知，异常通知都可以接受一个JoinPoint类型的对象作为参数。该对象封装了连接点的相关信息。主要关注：方法参数和方法签名。

返回通知的returning属性可以将目标方法的返回值定义一个名字，然后在返回通知的形参上声明一个同名的Object类型的参数，来访问方法的返回结果。

<aop:after-returning method=”afterReturnLog” pointcut-ref=”userDaoPointccut” returning=”result” /> 环绕通知 环绕通知必须要有返回值（Object类型）

环绕通知必须要有形参（ProceedingJoinPoint pjp）

在环绕通知中，通过pjp.proceed()方法显示调用目标对象的切点并将结果返回出去。

使用注解配置aop

引入约束 beans context aop 扫描包 开启注解式的aop <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

在业务类上加上注解（@Component）

在属性上加@Autowired注解

在切面类上加注解 （@Component  @Aspect）

在通知上加上相应的注解 @Before（value=""）

@AfterReturning(returning="目标切点返回值的名字") 在通知方法参数只能为Object

@AfterThrowing(throwing="异常的名字") 在通知方法参数可以为Object也可为Exception

重用切入点表达式： 在切面中定义一个空的方法，在方法上加@Pointcut注解，在value属性中指定切入点表达式 @Pointcut（value=“execution(* com.cdsxt.dao.*.*(..))”） Public void pointcutExpression(){} @Before(value="pointcutExpression()")

在面对多个切面时可以在类上加@Order(1)数字越小越优先执行



AOP两种代理的区别：

AOP支持2种代理，jdk的动态代理和CGLIB实现机制。

jdk基于接口实现：jdk动态代理对实现了接口的类进行代理。

CGLIB基于继承：CGLIB代理可以对类代理，主要对指定的类生成一个子类，因为是继承，所以目标类最好不要使用final声明。

通常情况下，鼓励使用jdk代理，因为业务一般都会抽象出一个接口，而且不用引入新的东西。如果是遗留的系统，以前没有实现接口，那么只能使用CGLIB。

 

在工作中有一个在切面中需要记录一下操作日志的需求，而且要求这些操作日志要存入数据库，并且无论业务层有什么异常，日志照常记录，那就不能沿用业务层的事务，而是需要新启一个事务了。

sping的声明式事务就是靠AOP来实现的，一般事务都在业务层中启用，那如果要在AOP的逻辑中启用一个新的事务要怎么做呢？比如下面的例子：
//定义一个切点，这里指com.lidehang.remote包下所有的类的方法
@Pointcut("execution(public * com.lidehang.remote..*.*(..))")
 public void remote(){}

//切点指定的方法执行完返回后调用
@AfterReturning(returning = "ret", pointcut = "remote()")
 public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
 	//一些切面逻辑，包含了数据库操作，为了即便业务层的原事务回滚也不会影响切面中的数据库操作，需要启用新的事务
...
 }

经过我的测试，通过在doAfterReturning方法上加上注解@Transactional，并指定传播行为是REQUIRES_NEW依然不行。因为@Transactional也是声明式事务，本身就是AOP实现的，在AOP的代码中使用不起作用。所以就只能使用spring的编程式事务了，需要引入TransactionTemplate。如下：
@Autowired
private TransactionTemplate transactionTemplate;

@AfterReturning(returning = "ret", pointcut = "remote()")
 public void doAfterReturning(JoinPoint joinPoint,Object ret) throws Throwable {
//声明式事务在切面中不起作用，需使用编程式事务
//设置传播行为：总是新启一个事务，如果存在原事务，就挂起原事务
transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
transactionTemplate.execute(new TransactionCallback<T>() {
@Override
		public T doInTransaction(TransactionStatus arg0) {
 			//一些切面逻辑，包含了数据库操作
...
}
});
 }

通过以上的步骤，切面里的逻辑会在新事务中执行，执行完就会提交，和业务层中的原事务无关，即便执行完切面逻辑后继续执行业务代码的过程中出现异常，业务层中的数据库操作因为有原事务而回滚，但切面中的数据库操作不会回滚，因为这是个新的事务！

一、对AOP的初印象

首先先给出一段比较专业的术语（来自百度）：

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个
热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
了开发的效率。


然后我们举一个比较容易理解的例子（来自：Spring 之 AOP）：

要理解切面编程，就需要先理解什么是切面。用刀把一个西瓜分成两瓣，切开的切口就是切面；炒菜，锅与炉子共同来完成炒菜，锅与炉子就是切面。web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。

我们一般做活动的时候，一般对每一个接口都会做活动的有效性校验（是否开始、是否结束等等）、以及这个接口是不是需要用户登录。

按照正常的逻辑，我们可以这么做。 



这有个问题就是，有多少接口，就要多少次代码copy。对于一个“懒人”，这是不可容忍的。好，提出一个公共方法，每个接口都来调用这个接口。这里有点切面的味道了。 



同样有个问题，我虽然不用每次都copy代码了，但是，每个接口总得要调用这个方法吧。于是就有了切面的概念，我将方法注入到接口调用的某个地方（切点）。



这样接口只需要关心具体的业务，而不需要关注其他非该接口关注的逻辑或处理。 

红框处，就是面向切面编程。



二、AOP中的相关概念

看过了上面的例子，我想大家脑中对AOP已经有了一个大致的雏形，但是又对上面提到的切面之类的术语有一些模糊的地方，接下来就来讲解一下AOP中的相关概念，了解了AOP中的概念，才能真正的掌握AOP的精髓。 

这里还是先给出一个比较专业的概念定义：


Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程


然后举一个容易理解的例子： 

看完了上面的理论部分知识, 我相信还是会有不少朋友感觉到 AOP 的概念还是很模糊, 对 AOP 中的各种概念理解的还不是很透彻. 其实这很正常, 因为 AOP 中的概念是在是太多了, 我当时也是花了老大劲才梳理清楚的. 

下面我以一个简单的例子来比喻一下 AOP 中 Aspect, Joint point, Pointcut 与 Advice之间的关系. 

让我们来假设一下, 从前有一个叫爪哇的小县城, 在一个月黑风高的晚上, 这个县城中发生了命案. 作案的凶手十分狡猾, 现场没有留下什么有价值的线索. 不过万幸的是, 刚从隔壁回来的老王恰好在这时候无意中发现了凶手行凶的过程, 但是由于天色已晚, 加上凶手蒙着面, 老王并没有看清凶手的面目, 只知道凶手是个男性, 身高约七尺五寸. 爪哇县的县令根据老王的描述, 对守门的士兵下命令说: 凡是发现有身高七尺五寸的男性, 都要抓过来审问. 士兵当然不敢违背县令的命令, 只好把进出城的所有符合条件的人都抓了起来.

来让我们看一下上面的一个小故事和 AOP 到底有什么对应关系. 

首先我们知道, 在 Spring AOP 中 Joint point 指代的是所有方法的执行点, 而 point cut 是一个描述信息, 它修饰的是 Joint point, 通过 point cut, 我们就可以确定哪些 Joint point 可以被织入 Advice. 对应到我们在上面举的例子, 我们可以做一个简单的类比, Joint point 就相当于 爪哇的小县城里的百姓,pointcut 就相当于 老王所做的指控, 即凶手是个男性, 身高约七尺五寸, 而 Advice 则是施加在符合老王所描述的嫌疑人的动作: 抓过来审问. 

为什么可以这样类比呢?


Joint point ： 爪哇的小县城里的百姓: 因为根据定义, Joint point 是所有可能被织入 Advice 的候选的点, 在 Spring AOP中, 则可以认为所有方法执行点都是 Joint point. 而在我们上面的例子中, 命案发生在小县城中, 按理说在此县城中的所有人都有可能是嫌疑人.
Pointcut ：男性, 身高约七尺五寸: 我们知道, 所有的方法(joint point) 都可以织入 Advice, 但是我们并不希望在所有方法上都织入 Advice, 而 Pointcut 的作用就是提供一组规则来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice. 同理, 对于县令来说, 他再昏庸, 也知道不能把县城中的所有百姓都抓起来审问, 而是根据凶手是个男性, 身高约七尺五寸, 把符合条件的人抓起来. 在这里 凶手是个男性, 身高约七尺五寸 就是一个修饰谓语, 它限定了凶手的范围, 满足此修饰规则的百姓都是嫌疑人, 都需要抓起来审问.
Advice ：抓过来审问, Advice 是一个动作, 即一段 Java 代码, 这段 Java 代码是作用于 point cut 所限定的那些 Joint point 上的. 同理, 对比到我们的例子中, 抓过来审问 这个动作就是对作用于那些满足 男性, 身高约七尺五寸 的爪哇的小县城里的百姓.
Aspect:：Aspect 是 point cut 与 Advice 的组合, 因此在这里我们就可以类比: “根据老王的线索, 凡是发现有身高七尺五寸的男性, 都要抓过来审问” 这一整个动作可以被认为是一个 Aspect.


最后是一个描述这些概念之间关系的图： 





三、其他的一些内容

AOP中的Joinpoint可以有多种类型：构造方法调用，字段的设置和获取，方法的调用，方法的执行，异常的处理执行，类的初始化。也就是说在AOP的概念中我们可以在上面的这些Joinpoint上织入我们自定义的Advice，但是在Spring中却没有实现上面所有的joinpoint，确切的说，Spring只支持方法执行类型的Joinpoint。

Advice 的类型


before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)
after return advice, 在一个 join point 正常返回后执行的 advice
after throwing advice, 当一个 join point 抛出异常后执行的 advice
after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.
around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.
introduction，introduction可以为原有的对象增加新的属性和方法。


在Spring中，通过动态代理和动态字节码技术实现了AOP，这些内容，我们将在以后进行讲解。

AOP:不是由Spring定义.AOP联盟的组织定义.

Spring中的通知:(增强代码)

前置通知 org.springframework.aop.MethodBeforeAdvice

* 在目标方法执行前实施增强

后置通知 org.springframework.aop.AfterReturningAdvice

* 在目标方法执行后实施增强

环绕通知 org.aopalliance.intercept.MethodInterceptor

* 在目标方法执行前后实施增强

异常抛出通知 org.springframework.aop.ThrowsAdvice

* 在方法抛出异常后实施增强

第一步:导入相应jar包.

* spring-aop-3.2.0.RELEASE.jar
* com.springsource.org.aopalliance-1.0.0.jar

第二步:编写被代理对象:

* CustomerDao接口
* CustoemrDaoImpl实现类

第三步:写一个类继承相关Advice的接口：

public class MyBeforeAdvice implements MethodBeforeAdvice{

        /**
         * method:执行的方法
         * args:参数
         * target:目标对象
         */
    public void before(Method method, Object[] args, Object target)throws Throwable {
        System.out.println("前置增强...");
    }
}

 

第四步:生成代理:(配置生成代理:)

spring是支持配置文件帮我们生成代理的。

<?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.xsd">
<!-- 目标对象 -->
    <bean id="customerDao" class="cn.itcast.aop.dao.CustomerDaoImpl"/>


<!-- 定义增强对象 -->
<bean id="beforeAdvice" class="cn.itcast.aop.advice.MyBeforeAdvice"/>
<!-- 使用spring框架生成代理对象 -->
<bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 代理的目标对象 -->
<property name="target" ref="customerDao"></property>
<!-- 设置实现的接口告诉代理实现的接口跟CustomerDaoImpl实现类实现的接口一样 -->
<property name="proxyInterfaces" value="cn.itcast.aop.dao.CustomerDao"></property>
<!-- 增强是通知name="interceptorNames"拦截所有的方法    value="beforeAdvice" 增强的通知告诉代理对象应该使用前置增强-->
<property name="interceptorNames" value="beforeAdvice"></property>
</bean>

</beans>

第五步：编写测试类

利用spring集成junit将我们需要的目标类注入到测试类中

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest {
    @Autowired
    // @Qualifier("customerDao")//注入真实对象
    @Qualifier("customerDaoProxy")//注入代理对象
    private CustomerDao customerDao;

    @Test
    public void test(){
        customerDao.add();
        customerDao.delete();
        customerDao.find();
        customerDao.update();
    }
}