Spring入门第2天--面向切面编程入门

文档版本	开发工具	测试平台	工程名字	日期	作者	备注
V1.0				2016.06.22	lutianfei	none

AOP的概述

什么是AOP

AOP Aspect Oriented Programing 面向切面编程

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）

Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码

AspecJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

AOP底层原理

代理机制:

动态代理:(JDK中使用)

JDK的动态代理,对实现了接口的类生成代理.

Spring的AOP代理

JDK动态代理:对实现了接口的类生成代理

CGLib代理机制:对类生成代理

AOP的术语

Joinpoint(连接点)

:所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点)

:所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强)

:所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介)

:引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象)

:代理的目标对象

Weaving(织入)

:是指把增强应用到目标对象来创建新的代理对象的过程.

spring采用动态代理织入，而AspectJ采用编译期织入和类转载期织入

Proxy（代理）

:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面)

: 是切入点和通知（引介）的结合

AOP的底层实现

JDK动态代理

UserDao & UserDaoImpl

public interface UserDao {
public void add();
public void update();
}

public class UserDaoImpl implements UserDao {

public void add() {
System.out.println("添加用户...");
}

public void update() {
System.out.println("修改用户...");
}

}

@Test
public void demo2(){
// 被代理对象
UserDao userDao = new UserDaoImpl();
// 创建代理对象的时候传入被代理对象.
UserDao proxy = new JDKProxy(userDao).createProxy();
proxy.add();
proxy.update();
}

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("日志记录=================");
Object result = method.invoke(userDao, args);
return result;
}
return method.invoke(userDao, args);
}
}

CGLIB动态代理

CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。 Hibernate支持它来实现PO(Persistent Object 持久化对象)字节码的动态生成

CGLIB生成代理机制:CGlib采用非常底层字节码技术，可以为一个类创建子类，解决无接口代理问题

现在做cglib的开发,可以不用直接引入cglib的包.已经在spring的核心中集成cglib.

关于intercept拦截方法

@param obj CGlib根据指定父类生成的代理对象

@param method 拦截的方法

@param args 拦截方法的参数数组

@param proxy 方法的代理对象，用于执行父类的方法

@return

public Object intercept(Object obj, Method method, Object[] args,

MethodProxy proxy) throws Throwable {

… …

}

public class CGLibProxy implements MethodInterceptor{
private ProductDao productDao;

public CGLibProxy(ProductDao productDao) {
super();
this.productDao = productDao;
}

public ProductDao createProxy(){

// 使用CGLIB生成代理:

// 1.创建核心类:
Enhancer enhancer = new Enhancer();

// 2.为其设置父类:
enhancer.setSuperclass(productDao.getClass());

// 3.设置回调:
enhancer.setCallback(this);

// 4.创建代理:
return (ProductDao) enhancer.create();

}

public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable {

if("add".equals(method.getName())){
System.out.println("日志记录==============");
Object obj = methodProxy.invokeSuper(proxy, args);
return obj;
}

return methodProxy.invokeSuper(proxy, args);
}
}

//SpringTest
@Test
public void demo2(){
ProductDao productDao = new ProductDao();
ProductDao proxy = new CGLibProxy(productDao).createProxy();
proxy.add();
proxy.update();
}

结论 : Spring框架,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象

代理知识总结

Spring在运行期，生成动态代理对象，不需要特殊的编译器

Spring AOP的底层就是通过JDK动态代理或CGLib动态代理技术 为目标Bean执行横向织入

1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

程序中应优先对接口创建代理，便于程序解耦维护

标记为final的方法，不能被代理，因为无法进行覆盖

JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰

CGLib 是针对目标类生产子类，因此类或方法 不能使final的

Spring只支持方法连接点，不提供属性连接

Spring中的AOP

Spring的传统AOP

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

Spring中的通知(增强类型)

AOP联盟为通知Advice定义了org.aopalliance.aop.Interface.Advice

Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

前置通知 org.springframework.aop.MethodBeforeAdvice

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

后置通知 org.springframework.aop.AfterReturningAdvice

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

环绕通知 org.aopalliance.intercept.MethodInterceptor

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

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

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

引介通知 org.springframework.aop.IntroductionInterceptor(课程不讲.)

在目标类中添加一些新的方法和属性

Spring中的切面类型

Advisor : Spring中传统切面.代表一般切面，Advice本身就是一个切面，对目标类所有方法进行拦截

Advisor:都是有一个切点和一个通知组合.

Aspect:多个切点和多个通知组合.

PointcutAdvisor : 代表具有切点的切面，可以指定拦截目标类哪些方法(带有切点的切面,针对某个方法进行拦截)

IntroductionAdvisor : 代表引介切面，针对引介通知而使用切面（不要求掌握）

Spring的AOP的开发

针对所有方法的增强:(不带有切点的切面)

第一步:导入相应jar包.

spring-aop-3.2.0.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

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

CustomerDao接口

CustoemrDaoImpl实现类

第三步:编写增强的代码:

public class MyBeforeAdvice implements MethodBeforeAdvice{

/**
* method:执行的方法
* args:参数
* target:目标对象
*/

public void before(Method method, Object[] args, Object target)
throws Throwable {
System.out.println("前置增强...");
}
}

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

生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.

属性:

target : 代理的目标对象

proxyInterfaces : 代理要实现的接口

如果多个接口可以使用以下格式赋值

<list>
<value></value>
....
</list>

* proxyTargetClass : 是否对类代理而不是接口，设置为true时，使用CGLib代理
* interceptorNames : 需要织入目标的Advice
* singleton : 返回代理是否为单实例，默认为单例
* optimize : 当设置为true时，强制使用CGLib

applicationContext.xml

<!-- 定义目标对象 -->
<bean id="customerDao" class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>

<!-- 定义增强 -->
<bean id="beforeAdvice" class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>

<!-- Spring支持配置生成代理: -->
<bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<!-- 设置目标对象 -->
<property name="target" ref="customerDao"/>

<!-- 设置实现的接口 ,value中写接口的全路径 -->
<property name="proxyInterfaces" value="cn.itcast.spring3.demo3.CustomerDao"/>

<!-- 需要使用value:要的名称 -->
<property name="interceptorNames" value="beforeAdvice"/>
</bean>

注入的时候要注入代理对象:

@Autowired
// @Qualifier("customerDao")// 注入是真实的对象,必须注入代理对象.
@Qualifier("**customerDaoProxy**")
private CustomerDao customerDao;

带有切点的切面:(针对目标对象的某些方法进行增强)

常用PointcutAdvisor 实现类

DefaultPointcutAdvisor 最常用的切面类型，它可以通过任意Pointcut和Advice 组合定义切面

RegexpMethodPointcutAdvisor 构造正则表达式切点切面

第一步:创建被代理对象.

OrderDao

第二步:编写增强的类:

public class MyAroundAdvice implements MethodInterceptor{

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

System.out.println("环绕前增强...");
Object result = methodInvocation.proceed();// 执行目标对象的方法
System.out.println("环绕后增强...");
return result;
}
}

第三步:生成代理:

<!-- 带有切点的切面 -->

<!-- 定义目标对象 -->
<bean id="orderDao" class="cn.itcast.spring3.demo4.OrderDao"></bean>

<!-- 定义增强 -->
<bean id="aroundAdvice" class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>

<!-- 定义切点切面: -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

<!-- 定义表达式,规定哪些方法执行拦截 -->
<!-- . 任意字符  * 任意个 -->
<!-- <property name="pattern" value=".*"/> -->
<!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->
<!-- <property name="pattern" value=".*add.*"></property> -->
<property name="patterns" value=".*add.*,.*find.*"></property>

<!-- 应用增强 -->
<property name="advice" ref="aroundAdvice"/>

</bean>

<!-- 定义生成代理对象 -->
<bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<!-- 配置目标 -->
<property name="target" ref="orderDao"></property>

<!-- 针对类的代理 -->
<property name="proxyTargetClass" value="true"></property>

<!-- 在目标上应用增强 -->
<property name="interceptorNames" value="myPointcutAdvisor"></property>

</bean>

自动代理

前面的案例中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大。

自动创建代理(基于后处理Bean.在Bean创建的过程中完成的增强.生成Bean就是代理.)

BeanNameAutoProxyCreator

根据Bean名称创建代理

DefaultAdvisorAutoProxyCreator

根据Advisor本身包含信息创建代理

AnnotationAwareAspectJAutoProxyCreator

基于Bean中的AspectJ 注解进行自动代理

BeanNameAutoProxyCreator :按名称生成代理

<!-- 定义目标对象 -->
<bean id="customerDao" class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao" class="cn.itcast.spring3.demo4.OrderDao"></bean>

<!-- 定义增强 -->
<bean id="beforeAdvice" class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice" class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>

<!-- 自动代理:按名称的代理 基于后处理Bean,后处理Bean不需要配置ID-->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="*Dao"/>**
<property name="interceptorNames" value="beforeAdvice"/>**
</bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest5 {

@Autowired
@Qualifier("orderDao")
private OrderDao orderDao;
@Autowired
@Qualifier("customerDao")
private CustomerDao customerDao;

@Test
public void demo1(){
orderDao.add();
orderDao.delete();

customerDao.update();
}
}

DefaultAdvisorAutoProxyCreator :根据切面中定义的信息生成代理

<!-- 定义目标对象 -->
<bean id="customerDao" class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao" class="cn.itcast.spring3.demo4.OrderDao"></bean>

<!-- 定义增强 -->
<bean id="beforeAdvice" class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice" class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>

<!--定义一个带有切点的切面 -->
<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">**
<property name="pattern" value=".*add.*"/>
<property name="advice" ref="aroundAdvice"/>
</bean>

<!--自动生成代理 -->

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class SpringTest6 {
@Autowired
@Qualifier("orderDao")
private OrderDao orderDao;
@Autowired
@Qualifier("customerDao")
private CustomerDao customerDao;

@Test
public void demo1(){
orderDao.add();
orderDao.update();
orderDao.delete();

customerDao.add();
}
}

区分基于ProxyFattoryBean****的代理与自动代理区别?

ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理.

自动代理基于后处理Bean.在Bean的生成过程中就产生了代理对象,把代理对象返回.生成Bean已经是代理对象

使用AspectJ实现AOP

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

AspectJ是一个基于Java语言的AOP框架

Spring2.0以后新增了对AspectJ切点表达式支持

@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

AspectJ表达式

语法:execution(表达式)

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

execution(“* cn.itcast.spring3.demo1.dao.*(..)”)

—只检索当前包

execution(“* cn.itcast.spring3.demo1.dao..*(..)”)

—检索包及当前包的子包.

execution(* cn.itcast.dao.GenericDAO+.*(..))

—检索GenericDAO及子类

AspectJ的通知类型

@Before

前置通知，相当于BeforeAdvice

就在方法之前执行.没有办法阻止目标方法执行的.

@AfterReturning

后置通知，相当于AfterReturningAdvice

后置通知,获得方法返回值.

@Around

环绕通知，相当于MethodInterceptor

在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.

@AfterThrowing

抛出通知，相当于ThrowAdvice

@After

最终final通知，不管是否异常，该通知都会执行

@DeclareParents

引介通知，相当于IntroductionInterceptor (不要求掌握)

基于注解方式配置切面

第一步:引入相应jar包.

aspectj依赖aop环境,之前导入的AOP jar包需要继续导入。

spring-aop-3.2.0.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

spring-aspects-3.2.0.RELEASE.jar

com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:编写被增强的类:

UserDao



第三步:使用AspectJ注解形式:

@Aspect
public class MyAspect {
@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")

public void before(){
System.out.println("前置增强....");
}
}

第四步:创建applicationContext.xml

引入aop的约束:

<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启AspectJ自动代理-->
<aop:aspectj-autoproxy />
</beans>

开启AspectJ自动代理 :

<aop:aspectj-autoproxy />

底层就是AnnotationAwareAspectJAutoProxyCreator

定义目标类与切面类

<bean id="userDao" class="cn.itcast.spring3.demo1.UserDao"></bean>
<bean id="myAspect" class="cn.itcast.spring3.demo1.MyAspect"></bean>

常见切面类编写

[b]@Before前置通知[/b]

可以在方法中传入JoinPoint对象，用来获得切点信息



[b]@AfterReturing 后置通知[/b]

通过returning属性 可以定义方法返回值，作为参数



[b]@Around 环绕通知[/b]

around方法的返回值就是目标代理方法执行返回值

参数为ProceedingJoinPoint 可以调用拦截目标方法执行

重点：如果不调用 ProceedingJoinPoint的 proceed方法，那么目标方法就被拦截了



[b]@AfterThrowing 抛出通知[/b]

通过设置throwing属性，可以设置发生异常对象参数



[b]@After 最终通知[/b]

/**
* 切面类:就是切点与增强结合
* @author 姜涛
*
*/
@Aspect
public class MyAspect {

@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
public void before(JoinPoint joinPoint){
System.out.println("前置增强...."+joinPoint);
}

@AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")
public void afterReturin(Object returnVal){
System.out.println("后置增强....方法的返回值:"+returnVal);
}

@Around(value="MyAspect.myPointcut()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕前增强....");
Object obj = proceedingJoinPoint.proceed();
System.out.println("环绕后增强....");
return obj;
}

@AfterThrowing(value="MyAspect.myPointcut()",throwing="e")
public void afterThrowing(Throwable e){
System.out.println("不好了 出异常了!!!"+e.getMessage());
}

@After("MyAspect.myPointcut()")
public void after(){
System.out.println("最终通知...");
}

@Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
private void myPointcut(){}
}

通过@Pointcut为切点命名

在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用

@Poingcut

进行定义

切点方法：private void 无参数方法，方法名为切点名

当通知多个切点时，可以使用

||

进行连接



面试: Advisor和Aspect的区别?

Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.

Aspect:可以支持多个切点和多个通知的组合.

使用XML配置切面

第一步:编写被增强的类:

ProductDao

第二步:定义切面

第三步:配置applicationContext.xmll

前置通知

代码:

public void before(){
System.out.println("前置通知...");
}

配置:

<aop:config>
<!-- 定义切点: -->
<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">
<!-- 前置通知 -->
<aop:before method="before" pointcut-ref="mypointcut"/>
</aop:aspect>
</aop:config>

示例：

后置通知

代码:

public void afterReturing(Object returnVal){
System.out.println("后置通知...返回值:"+returnVal);
}

配置:

<aop:config>
<!-- 定义切点: -->
<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
<aop:aspect ref="myAspectXML">

<!-- 后置通知 -->
<aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/>
</aop:aspect>
</aop:config>

示例：

环绕通知

代码:

public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕前增强....");
Object result = proceedingJoinPoint.proceed();
System.out.println("环绕后增强....");
return result;
}

配置:

<aop:config>

<!-- 定义切点: -->
<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
<aop:aspect ref="myAspectXML">
<!-- 环绕通知 -->
**<aop:around method="around" pointcut-ref="mypointcut"/>**
</aop:aspect>
</aop:config>

示例：

异常通知

代码

public void afterThrowing(Throwable e){
System.out.println("异常通知..."+e.getMessage());
}

配置

<aop:config>

<!-- 定义切点: -->
<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">
<!-- 异常通知 -->
<aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/>
</aop:aspect>

</aop:config>

示例：

最终通知

代码:

public void after(){
System.out.println("最终通知....");
}

配置:

<aop:config>

<!-- 定义切点: -->
<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">
<!-- 最终通知 -->
<aop:after method="after" pointcut-ref="mypointcut"/>
</aop:aspect>
</aop:config>

示例：