Spring 基础知识三解析

不点 阅读:240 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: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  [email protected]

@Component 
public class TimeHandler { 
	 
}

4.2  [email protected] 注解声明为切面

@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.作者投稿可能会经我们编辑修改或补充。

发表评论
搜索
排行榜
KIKK导航

KIKK导航

关注我们