Spring简介

Spring体系结构

IOC_控制反转思想

IOC_自定义对象容器

IOC_Spring实现IOC

IOC_Spring容器类型

容器实现类

IOC_对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

IOC_对象的创建策略

IOC_对象的销毁时机

IOC_生命周期方法

IOC_获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

DI_什么是依赖注入

DI_依赖注入方式

Setter注入

构造方法注入

自动注入

DI_依赖注入类型

注入bean类型

注入基本数据类型

注入List集合

注入Set集合

注入Map集合

注入Properties对象

注解实现IOC_准备工作

注解实现IOC_@Component

注解实现IOC_@Repository、@Service、@Controller

注解实现IOC_@Scope

注解实现IOC_@Autowired

注解实现IOC_@Qualifier

注解实现IOC_@Value

注解实现IOC_@Configuration

注解实现IOC_@ComponentScan

注解实现IOC_@PropertySource

注解实现IOC_@Bean

注解实现IOC_@Import

Spring整合MyBatis_搭建环境

创建maven项目，引入依赖。

Spring整合MyBatis_编写配置文件

1、编写数据库配置文件db.properties

Spring整合MyBatis_准备数据库和实体类

准备数据库

准备实体类

Spring整合MyBatis_编写持久层接口和service类

编写持久层接口

编写service类

Spring整合MyBatis_Spring整合Junit进行单元测试

Spring整合MyBatis_自动创建代理对象

SpringAOP_AOP简介

SpringAOP_AOP相关术语

SpringAOP_AOP入门

SpringAOP_通知类型

SpringAOP_切点表达式

SpringAOP_多切面配置

SpringAOP_注解配置AOP

SpringAOP_原生Spring实现AOP

SpringAOP_SchemaBased实现AOP

Spring事务_事务简介

Spring事务_Spring事务管理方案

Spring事务_Spring事务管理器

Spring事务_事务控制的API

Spring事务_事务的相关配置

Spring事务_事务的传播行为

Spring事务_事务的隔离级别

Spring事务_注解配置声明式事务

Spring简介

Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层 SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。 Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：https://spring.io/

Spring体系结构

Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。

1、Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。

2、Data Access/Integration：该模块提供了数据持久化的相应功能。

3、Web：该模块提供了web开发的相应功能。

4、AOP：提供了面向切面编程实现

5、Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。

6、Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。

7、Messaging：为Spring框架集成一些基础的报文传送应用

8、Test：提供与测试框架的集成

IOC_控制反转思想

IOC(Inversion of Control) ：程序将创建对象的权利交给框架。之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：

public interface StudentDao {// 根据id查询学生Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{@Overridepublic Student findById(int id) {// 模拟从数据库查找出学生return new Student(1,"程序员","北京");}
}
public class StudentService {public Student findStudentById(int id){// 此处就是调用者在创建对象StudentDao studentDao = new StudentDaoImpl();return studentDao.findById(1);}
}

这种写法有两个缺点：

1 浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用方法则会创建大量StudentDao对象。

2 代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService 中想使用StudentDaoImpl2，则必须修改源码。

而IOC思想是将创建对象的权利交给框架，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。

IOC_自定义对象容器

接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将对象创建出来放到容器中，需要使用对象时，只需要从容器中获取对象即可，而不需要重新创建，此时容器就是对象的管理者。

创建实体类

public class Student {private int id;private String name;private String address;// 省略getter/setter/构造方法/tostring
}

创建Dao接口和实现类

public interface StudentDao {// 根据id查询学生Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{@Overridepublic Student findById(int id) {// 模拟从数据库查找出学生return new Student(1,"程序员","北京");}
}
public class StudentDaoImpl2 implements StudentDao{@Overridepublic Student findById(int id) {// 模拟根据id查询学生System.out.println("新方法！！！");return new Student(1,"程序员","北京");}
}

创建配置文件bean.properties，该文件中定义管理的对象

studentDao=com.itbaizhan.dao.StudentDaoImpl

创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。

public class Container {static Map<String,Object> map = new HashMap();static {// 读取配置文件InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties");Properties properties = new Properties();try {properties.load(is);} catch (IOException e) {e.printStackTrace();}// 遍历配置文件的所有配置Enumeration<Object> keys = properties.keys();while (keys.hasMoreElements()){String key = keys.nextElement().toString();String value = properties.getProperty(key);try {// 创建对象Object o = Class.forName(value).newInstance();// 将对象放入集合中map.put(key,o);} catch (Exception e) {e.printStackTrace();}}}// 从容器中获取对象public static Object getBean(String key){return map.get(key);}
}

创建Dao对象的调用者StudentService

public class StudentService {public Student findStudentById(int id){// 从容器中获取对象StudentDao studentDao = (StudentDao) Container.getBean("studentDao");System.out.println(studentDao.hashCode());return studentDao.findById(id);}
}

测试StudentService

public class Test {public static void main(String[] args){StudentService studentService = new StudentService();System.out.println(studentService.findStudentById(1));System.out.println(studentService.findStudentById(1));}
}

IOC_Spring实现IOC

接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管理对象。

创建Maven工程，引入依赖

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.13</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency>
</dependencies>

创建POJO类、Dao类和接口

public class Student {private int id;private String name;private String address;// 省略getter/setter/构造方法/tostring
}
public interface StudentDao {// 根据id查询学生Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{@Overridepublic Student findById(int id) {// 模拟从数据库查找出学生return new Student(1,"程序员","北京");}
}

编写xml配置文件，配置文件中配置需要Spring帮我们创建的对象。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>     
</beans>

测试从Spring容器中获取对象。

public class TestContainer {@Testpublic void t1(){// 创建Spring容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");// 从容器获取对象StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao");StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao");System.out.println(studentDao1.hashCode());System.out.println(studentDao2.hashCode());System.out.println(studentDao1.findById(1));}
}

IOC_Spring容器类型容器接口

1、BeanFactory：BeanFactory是Spring容器中的顶层接口，它可以对Bean对象进行管理。

2、ApplicationContext：ApplicationContext是BeanFactory的子接口。它除了继承 BeanFactory的所有功能外，还添加了对国际化、资源访问、事件传播等方面的良好支持。

ApplicationContext有以下三个常用实现类：、

容器实现类

1、ClassPathXmlApplicationContext：该类可以从项目中读取配置文件

2、FileSystemXmlApplicationContext：该类从磁盘中读取配置文件

3、AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解

@Test
public void t2(){// 创建spring容器//       ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\a\\IdeaProjects\\spring_demo\\src\\main\\resources\\bean.xml");// 从容器中获取对象StudentDao userDao = (StudentDao)ac.getBean("studentDao");System.out.println(userDao);System.out.println(userDao.findById(1));
}

IOC_对象的创建方式

Spring会帮助我们创建bean，那么它底层是调用什么方法进行创建的呢？

使用构造方法

Spring默认使用类的空参构造方法创建bean：

// 假如类没有空参构造方法，将无法完成bean的创建
public class StudentDaoImpl implements StudentDao{public StudentDaoImpl(int a){}    @Overridepublic Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}

使用工厂类的方法

Spring可以调用工厂类的方法创建bean：

1、创建工厂类，工厂类提供创建对象的方法：

public class StudentDaoFactory {public StudentDao getStudentDao(){return new StudentDaoImpl(1);}
}

2 在配置文件中配置创建bean的方式为工厂方式。

<!-- id：工厂对象的id，class：工厂类 -->
<bean id="studentDaoFactory" class="com.itbaizhan.dao.StudentDaoFactory"></bean>
<!-- id：bean对象的id，factory-bean：工厂对象 的id，factory-method：工厂方法 -->
<bean id="studentDao" factorybean="studentDaoFactory" factory-method="getStudentDao"></bean>

3 测试

使用工厂类的静态方法

Spring可以调用工厂类的静态方法创建bean：

1 创建工厂类，工厂提供创建对象的静态方法。

public class StudentDaoFactory2 {public static StudentDao getStudentDao2() {return new StudentDaoImpl();}
}

2 在配置文件中配置创建bean的方式为工厂静态方法。

<!-- id:bean的id class:工厂全类名 factory-method:工厂静态方法   -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoFactory2" factory-method="getStudentDao2"></bean>

3 测试

IOC_对象的创建策略

Spring通过配置中的 scope 属性设置对象的创建策略，共有五种创建策略

1、singleton：单例，默认策略。整个项目只会创建一个对象，通过中的 lazy-init 属性可以设置单例对象的创建时机：

lazy-init="false"(默认)：立即创建，在容器启动时会创建配置文件中的所有Bean对象。 lazy-init="true"：延迟创建，第一次使用Bean对象时才会创建。

配置单例策略：

<!--   <bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton" lazy-init="true"> </bean>-->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton" lazy-init="false">
</bean>

测试单例策略：

// 为Bean对象的类添加构造方法
public StudentDaoImpl2(){System.out.println("创建 StudentDao！！！");
}
@Test
public void t2(){// 创建Spring容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");// 从容器获取对象StudentDao studentDao1 = (StudentDao)ac.getBean("studentDao");StudentDao studentDao2 = (StudentDao)ac.getBean("studentDao");StudentDao studentDao3 = (StudentDao)ac.getBean("studentDao");System.out.println(studentDao1.hashCode());System.out.println(studentDao2.hashCode());System.out.println(studentDao3.hashCode());
}

2、prototype：多例，每次从容器中获取时都会创建对象。

<!-- 配置多例策略 -->
<bean id="studentDao"  class="com.itbaizhan.dao.StudentDaoImpl2" scope="prototype"></bean>

3、request：每次请求创建一个对象，只在web环境有效。

4、session：每次会话创建一个对象，只在web环境有效。

5、gloabal-session：一次集群环境的会话创建一个对象，只在web 环境有效。

IOC_对象的销毁时机

对象的创建策略不同，销毁时机也不同：

singleton：对象随着容器的销毁而销毁。

prototype：使用JAVA垃圾回收机制销毁对象。

request：当处理请求结束，bean实例将被销毁。

session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。

gloabal-session：集群环境下的session销毁，bean实例也将被销毁。

IOC_生命周期方法

Bean对象的生命周期包含创建——使用——销毁，Spring可以配置 Bean对象在创建和销毁时自动执行的方法：

1 定义生命周期方法

public class StudentDaoImpl2 implements StudentDao{// 创建时自动执行的方法public void init(){System.out.println("创建StudentDao！！！");}// 销毁时自动执行的方法public void destory(){System.out.println("销毁StudentDao！！！");}
}

2 配置生命周期方法

<!-- init-method:创建对象时执行的方法  destroy-method:销毁对象时执行的方法 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton"init-method="init" destroy-method="destory"></bean>

3 测试

@Test
public void t3(){// 创建Spring容器ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");// 销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法ac.close();
}

IOC_获取Bean对象的方式

Spring有多种获取容器中对象的方式：

通过id/name获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>

获取对象

StudentDao studentDao = (StudentDao) ac.getBean("studentDao");

通过类型获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>

获取对象

StudentDao studentDao2 = ac.getBean(StudentDao.class);

通过类型+id/name获取

虽然使用类型获取不需要强转，但如果在容器中有一个接口的多个实现类对象，则获取时会报错，此时需要使用类型+id/name获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>
<bean name="studentDao1" class="com.itbaizhan.dao.StudentDaoImpl"></bean>

获取对象

StudentDao studentDao2 = ac.getBean("studentDao",StudentDao.class);

DI_什么是依赖注入

依赖注入（Dependency Injection，简称DI），它是Spring控制反转思想的具体实现。控制反转将对象的创建交给了Spring，但是对象中可能会依赖其他对象。比如service类中要有dao类的属性，我们称service依赖于 dao。之前需要手动注入属性值，代码如下：

public interface StudentDao {Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{@Overridepublic Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}
public class StudentService {// service依赖dao，手动注入属性值，即手动维护依赖关系private StudentDao studentDao = new StudentDaoImpl();public Student findStudentById(int id){return studentDao.findById(id);}
}

此时，当StudentService的想要使用StudentDao的另一个实现类如 StudentDaoImpl2时，则需要修改Java源码，造成代码的可维护性降低。而使用Spring框架后，Spring管理Service对象与Dao对象，此时它能够为Service对象注入依赖的Dao属性值。这就是Spring的依赖注入。简单来说，控制反转是创建对象，依赖注入是为对象的属性赋值。

DI_依赖注入方式

在之前开发中，可以通过setter方法或构造方法设置对象属性值：

// setter方法设置属性
StudentService studentService = new StudentService();
StudentDao studentDao = new StudentDao();
studentService.setStudentDao(studentDao);
// 构造方法设置属性
StudentDao studentDao = new StudentDao();
StudentService studentService = new StudentService(studentDao);

Spring可以通过调用setter方法或构造方法给属性赋值

Setter注入

被注入类编写属性的setter方法

public class StudentService {private StudentDao studentDao;public void setStudentDao(StudentDao studentDao) {this.studentDao = studentDao;}
}

配置文件中，给需要注入属性值的<bean> 中设置<property>

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService"><!--依赖注入--><!--name:对象的属性名 ref:容器中对象的id值--><property name="studentDao" ref="studentDao"></property>
</bean>

测试是否注入成功

@Test
public void t2(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");StudentService studentService = (StudentService) ac.getBean("studentService");System.out.println(studentService.findStudentById(1));
}

构造方法注入

被注入类编写有参的构造方法

public class StudentService {private StudentDao studentDao;public StudentService(StudentDao studentDao) {this.studentDao = studentDao;}
}

给需要注入属性值的<bean> 中设置<constructor-arg>

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService"><!-- 依赖注入 --><!-- name:对象的属性名 ref：配置文件中注入对象的id值 --><constructor-arg name="studentDao" ref="studentDao"></constructor-arg>
</bean>

测试是否注入成功

@Test
public void t2(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");StudentService studentService =(StudentService) ac.getBean("studentService");System.out.println(studentService.findStudentById(1));
}

自动注入

自动注入不需要在标签中添加其他标签注入属性值，而是自动从容器中找到相应的bean对象设置为属性值。

测试自动注入：

1、为依赖的对象提供setter和构造方法：

public class StudentService {// 依赖private StudentDao studentDao;// 构造方法public StudentService() { }public StudentService(StudentDao studentDao) {this.studentDao = studentDao;}// setter方法public void setStudentDao(StudentDao studentDao) {this.studentDao = studentDao;}// 调用依赖的方法public Student findStudentById(int id){return studentDao.findById(id);}
}

2、配置自动注入：

<!-- 根据beanId等于属性名自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="byName"></bean>

<!-- 根据bean类型等于属性类型自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="byType"></bean>

<!-- 利用构造方法自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="constructor"></bean>

<!-- 配置全局自动注入 -->
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"default-autowire="constructor">

DI_依赖注入类型

DI支持注入bean类型、基本数据类型和字符串、List集合、Set集合、Map集合、Properties对象类型等，他们的写法如下：

1、准备注入属性的类

public class StudentService {private StudentDao studentDao; // bean属性private String name; //字符串类型private int count; //基本数据类型private List<String> names; // 字符串类型List集合private List<Student> students1; // 对象类型List集合private Set<Student> students2; // 对象类型Set集合private Map<String,String> names2; //字符串类型Map集合private Map<String,Student> students3;// 对象类型Map集合private Properties properties;//Properties类型// 省略getter/setter/toString
}

2、准备测试方法

@Test
public void t3(){ApplicationContext ac = newClassPathXmlApplicationContext("bean.xml");StudentService studentService =(StudentService)ac.getBean("studentService");System.out.println(studentService);
}

注入bean类型

写法一：

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService"><property name="studentDao" ref="studentDao"></property>
</bean>

写法二：

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService"><property name="studentDao" ><ref bean="studentDao"></ref></property>
</bean>

注入基本数据类型

<bean id="studentService" class="com.itbaizhan.service.StudentService"><!-- 写法一 name：属性名 value：属性值--><property name="name" value="百百">
</property><!-- 写法二 name：属性名 value：属性值--><property name="count"><value>10</value></property>
</bean>

注入List集合

<bean id="studentService"
class="com.itbaizhan.service.StudentService"><!-- 简单数据类型List集合 name：属性名 --><property name="names"><list><value>强学堂</value><value>程序员</value></list></property><!-- 对象类型List集合 name：属性名 --><property name="students1"><list><bean class="com.itbaizhan.domain.Student"><property name="id" value="1"/><property name="name" value="强学堂"/><property name="address" value="北京"/></bean><bean class="com.itbaizhan.domain.Student"><property name="id" value="2"/><property name="name" value="百战不败"/><property name="address" value="北京"/></bean></list></property>
</bean>

注入Set集合

<bean id="studentService" class="com.itbaizhan.service.StudentService"><!-- Set集合 --><property name="students2"><set><bean class="com.itbaizhan.domain.Student"><property name="id" value="1"/><property name="name" value="强学堂"/><property name="address" value="北京"/></bean><bean class="com.itbaizhan.domain.Student"><property name="id" value="2"/><property name="name" value="百战不败"/><property name="address" value="北京"/></bean></set></property>
</bean>

注入Map集合

简单数据类型Map集合：

<bean id="studentService" class="com.itbaizhan.service.StudentService"><property name="names2"><map><entry key="student1" value="bz"/><entry key="student2" value="sxt"/></map></property>
</bean>

对象类型Map集合：

<bean id="studentService" class="com.itbaizhan.service.StudentService"><property name="students3"><map><entry key="student1" value-ref="s1"/><entry key="student2" value-ref="s2"/></map></property>
</bean>
<bean id="s1" class="com.itbaizhan.domain.Student"><property name="id" value="1"/><property name="name" value="强学堂"/><property name="address" value="北京"/>
</bean>
<bean id="s2" class="com.itbaizhan.domain.Student"><property name="id" value="2"/><property name="name" value="百战不败"/><property name="address" value="北京"/>
</bean>

注入Properties对象

<bean id="studentService" class="com.itbaizhan.service.StudentService"><property name="properties"><props><prop key="配置1">值1</prop><prop key="配置2">值2</prop></props></property>
</bean>

注解实现IOC_准备工作

注解配置和xml配置对于Spring的IOC要实现的功能都是一样的，只是配置的形式不一样。

准备工作

1 创建一个新的Spring项目。

2 编写pojo，dao，service类。

3 编写空的配置文件，如果想让该文件支持注解，需要添加新的约束：

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">
</beans>

注解实现IOC_@Component

作用：用于创建对象，放入Spring容器，相当于

位置：类上方

注意：

1、要在配置文件中配置扫描的包，扫描到该注解才能生效。
<context:component-scan base-package="com.itbaizhan"></context:component-scan>
2、@Component 注解配置bean的默认id是首字母小写的类名。也可以手动设置bean的id值。
// 此时bean的id为studentDaoImpl
@Component
public class StudentDaoImpl implements StudentDao{public Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}
// 此时bean的id为studentDao
@Component("studentDao")
public class StudentDaoImpl implements StudentDao{public Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}

注解实现IOC_@Repository、@Service、@Controller

作用：这三个注解和@Component的作用一样，使用它们是为了区分该类属于什么层。

位置：

1、@Repository用于Dao层

2、@Service用于Service层

3、@Controller用于Controller层

@Repository
public class StudentDaoImpl implements StudentDao{}
@Service
public class StudentService {}

注解实现IOC_@Scope

作用：指定bean的创建策略

位置：类上方

取值：singleton prototype request session globalsession
@Service
@Scope("singleton")
public class StudentService {}

注解实现IOC_@Autowired

作用：从容器中查找符合属性类型的对象自动注入属性中。用于代替<bean> 中的依赖注入配置。

位置：属性上方、setter方法上方、构造方法上方。

注意：

1、@Autowired 写在属性上方进行依赖注入时，可以省略setter方法。

@Component
public class StudentService {@Autowiredprivate StudentDao studentDao;public Student findStudentById(int id){return studentDao.findById(id);}
}
@Test
public void t2(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");StudentService studentService =(StudentService)ac.getBean("studentService");System.out.println(studentService.findStudentById(1));
}

2、容器中没有对应类型的对象会报错

// 如果StudentDaoImpl没有放到容器中会报错
//@Component("studentDao")
public class StudentDaoImpl implements StudentDao{public Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}

3 、容器中有多个对象匹配类型时，会找beanId等于属性名的对象，找不到会报错。

// 如果容器中都多个同类型对象，会根据id值等于属性
名找对象
@Component("studentDao")
public class StudentDaoImpl implements StudentDao{public Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}
@Component
public class StudentDaoImpl implements StudentDao{public Student findById(int id) {// 模拟根据id查询学生return new Student(1,"程序员","北京");}
}

注解实现IOC_@Qualifier

作用：在按照类型注入对象的基础上，再按照bean的id注入。

位置：属性上方

注意：@Qualifier必须和@Autowired一起使用。

@Component
public class StudentService {@Autowired@Qualifier("studentDaoImpl2")private StudentDao studentDao;public Student findStudentById(int id){return studentDao.findById(id);}
}

注解实现IOC_@Value

作用：注入String类型和基本数据类型的属性值。

位置：属性上方

用法：

1 、直接设置固定的属性值
@Service
public class StudentService {@Value("1")private int count;@Value("hello")private String str;
}
2 、获取配置文件中的属性值：

2.1 、编写配置文件db.properties
jdbc.username=root
jdbc.password01=123456
2.2、spring核心配置文件扫描配置文件
<context:property-placeholder location="db.properties">
</context:property-placeholder>
2.3 注入配置文件中的属性值
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;

注解实现IOC_@Configuration

此时基于注解的IOC配置已经完成，但是我们依然离不开Spring的 xml配置文件。接下来我们脱离bean.xml，使用纯注解实现IOC。

在真实开发中，我们一般还是会保留xml配置文件，很多情况下使用配置文件更加方便。

纯注解实现IOC需要一个Java类代替xml文件。这个Java类上方需要添加@Configuration，表示该类是一个配置类，作用是代替配置文件。

@Configuration
public class SpringConfig {  
}

注解实现IOC_@ComponentScan

作用：指定spring在初始化容器时扫描的包。

位置：配置类上方
@Configuration
@ComponentScan("com.itbaizhan")public class SpringConfig { }

注解实现IOC_@PropertySource

作用：代替配置文件中的<context:property-placeholder> 扫描配置文件

位置：配置类上方

注意：配置文件位置前要加关键字 classpath

@Configuration
@PropertySource("classpath:db.properties")
public class JdbcConfig {@Value("${jdbc.username}")private String username;@Value("${jdbc.password}")private String password;
}

注解实现IOC_@Bean

作用：将方法的返回值对象放入Spring容器中。如果想将第三方类的对象放入容器，可以使用@Bean

位置：配置类的方法上方。

属性：name：给bean对象设置id

注意：@Bean修饰的方法如果有参数，spring会根据参数类型从容器中查找可用对象。

举例：如果想将jdbc连接对象放入Spring容器，我们无法修改 Connection源码添加@Component，此时就需要使用将@Bean该对象放入Spring容器

1 、添加驱动依赖
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.27</version>
</dependency>
2、将Connection对象放入Spring容器
@Bean(name = "connection")
public Connection getConnection(){try {Class.forName("com.mysql.cj.jdbc.Driver");returnDriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");} catch (Exception exception) {return null;}
}
3、测试
@Test
public void t5(){ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);Connection connection = (Connection)ac.getBean("connection");System.out.println(connection);
}

注解实现IOC_@Import

作用：如果配置过多，会有多个配置类，该注解可以为主配置类导入其他配置类

位置：主配置类上方

// Jdbc配置类
@Configuration
public class JdbcConfig {@Bean(name = "connection")public Connection getConnection(){try {Class.forName("com.mysql.cj.jdbc.Driver");return DriverManager.getConnection("jdbc:mysql:///mysql", "root", "root");} catch (Exception exception) {return null;}}
}
// 主配置类
@Configuration
@ComponentScan("com.itbaizhan")
@Import(JdbcConfig.class)
public class SpringConfig { }

Spring整合MyBatis_搭建环境

我们知道使用MyBatis时需要写大量创建 SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession等对象的代码，而Spring的作用是帮助我们创建和管理对象，所以我们可以使用Spring整合MyBatis，简化MyBatis开发。

创建maven项目，引入依赖。

<dependencies><!-- mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version></dependency><!-- mysql驱动包 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.26</version></dependency><!-- spring --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.13</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.3.13</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.13</version></dependency><!-- MyBatis与Spring的整合包，该包可以让Spring创建MyBatis的对象 --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.6</version></dependency>
</dependencies>

Spring整合MyBatis_编写配置文件

1、编写数据库配置文件db.properties

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///student
jdbc.username = root
jdbc.password01 = root

2、创建MyBatis配置文件SqlMapConfig.xml，数据源、扫描接口都交由Spring管理，不需要在MyBatis配置文件中设置。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
</configuration>

3、创建Spring配置文件applicationContext.xml

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 包扫描 --><context:component-scan base-package="com.itbaizhan"></context:component-scan><!-- 读取配置文件 --><context:property-placeholder location="classpath:db.properties"></context:property-placeholder><!-- 创建druid数据源对象 --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driverClassName}"></property><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property></bean><!-- Spring创建封装过的SqlSessionFactory--><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"></property></bean><!-- Spring创建封装过的SqlSession --><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"><constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/></bean>
</beans>

Spring整合MyBatis_准备数据库和实体类

准备数据库

CREATE DATABASE `student`;
USE `student`;
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(255) DEFAULT NULL,`sex` varchar(10) DEFAULT NULL,`address` varchar(255) DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into
`student`(`id`,`name`,`sex`,`address`)
values (1,'程序员','男','北京'),(2,'北京学堂','女','北京');

准备实体类

public class Student {private int id;private String name;private String sex;private String address;// 省略构造方法/getter/setter/tostring
}

Spring整合MyBatis_编写持久层接口和service类

编写持久层接口

@Repository
public interface StudentDao {// 查询所有学生@Select("select * from student")List<Student> findAll();// 添加学生@Insert("insert into student values(null,#{name},#{sex},#{address})")void add(Student student);
}

编写service类

@Service
public class StudentService {// SqlSession对象@Autowiredprivate SqlSessionTemplate sqlSession;// 使用SqlSession获取代理对象public List<Student> findAllStudent(){StudentDao studentDao = sqlSession.getMapper(StudentDao.class);return studentDao.findAll();}
}

Spring整合MyBatis_Spring整合Junit进行单元测试

之前进行单元测试时都需要手动创建Spring容器，能否在测试时让 Spring自动创建容器呢？

1 、引入Junit和Spring整合Junit依赖

<!-- junit,如果Spring5整合junit，则junit版本
至少在4.12以上 -->
<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope>
</dependency>
<!-- spring整合测试模块 -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.3.13</version>
</dependency>

2 、编写测试类

// JUnit使用Spring方式运行代码，即自动创建spring容器。
@RunWith(SpringJUnit4ClassRunner.class)
// 告知创建spring容器时读取哪个配置类或配置文件
// 配置类写法：
@ContextConfiguration(classes=配置类.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest {@Autowiredprivate StudentService studentService;@Testpublic void testFindAll(){List<Student> allStudent = studentService.findAllStudent();allStudent.forEach(System.out::println);}
}

注：使用SqlSessionTemplate创建代理对象还是需要注册接口或者映射文件的。

1、在MyBatis配置文件注册接口
<configuration><mappers><mapper class="com.itbaizhan.dao.StudentDao"></mapper></mappers>
</configuration>
2、创建sqlSessionFactory时指定MyBatis配置文件

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"></property><property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
</bean>

Spring整合MyBatis_自动创建代理对象

Spring提供了MapperScannerConfigurer对象，该对象可以自动扫描包创建代理对象，并将代理对象放入容器中，此时不需要使用 SqlSession手动创建代理对象。

1、创建MapperScannerConfigurer对象

<!-- 该对象可以自动扫描持久层接口，并为接口创建代理对象 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer"><!-- 配置扫描的接口包 --><property name="basePackage" value="com.itbaizhan.dao"></property>
</bean>

2、Service类直接使用代理对象即可

@Service
public class StudentService {// 直接注入代理对象@Autowiredprivate StudentDao studentDao;// 直接使用代理对象public void addStudent(Student student){studentDao.add(student);}
}

3、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath :applicationContext.xml")
public class StudentServiceTest {@Autowiredprivate StudentService studentService;@Testpublic void testAdd(){Student student = new Student(0, "百战不败", "男", "上海");studentService.addStudent(student);}
}

SpringAOP_AOP简介

AOP的全称是Aspect Oriented Programming，即面向切面编程。是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

作用：在不修改源码的基础上，对已有方法进行增强。

实现原理：动态代理技术。

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

应用场景：事务处理、日志管理、权限控制、异常处理等方面。

SpringAOP_AOP相关术语

为了更好地理解AOP，就需要对AOP的相关术语有一些了解

SpringAOP_AOP入门

AspectJ是一个基于Java语言的AOP框架，在Spring框架中建议使用 AspectJ实现AOP。

接下来我们写一个AOP入门案例：dao层的每个方法结束后都可以打印一条日志：

1、引入依赖

<!-- spring -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.13</version>
</dependency><!-- AspectJ -->
<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.7</version>
</dependency><!-- junit -->
<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope>
</dependency>

2、编写连接点

@Repository
public class UserDao {public void add(){System.out.println("用户新增");}public void delete(){System.out.println("用户删除");}public void update(){System.out.println("用户修改");}
}

3、编写通知类

public class MyAspectJAdvice {// 后置通知public void myAfterReturning() {System.out.println("打印日志...");}
}

4、配置切面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><context:component-scan base-package="com.itbaizhan"></context:component-scan><!-- 通知对象 --><bean id="myAspectJAdvice" class="com.itbaizhan.advice.MyAspectAdvice"></bean><!-- 配置AOP --><aop:config><!-- 配置切面 --><aop:aspect ref="myAspectJAdvice"><!-- 配置切点 --><aop:pointcut id="myPointcut" expression="execution(* com.itbaizhan.dao.UserDao.*(..))"/><!-- 配置通知 --><aop:after-returning method="myAfterReturning" pointcutref="myPointcut"/></aop:aspect></aop:config>
</beans>

5、测试

public class UserDaoTest {@Testpublic void testAdd(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");UserDao userDao = (UserDao) ac.getBean("userDao");userDao.add();}@Testpublic void testDelete(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");UserDao userDao = (UserDao)ac.getBean("userDao");userDao.delete();}@Testpublic void testUpdate(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");UserDao userDao = (UserDao) ac.getBean("userDao");userDao.update();}
}

SpringAOP_通知类型

AOP有以下几种常用的通知类型：

1、编写通知方法

// 通知类
public class MyAspectAdvice {// 后置通知public void myAfterReturning(JoinPoint joinPoint) {System.out.println("切点方法名：" + joinPoint.getSignature().getName());System.out.println("目标对象：" + joinPoint.getTarget());System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");}// 前置通知public void myBefore() {System.out.println("前置通知...");}// 异常通知public void myAfterThrowing(Exception ex) {System.out.println("异常通知...");System.err.println(ex.getMessage());}// 最终通知public void myAfter() {System.out.println("最终通知");}// 环绕通知public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕前");Object obj = proceedingJoinPoint.proceed(); // 执行方法System.out.println("环绕后");return obj;}
}

2、配置切面

<!-- 配置AOP -->
<aop:config><!-- 配置切面 --><aop:aspect ref="myAspectJAdvice"><!-- 配置切点 --><aop:pointcut id="myPointcut" expression="execution(* com.itbaizhan.dao.UserDao.*(..))"/><!-- 前置通知 --><aop:before method="myBefore" pointcut-ref="myPointcut"></aop:before><!-- 后置通知 --><aop:after-returning method="myAfterReturning" pointcutref="myPointcut"/><!-- 异常通知 --><aop:after-throwing method="myAfterThrowing" pointcutref="myPointcut" throwing="ex"/><!-- 最终通知 --><aop:after method="myAfter" pointcut-ref="myPointcut"></aop:after><!-- 环绕通知 --><aop:around method="myAround" pointcut-ref="myPointcut"></aop:around></aop:aspect>
</aop:config>

SpringAOP_切点表达式

使用AspectJ需要使用切点表达式配置切点位置，写法如下：

1、标准写法：访问修饰符返回值包名.类名.方法名(参数列表)

2、访问修饰符可以省略。

3、返回值使用 * 代表任意类型。

4、包名使用 * 表示任意包，多级包结构要写多个 * ，使用 *.. 表示任意包结构

5、类名和方法名都可以用 * 实现通配。

6、参数列表
基本数据类型直接写类型
引用类型写 包名.类名
* 表示匹配一个任意类型参数
.. 表示匹配任意类型任意个数的参数
7、全通配： * *..*.*(..)

SpringAOP_多切面配置

我们可以为切点配置多个通知，形成多切面，比如希望dao层的每个方法结束后都可以打印日志并发送邮件：

1、编写发送邮件的通知：

public class MyAspectJAdvice2 {// 后置通知public void myAfterReturning(JoinPoint joinPoint) {System.out.println("发送邮件");}
}

2、配置切面：

<!-- 通知对象 -->
<bean id="myAspectJAdvice" class="com.itbaizhan.advice.MyAspectAdvice"></bean>
<bean id="myAspectJAdvice2" class="com.itbaizhan.advice.MyAspectAdvice2"></bean>
<!-- 配置AOP -->
<aop:config><!-- 配置切面 --><aop:aspect ref="myAspectJAdvice"><!-- 配置切点 --><aop:pointcut id="myPointcut" expression="execution(* *..*.*(..))"/><!-- 后置通知 --><aop:after-returning method="myAfterReturning" pointcutref="myPointcut"/></aop:aspect><aop:aspect ref="myAspectJAdvice2"><aop:pointcut id="myPointcut2" expression="execution(*com.itbaizhan.dao.UserDao.*(..))"/><aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut2"/></aop:aspect>
</aop:config>

SpringAOP_注解配置AOP

Spring可以使用注解代替配置文件配置切面：

1、在xml中开启AOP注解支持

<!-- 开启注解配置Aop -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

2、在通知类上方加入注解 @Aspect

3、在通知方法上方加入注解

@Before/@AfterReturning/@AfterThrowing/@After/@Around

@Aspect
@Component
public class MyAspectAdvice {// 后置通知@AfterReturning("execution(* com.itbaizhan.dao.UserDao.*(..))")public void myAfterReturning(JoinPoint joinPoint) {System.out.println("切点方法名：" + joinPoint.getSignature().getName());System.out.println("目标对象：" + joinPoint.getTarget());System.out.println("打印日志" + joinPoint.getSignature().getName() + "方法被执行了！");}// 前置通知@Before("execution(* com.itbaizhan.dao.UserDao.*(..))")public void myBefore() {System.out.println("前置通知...");}// 异常通知@AfterThrowing(value = "execution(* com.itbaizhan.dao.UserDao.*(..))",throwing = "ex")public void myAfterThrowing(Exception ex) {System.out.println("异常通知...");System.err.println(ex.getMessage());}// 最终通知@After("execution(* com.itbaizhan.dao.UserDao.*(..))")public void myAfter() {System.out.println("最终通知");}// 环绕通知@Around("execution(* com.itbaizhan.dao.UserDao.*(..))")public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("环绕前");Object obj = proceedingJoinPoint.proceed(); // 执行方法System.out.println("环绕后");return obj;}
}

4、测试：

@Test
public void testAdd2(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");UserDao userDao = (UserDao) ac.getBean("userDao");userDao.update();
}

如何为一个类下的所有方法统一配置切点：

1、在通知类中添加方法配置切点
@Pointcut("execution(* com.itbaizhan.dao.UserDao.*(..))")
public void pointCut(){}
2、在通知方法上使用定义好的切点
@Before("pointCut()")
public void myBefore(JoinPoint joinPoint) {System.out.println("前置通知...");
}
@AfterReturning("pointCut()")
public void myAfterReturning(JoinPoint joinPoint) {System.out.println("后置通知...");
}
配置类如何代替xml中AOP注解支持？

在配置类上方添加@EnableAspectJAutoProxy即可
@Configuration
@ComponentScan("com.itbaizhan")
@EnableAspectJAutoProxy
public class SpringConfig {
}

SpringAOP_原生Spring实现AOP

除了AspectJ，Spring支持原生方式实现AOP。

1、引入依赖

<!-- AOP -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.13</version>
</dependency>

2、编写通知类

// Spring原生Aop的通知类
public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice,
ThrowsAdvice, MethodInterceptor {/*** 前置通知* @param method 目标方法* @param args 目标方法的参数列表* @param target 目标对象* @throws Throwable*/@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("前置通知");}/*** 后置通知* @param returnValue 目标方法的返回值* @param method 目标方法* @param args 目标方法的参数列表* @param target 目标对象* @throws Throwable*/@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("后置通知");}/*** 环绕通知* @param invocation 目标方法* @return* @throws Throwable*/@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("环绕前");Object proceed = invocation.proceed();System.out.println("环绕后");return proceed;}/*** 异常通知* @param ex 异常对象*/public void afterThrowing(Exception ex){System.out.println("发生异常了！");}
}

Spring原生方式实现AOP时，只支持四种通知类型：

3、编写配置类

<!-- 通知对象 -->
<bean id="springAop" class="com.itbaizhan.advice.SpringAop"></bean>
<!-- 配置代理对象 -->
<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"><!-- 配置目标对象 --><property name="target" ref="userDao"></property><!-- 配置通知 --><property name="interceptorNames"><list><value>springAop</value></list></property><!-- 代理对象的生成方式 true：使用CGLib false：使用原生JDK生成--><property name="proxyTargetClass" value="true"></property>
</bean>

4、编写测试类

public class UserDaoTest2 {@Testpublic void testAdd(){ApplicationContext ac = new ClassPathXmlApplicationContext("bean2.xml");UserDao userDao = (UserDao) ac.getBean("userDaoProxy"); // 获取的是代理对象userDao.update();}
}

SpringAOP_SchemaBased实现AOP

SchemaBased(基础模式)配置方式是指使用Spring原生方式定义通知，而使用AspectJ框架配置切面。

1、编写通知类

public class SpringAop implements MethodBeforeAdvice, AfterReturningAdvice,ThrowsAdvice, MethodInterceptor {/*** 前置通知* @param method 目标方法* @param args 目标方法的参数列表* @param target 目标对象* @throws Throwable*/@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("前置通知");}/*** 后置通知* @param returnValue 目标方法的返回值* @param method 目标方法* @param args 目标方法的参数列表* @param target 目标对象* @throws Throwable*/@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("后置通知");}/*** 环绕通知* @param invocation 目标方法* @return* @throws Throwable*/@Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {System.out.println("环绕前");Object proceed = invocation.proceed();System.out.println("环绕后");return proceed;}/*** 异常通知* @param ex 异常对象*/public void afterThrowing(Exception ex){System.out.println("发生异常了！");}
}

2、配置切面

<!-- 通知对象 -->
<bean id="springAop2" class="com.itbaizhan.aop.SpringAop2"/>
<!-- 配置切面 -->
<aop:config><!-- 配置切点--><aop:pointcut id="myPointcut" expression="execution(* com.itbaizhan.dao.UserDao.*(..))"/><!-- 配置切面：advice-ref：通知对象 pointcut-ref：切点 --><aop:advisor advice-ref="springAop2" pointcut-ref="myPointcut"/>
</aop:config>

3、测试

@Test
public void t6(){ApplicationContext ac = new ClassPathXmlApplicationContext("aop3.xml");UserDao userDao = (UserDao) ac.getBean("userDao");userDao.add();
}

Spring事务_事务简介

事务：不可分割的原子操作。即一系列的操作要么同时成功，要么同时失败。

开发过程中，事务管理一般在service层，service层中可能会操作多次数据库，这些操作是不可分割的。否则当程序报错时，可能会造成数据异常。

如：张三给李四转账时，需要两次操作数据库：张三存款减少、李四存款增加。如果这两次数据库操作间出现异常，则会造成数据错误。

1、准备数据库

CREATE DATABASE `spring` ;
USE `spring`;
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (`id` int(11) NOT NULL AUTO_INCREMENT,`username` varchar(255) DEFAULT NULL,`balance` double DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
CHARSET=utf8;
insert  into `account`(`id`,`username`,`balance`) values (1,'张三',1000),(2,'李四',1000);

2、创建maven项目，引入依赖

<dependencies><!-- mybatis --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version></dependency><!-- mysql驱动包 --><dependency><groupId>mysql</groupId><artifactId>mysql-connectorjava</artifactId><version>8.0.26</version></dependency><!-- druid连接池 --><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.2.8</version></dependency><!-- spring --><dependency><groupId>org.springframework</groupId><artifactId>springcontext</artifactId><version>5.3.13</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.3.13</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>springjdbc</artifactId><version>5.3.13</version></dependency><!-- MyBatis与Spring的整合包，该包可以让Spring创建MyBatis的对象 --><dependency><groupId>org.mybatis</groupId><artifactId>mybatisspring</artifactId><version>2.0.6</version></dependency><!-- junit,如果Spring5整合junit，则junit版本至少在4.12以上 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!-- spring整合测试模块 --><dependency><groupId>org.springframework</groupId><artifactId>springtest</artifactId><version>5.3.13</version><scope>test</scope></dependency>
</dependencies>

3、创建配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 包扫描 --><context:component-scan basepackage="com.itbaizhan"></context:component-scan><!-- 创建druid数据源对象 --><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="url" value="jdbc:mysql:///spring"></property><property name="username" value="root"></property><property name="password" value="root"></property></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"></property></bean><bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="com.itbaizhan.dao"></property></bean>
</beans>

4、编写Java代码

// 账户
public class Account {private int id; // 账号private String username; // 用户名private double balance; // 余额// 省略getter/setter/tostring/构造方法
}@Repository
public interface AccountDao {// 根据id查找用户@Select("select * from account where id = #{id}")Account findById(int id);// 修改用户@Update("update account set balance = #{balance} where id = #{id}")void update(Account account);
}@Service
public class AccountService {@Autowiredprivate AccountDao accountDao;/*** 转账* @param id1 转出人id* @param id2 转入人id* @param price 金额*/public void transfer(int id1, int id2, double price) {// 转出人减少余额Account account1 = accountDao.findById(id1);account1.setBalance(account1.getBalance()-price);accountDao.update(account1);int i = 1/0; // 模拟程序出错// 转入人增加余额Account account2 = accountDao.findById(id2);account2.setBalance(account2.getBalance()+price);accountDao.update(account2);}
}

5、测试转账

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath :applicationContext.xml")
public class AccountServiceTest {@Autowiredprivate AccountService accountService;@Testpublic void testTransfer(){accountService.transfer(1,2,500);}
}

此时没有事务管理，会造成张三的余额减少，而李四的余额并没有增加。所以事务处理位于业务层，即一个service方法是不能分割的。

Spring事务_Spring事务管理方案

在service层手动添加事务可以解决该问题：

@Autowired
private SqlSessionTemplate sqlSession;
public void transfer(int id1, int id2,double price) {try{// account1修改余额Account account1 = accountDao.findById(id1);account1.setBalance(account1.getBalance()- price);accountDao.update(account1);int i = 1/0; // 模拟转账出错// account2修改余额Account account2 = accountDao.findById(id2);account2.setBalance(account2.getBalance()+price);accountDao.update(account2);  sqlSession.commit();}catch(Exception ex){sqlSession.rollback();}
}

但在Spring管理下不允许手动提交和回滚事务。此时我们需要使用 Spring的事务管理方案，在Spring框架中提供了两种事务管理方案：

1 编程式事务：通过编写代码实现事务管理。

2 声明式事务：基于AOP技术实现事务管理。

在Spring框架中，编程式事务管理很少使用，我们对声明式事务管理进行详细学习。 Spring的声明式事务管理在底层采用了AOP技术，其最大的优点在于无需通过编程的方式管理事务，只需要在配置文件中进行相关的规则声明，就可以将事务规则应用到业务逻辑中。

使用AOP技术为service方法添加如下通知：

Spring事务_Spring事务管理器

Spring依赖事务管理器进行事务管理，事务管理器即一个通知类，我们为该通知类设置切点为service层方法即可完成事务自动管理。由于不同技术操作数据库，进行事务操作的方法不同。如：JDBC提交事务是 connection.commit() ，MyBatis提交事务是 sqlSession.commit() ，所以 Spring提供了多个事务管理器。

我们使用MyBatis操作数据库，接下来使用 DataSourceTransactionManager 进行事务管理。

1、引入依赖

<!-- 事务管理 -->
<dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.3.13</version>
</dependency>
<!-- AspectJ -->
<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.7</version>
</dependency>

2、在配置文件中引入约束

xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd

3、进行事务配置

<!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 进行事务相关配置 -->
<tx:advice id = "txAdvice"><tx:attributes><tx:method name="*"/></tx:attributes>
</tx:advice>
<!-- 配置切面 -->
<aop:config><!-- 配置切点 --><aop:pointcut id="pointcut" expression="execution(* com.itbaizhan.service.*.*(..))"/><!-- 配置通知 --><aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
</aop:config>

Spring事务_事务控制的API

Spring进行事务控制的功能是由三个接口提供的，这三个接口是 Spring实现的，在开发中我们很少使用到，只需要了解他们的作用即可：

PlatformTransactionManager接口

PlatformTransactionManager是Spring提供的事务管理器接口，所有事务管理器都实现了该接口。该接口中提供了三个事务操作方法：

1、TransactionStatus getTransaction（TransactionDefinition definition）：获取事务状态信息。

2、void commit（TransactionStatus status）：事务提交

3、void rollback（TransactionStatus status）：事务回滚

TransactionDefinition接口

TransactionDefinition是事务的定义信息对象，它有如下方法：

String getName()：获取事务对象名称。

int getIsolationLevel()：获取事务的隔离级别。

int getPropagationBehavior()：获取事务的传播行为。

int getTimeout()：获取事务的超时时间。

boolean isReadOnly()：获取事务是否只读。

TransactionStatus接口

TransactionStatus是事务的状态接口，它描述了某一时间点上事务的状态信息。它有如下方法：

void flush() 刷新事务

boolean hasSavepoint() 获取是否存在保存点

boolean isCompleted() 获取事务是否完成

boolean isNewTransaction() 获取是否是新事务

boolean isRollbackOnly() 获取是否回滚

void setRollbackOnly() 设置事务回滚

Spring事务_事务的相关配置

在<tx:advice> 中可以进行事务的相关配置：

<tx:advice id="txAdvice"><tx:attributes><tx:method name="*"/><tx:method name="find*" readonly="true"/></tx:attributes>
</tx:advice>

Spring事务_事务的传播行为

事务传播行为是指多个含有事务的方法相互调用时，事务如何在这些方法间传播。如果在service层的方法中调用了其他的service方法，假设每次执行 service方法都要开启事务，此时就无法保证外层方法和内层方法处于同一个事务当中。
// method1的所有方法在同一个事务中
public void method1(){// 此时会开启一个新事务，这就无法保证method1()中所有的代码是在同一个事务中method2();System.out.println("method1");
}
public void method2(){System.out.println("method2");
}
事务的传播特性就是解决这个问题的，Spring帮助我们将外层方法和内层方法放入同一事务中。

Spring事务_事务的隔离级别

事务隔离级别反映事务提交并发访问时的处理态度，隔离级别越高，数据出问题的可能性越低，但效率也会越低。

Spring事务_注解配置声明式事务

Spring支持使用注解配置声明式事务。用法如下：

1、注册事务注解驱动

<!-- 注册事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

2、在需要事务支持的方法或类上加@Transactional

 @Service
// 作用于类上时，该类的所有public方法将都具有该类型的事务属性
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
public class AccountService {@Autowiredprivate AccountDao accountDao;/*** 转账* @param id1 转出人id* @param id2 转入人id* @param price 金额*/// 作用于方法上时，该方法将都具有该类型的事务属性@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)public void transfer(int id1, int id2,double price) {// account1修改余额Account account1 = accountDao.findById(id1);account1.setBalance(account1.getBalance()-price);accountDao.update(account1);int i = 1/0; // 模拟转账出错// account2修改余额Account account2 = accountDao.findById(id2);account2.setBalance(account2.getBalance()+price);accountDao.update(account2);}
}

3 配置类代替xml中的注解事务支持：在配置类上方写 @EnableTranscationManagement

@Configuration
@ComponentScan("com.itbaizhan")
@EnableTransactionManagement
public class SpringConfig {@Beanpublic DataSource getDataSource(){DruidDataSource druidDataSource = new DruidDataSource();druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");druidDataSource.setUrl("jdbc:mysql:///spring");druidDataSource.setUsername("root");druidDataSource.setPassword("root");return druidDataSource;
}@Beanpublic SqlSessionFactoryBean getSqlSession(DataSource dataSource){SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();sqlSessionFactoryBean.setDataSource(dataSource);return sqlSessionFactoryBean;}@Beanpublic MapperScannerConfigurer getMapperScanner(){MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();mapperScannerConfigurer.setBasePackage("com.itbaizhan.dao");return mapperScannerConfigurer;}@Beanpublic DataSourceTransactionManager getTransactionManager(DataSource dataSource){DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();dataSourceTransactionManager.setDataSource(dataSource);return dataSourceTransactionManager;}
}