面向切面编程（Spring AOP）
为了将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，Spring提供了面向切面的编程方式，也称Spring AOP，这有效的减少了系统间的重复代码，达到了模块间的松耦合目的。
AOP，Aspect Oriented Programing,即面向切面编程。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码，主要体现在事务处理、日志管理、权限控制、异常处理等方面。
目前流行的AOP框架有两个，分别是Spring AOP和AspectJ。AspectJ是一个基于Java语言的AOP框架。
AOP术语
- Joinpoint（连接点）：是指那些被拦截到的点，在Spring中，可以被动态代理拦截目标类的方法。
- Pointcut(切入点)：是指要对哪些Joinpoint进行拦截，即被拦截的拦截点。
- Advice(通知)：是指拦截到Joinpoint之后要做的事情，即对切入点增强的内容。
- Target(目标)：是指代理的目标对象。
- Weaving(织入)：是指把增强代码应用到目标上，生成代理对象的过程。
- Proxy(代理)：是指生成的代理对象。
- Aspect(切面)：是切入点和通知的结合。
AspectJ开发
基于XML的声明式AspectJ
导入AOP的的jar包
- spring-aop-3.2.0.RELEASE.jar：是Spring为AOP提供的实现。
- com.springsource.org.aopalliance-1.0.0.jar：是AOP联盟提供的规范。
导入AsprctJ相关的jar包
- spring-aspects-3.2.0.RELEASE.jar：Spring为AspectJ提供的实现。
- com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar：AspectJ提供的规范。
建立UserDao.java
package cn.itcast.dao;
public interface UserDao {
void save();
void update();
void delete();
void find();
}UserDaoImpl.java
package cn.itcast.dao;
public class UserDaoImpl implements UserDao{
@Override
public void save() {
System.out.println("save添加用户");
}
@Override
public void update() {
System.out.println("update修改用户");
}
@Override
public void delete() {
System.out.println("delete删除用户");
}
@Override
public void find() {
System.out.println("find查询用户");
}
}MyAspect.java
package cn.itcast.aspectj.xml;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
/*
* 切面类，在此编写通知
* 可以在XML配置文件中确定通知类型
*/
public class MyAspect {
//前置通知
public void myBefore(JoinPoint joinPoint){
System.out.println("前置通知，目标：");
System.out.println(joinPoint.getTarget()+",方法名称：");
System.out.println(joinPoint.getSignature().getName());
}
//后置通知
public void myAfterReturning(JoinPoint joinPoint){
System.out.println("后置通知，方法名称："+joinPoint.getSignature().getName());
}
//环绕通知
//ProceedingJoinPoint是JoinPoint子接口，表示可以执行目标方法
//1.必须返回Object类型值
//2.必须接收一个参数，类型为ProceedingJoinPoint
//3.必须throws Throwable
public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
//开始
System.out.println("环绕开始");
//执行当前目标方法
Object obj=proceedingJoinPoint.proceed();
//结束
System.out.println("环绕结束");
return obj;
}
//异常通知
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
System.out.println("异常通知，出错了"+e.getMessage());
}
//最终通知
public void myAfter(){
System.out.println("最终通知");
}
}applicationContext.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: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">
<!-- 1.目标类 -->
<bean id="userDao" class="cn.itcast.dao.UserDaoImpl"></bean>
<!-- 2.切面 -->
<bean id="myAspect" class="cn.itcast.aspectj.xml.MyAspect"></bean>
<!-- 3.aop编程 -->
<aop:config>
<aop:aspect ref="myAspect">
<!-- 3.1 配置切入点，通知最后增强哪些方法 -->
<aop:pointcut expression="execution(* cn.itcast.dao..*.*(..))" id="myPointCut"/>
<!-- 3.2关联通知Advice和切入点pointCut -->
<!-- #1前置通知 -->
<aop:before method="myBefore" pointcut-ref="myPointCut"/>
<!-- #2后置通知，在方法返回之后执行，就可以获得返回值
returning属性：用于设置后置通知的第二个参数的名称，类型是Object
-->
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="returnVal"/>
<!-- #3环绕通知 -->
<aop:around method="myAround" pointcut-ref="myPointCut"/>
<!-- #4抛出通知：用于处理程序发生异常，就可以接受当前方法产生的异常
注意：如果程序没有异常，将不会执行增强
throwing属性：用于设置通知第二个参数的名称，类型Throwable
-->
<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
<!-- #5最终通知：无论程序发生任何事情，都将执行 -->
<aop:after method="myAfter" pointcut-ref="myPointCut"/>
</aop:aspect>
</aop:config>
</beans>AspectJ表达式
execution() 用于描述方法
语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常)
- 修饰符：一般省略。
- public：公共方法
- *：任意
- 返回值：不能省略
- void：无返回值
- String：返回值为字符串
- *：任意（一般用这个）
- 包：可以省略
- com.eaglezsx.crm：固定包
- com.eaglezsx.crm.*.service：crm包下面的任意子包，但要包含service。比如com.eaglezsx.crm.staff.service
- com.eaglezsx.crm..：crm下面的任意子包（包括孙包）
- com.eaglezsx.crm.*.service.. ：crm包下面任意子包，固定目录service，service目录任意包
- 类：可以省略
- UserServiceImplement：指定类
- *Impl：以Impl结尾的类
- User*：以User开头的类
- *：任意类
- 方法名：不能省略
- addUser：固定方法
- add*：以add开头的方法
- *Do：以Do结尾的方法
- *：任意方法
- （参数）
- ()：无参
- (int)：一个整型参数
- (int,int)：两个整型参数
- (..)：任意参数
- throws：可省略，一般不写。
* cn.itcast.dao..*.*(..)
意思是，返回值任意，cn.itcast.dao下的任意包，下的任意类，下的任意方法，方法的参数任意TestXML.java
package cn.itcast.aspectj.xml;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.itcast.dao.UserDao;
public class TestXML {
@Test
public void demo01(){
String xmlPath="applicationContext.xml";
ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
//1.从Spring容器获得内容
UserDao userDao=(UserDao)applicationContext.getBean("userDao");
//2.执行方法
userDao.save();
}
}运行结果
前置通知，目标：
cn.itcast.dao.UserDaoImpl@110fcd9,方法名称：
save
环绕开始
save添加用户
后置通知，方法名称：save
环绕结束
最终通知基于Annotation的声明式AspectJ
- @AspectJ:用于定义一个切面
- @Before：用于定义前置通知，相当于BeforeAdvice
- @AfterReturning：用于定义后置通知，相当于AfterReturningAdvice
- @Around：用于定义环绕通知，相当于MethodInterceptor
- @AfterThrowing：用于定义抛出通知，相当于ThrowAdvice
- @After：用于定义最终final通知，不管是否异常，该通知都会执行
@Aspect
@Component
public class MyAspect {
/*
用于取代<aop:pointcut expression="execution(* cn.itcast.dao..*.*(..))" id="myPointCut"/>
要求：方法必须是private没有值 名称自定义，没有参数
*/
@Pointcut("execution(* cn.itcast.dao..*.*(..))")
private void myPointCut(){}
@Before("myPointCut()")
public void myBefore(JoinPoint joinPoint){
...
}
@AfterReturning(value="myPointCut()")
public void myAfterReturning(JoinPoint joinPoint){
...
}
@Around("myPointCut()")
public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
...
}
@AfterThrowing(value="myPointCut()"，throwing="e")
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
...
}
@After("myPointCut()")
public void myAfter(){
...
}
}@Repository("userDao")
public class UserDaoImpl implements UserDao{
...
}applicationContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 扫描包：使注解生效 -->
<context:component-scan base-package="cn.itcast"></context:component-scan>
<!-- 使切面开启自动代理 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>TestAnnotation.java
public class TestAnnotation {
@Test
public void demo01(){
String xmlPath="applicationContext.xml";
ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
//1.从Spring容器获得内容
UserDao userDao=(UserDao)applicationContext.getBean("userDao");
//2.执行方法
userDao.save();
}
}
扫一扫
640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
