Spring5 - Aop
一、AOP 的相关概念
1.1AOP 概述
1.1.1 什么是 AOP
AOP：全称是Aspect Oriented Programming即：面向切面编程。- 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
1.1.2 AOP 的作用及优势
- 作用：在程序运行期间，不修改源码对已有方法进行增强。
- 优势：
- 减少重复代码
- 提高开发效率
- 维护方便
1.1.3 AOP 的实现方式
- 使用动态代理技术
1.2 动态代理
1.2.1 动态代理的特点
- 字节码随用随创建，随用随加载。
- 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
- 装饰者模式就是静态代理的一种体现。
1.2.2 动态代理常用的有两种方式
- 基于接口的动态代理
- 提供者：
JDK官方的Proxy类。 - 要求：被代理类最少实现一个接口。
- 提供者：
1.2.3 使用 JDK 官方的 Proxy 类创建代理对象
public interface IProducer {
/**
* 销售
* @param money
*/
void saleProduct(float money);
/**
* 售后
* @param money
*/
void afterService(float money);
}
public class Producer implements IProducer{
@Override
public void saleProduct(float money){
System.out.println("销售产品，并拿到钱："+money);
}
@Override
public void afterService(float money){
System.out.println("提供售后服务，并拿到钱："+money);
}
}
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
/**
* 动态代理：
* 如何创建代理对象：
* 使用Proxy类中的newProxyInstance方法
* 创建代理对象的要求：
* 被代理类最少实现一个接口，如果没有则不能使用
* newProxyInstance方法的参数：
* ClassLoader：类加载器
* 它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
* Class[]：字节码数组
* 它是用于让代理对象和被代理对象有相同方法。固定写法。
* InvocationHandler：用于提供增强的代码
* 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
* 此接口的实现类都是谁用谁写。
*/
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用：执行被代理对象的任何接口方法都会经过该方法
* @param proxy 代理对象的引用
* @param method 当前执行的方法
* @param args 当前执行方法所需的参数
* @return 和被代理对象方法有相同的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float) args[0];
//2.判断当前方法是不是销售
if ("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money * 0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(10000f);
}
}
1.2.4 使用 CGLib 的 Enhancer 类创建代理对象
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.1_3</version>
</dependency>
public class Producer {
/**
* 销售
* @param money
*/
public void saleProduct(float money){
System.out.println("销售产品，并拿到钱："+money);
}
/**
* 售后
* @param money
*/
public void afterService(float money){
System.out.println("提供售后服务，并拿到钱："+money);
}
}
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
/**
* 如何创建代理对象：
* 使用Enhancer类中的create方法
* 创建代理对象的要求：
* 被代理类不能是最终类
* create方法的参数：
* Class：字节码
* 它是用于指定被代理对象的字节码。
* Callback：用于提供增强的代码
* 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
* 此接口的实现类都是谁用谁写。
* 我们一般写的都是该接口的子接口实现类：MethodInterceptor
*/
Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 执行北地阿里对象的任何方法都会经过该方法
* @param proxy
* @param method
* @param args
* 以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
* @param methodProxy ：当前执行方法的代理对象
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float)args[0];
//2.判断当前方法是不是销售
if("saleProduct".equals(method.getName())) {
returnValue = method.invoke(producer, money*0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(12000f);
}
}
二、 Spring 中的 AOP
2.1 Spring 中 AOP 的细节
2.1.1 AOP 相关术语
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下,Introduction可以在运行期为类动态地添加一些方法或Field。Target(目标对象):代理的目标对象。Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类。Aspect(切面):是切入点和通知（引介）的结合。
2.2 基于 XML 的 AOP 配置
2.2.1 环境搭建
2.2.1.1 添加依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
public class AccountServiceImpl implements AccountService {
@Override
public void saveAccount() {
System.out.println("执行了保存");
}
@Override
public void updateAccount(int i) {
System.out.println("执行了更新"+i);
}
@Override
public int deleteAccount() {
System.out.println("执行了删除");
return 0;
}
}
public class Logger {
/**
* 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
*/
public void printLog(){
System.out.println("Logger类中的pringLog方法开始记录日志了。。。");
}
}
2.2.1.2 配置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">
<!-- 配置srping的Ioc,把service对象配置进来-->
<bean id="accountService" class="com.cy.service.impl.AccountServiceImpl"></bean>
<!-- 配置Logger类 -->
<bean id="logger" class="com.cy.utils.Logger"></bean>
<!--配置AOP-->
<aop:config>
<!--配置切面 -->
<aop:aspect id="logAdvice" ref="logger">
<!-- 配置通知的类型，并且建立通知方法和切入点方法的关联-->
<aop:before method="printLog" pointcut="execution(* com.cy.service.impl.*.*(..))"></aop:before>
</aop:aspect>
</aop:config>
</beans>
2.2.2 配置步骤
-
把通知类用
bean标签配置起来<!-- 配置srping的Ioc,把service对象配置进来--> <bean id="accountService" class="com.cy.service.impl.AccountServiceImpl"></bean> -
使用
aop:config声明aop配置<!--配置AOP--> <aop:config> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--> <aop:before method="printLog" pointcut="execution(* com.cy.service.impl.*.*(..))"></aop:before> </aop:aspect> </aop:config> -
使用
aop:aspect配置切面<!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--> <aop:before method="printLog" pointcut="execution(* com.cy.service.impl.*.*(..))"></aop:before> </aop:aspect> -
使用
aop:pointcut配置切入点表达式<!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--> <aop:before method="printLog" pointcut="execution(* com.cy.service.impl.*.*(..))"></aop:before> -
切入点表达式说明
关键字：execution(表达式) 表达式：访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表) 标准的表达式写法：public void com.cy.service.impl.AccountServiceImpl.saveAccount() 访问修饰符可以省略:void com.cy.service.impl.AccountServiceImpl.saveAccount() 返回值可以使用通配符，表示任意返回值: * com.cy.service.impl.AccountServiceImpl.saveAccount() 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*: * *.*.*.*.AccountServiceImpl.saveAccount()) 包名可以使用..表示当前包及其子包: * *..AccountServiceImpl.saveAccount() 类名和方法名都可以使用*来实现通配: * *..*.*() 参数列表： 可以直接写数据类型： 基本类型直接写名称 int 引用类型写包名.类名的方式 java.lang.String 可以使用通配符表示任意类型，但是必须有参数 可以使用..表示有无参数均可，有参数可以是任意类型 全通配写法： * *..*.*(..) 实际开发中切入点表达式的通常写法： 切到业务层实现类下的所有方法 * com.cy.service.impl.*.*(..) -
置前置通知
/** * 前置通知 */ public void beforePrintLog(){ System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。"); }<!-- 配置Logger类 --> <bean id="logger" class="com.cy.utils.Logger"></bean> <!--配置AOP--> <aop:config> <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容 此标签写在aop:aspect标签内部只能当前切面使用。 它还可以写在aop:aspect外面，此时就变成了所有切面可用 --> <aop:pointcut id="pt1" expression="execution(* com.cy.service.impl.*.*(..))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置前置通知：在切入点方法执行之前执行--> <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before> </aop:aspect> </aop:config> -
后置通知
/** * 后置通知 */ public void afterReturningPrintLog(){ System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。"); }<!--配置AOP--> <aop:config> <aop:pointcut id="pt1" expression="execution(* com.cy.service.impl.*.*(..))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个--> <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning> </aop:aspect> </aop:config> -
异常通知
/** * 异常通知 */ public void afterThrowingPrintLog(){ System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。"); }<!--配置AOP--> <aop:config> <aop:pointcut id="pt1" expression="execution(* com.cy.service.impl.*.*(..))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个--> <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing> </aop:aspect> </aop:config> -
置最终通知
/** * 最终通知 */ public void afterPrintLog(){ System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。"); }<!--配置AOP--> <aop:config> <aop:pointcut id="pt1" expression="execution(* com.cy.service.impl.*.*(..))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行--> <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after> </aop:aspect> </aop:config> -
环绕通知
public Object aroundPringLog(ProceedingJoinPoint pjp){ Object rtValue = null; try{ //得到方法执行所需的参数 Object[] args = pjp.getArgs(); System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置"); //明确调用业务层方法（切入点方法） rtValue = pjp.proceed(args); System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置"); return rtValue; }catch (Throwable t){ System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常"); throw new RuntimeException(t); }finally { System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终"); } }<!--配置AOP--> <aop:config> <aop:pointcut id="pt1" expression="execution(* com.cy.service.impl.*.*(..))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="logAdvice" ref="logger"> <!-- 配置环绕通知 详细的注释请看Logger类中--> <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around> </aop:aspect> </aop:config>
2.3基于注解的 AOP 配置
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
</dependencies>
@Component("logger")//表示当前类是一个切面类
@Aspect
public class Logger {
@Pointcut("execution(* com.cy.service.impl.*.*(..))")
private void pt1(){}
/**
* 前置通知
*/
@Before("pt1()")
public void beforePrintLog(){
System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
}
/**
* 后置通知
*/
@AfterReturning("pt1()")
public void afterReturningPrintLog(){
System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
}
/**
* 异常通知
*/
@AfterThrowing("pt1()")
public void afterThrowingPrintLog(){
System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
}
/**
* 最终通知
*/
@After("pt1()")
public void afterPrintLog(){
System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
}
/**
* 环绕通知
*/
//@Around("pt1()")
public Object aroundPringLog(ProceedingJoinPoint pjp){
Object rtValue = null;
try{
//得到方法执行所需的参数
Object[] args = pjp.getArgs();
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
//明确调用业务层方法（切入点方法）
rtValue = pjp.proceed(args);
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
return rtValue;
}catch (Throwable t){
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
throw new RuntimeException(t);
}finally {
System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
}
}
}
<!-- 配置spring创建容器时要扫描的包-->
<context:component-scan base-package="com.cy"></context:component-scan>
<!-- 配置spring开启注解AOP的支持 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
不使用 XML 的配置方式
@Configuration
@ComponentScan(basePackages="com.cy")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}
三、 Spring 中的 JdbcTemplate
3.1 JdbcTemplate 概述
它是 spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单封装。spring 框架为我们提供了很多的操作模板类。
操作关系型数据的：JdbcTemplate，HibernateTemplate
操作 nosql 数据库的：RedisTemplate
操作消息队列的：JmsTemplate
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
