Spring 基础知识三

r囧r小猫 2023-10-10 11:06 16阅读 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 包:

<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">
    		
    		 
             <context:component-scan base-package="com.zzg.aop" />
             
            <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:config

3.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 的支持

<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;
     }