Spring 基础知识三
不点
阅读：576
2021-03-31 14:14:42
评论：0
第一:Spring AOP 相关概念
1.1 什么是AOP
AOP：全称是 Aspect Oriented Programming 即：面向切面编程。
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
1.2 AOP的作用和优势
作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便1.3 动态代理的特点
字节码随用随创建，随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
装饰者模式就是静态代理的一种体现。1.3.1 动态代理常用的两种方式
基于接口的动态代理:
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。1.3.2 JDK 官方的 Proxy 类创建代理对象
package com.zzg.aop.proxy.jdk;
public interface Car {
/**
* 汽车品牌
* @param name
*/
public void bran(String name);
/**
* 汽车价格
* @param money
*/
public void price(String money);
}
package com.zzg.aop.proxy.jdk;
public class BMW implements Car {
@Override
public void bran(String name) {
// TODO Auto-generated method stub
System.out.println("BMW" + name);
}
@Override
public void price(String money) {
// TODO Auto-generated method stub
System.out.println("总价:" + money + "万元");
}
}
package com.zzg.aop.proxy.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JDKProxy {
public static void main(String[] args) {
// 对象实例化
BMW bmw = new BMW();
/**
* 代理： 间接。 获取代理对象： 要求： 被代理类最少实现一个接口 创建的方式 Proxy.newProxyInstance(三个参数) 参数含义：
* ClassLoader：和被代理对象使用相同的类加载器。 Interfaces：和被代理对象具有相同的行为。实现相同的接口。
* InvocationHandler：如何代理。 策略模式：使用场景是： 数据有了，目的明确。 如何达成目标，就是策略。
*
*/
Car proxyCar = (Car) Proxy.newProxyInstance(bmw.getClass().getClassLoader(), bmw.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 执行被代理对象的任何方法，都会经过该方法。 此方法有拦截的功能。
*
* 参数： proxy：代理对象的引用。不一定每次都用得到 method：当前执行的方法对象 args：执行方法所需的参数 返回值： 当前执行方法的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String name = method.getName();
String paramter = (String) args[0];
Object rtValue = null;
// 方法名比较
if ("bran".equals(name)) {
rtValue = method.invoke(bmw, paramter);
}
if ("price".equals(name)) {
rtValue = method.invoke(bmw, paramter);
}
return rtValue;
}
});
proxyCar.bran("X3");
proxyCar.price("45");
}
}
1.3.3 CGLib 的 Enhancer 类创建代理对象
package com.zzg.aop.proxy.cglib;
public class Audi {
public void bran(String name) {
// TODO Auto-generated method stub
System.out.println("AUDI" + name);
}
public void price(String money) {
// TODO Auto-generated method stub
System.out.println("总价:" + money + "万元");
}
}
package com.zzg.aop.proxy.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy {
public static void main(String[] args) {
final Audi audi = new Audi();
Audi cglibAudi = (Audi) Enhancer.create(audi.getClass(), new MethodInterceptor() {
/**
* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何 方法进行增强。
*
* 参数： 前三个和基于接口的动态代理是一样的。 MethodProxy：当前执行方法的代理对象。 返回值： 当前执行方法的返回值
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
throws Throwable {
String name = method.getName();
String paramter = (String) args[0];
Object rtValue = null;
// 方法名比较
if ("bran".equals(name)) {
rtValue = method.invoke(audi, paramter);
}
if ("price".equals(name)) {
rtValue = method.invoke(audi, paramter);
}
return rtValue;
}
});
cglibAudi.bran("A6L");
cglibAudi.price("45");
}
}
第二:Spring 中的AOP
2.1 Spring AOP 相关术语
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target(目标对象):代理的目标对象。
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):是切入点和通知（引介）的结合。2.1 Spring AOP 基于XML 配置
2.1.1 添加依赖jar 包:
<!--spring aop 依赖jar 包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>2.1.2 示例代码
package com.zzg.aop;
public interface HelloWorld {
void printHelloWorld();
void doPrint();
}
package com.zzg.aop.impl;
import com.zzg.aop.HelloWorld;
public class HelloWorldImpl1 implements HelloWorld {
@Override
public void printHelloWorld() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
}
@Override
public void doPrint() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl1.doPrint()");
}
}
package com.zzg.aop.impl;
import com.zzg.aop.HelloWorld;
public class HelloWorldImpl2 implements HelloWorld {
@Override
public void printHelloWorld() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
}
@Override
public void doPrint() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl2.doPrint()");
}
}
package com.zzg.aop.handler;
/**
* 时间工具类
* @author Administrator
*
*/
public class TimeHandler {
public void printTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}
aop.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">
<bean id="helloWorldImpl1" class="com.zzg.aop.impl.HelloWorldImpl1" />
<bean id="helloWorldImpl2" class="com.zzg.aop.impl.HelloWorldImpl2" />
<bean id="timeHandler" class="com.zzg.aop.handler.TimeHandler" />
<aop:config>
<aop:aspect id="time" ref="timeHandler">
<aop:pointcut id="addAllMethod" expression="execution(* com.zzg.aop.impl.*.*(..))" />
<aop:before method="printTime" pointcut-ref="addAllMethod" />
<aop:after method="printTime" pointcut-ref="addAllMethod" />
</aop:aspect>
</aop:config>
</beans>
package com.zzg.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AOPXML {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext ctx =
new ClassPathXmlApplicationContext("aop.xml");
HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
hw1.printHelloWorld();
System.out.println();
hw1.doPrint();
System.out.println();
hw2.printHelloWorld();
System.out.println();
hw2.doPrint();
}
}
2.2 Spring AOP 基于注解 配置
示例代码:
package com.zzg.aop;
public interface HelloWorld {
void printHelloWorld();
void doPrint();
}
package com.zzg.aop.impl;
import org.springframework.stereotype.Service;
import com.zzg.aop.HelloWorld;
@Service
public class HelloWorldImpl1 implements HelloWorld {
@Override
public void printHelloWorld() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
}
@Override
public void doPrint() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl1.doPrint()");
}
}
package com.zzg.aop.impl;
import org.springframework.stereotype.Service;
import com.zzg.aop.HelloWorld;
@Service
public class HelloWorldImpl2 implements HelloWorld {
@Override
public void printHelloWorld() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
}
@Override
public void doPrint() {
// TODO Auto-generated method stub
System.out.println("Enter HelloWorldImpl2.doPrint()");
}
}
package com.zzg.aop.handler;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
* 时间工具类
* @author Administrator
*
*/
@Component
@Aspect
public class TimeHandler {
@Before("execution(* com.zzg.aop.impl.*.*(..))")
public void startTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@After("execution(* com.zzg.aop.impl.*.*(..))")
public void endTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}
aop.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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--开启Spring注解扫描器 -->
<context:component-scan base-package="com.zzg.aop" />
<!-- 在配置IOC的基础上增加了aop:aspectj-autoproxy节点，Spring框架会自动为与AspectJ切面配置的Bean创建代理，
proxy-target-class="true"属性表示被代理的目标对象是一个类，
而非实现了接口的类，反之proxy-target-class="false" 主要是为了选择不同的代理方式。-->
<aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>
</beans>
package com.zzg.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AOPAnnotation {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext ctx =
new ClassPathXmlApplicationContext("aop.xml");
HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
hw1.printHelloWorld();
System.out.println();
hw1.doPrint();
System.out.println();
hw2.printHelloWorld();
System.out.println();
hw2.doPrint();
}
}第三:Spring 中的AOP基于XML 配置说明:
3.1 使用 aop:config 声明 aop 配置
aop:config
作用：用于声明开始 aop 的配置
<aop:config>
<!-- 配置的代码都写在此处 -->
</aop:config3.2 使用 aop:aspect 配置切面
aop:aspect:
作用：
用于配置切面。
属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="time" ref="timeHandler">
<!--配置通知的类型要写在此处-->
</aop:aspect>3.3 使用 aop:pointcut 配置切入点表达式
aop:pointcut：
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut id="addAllMethod" expression="execution(* com.zzg.aop.impl.*.*(..))" />3.4 使用 aop:xxx 配置对应的通知类型
aop:before
作用：
用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
method:用于指定通知类中的增强方法名称
ponitcut-ref：用于指定切入点的表达式的引用
poinitcut：用于指定切入点表达式
执行时间点：
切入点方法执行之前执行
<aop:before method="printTime" pointcut-ref="addAllMethod" />
aop:after-returning
作用：
用于配置后置通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行
<aop:after-returning method="printTime" pointcut-ref="addAllMethod"/>
aop:after-throwing
作用：
用于配置异常通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个
<aop:after-throwing method="printTime" pointcut-ref="addAllMethod"/>
aop:after
作用：
用于配置最终通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。
<aop:after method="printTime" pointcut-ref="addAllMethod"/>3.5 切入点表达式说明
execution:匹配方法的执行(常用)
execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
写法说明：
包名可以使用*号，表示任意包，但是有几级包，需要写几个*
* *.*.*.*.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
使用..来表示当前包，及其子包
* com..AccountServiceImpl.saveAccount(com.itheima.domain.Account)
类名可以使用*号，表示任意类
* com..*.saveAccount(com.itheima.domain.Account)
方法名可以使用*号，表示任意方法
* com..*.*( com.itheima.domain.Account)
参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
* com..*.*(*)
参数列表可以使用..表示有无参数均可，有参数可以是任意类型
* com..*.*(..)
全通配方式：
* *..*.*(..)
注：
通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
execution(* com.itheima.service.impl.*.*(..))第四:Spring 中的AOP基于注解配置说明:
4.1 通知类添加@Component注解声明为组件
@Component
public class TimeHandler {
}4.2 通知类上添加@Aspect 注解声明为切面
@Component
@Aspect
public class TimeHandler {
}4.3 通知类在增强的方法上使用注解配置通知
@Before
作用：把当前方法看成是前置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。
@Component
@Aspect
public class TimeHandler {
@Before("execution(* com.zzg.aop.impl.*.*(..))")
public void startTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}
@AfterReturning
作用：把当前方法看成是后置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
package com.zzg.aop.handler;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
* 时间工具类
* @author Administrator
*
*/
@Component
@Aspect
public class TimeHandler {
@Before("execution(* com.zzg.aop.impl.*.*(..))")
public void startTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@AfterReturning("execution(* com.zzg.aop.impl.*.*(..))")
public void commit() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}
@AfterThrowing
作用：把当前方法看成是异常通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
@Component
@Aspect
public class TimeHandler {
@Before("execution(* com.zzg.aop.impl.*.*(..))")
public void startTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@AfterReturning("execution(* com.zzg.aop.impl.*.*(..))")
public void commit() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@AfterThrowing("execution(* com.zzg.aop.impl.*.*(..))")
public void rollback() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}
@After
作用：把当前方法看成是最终通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
@Component
@Aspect
public class TimeHandler {
@Before("execution(* com.zzg.aop.impl.*.*(..))")
public void startTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@AfterReturning("execution(* com.zzg.aop.impl.*.*(..))")
public void commit() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@AfterThrowing("execution(* com.zzg.aop.impl.*.*(..))")
public void rollback() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
@After("execution(* com.zzg.aop.impl.*.*(..))")
public void endTime() {
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}4.4 在 spring 配置文件中开启 spring 对注解 AOP 的支持
<!-- 开启 spring 对注解 AOP 的支持 -->
<aop:aspectj-autoproxy/>4.5 环绕通知注解配置
@Around
作用：把当前方法看成是环绕通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("execution(* com.zzg.aop.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}4.6 切入点表达式注解
@Pointcut
作用：指定切入点表达式
属性：
value：指定表达式的内容
@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1() {}
引用方式：
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}
声明
1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。
