AOP相关术语如下：
1. Joinpoint(连接点) -- 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点
2. Pointcut(切入点) -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
3. Advice(通知/增强) -- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
4. Introduction(引介) -- 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field
5. Target(目标对象) -- 代理的目标对象
6. Weaving(织入) -- 是指把增强应用到目标对象来创建新的代理对象的过程
7. Proxy（代理） -- 一个类被AOP织入增强后，就产生一个结果代理类
8. Aspect(切面) -- 是切入点和通知的结合，以后咱们自己来编写和配置的
切入点的表达式
原：<aop:before method="log" pointcut="execution(public void com.spring.demo08.UserDaoImpl.save())"/> 简：<aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/> //切入点表达式 1.execution() 固定的，必须写 2.public 可以忽略 3.void 返回值可以出现* 表示任意返回类型，但不能不写 4.可以使用*代替每层包名，不能不写，简写方式*..*方法，任意位置 5.*DaoImpl 6.方法save*() 7.方法参数：save*(..)任意参数
AOP的通知类型
1. 前置通知
* 在目标类的方法执行之前执行。
* 配置文件信息：<aop:after method="before" pointcut-ref="myPointcut3"/>
* 应用：可以对方法的参数来做校验
2. 最终通知
* 在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行。
* 在配置文件中编写具体的配置：<aop:after method="after" pointcut-ref="myPointcut3"/>
* 应用：例如像释放资源
3. 后置通知
* 方法正常执行后的通知。
* 在配置文件中编写具体的配置：<aop:after-returning method="afterReturning" pointcut-ref="myPointcut2"/>
* 应用：可以修改方法的返回值
4. 异常抛出通知
* 在抛出异常后通知
* 在配置文件中编写具体的配置：<aop:after-throwing method="afterThorwing" pointcut-ref="myPointcut3"/>
* 应用：包装异常的信息
5. 环绕通知
* 方法的执行前后执行。
* 在配置文件中编写具体的配置：<aop:around method="around" pointcut-ref="myPointcut2"/>
* 要注意：目标的方法默认不执行，需要使用ProceedingJoinPoint对来让目标对象的方法执行。
XML方式实现
UserDao,UserDaoImol:
package com.spring.demo08;
public interface UserDao {
public void save();
public void update();
}
package com.spring.demo08;
public class UserDaoImpl implements UserDao{
public void save() {
System.out.println("保存数据库。。。");
}
public void update() {
System.out.println("更新数据库。。。");
}
}
切面类：
package com.spring.demo08;
/*
* 切面类
*/
public class MyAspectXml {
//通知（具体的增强）
public void log() {
System.err.println("日志记录。。。");
}
}
配置文件配置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">
<!-- 配置用户 -->
<bean id="userDao" class="com.spring.demo08.UserDaoImpl"/>
<!-- 配置切面类 -->
<bean id="myAspectXml" class="com.spring.demo08.MyAspectXml"/>
<!-- 配置AOP -->
<aop:config>
<!-- 配置切面类：切入点+通知 -->
<aop:aspect ref="myAspectXml">
<!-- 配置的前置通知，save方法执行前，增强方法会执行 -->
<!-- 切入点的表达式 ：execution(public void com.spring.demo08.UserDaoImpl.save())-->
<!--
1.execution() 固定的，必须写
2.public 可以忽略
3.void 返回值可以出现* 表示任意返回类型，但不能不写
4.可以使用*代替每层包名，不能不写，简写方式*..*方法，任意位置
5.*DaoImpl
6.方法save*()
7.方法参数：save*(..)任意参数
-->
<!-- <aop:before method="log" pointcut="execution(public void com.spring.demo08.UserDaoImpl.save())"/> -->
<aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>
</aop:aspect>
</aop:config>
</beans>
测试：
package com.spring.demo08;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/*
* 测试AOP功能
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAOP {
@Resource(name="userDao")
private UserDao userDao;
@Test
public void run() {
userDao.save();
userDao.update();
}
}
运行结果：
AOP实现注解方式
UserDao,UserDaoImpl:
package com.spring.demo09;
public interface UserDao {
public void save();
public void update();
}
package com.spring.demo09;
public class UserDaoImpl implements UserDao{
public void save() {
System.out.println("保存数据库。。。");
}
public void update() {
System.out.println("更新数据库。。。");
}
}
切面类：
package com.spring.demo09;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/*
* 注解的方式切面类
*/
@Aspect
public class MyAspectAnno {
/**
* 切入点：@Before前置通知
*/
@Before(value="execution(* *..*.*DaoImpl.save*(..))")
public void log() {
System.err.println("日志记录。。。");
}
}
配置：
<?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">
<!-- 开启自动代理 -->
<aop:aspectj-autoproxy />
<!-- 配置目标对象 -->
<bean id="userDao" class="com.spring.demo09.UserDaoImpl"/>
<!-- 配置切面类 -->
<bean id="myAspectAnno" class="com.spring.demo09.MyAspectAnno"/>
</beans>
测试：
package com.spring.demo09;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/*
* 测试AOP功能
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAOP {
@Resource(name="userDao")
private UserDao userDao;
@Test
public void run() {
userDao.save();
userDao.update();
}
}
运行结果：
通知类型+自定义切入点：
通知类型：
* @Before -- 前置通知 * @AfterReturing -- 后置通知 * @Around -- 环绕通知 * @After -- 最终通知 * @AfterThrowing -- 异常抛出通知
package com.spring.demo09;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/*
* 注解的方式切面类
*/
@Aspect
public class MyAspectAnno {
/**
* 切入点：@Before前置通知
*/
@Before(value="MyAspectAnno.fn()")
public void log() {
System.err.println("日志记录。。。");
}
@After(value="MyAspectAnno.fn()")
public void after() {
System.err.println("最终通知。。。");
}
@Around(value="MyAspectAnno.fn()")
public void around(ProceedingJoinPoint joinPoint) {
System.out.println("环绕通知1。。。。");
try {
joinPoint.proceed();
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("环绕通知2。。。。");
}
//自定义切入点
@Pointcut(value="execution(* *..*.*DaoImpl.save*(..))")
public void fn() {}
}
运行结果：
原文地址：https://www.cnblogs.com/jumpkin1122/p/11624674.html
时间： 2024-11-09 07:00:34