Spring框架

最新推荐文章于 2025-06-23 10:15:35 发布

书虫罢了

最新推荐文章于 2025-06-23 10:15:35 发布

阅读量373

点赞数 1

CC 4.0 BY-SA版权

文章标签： java spring 后端

本文链接：https://blog.youkuaiyun.com/lazyboy2/article/details/121524406

1.Spring简介

Spring优点

1.非侵入式

2.容器

在应用加载时，创建一个 Map，用于存放三层对象。我们把这个 map 称之为容器。

3.Ioc：控制反转

即将对象创建的权利交给了框架，包括依赖注入和依赖查找

原来：我们在获取对象时，都是采用 new 的方式。是主动的。

现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

作用：削减计算机程序的耦合(解除我们代码中的依赖关系)

4.依赖注入

5.AOP：面向方面的编程

面向方面编程，将日志、安全、事务管理等理解成一共方面，以前这些服务通常是直接写在业务逻辑中，这两个缺点：1，业务逻辑不干净 2，这些服务被很多业务逻辑反复使用，不能复用。AOP解决了这些，将这些服务剥离了出来。

Spring体系结构

在这里插入图片描述

2.Spring Bean的装配模式

2.1 Spring IOC容器

Spring IOC容器的设计主要基于BeanFactory和ApplicationContext这两个接口

BeanFactory是底层接口，ApplicationContext是其子接口，提供更好的功能

2.1.1ApplicationContext的常用实现类

ClassPathXmlApplicationContext

从类路径classPath中寻找指定的XML配置文件，找到并装载ApplicationContext的实例化工作

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

FileSystemXmlApplicationContext

采用绝对路径的方式不推荐使用

AnnotationConfigApplicationContext

当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

2.1.2 ApplicationContext容器由Web服务器实例化

这些放在web.xml文件中

基于ContextLoaderListener实现

指定Spring配置文件的位置
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-name>classpath:applicationContext.xml</param-name>
</context-param>
指定以ContextLoaderListener方式启动Spring容器
<listener>
   <listener-class>
       org.springframework.web.context.ContextLoaderListener
   </listener-class>
</listener>

基于ContextLoaderServlet实现

指定Spring配置文件的位置
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-name>classpath:applicationContext.xml</param-name>
</context-param>
指定以ContextLoaderListener方式启动Spring容器
<listener>
    <servlet-name>context</servlet-name>
   <listener-class>
       org.springframework.web.context.ContextLoaderListener
   </listener-class>
    <load-on-startup>1</load-on-startup>
</listener>

在Spring、Mybatis和SpringMVC的整合开发时，常用这种方式。

2.2 Bean的配置

2.2.1Bean标签简介

作用：
	用于配置对象让 spring 来创建的。
	默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
	id：给对象在容器中提供一个唯一标识。用于获取对象。
	class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
	scope：指定对象的作用范围。
		* singleton :默认值，单例的.
		* prototype :多例的.
		* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
		* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
		* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么
			globalSession 相当于 session.
	init-method：指定类中的初始化方法名称。
	destroy-method：指定类中销毁方法名称。

2.2.2 Bean的作用范围与生命周期

单例对象：scope="singleton"
	一个应用只有一个对象的实例。它的作用范围就是整个引用。
	生命周期：
		对象出生：当应用加载，创建容器时，对象就被创建了。
		对象活着：只要容器在，对象一直活着。
	对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope="prototype"
	每次访问对象时，都会重新创建对象实例。
	生命周期：
		对象出生：当使用对象时，创建新的对象实例。
		对象活着：只要对象在使用中，就一直活着。
		对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

2.2.3 Bean实例化的三种方式

使用无参构造函数

<!--在默认情况下：
它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。
-->
<bean id="accountService" class="com.service.impl.AccountServiceImpl"/>

spring 管理静态工厂-使用静态工厂的方法创建对象

/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
public static IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService"
 class="com.factory.StaticFactory"
 factory-method="createAccountService"></bean

spring 管理实例工厂-使用实例工厂的方法创建对象

第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
public IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.factory.InstanceFactory"></bean>
<bean id="accountService"
 factory-bean="instancFactory"
      factory-method="createAccountService"></bean>

3.Spring 依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

3.1构造函数注入

java代码部分

public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public AccountServiceImpl(String name, Integer age, Date birthday) {
		this.name = name;
		this.age = age;
		this.birthday = birthday;
	}
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	}
}

xml部分

<!-- 使用构造函数的方式，给 service 中的属性传值
	要求：
	类中需要提供一个对应参数列表的构造函数。
	涉及的标签：
	constructor-arg
	属性：
		index:指定参数在构造函数参数列表的索引位置
		type:指定参数在构造函数中的数据类型
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
		value:它能赋的值是基本数据类型和 String 类型
		ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="com.service.impl.AccountServiceImpl">
	<constructor-arg name="name" value="张三"></constructor-arg>
	<constructor-arg name="age" value="18"></constructor-arg>
	<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>

3.2 Set方法注入

java代码部分

public class AccountServiceImpl implements IAccountService {
	private String name;
	private Integer age;
	private Date birthday;
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	@Override
	public void saveAccount() {
		System.out.println(name+","+age+","+birthday);
	}
}

xml配置

<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：
	property
属性：
	name：找的是类中 set 方法后面的部分
	ref：给属性赋值是其他 bean 类型的
	value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="com.service.impl.AccountServiceImpl">
	<property name="name" value="test"></property>
	<property name="age" value="21"></property>
	<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

3.3对集合属性的注入

java代码部分

public class AccountServiceImpl implements IAccountService {
	private String[] myStrs;
	private List<String> myList;
	private Set<String> mySet;
	private Map<String,String> myMap;
	private Properties myProps;
	public void setMyStrs(String[] myStrs) {
		this.myStrs = myStrs;
	}
	public void setMyList(List<String> myList) {
		this.myList = myList;
	}
	public void setMySet(Set<String> mySet) {
		this.mySet = mySet;
	}
	public void setMyMap(Map<String, String> myMap) {
		this.myMap = myMap;
	}
	public void setMyProps(Properties myProps) {
		this.myProps = myProps;
	}
	@Override
	public void saveAccount() {
		System.out.println(Arrays.toString(myStrs));
		System.out.println(myList);
		System.out.println(mySet);
		System.out.println(myMap);
		System.out.println(myProps);
	}
}

xml配置

<!-- 注入集合数据
	List 结构的：
		array,list,set
	Map 结构的
		map,entry,props,prop
-->
<bean id="accountService" class="com.service.impl.AccountServiceImpl">
<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
<!-- 给数组注入数据 -->
<property name="myStrs">
<set>
	<value>AAA</value>
	<value>BBB</value>
	<value>CCC</value>
</set>
</property>
<!-- 注入 list 集合数据 -->
<property name="myList">
  <array>
	<value>AAA</value>
	<value>BBB</value>
	<value>CCC</value>
  </array>
</property>
<!-- 注入 set 集合数据 -->
<property name="mySet">
 <list>
	<value>AAA</value>
	<value>BBB</value>
	<value>CCC</value>
 </list>
</property>
<!-- 注入 Map 数据 -->
<property name="myMap">
 <props>
	<prop key="testA">aaa</prop>
	<prop key="testB">bbb</prop>
 </props>
</property>
<!-- 注入 properties 数据 -->
<property name="myProps">
 <map>
	<entry key="testA" value="aaa"></entry>
	<entry key="testB">
		<value>bbb</value>
	</entry>
 </map>
</property>
</bean>

4.Spring 基于注解的IOC配置

4.1 开启对注解的支持配置

还依赖spring-aop包

注意：
基于注解整合时，导入约束时需要多导入一个 context 名称空间下的约束。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 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">
 
<!-- 告知 spring 创建容器时要扫描的包 -->
<context:component-scan base-package="com"></context:component-scan>
</beans>

4.2 常用注解

@Component

作用：把资源让 spring 来管理。相当于在 xml 中配置一个 bean。

属性： value：指定 bean 的 id。如果不指定 value 属性，默认 bean 的 id 是当前类的类名。首字母小写。

@Component("accountService")
public class AccountServiceImpl implements IAccountService {
	private IAccountDao accountDao;
	public void setAccountDao(IAccountDao accountDao) {
		this.accountDao = accountDao;
	}
}

@Controller @Service @Repository

他们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。他们只不过是提供了更加明确的语义化。

@Controller：一般用于表现层的注解。

@Service：一般用于业务层的注解。

@Repository：一般用于持久层的注解。细节：如果注解中有且只有一个属性要赋值时，且名称是 value，value 在赋值是可以不写。

@Autowired

作用：自动按照类型注入。当使用注解注入属性时，set 方法可以省略。它只能注入其他 bean 类型。当有多个类型匹配时，使用要注入的对象变量名称作为 bean 的 id，在 spring 容器查找，找到了也可以注入成功。找不到就报错

@Qualifier

作用：在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须和 @Autowire 一起使用；但是给方法参数注入时，可以独立使用。属性： value：指定 bean 的 id。

@Resource

作用：直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。属性： name：指定 bean 的 id

相当于@Autowired和@Qualifier

@Value

作用：注入基本数据类型和 String 类型数据的

属性： value：用于指定值

@Scope

作用：指定 bean 的作用范围。

属性： value：指定范围的值。

取值：singleton prototype request session globalsession

@PostConstruct

作用：用于指定初始化方法。

@PreDestroy

作用：用于指定销毁方法。

4.3 采用全注解配置

@Configuration

作用：用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用 AnnotationApplicationContext(有@Configuration 注解的类.class)。

属性： value:用于指定配置类的字节码

@ComponentScan

作用：用于指定 spring 在初始化容器时要扫描的包。作用和在 spring 的 xml 配置文件中的：是一样的。

属性： basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样。

@Bean

作用：该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。

属性： name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

@PropertySource

作用：用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到 properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。

属性： value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

代码示例

jdbc.properties 文件：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/day44_ee247_spring
jdbc.username=root
jdbc.password=1234

@Confirguration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
	@Value("${jdbc.driver}")
	private String driver;
	@Value("${jdbc.url}")
	private String url;
	@Value("${jdbc.username}")
	private String username;
	@Value("${jdbc.password}")
	private String password;
/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
	@Bean(name="dataSource")
	public DataSource createDataSource() {
		try {
			ComboPooledDataSource ds = new ComboPooledDataSource();
			ds.setDriverClass(driver);
			ds.setJdbcUrl(url);
			ds.setUser(username);
			ds.setPassword(password);
			return ds;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
    }
}

@Configuration
@ComponentScan(basePackages = "com.itheima.spring")
@Import({ JdbcConfig.class})
public class SpringConfiguration {
}

5.Spring AOP

5.1 AOP简介

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

作用：在程序运行期间，不修改源码对已有方法进行增强。

优势：减少重复代码提高开发效率维护方便

实现方式:使用动态代理技术

5.2 动态代理

基于接口的动态代理

此处我们使用的是一个演员的例子：
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。
而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪
人来找了。下面我们就用代码演示出来。
/**
* 一个经纪公司的要求:
* 能做基本的表演和危险的表演
*/
public interface IActor {
/**
* 基本演出
* @param money
*/
public void basicAct(float money);
/**
* 危险演出
* @param money
*/
public void dangerAct(float money);
}
/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演："+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演："+money);
	}
}

public class Client {
	public static void main(String[] args) {
//一个剧组找演员：
		final Actor actor = new Actor();//直接
/**
* 代理：
* 间接。
* 获取代理对象：
* 要求：
* 被代理类最少实现一个接口
* 创建的方式
* Proxy.newProxyInstance(三个参数)
* 参数含义：
* ClassLoader：和被代理对象使用相同的类加载器。
* Interfaces：和被代理对象具有相同的行为。实现相同的接口。
* InvocationHandler：如何代理。
* 策略模式：使用场景是：
* 数据有了，目的明确。
* 如何达成目标，就是策略。
* 
*/
	IActor proxyActor = (IActor) Proxy.newProxyInstance(
						actor.getClass().getClassLoader(), 
						actor.getClass().getInterfaces(), 
						new InvocationHandler() {
/**
* 执行被代理对象的任何方法，都会经过该方法。
* 此方法有拦截的功能。
* 
* 参数：
* proxy：代理对象的引用。不一定每次都用得到
* method：当前执行的方法对象
* args：执行方法所需的参数
* 返回值：
* 当前执行方法的返回值
*/
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) 
					throws Throwable {
						String name = method.getName();
						Float money = (Float) args[0];
						Object rtValue = null;

						//每个经纪公司对不同演出收费不一样，此处开始判断
						if("basicAct".equals(name)){
					//基本演出，没有 2000 不演
							if(money > 2000){
				//看上去剧组是给了 8000，实际到演员手里只有 4000
					//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
								rtValue = method.invoke(actor, money/2);
						}
					}
						if("dangerAct".equals(name)){
//危险演出,没有 5000 不演
							if(money > 5000){
//看上去剧组是给了 50000，实际到演员手里只有 25000
//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
								rtValue = method.invoke(actor, money/2);
							}
						}
							return rtValue;
					}
				});
//没有经纪公司的时候，直接找演员。
// actor.basicAct(1000f);
// actor.dangerAct(5000f);
//剧组无法直接联系演员，而是由经纪公司找的演员
		proxyActor.basicAct(8000f);
		proxyActor.dangerAct(50000f);
	}
}

5.3 AOP相关术语

Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

Pointcut(切入点): 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

Advice(通知/增强): 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

Target(目标对象): 代理的目标对象。

Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy（代理）: 一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面): 是切入点和通知（引介）的结合。

5.4 基于XML的Spring AOP配置

导入约束

此处要导入 aop 的约束
<?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">
</beans

配置事务管理器(通知类)

<!-- 配置通知 -->
<bean id="txManager" class="com.itheima.utils.TransactionManager">
  <property name="dbAssit" ref="dbAssit"></property>
    <!--dbAssit是连接池的bean-->
</bean>

使用 aop:config 声明 aop 配置

aop:config:
作用：用于声明开始 aop 的配置
<aop:config>
<!-- 配置的代码都写在此处 -->
</aop:config>

用 aop:pointcut 配置切入点表达式

aop:pointcut：
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution(public void com.service.impl.AccountServiceImpl.transfer(
                         java.lang.String, java.lang.String, java.lang.Float)
)" id="pt1"/>

使用 aop:xxx 配置对应的通知类型

aop:before
	作用：
		用于配置前置通知。指定增强的方法在切入点方法之前执行
	属性：
		method:用于指定通知类中的增强方法名称
		ponitcut-ref：用于指定切入点的表达式的引用
		poinitcut：用于指定切入点表达式
	执行时间点：
		切入点方法执行之前执行
			<aop:before method="beginTransaction" pointcut-ref="pt1"/>

aop:after-returning

	作用：
		用于配置后置通知
	属性：
		method：指定通知中方法的名称。
		pointct：定义切入点表达式
		pointcut-ref：指定切入点表达式的引用
	执行时间点：
		切入点方法正常执行之后。它和异常通知只能有一个执行
			<aop:after-returning method="commit" pointcut-ref="pt1"/>
aop:after-throwing
	作用：
		用于配置异常通知
	属性：
		method：指定通知中方法的名称。
		pointct：定义切入点表达式
		pointcut-ref：指定切入点表达式的引用
	执行时间点：
		切入点方法执行产生异常后执行。它和后置通知只能执行一个
			<aop:after-throwing method="rollback" pointcut-ref="pt1"/>
aop:after
	作用：
		用于配置最终通知
	属性：
		method：指定通知中方法的名称。
		pointct：定义切入点表达式
		pointcut-ref：指定切入点表达式的引用
	执行时间点：
		无论切入点方法执行时是否有异常，它都会在其后面执行。
			<aop:after method="release" pointcut-ref="pt1"/>

切入点表达式说明

execution:匹配方法的执行(常用)
execution(表达式)
	表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
	写法说明：
		全匹配方式：
	public void com.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
		访问修饰符可以省略
	void com.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)

		返回值可以使用*号，表示任意返回值
	* com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
		包名可以使用*号，表示任意包，但是有几级包，需要写几个*
				* *.*.*.*.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.*.*(..))

环绕通知

配置方式:
<aop:config>
	<aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))" id="pt1"/>
	<aop:aspect id="txAdvice" ref="txManager">
<!-- 配置环绕通知 -->
		<aop:around method="transactionAround" pointcut-ref="pt1"/>
	</aop:aspect>
</aop:config>
aop:around：
作用：
	用于配置环绕通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
说明：
	它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
	通常情况下，环绕通知都是独立使用

/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
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;
}