JavaWeb - Spring AOP
JavaWeb - Spring AOP
目录
1 Spring AOP
1.1 AOP的概念
AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程 序功能的统一维护的一种技术
1.1.1 AOP 的优点
- 对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
- 在程序运行期间，在不修改源码的情况下对方法进行功能增强
- 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码
- 减少重复代码，提高开发效率，便于后期维护
1.1.2 AOP底层实现
- AOP 的底层是通过 Spring 提供的的动态代理技术实现的
- 实现了接口的类 - JDK 动态代理
- 未实现接口的类 - CGLIB 动态代理
1.1.3 AOP相关概念
- Target（目标对象）：代理的目标对象
- Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
- Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
- Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
- Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知,分类：前置通知、后置通知、异常通知、最终通知、环绕通知
- Aspect（切面）：是切入点和通知（引介）的结合
- Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入
1.2 AOP开发流程
1.2.1 开发阶段
- 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求
- 把公用代码抽取出来，制作成通知。：少部分程序员来做，要求熟悉AOP思想
- 在配置文件中，声明切入点与通知间的关系，即切面。：少部分程序员来做，要求熟悉AOP思想
1.2.2 运行阶段
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对 象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行
1.3 XML的AOP 开发快速入门 - 转账案例
步骤 1：
// 1 创建项目，导入相关坐标
// 数据库 mysql, 测试 junit, 数据源 druid, queryRunner dbutils, spring context和test, 切面 aspectjweaver
步骤 2:
// 2 创建Spring 核心配置类文件 applicationContext 并创建properties 文件封装数据源信息
// 核心配置文件文件头
<?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">
</beans>
//引入properties文件
<context:property-placeholder location="classpath:druid.properties"></context:property-placeholder>
步骤 3:
// 3 在核心配置文件中配置datasource （IOC 配置非自定义类）
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
步骤 4:
// 4 编写线程绑定工具类和事务控制工具类
// 编写线程绑定工具类
// 需要使用 datasource，在自定义类中可通过构造方法注入或set方法注入
// 构造方法注入
private DataSource dataSource;
public connectionUtils(DataSource dataSource) {
this.dataSource = dataSource;
}
<bean id="connectionUtils" class="aopXml.utils.connectionUtils">
<constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
</bean>
// set 方法注入
private DataSource dataSource;
public void setConnectionUtils(DataSource dataSource) {
this.dataSource = dataSource;
}
<bean id="connectionUtils" class="aopXml.utils.connectionUtils">
<property name="dataSource" ref="dataSource"></property>
</bean>
// ThreadLocal 完成线程绑定，编写getConnection 和 romove 方法
// 事务工具控制类，需要注入线程工具类connectionUtils并编写开启事务，提交事务，回滚事务，释放资源的方法
步骤5:
// 5 创建目标接口和目标实现类 Dao 层编写操作数据库的方法， service层编写业务逻辑
// Dao 层需要用到queryrunner和线程工具类connectionUtils
// 核心配置文件中配置queryRunner 类，并在Dao 实现类中注入
// Service 层需要注入Dao并调用其操作数据库的方法
步骤6 :
// 6 编写通知类，将事务管理类注入，并在核心配置文件中配置切面
// 核心配置文件 aop 配置
<aop:config>
<aop:aspect ref=“通知类”>
<aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
</aop:aspect>
</aop:config>
// 直接使用事务管理类及其方法配置切面
// 核心配置xml 文件
<aop:config>
<!--切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* com.lagou.service..*.*(..))"/>
<!-- 切面配置 -->
<aop:aspect ref="transactionManager">
<aop:before method="beginTransaction" pointcut-ref="myPointcut"/>
<aop:after-returning method="commit" pointcut-ref="myPointcut"/>
<aop:after-throwing method="rollback" pointcut-ref="myPointcut"/>
<aop:after method="release" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>
// 直接将事务管理类方法作为不同切点的增强
// 切点表达式 - 语法
- execution([修饰符] 返回值类型 包名.类名.方法名(参数))
-访问修饰符可以省略
-返回值类型、包名、类名、方法名可以使用星号 * 代替，代表任意
-包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
-参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
// 切点表达式抽取
<aop:config>
<!--抽取的切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* com.lagou.service..*.*(..))">
</aop:pointcut>
<aop:aspect ref="myAdvice">
<aop:before method="before" pointcut-ref="myPointcut"></aop:before>
</aop:aspect>
</aop:config>
// 通知类型
前置通知 <aop:before> 用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知 <aop:afterReturning> 用于配置后置通知。指定增强的方法在切入点方法之后执行
异常通知 <aop:afterThrowing> 用于配置异常通知。指定增强的方法出现异常后执行
最终通知 <aop:after> 用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
环绕通知 <aop:around> 用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行
* 环绕通知独立使用
// 环绕通知使用示例：
public Object around(ProceedingJoinPoint pjp) {
Object proceed = null;
try {
transactionManager.startTransfer();
proceed = pjp.proceed();
transactionManager.commit();
} catch (Throwable throwable) {
transactionManager.rollback();
throwable.printStackTrace();
} finally {
transactionManager.release();
}
return proceed;
}
// 配置aop自动代理 <aop:aspectj-autoproxy/> 或 @EnableAspectJAutoProxy (当使用注解的时候有切面类时开启)
1.4 基于注解的AOP开发 - 转账案例
步骤1 ：
// 1 创建项目，导入相关坐标
// 数据库 mysql, 测试 junit, 数据源 druid, queryRunner dbutils, spring context和test, 切面 aspectjweaver
步骤2 ：
// 2 创建核心配置类 和 封装数据源信息的properties文件
@Configuration // 将该类设置为核心配置类
@PropertySource("classpath:druid.properties") // 读取数据源 properties文件
@ComponentScan("anno") // 添加注解包扫描范围
public class springConfig {
}
步骤3 ：
// 3 在核心配置类中配置非自定义 dataSource
// 设置常量接收数据源信息
@Value("${jdbc.driverClassName}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
// 配置dataSource
@Bean
public DataSource getDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
步骤4 ：
// 4 配置线程绑定工具类和事务管理工具类
// 在线程工具类中注入 dataSource，并将该类交给交给Sping管理
@Component
public class ConnectionUtils {
@Autowired
private DataSource dataSource;
// 通过ThreadLocal 编写获取connection 和释放资源的方法
}
// 在事务管理类中注入 ConnectionUtils
@Component
public class TransactionManager {
@Autowired
private ConnectionUtils connectionUtils;
// 编写开启事务，提交事务，回滚事务，释放资源的方法
}
步骤5 ：
// 5 编写Dao 和 Service 方法
// 在 Dao 层中注入 线程工具类ConnectionUtils 和 QueryRunner 类
// 需要先在核心配置文件中先配置QueryRunner 类
@Bean
public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
QueryRunner queryRunner = new QueryRunner(dataSource);
return queryRunner;
}
// 在Dao 层中编写操作数据库的代码
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private ConnectionUtils connectionUtils;
@Autowired
private QueryRunner queryRunner;
}
// 在service 层中注入 Dao
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
}
步骤6 ：
// 6 编写通知类，注入事务管理类，并配置切面
@Aspect // 切面类
@Component // 该通知类交给Spring 管理
public class MyAdvice {
@Autowired // 注入事务管理类
private TransactionManager transactionManager;
//编写切点表达式
@Around("execution(* anno.service.AccountServiceImpl.transfer(..))")
public Object around(ProceedingJoinPoint pjp){
Object proceed = null;
try {
transactionManager.start();
proceed = pjp.proceed();
transactionManager.commit();
} catch (Throwable throwable) {
transactionManager.rollback();
throwable.printStackTrace();
} finally {
transactionManager.release();
}
return proceed;
}
}
// 直接使用事务管理类
@Component
@Aspect
public class TransactionManager {
@Autowired
ConnectionUtils connectionUtils;
@Around("execution(* com.lagou.serivce..*.*(..))")
public Object around(ProceedingJoinPoint pjp) {
Object object = null;
try {
// 开启事务
connectionUtils.getThreadConnection().setAutoCommit(false);
// 业务逻辑
pjp.proceed();
// 提交事务
connectionUtils.getThreadConnection().commit();
} catch (Throwable throwable) {
throwable.printStackTrace();
// 回滚事务
try {
connectionUtils.getThreadConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
} finally {
try {
connectionUtils.getThreadConnection().setAutoCommit(true);
connectionUtils.getThreadConnection().close();
connectionUtils.removeThreadConnection();
} catch (SQLException e) {
e.printStackTrace();
}
}
return object;
}
}
// 注解切点表达式抽取
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.lagou..*.*(..))")
public void myPoint(){}
@Before("MyAdvice.myPoint()")
public void before() {
System.out.println("前置通知...");
}
// 注解通知类型
- 前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
- 后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
- 异常通知 @AfterThrowing 用于配置异常通知。指定增强的方法出现异常后执行
- 最终通知 @After 用于配置最终通知。无论切入点方法执行时是否有异常，都会执行
- 环绕通知 @Around 用于配置环绕通知。开发者可以手动控制增强代码在什么时候执行
* - 当前四个通知组合在一起时，执行顺序如下：
@Before -> @After -> @AfterReturning（如果有异常：@AfterThrowing）
步骤7 ：
// 7 在核心配置类中设置AOP自动代理
@EnableAspectJAutoProxy
public class springConfig {}
浙公网安备 33010602011771号