时间：2017-2-3 00:33
——AOP概述
1、什么是AOP
1）AOP，Aspect Oriented Programming，面向切面编程。
2）AOP采用横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）。
3）Spring AOP使用纯Java代码实现，不需要同过专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强代码。
4）AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入。
——AOP底层原理
JDK动态代理：
对实现了接口的类生成代理对象。
CGLib代理机制：
可以对没有实现接口的类生成代理对象。
——AOP相关术语
Joinpoint（连接点）：指的是哪些方法可以被拦截，可以被拦截的方法就叫做连接点。
所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法,因为spring只支持方法类型的连接点。
Pointcut（切入点）：所谓切入点是指我们要对哪些Joinpoint进行拦截。
Advice（通知、增强）：要增强的代码（方法），一般指的是方法级别的增强。
所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction（引介）：一个特殊的Advice（特殊增强方法），一般指类级别的增强，会在原有类中添加属性或方法。
引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target（目标对象）：需要被增强的对象。
Weaving（织入）：把增强方法放到被增强方法之前。
是指把增强应用到目标对象来创建新的代理对象的过程。
Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
Proxy（代理）：代理对象。
一个类被AOP织入增强后，就产生一个结果代理类。
Aspect（切面）：在被增强方法上应用增强。
是切入点和通知（引介）的结合。
——JDK的动态代理
示例代码：
public class JDKProxy implements InvocationHandler{
private UserDao userDao;
public JDKProxy(UserDao userDao) {
super();
this.userDao = userDao;
}
public UserDao createProxy(){
UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
return proxy;
}
// 调用目标对象的任何方法，都相当于调用invoke()方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("add".equals(method.getName())){
// 进行增强
System.out.println("增强...");
return method.invoke(userDao, args);
}
return method.invoke(userDao, args);
}
}
----------------------------------------------------------------------------------------------------------------------------
测试代码：
public void fun2() {
UserDao userDao = new UserDaoImpl();
UserDao proxy = new JDKProxy(userDao).createProxy();
proxy.add();
proxy.update();
}
——CGLib的动态代理
CGLib是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。Hibernate支持用它来实现PO（Persistent Object 持久化对象）字节码的动态生成。
1、CGLib生成代理的机制：
其实是生成了一个真实对象的子类，使用继承的方式来生成一个代理对象。
2、使用步骤
1）下载CGLib的jar包
现在做CGLib开发，可以不直接引入CGLib的jar包，因为在Spring核心包中已经集成了CGLib。
2）编码：
* 创建核心类
* 为其设置父类，因为CGLib底层通过继承的方式创建代理
* 设置回调方法，相当于invoke()方法，必须实现MethodInterceptor接口
* 创建代理
3、结论
Spring框架中，如果类实现了接口，那么就使用JDK的动态代理来生成代理对象。
如果类没有实现任何接口，那么就使用CGLib来生成代理对象。
4、实例代码
CGLibProxy类，该类的方法需要被增强
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
/**
* 使用CGLib生成代理对象
* @author WYC
*
*/
public class CGLibProxy implements MethodInterceptor {
// 获取被代理对象
private ProductDao productDao;
public CGLibProxy(ProductDao productDao) {
super();
this.productDao = productDao;
}
public ProductDao createProxy(){
/*
* 使用CGLib生成代理对象
* 1、创建核心类
* 2、为其设置父类，因为CGLib底层通过继承的方式创建代理
* 3、设置回调方法，相当于invoke()方法，必须实现MethodInterceptor接口
* 4、创建代理
*/
// 创建核心类
Enhancer enhancer = new Enhancer();
// 为其设置父类
enhancer.setSuperclass(productDao.getClass());
// 设置回调方法
enhancer.setCallback(this);
// 创建代理
return (ProductDao) enhancer.create();
}
/*
* @param obj CGLib根据指定父类生成的代理对象
* @param method 拦截的方法
* @param args 拦截方法的参数数组
* @param proxy 方法的代理对象，用于执行父类的方法
*/
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if("add".equals(method.getName())){
System.out.println("增强...");
/*
* 调用父类的方法
* proxy是子类，所以调用子类的方法时，相当于调用父类productDao的方法
*/
return methodProxy.invokeSuper(proxy, args);
}
return methodProxy.invokeSuper(proxy, args);
}
}
----------------------------------------------------------------------------------------------------------------------------
测试：
public void fun2(){
ProductDao productDao = new ProductDao();
ProductDao proxy = new CGLibProxy(productDao).createProxy();
proxy.add();
proxy.update();
}
----------------------------------------------------------------------------------------------------------------------------
输出结果：
增强...
添加商品
修改商品
——代理知识总结
1、Spring在运行期间，生成动态代理对象，不需要特殊的编译器。
2、Spring AOP的底层就是通过JDK动态代理或CGLib动态代理技术为Bean执行横向织入：
1）若目标对象实现了若干接口，则Spring使用JDK的java.lang.reflect.Proxy类来创建代理。
2）若目标对象没有实现任何接口，则Spring使用CGLib库生成目标对象的子类。
3、程序中应优先对接口创建代理，便于程序解耦维护。
4、标记为final的方法，不能被代理，因为无法进行覆盖。
1）JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰。
2）CGLib是针对目标类创建子类，因此类或方法不能使用final修饰。
5、Spring只支持方法连接点，不提供属性连接。
——Spring中的AOP
1、Spring的传统AOP
AOP不是由Spring定义，而是由AOP联盟的组织定义。
2、Spring AOP通知（增强）类型
1）AOP联盟为通知Advice定义了接口：org.aopalliance.aop.Interface.Advice
2）Spring按照通知Advice在目标类方法的连接点位置，可以分为5类：
* 前置通知 org.springframework.aop.MethodBeforeAdvice
在目标方法执行前实施增强
* 后置通知 org.springframework.aop.AfterReturningAdvice
在目标方法执行后实施增强
* 环绕通知 org.aopalliance.intercept.MethodInterceptor
在目标方法执行前后实施增强
* 异常抛出通知 org.springframework.aop.ThrowsAdvice
在方法抛出异常后实施增强
* 引介通知 org.springframework.aop.IntroductionInterceptor
在目标类中添加一些新的方法和属性
3、Spring中的切面类型
1）Advisor：表示一般切面，对目标类的所有方法进行拦截，Spring中传统切面就叫做Advisor
* Advisor：一个切点和一个切面的组合。
* Aspect：多个切点和多个通知的组合
2）PointcutAdvisor：
表示具有切点的切面，可以指定拦截目标类哪些方法。
3）IntroductionAdvisor：
表示引介切面，针对引介通知而使用切面。
——Spring的AOP的开发（针对所有方法进行增强，不带有切点的切面，Advisor）
1、步骤：
1）导入jar包
* AOPjar包：spring-aop-3.2.0.RELEASE.jar
* AOP联盟jar包：com.springsource.org.aopalliance-1.0.0.jar
2）编写被代理对象
* CustomerDao接口
* CustomerDaoImpl实现类
3）编写增强的代码
/**
* 前置增强
* @author WYC
*
*/
public class MyBeforeAdvice implements MethodBeforeAdvice {
/**
* method：执行的方法
* args：方法参数
* target：目标对象
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("前置增强");
}
}
4）生成代理
可以通过配置生成代理，不需要手动编写代码。
Spring基于ProxyFactoryBean类来生成代理，该类底层自动选择使用JDK的动态代理还是CGLib的代理。
配置文件中ProxyFactoryBean标签的属性：
* target：代理的目标对象。
* proxyInterfaces：代理要实现的接口，如果有多个接口可以使用以下格式赋值：
> <list> <value> </value> ... </list>
* proxyTargetClass：是否对类代理而不是接口，设置为true时，使用CGLib代理。
* interceptorNames：需要织入目标的Advice。
* singleton：返回代理是否为单例，默认为单例。
* optimize：当设置为true时，强制使用CGLib。
proxyInterfaces和proxyTargetClass配一个就可以了。
2、示例代码
CustomerDao接口：
public interface CustomerDao {
public void add();
public void update();
public void delete();
public void find();
}
----------------------------------------------------------------------------------------------------------------------------
CustomerDaoImpl实现类：
public class CustomerDaoImpl implements CustomerDao {
public void add() {
System.out.println("添加客户");
}
public void update() {
System.out.println("修改客户");
}
public void delete() {
System.out.println("删除客户");
}
public void find() {
System.out.println("查找客户");
}
}
----------------------------------------------------------------------------------------------------------------------------
MyBeforeAdvice前置增强类：
/**
* 前置增强
* @author WYC
*
*/
public class MyBeforeAdvice implements MethodBeforeAdvice {
/**
* method：执行的方法
* args：方法参数
* target：目标对象
*/
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("前置增强");
}
}
----------------------------------------------------------------------------------------------------------------------------
配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- 目标对象（被增强的对象） -->
<bean id="customerDao" class="com.wyc.spring3.demo3.CustomerDaoImpl" />
<!-- 定义增强（通知） -->
<bean id="beforeAdvice" class="com.wyc.spring3.demo3.MyBeforeAdvice" />
<!-- Spring支持配置生成代理，基于ProxyFactoryBean -->
<bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 设置目标对象 -->
<property name="target" ref="customerDao" />
<!-- 设置实现的接口，value中要写接口的全路径 -->
<property name="proxyInterfaces" value="com.wyc.spring3.demo3.CustomerDao"/>
<!-- 织入的增强方法（通知），需要使用value属性 -->
<property name="interceptorNames" value="beforeAdvice"/>
<!-- 相当于new ProxyInstance(Classloader, Class[] interfaces, InvocationHandler)的三个参数 -->
</bean>
</beans>
----------------------------------------------------------------------------------------------------------------------------
测试代码：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
@Autowired
// @Qualifier("customerDao") 这里注入的是真实对象，需要注入代理对象
@Qualifier("customerDaoProxy")
private CustomerDao customerDao;
@Test
public void fun1(){
customerDao.add();
customerDao.update();
customerDao.delete();
customerDao.find();
}
}
——带有切点的切面（针对目标对象的某些方法进行增强，PointcutAdvisor）
1、使用普通Advisor作为切面，将对目标类的所有方法进行拦截，不够灵活，在实际开发中通常采用带有切点的切面。
2、常用PointcutAdvisor实现类：
1）DefaultPointcutAdvisor
最常用的切面类型，它可以通过任意Pointcut和Advice组合定义切面。
2）RegexpMethodPointcutAdvisor
构造正则表达式切点切面。
通过正则表达式来确定哪些方法需要执行增强。
3、步骤
1）导包
* AOPjar包：spring-aop-3.2.0.RELEASE.jar
* AOP联盟jar包：com.springsource.org.aopalliance-1.0.0.jar
2）创建目标对象
/**
* 目标对象
*
* @author WYC
*
*/
public class OrderDao {
public void add() {
System.out.println("添加订单");
}
public void update() {
System.out.println("修改订单");
}
public void delete() {
System.out.println("删除订单");
}
public void find() {
System.out.println("查询订单");
}
}
3）编写增强的类
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
* 增强的类：
* 使用的是环绕增强：org.aopalliance.intercept.MethodInterceptor
* @author WYC
*
*/
public class MyAroundAdvice implements MethodInterceptor {
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("环绕前增强");
// 相当于执行目标对象的方法
Object result = methodInvocation.proceed();
System.out.println("环绕后增强");
return result;
}
}
4）生成代理
<!-- 定义目标对象 -->
<bean id="orderDao" class="com.wyc.spring3.demo4.OrderDao" />
<!-- 定义代理对象（增强对象） -->
<bean id="aroundAdvice" class="com.wyc.spring3.demo4.MyAroundAdvice" />
<!-- 定义切点 -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 定义一个正则表达式，来规定拦截哪些方法 -->
<!-- . 表示任意字符， * 表示任意个数 -->
<!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/>表示只增强该类的add方法 -->
<property name="patterns" value=".*add.*,.*find.*" />
<!-- 应用增强 -->
<property name="advice" ref="aroundAdvice" />
</bean>
<!-- 定义生成的代理对象 -->
<bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标对象 -->
<property name="target" ref="orderDao" />
<!-- 针对类的代理，而不是接口 -->
<property name="proxyTargetClass" value="true" />
<!-- 在目标对象上配置增强，需要写已经定义好的切面 -->
<property name="interceptorNames" value="myPointcutAdvisor" />
</bean>
4、示例代码
OrderDao目标类：
/**
* 目标对象
*
* @author WYC
*
*/
public class OrderDao {
public void add() {
System.out.println("添加订单");
}
public void update() {
System.out.println("修改订单");
}
public void delete() {
System.out.println("删除订单");
}
public void find() {
System.out.println("查询订单");
}
}
----------------------------------------------------------------------------------------------------------------------------
MyAroundAdvice环绕增强，代理对象：
/**
* 增强的类：
* 使用的是环绕增强，org.aopalliance.intercept.MethodInterceptor
* @author WYC
*
*/
public class MyAroundAdvice implements MethodInterceptor {
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("环绕前增强");
// 相当于执行目标对象的方法
Object result = methodInvocation.proceed();
System.out.println("环绕后增强");
return result;
}
}
----------------------------------------------------------------------------------------------------------------------------
XML配置：
<!-- 定义目标对象 -->
<bean id="orderDao" class="com.wyc.spring3.demo4.OrderDao" />
<!-- 定义代理对象（增强对象） -->
<bean id="aroundAdvice" class="com.wyc.spring3.demo4.MyAroundAdvice" />
<!-- 定义切点 -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 定义一个正则表达式，来规定拦截哪些方法 -->
<!-- . 表示任意字符， * 表示任意个数 -->
<!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/>表示只增强该类的add方法 -->
<property name="patterns" value=".*add.*,.*find.*" />
<!-- 应用增强 -->
<property name="advice" ref="aroundAdvice" />
</bean>
<!-- 定义生成的代理对象 -->
<bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标对象 -->
<property name="target" ref="orderDao" />
<!-- 针对类的代理，而不是接口 -->
<property name="proxyTargetClass" value="true" />
<!-- 在目标对象上配置增强，需要些定义好的切面 -->
<property name="interceptorNames" value="myPointcutAdvisor" />
</bean>
----------------------------------------------------------------------------------------------------------------------------
测试代码：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo4 {
@Autowired
@Qualifier("orderDaoProxy")
private OrderDao orderDao;
@Test
public void fun1(){
orderDao.add();
orderDao.delete();
orderDao.update();
orderDao.find();
}
}
——自动代理
之前的案例中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，如果Bean数量过多，每个Bean都需要配置ProxyFactoryBean，则开发维护量过大，可以通过自动创建代理的方式来完成。
自动创建代理：（基于后处理Bean，在类创建的过程中完成增强，生成得到的Bean就是代理对象）
1）BeanNameAutoProxyCreator
根据Bean名称创建代理。
2）DefaultAdvisorAutoProxyCreator
根据Advisor本身包含的信息创建代理。
3）AnnotationAwareAspectJAutoProxyCreator
基于Bean中的AspectJ注解进行自动代理。
2、BeanNameAutoProxyCreator
根据名称生成代理。
配置代码：
<!-- 目标对象（被增强的对象） -->
<bean id="customerDao" class="com.wyc.spring3.demo3.CustomerDaoImpl" />
<bean id="orderDao" class="com.wyc.spring3.demo4.OrderDao" />
<!-- 定义增强 -->
<bean id="beforeAdvice" class="com.wyc.spring3.demo3.MyBeforeAdvice" />
<bean id="aroundAdvice" class="com.wyc.spring3.demo4.MyAroundAdvice" />
<!-- 自动代理：根据名称生成代理，基于后处理Bean，后处理Bean不需要配置id -->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<!-- 指定需要生成代理的类 -->
<property name="beanNames" value="*Dao"/> // 对所有Dao结尾的类都创建代理
<property name="interceptorNames" value="beforeAdvice" /> // 声明织入的通知
</bean>
3、DefaultAdvisorAutoProxyCreator
根据切面中定义的信息生成代理。
配置代码：
<!-- 目标对象（被增强的对象） -->
<bean id="customerDao" class="com.wyc.spring3.demo3.CustomerDaoImpl" />
<bean id="orderDao" class="com.wyc.spring3.demo4.OrderDao" />
<!-- 定义增强 -->
<bean id="beforeAdvice" class="com.wyc.spring3.demo3.MyBeforeAdvice" />
<bean id="aroundAdvice" class="com.wyc.spring3.demo4.MyAroundAdvice" />
<!-- 定义一个带有切点的切面 -->
<bean id="myPoingcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 对所有的add方法进行增强 -->
<property name="pattern" value=".*add.*" />
<!-- 对所有的add方法添加环绕 -->
<property name="advice" ref="aroundAdvice" />
</bean>
<!-- 自动生成代理 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
4、区分基于ProxyFactoryBean的代理与自动代理的区别
1）ProxyFactoryBean是先创建目标对象，然后把目标对象传入代理类，然后生成代理。
2）自动代理是基于后处理Bean的代理，在Bean的生成过程中就创建了代理对象，并且将代理对象返回，所以创建的Bean已经是代理对象了。
——总结
1、AOP：
面向切面编程，不是代替面向对象，而是对面向对象的扩展和延伸。
2、AOP的思想
代理机制（横向抽取）
3、Spring使用AOP的时候，会根据目标类是否实现接口来自动选择代理机制
1）JDK动态代理
对实现接口的类创建代理。
2）CGLib代理
对没有实现接口的类创建代理。
创建代理的方式：生成目标类的子类，并扩展其功能。
4、AOP的开发中：
1）术语
* JoinPoint：连接点，可以被增强的方法。
* Pointcut：切入点，真正被增强的方法。
* Advice：通知，增强的代码（方法）。
* Target：目标对象，被增强的类。
* Weaving：织入，将增强代码应用到通知的过程。
* Aspect：切面，在切入点应用增强。
5、传统的Spring AOP：
1）不带有切点的切面
* Advisor，一个切点和一个通知的组合。
2）带有切点的切面
* PointcutAdvisor，
3）生成代理
* ProxyFactoryBean
> 根据目标对象是否实现了接口，选择使用JDK还是CGLib。
> 缺点：每个类都需要配置ProxyFactoryBean。
> 先创建一个目标对象，然后将目标对象传递给代理对象。
6、自动代理
都是基于后处理Bean。
在创建目标对象的过程中创建代理对象，这个目标对象就是代理对象。
1）基于Bean名称自动代理
2）基于切面信息的自动代理
