Spring AOP(面向方面编程)

Spring AOP(面向方面编程)

动态代理实现思路：
1.就是在运行时，动态生成一个类文件（被代理对象子类），在被代理对象要插入（织入）的地方加入代理的代码。
2.再编译这这个类文件生成一个类，并生成一个实例返回。
3.当运行实例时就可以运行你的代理代码了



AOP知识点:
1.AOP(Aspect-OrientedProgramming)面向方面编程，与OOP(面向对象)完全不同，使用AOP编程系统被分为方面或关注点，而不是OOP中的对象。
2.聚合就是一个类初始化时传入另一个类，类里面对传入这个类进行操作(一个类里面调用另一个对象)
3.JDK动态代理,实现了接口的类(没有实现接口的类是不行的)
4.CGLIB动态代理,针对类来实现代理,对指定目标类产生一个子类，通过方法拦截(intercept)所有父类方法的调用
5.AOP则将这些代码整理起来，将解决某个切面问题的代码单独的放在某个java文件中，然后再动态织入到程序中。



AOP中的术语:
1.Aspect：(方面)把散落在系统各处与横切关注点相关的重复代码抽取出来归整到一处形成一个模块,我们称为方面。就是一个java，里面实现了要在切入点执行的代码。
2.Joinpoint：（连接点），程序运行过程中的某一点.比如方法调用、属性访问、异常抛出。就是插入代理代码的位置。
3.Pointcut：（切入点）， 一组连接点（类似于过滤器的匹配规则 ）
4.Advice：（增强）， 在不修改原有代码的前提下,为某一个对象增加新的功能，就是Aspect中的方法代码,要加入什么功能。
5.Weave：（织入），将方面加入到(拦截器)方法中为对象增加额外功能的过程称为织入，就是加入代理代码到被代理代码中的过程
6.Proxy：（代理对象），就是通过何种方式进行完成这种代码织入的
7.Target：（目标对象），需要被增强功能的对象称之为目标对象,也被称为被增强或被代理对象。



AOP织入位置：
1.before:在某连接点（JoinPoint）之前执行。(多个时名字排序先的织入到最里面,就是名字排序先的先运行)
2.after:当某连接点退出的时候执行（不论是正常返回还是异常退出）,每次都在finally退出时的点织入(多个时名字排序先的织入到最里面,就是名字排序先的先运行)
3.AfterReturning:在某连接点正常完成后执行，不包括抛出异常的情况。(执行完after才到AfterReturning),每次都在Return前的点织入(多个时名字排序先的织入到最里面,就是名字排序先的先运行)
4.afterThrowing:在方法抛出异常退出时执行。after先于afterThrowing执行,每次都在Exception退出时的点织入(多个时名字排序先的织入到最里面,就是名字排序先的先运行)
5.Around:包围一个连接点的通知,在方法执行前后和抛出异常时执行，相当于综合了以上三种;(多个时名字排序先的织入到最里面,就是名字排序先的先运行)
6.Around先于before织入,所以先运行Around再到before
7.Around先于after织入,所以先运行Around再到after


类似于这样：

AroundA
AroundB
beforeA;
beforeB;
try {
	AfterReturningA;
	AfterReturningB;
	Target
	AroundB
	AroundA
	AfterReturningA;
	AfterReturningB;
} catch (Exception e) {
	afterThrowingA;
	afterThrowingB;
}finally {
	afterA;
	afterB;
}

例子：

package com.SpringAop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.SpringAop.Object.ObjectTest;

//@RunWith(BlockJUnit4ClassRunner.class)
public class SpringAopMain {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

		System.out.println("Start");
		ObjectTest objectTest = (ObjectTest) applicationContext.getBean("objectTest");
		objectTest.objectTest();
	}
}

package com.SpringAop.Proxy;

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;

@Component	//定义组件
@Aspect		//注解定义一个Pointcut（切面或切入点）
public class ProxyAop {
	// 定义一个Pointcut（切入点）这样后面就不用每个都写"execution(* com.xing..*.*(..))"
	@Pointcut("execution(* com.SpringAop..*.*(..))")
	public void pointCut() {
	};

	@AfterReturning("pointCut()")
	public void afterReturning() {
		System.out.println("ProxyAop pointCut afterReturning");
	}

	@AfterThrowing("pointCut()")
	public void cfterThrowing() {
		System.out.println("ProxyAop pointCut afterThrowing");
	}

	@Before("pointCut()")
	public void beforec() {
		System.out.println("ProxyAop pointCut before");
	}

	@After("pointCut()")
	public void after() {
		System.out.println("ProxyAop pointCut after");
	}

	@Around("pointCut()")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("ProxyAop pointCut around pjp.proceed before");
		Object obj = pjp.proceed();
		System.out.println("ProxyAop pointCut around pjp.proceed after");
		System.out.println("ProxyAop pointCut Around Object ==  " + obj);
		return obj;
	}

}

package com.SpringAop.Object;

import org.springframework.stereotype.Service;

@Service("objectTest")
public class ObjectTest {
	public void objectTest() {
		System.out.println("objectTest");
		// throw new RuntimeException();
	}
}

<?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:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:task="http://www.springframework.org/schema/task"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
        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.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/task
		http://www.springframework.org/schema/task/spring-task-3.2.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

	<context:annotation-config />
	<context:component-scan base-package="com.SpringAop" />

	<!-- AOP注解解析引入 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

参考原文：http://www.cnblogs.com/yangyquin/p/5462488.html
参考原文（拦截点配置）：http://www.blogjava.net/supercrsky/articles/174368.html