Spring笔记
一、Spring概述
1.1、Spring框架是什么
Spring框架是可以在JavaSE/EE中使用的轻量级开源框架，目的是为了解决企业应用开发的复杂性而创建的，Spring的核心是控制反转（IoC）和面向切面编程（AOP）。
Spring的主要作用就是为代码 “解耦”，降低代码间的耦合度，就是让对象和对象（模块和模块）之间的关系不是使用代码关联，而是通过配置来说明。Spring根据代码的功能特点，使用IoC降低业务对象之间的耦合度。IoC使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由Spring容器统一管理，自动“注入”，即赋值。而AOP使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂‘到主业务逻辑中了，而是由Spring容器统一完成"织入"。
1.2、Spring体系结构
Spring框架至今已集成了20多个模块，这些模块分布在核心容器（Core Container）、数据访问/集成（Data Access/Integration）层、Web层、AOP（Aspect Oriented Programming，面向切面的编程）模块、植入（Instrumentation）模块、消息传输（Messaging）和测试（Test）模块中。
二、Spring IoC
2.1、Spring IoC的基本概念
控制反转（Inversion of Control，IoC）是一个比较抽象的概念，是一种思想，是Spring框架的核心，目的是减少对代码的改动，实现解耦合。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。其实现方式很多，当前应用较为广泛的实现方式是依赖注入。
控制：创建对象，给对象的属性赋值，对象之间的关系管理。
反转：把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。由容器代替开发人员管理对象，创建对象。
正转：由开发人员在代码中，使用new构造方法创建对象，开发人员主动管理对象。
依赖：类A中含有类B的实例，在类A中调用类B的方法完成功能，即类A对类B有依赖。
依赖注入：（Dependency In jection，DI），只需要在程序中提供要使用的对象名称就可以，至于对象如何在容器中创建，赋值，查找都由容器内部实现。Spring是使用的DI实现了IoC的功能，Spring底层创建对象，使用的是反射机制。
Java中创建对象的方式：1、构造方法，new对象；2、反射；3、序列化；4、克隆；5、IoC，容器创建对象；6、动态代理。
IoC的体现：之前学习过的JavaWeb中的Servlet。1、创建类继承HttpServlet；2、在web.xml注册Servlet，使用<servlet-name>，<servlet-class>标签；3、没有创建Servlet对象，没有new XxxServlet()；4、Servlet是Tomcat服务器为你创建的，Tomcat也称为容器。Tomcat作为容器，里面存放着Servlet对象，Listener、Filter对象。
2.2、Spring的第一个程序
使用maven工具来完成。
定义接口和实体类：
代码语言：javascript复制public interface SomeService {
void doSome();
}
//实体类:
public class SomeServiceImpl implements SomeService {
public SomeServiceImpl() {
System.out.println("SomeServiceImpl类的无参构造方法执行了！");
}
@Override
public void doSome() {
System.out.println("执行了SomeServiceImpl的doSome方法");
}
}创建spring配置文件：
在src/main/resource/目录下创建一个xml文件，文件名可以随意，推荐使用application Context。spring配置中需要加入约束文件才能正常使用，约束文件是xsd扩展名。
代码语言：javascript复制<?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/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--告诉Spring创建对象
声明bean：就是告诉spring要创建某个类的对象
id：对象的自定义名称，唯一值，spring通过这个名称找到对象,bean与Bean之间的依赖关系也是通过id属性关联
class：类的全限定名称（不能是接口，因为spring是通过反射机制创建对象，必须使用类）
spring就完成 SomeServiceImpl service = new SomeServiceImpl();
spring是把创建好的对象放到map中，spring框架内部有一个map存放对象的
springMap.put(id的值，对象);
一个bean标签声明一个对象
-->
<bean id="someService" class="com.service.impl.SomeServiceImpl"/>
<bean id="someService1" class="com.service.impl.SomeServiceImpl"/>
<!--
spring可以创建一个非自定义类的对象，创建一个存在的某个类的对象。
-->
<bean id="myDate" class="java.util.Date" />
</beans>
<!--
spring的配置文件
1、beans：是根标签，spring把java对象称为bean
2、spring-beans.xsd 是约束文件，和mybatis指定 dtd是一样的
-->定义测试类：
代码语言：javascript复制 /**
* spring默认创建对象的时间 : 在创建spring容器时，会创建配置文件中的所有的对象
* spring创建对象，默认调用的是无参数的构造方法
*/
@Test
public void test02() {
//使用spring容器创建对象
//1、指定spring配置文件的名称
String config = "beans.xml";
//2、创建表示spring容器的对象，ApplicationContext
//ApplicationContext就是表示Spring容器，通过容器获取对象了
//ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取某个对象，要调用对象的方法
SomeService service = (SomeService) ac.getBean("someService");
//使用spring创建好的对象
service.doSome();
}Spring还可以创建非自定义类对象。
容器接口和实现类：
ApplicationContext接口（容器）
ApplicationContext用于加载Spring的配置文件，在程序中充当 ”容器“ 的角色。其实现类有两个。
若Spring配置文件存放在项目的类路径下，则使用ClassPathXmlApplicationContext实现类进行加载。
ApplicationContext容器，会在容器对象初始化时，将其中的所有对象一次性全部装配好。以后代码中若要是用到这些对象，只需从内存中直接获取即可。（执行效率高，但占用内存。）
使用Spring容器创建的java对象：
2.3、基于XML的DI
2.3.1、注入的分类
bean实例在调用无参构造器创建对象后，就要对bean对象的属性进行初始化。初始化是由容器自动完成的，称为注入。根据注入的方式不同，常用的有两类：set注入、构造注入。
（1）使用setter方法注入
使用setter方法注入是spring框架中最主流的注入方式，他利用Java Bean规范的所定义的setter方法来完成注入，灵活且可读性高。对于setter方法注入，Spring框架也是使用Java的反射方式实现的。
**简单类型：**spring中规定java的基本数据类型和String都是简单类型
Student类：
代码语言：javascript复制public class Student {
private String name;
private Integer age;
//setter
//toString()
}Spring配置文件，applicationContext.xml：
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--声明student对象
注入：就是赋值的意思
简单类型：spring中规定java的基本数据类型和String都是简单类型
di:给属性赋值
1、set注入（设置注入）：spring调用类的set方法，可以在set方法中完成属性的赋值
1）简单类型的set注入
<bean id="xx" class="yyy">
<property name="属性名" value="此属性的值" />
一个property只能给一个属性赋值
<property..../>
</bean>
-->
<bean id="myStudent" class="com.ba01.Student">
<property name="name" value="张三" /> <!--setName("张三")-->
<property name="age" value="18" /> <!--setName(18)-->
</bean>
</beans>测试类：
代码语言：javascript复制 @Test
public void test01() {
String config = "ba01/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取对象
Student myStudent = (Student) ac.getBean("myStudent");
System.out.println("student对象=" myStudent);
}引用类型：当指定bean的某属性值为另一bean的实例时，通过ref指定它们间的关系。ref的值必须为某bean的id值。
Student类：
代码语言：javascript复制package com.ba02;
public class Student {
private String name;
private Integer age;
private School school;
//settter
//toString()
}School类：
代码语言：javascript复制package com.ba02;
public class School {
private String name;
private String address;
//setter
//toString()
}Spring配置文件，applicationContext.xml：
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 2）引用类型的set注入
<bean id="xx" class="yyy">
<property name="属性名" ref="bean的id(对象的名称)" />
</bean>
-->
<bean id="myStudent" class="com.ba02.Student">
<property name="name" value="张三" /> <!--setName("张三")-->
<property name="age" value="18" /> <!--setName(18)-->
<!--引用类型-->
<property name="school" ref="mySchool" /> <!--setSchool(mySchool)-->
</bean>
<!--声明School对象-->
<bean id="mySchool" class="com.ba02.School" >
<property name="name" value="xpu" />
<property name="address" value="西安" />
</bean>
</beans>对于其他Bean对象的引用，使用<bean/>标签的ref属性
测试类：
代码语言：javascript复制 @Test
public void test01() {
String config = "ba02/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student myStudent = (Student) ac.getBean("myStudent");
System.out.println("myStudent: " myStudent);
}（2）构造注入
构造注入是指，在构造调用者实例的同时，完成被调用者的实例化。即，使用构造器设置依赖关系。
代码语言：javascript复制//有参数构造方法
public Student(String name, Integer age, School school) {
System.out.println("Student的有参数构造方法执行了！");
this.name = name;
this.age = age;
this.school = school;
}<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
2、构造注入：spring调用类的有参数构造方法，在创建对象的同时，在构造方法中给属性赋值
构造注入使用<constructor-arg>标签
<constructor-arg>标签:一个<constructor-arg>表示构造方法一个参数。
<constructor-arg>标签属性:
name:表示构造方法的形参名
index：表示构造方法的参数位置，参数从左往右位置是0，1，2的顺序
value：构造方法的形参类型是简单类型的使用value
ref：构造方法的形参类型是引用类型的使用ref
-->
<!--使用name属性完成构造注入-->
<bean id="myStudent" class="com.ba03.Student" >
<constructor-arg name="name" value="Danny" />
<constructor-arg name="age" value="15" />
<constructor-arg name="school" ref="mySchool" />
</bean>
<!--使用index属性完成构造注入-->
<bean id="myStudent2" class="com.ba03.Student" >
<constructor-arg index="0" value="Jenny" />
<constructor-arg index="1" value="25" />
<constructor-arg index="2" ref="mySchool" />
</bean>
<!--声明School对象-->
<bean id="mySchool" class="com.ba03.School" >
<property name="name" value="haFo" />
<property name="address" value="America" />
</bean>
<!--使用构造注入创建一个系统类File对象-->
<bean id="myFile" class="java.io.File">
<constructor-arg name="parent" value="E:QQ文件" />
<constructor-arg name="child" value="蓝桥杯校赛.doc" />
</bean>
</beans><constructor-arg />标签中用于指定参数的属性有：
name：指定参数名称
index：指明该参数对于着构造器的第几个参数，从0开始，不过，该属性不要也行，但要注意，若参数类型相同，则需要保证赋值顺序要与构造器中的参数顺序一致。
代码语言：javascript复制public class MyTest03 {
@Test
public void test01() {
String config = "ba03/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student myStudent = (Student) ac.getBean("myStudent");
System.out.println(myStudent);
}
@Test
public void test02() {
String config = "ba03/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student myStudent = (Student) ac.getBean("myStudent2");
System.out.println(myStudent);
}
@Test
public void test03() {
String config = "ba03/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
File myFile = (File) ac.getBean("myFile");
System.out.println(myFile.getName());
}
}2.3.2、引用类型属性自动注入
对于引用类型属性的注入，也可不在配置文件中显式的注入。可以通过为<bean/>标签设置autowire属性值，为引用类型属性进行隐式自动注入（默认是不自动注入引用类型属性）。根据自动注入判断标准的不同，可以分为两种：byName：（根据名称自动注入）、byType：根据类型自动注入
（1）byName方式自动注入
Java类中引用类型的属性名和spring容器中（配置文件）<bean>的id名称一样。且数据类型是一致的，这样的容器中的bean，spring能够赋值给引用类型。
代码语言：javascript复制public class Student {
private String name;
private Integer age;
private School school;
//setter
//toString
}<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--byName-->
<bean id="myStudent" class="com.ba04.Student" autowire="byName">
<property name="name" value="张三" /> <!--setName("张三")-->
<property name="age" value="18" /> <!--setName(18)-->
</bean>
<!--声明School对象-->
<bean id="school" class="com.ba04.School" >
<property name="name" value="xu" />
<property name="address" value="xian" />
</bean>
</beans>（2）byType方式自动注入
byType（按类型注入）：Java类中引用类型的数据类型和spring容器中（配置文件）<bean>的class属性同源关系的，这样的bean能够赋值给引用类型。
1、Java类中引用类型的数据类型和bean的class的值是一样的 2、Java类中引用类型的数据类型和bean的class的值是父子关系的 3、Java类中引用类型的数据类型和bean的class的值是接口和实现类关系的
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--byType-->
<bean id="myStudent" class="com.ba05.Student" autowire="byType">
<property name="name" value="王五" /> <!--setName("张三")-->
<property name="age" value="19" /> <!--setName(18)-->
</bean>
<!--声明School对象-->
<bean id="mySchool" class="com.ba05.School" >
<property name="name" value="lj" />
<property name="address" value="xian" />
</bean>
</beans>使用byType自动注入首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。
2.3.3、为应用指定多个Spring配置文件
在实际应用中，随着应用规模的增加，系统bean数量也大量增加，导致配置文件变得非常庞大。为了避免这种情况的发生，提高配置文件的可读性与可维护性，可以将Spring配置文件分解成多个配置文件。
包含关系的配置文件：
多个配置文件中有一个总文件，总配置文件将各其他子文件通过<import/>引入。在java代码中只需使用总配置文件对容器进行初始化即可。
spring-student.xml
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myStudent" class="com.ba06.Student" autowire="byType">
<property name="name" value="王五" /> <!--setName("张三")-->
<property name="age" value="19" /> <!--setName(18)-->
</bean>
</beans> spring-school.xml
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--声明School对象-->
<bean id="mySchool" class="com.ba06.School" >
<property name="name" value="lj" />
<property name="address" value="xian" />
</bean>
</beans>total.xml
代码语言：javascript复制<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
total表示主配置文件：包含其他的配置文件的。注配置文件一般是不定义对象的
语法：<import resource="其他配置文件的路径"/>
关键字：“classpath”表示类路径（class文件所在的目录）
在spring的配置文件中要制定其他文件的位置，需要使用classpath，告诉spring到哪去加载读取文件
-->
<import resource="classpath:06包含关系的配置文件/spring-school.xml" />
<import resource="classpath:06包含关系的配置文件/spring-student.xml" />
<!--两者选其一-->
<!--
在包含关系的配置文件中，可以使用通配符(*:表示任意字符)
注意：主的配置文件名称不能包含在通配符范围内(不能叫做spring-total.xml)
如果要用通配符这种方案指定多个文件，spring规定:这些文件必须放在同一级目录之中
-->
<!--<import resource="classpath:06包含关系的配置文件/spring-*.xml" />-->
</beans>也可使用通配符*。但此时要求父配置文件名不能满足*所能匹配的格式，否则将出现循环递归包含。
注意：如果要用通配符这种方案指定多个文件，spring规定:这些文件必须放在同一级目录之中。
2.4、基于注解的DI
对于DI使用注解，将不需要在Spring配置文件中声明bean实例。Spring中使用注解，需要在Spring配置文件中配置组件扫描器，用于指定的基本包中扫描注解。
代码语言：javascript复制<?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: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 https://www.springframework.org/schema/context/spring-context.xsd">
<!--声明组件扫描器(component-scan),组件就是java对象
base-package：指定注解在你的项目中的包名
component-scan的工作方式：spring会扫描遍历base-package指定的包1
把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象或给属性赋值
-->
<context:component-scan base-package="com.anno.Component" />
</beans>指定多个包的三种方式：
第一种方式：使用多个组件扫描器，指定不同的包
第二种方式：使用分隔符(;或,)分隔多个包名
第三种方式：指定父包，但不建议使用顶级的父包，扫描的路径比较多，导致容器启动时间变慢。
2.4.1定义Bean的注解@Component
需要在类上使用注解@Component，该注解的value属性用于指定该bean的id值。
代码语言：javascript复制//使用value属性，指定对象名称
//@Component(value = "myStudent")
//省略value (这个用的最多)
@Component("myStudent")
//不指定对象名称，由spring提供默认名称：类名的首字母小写
//@Component
public class Student {
String name;
Integer age;
}spring中和@Component功能一致，创建对象的注解还有：
1、@Repository(用在持久层类的上面)：放在dao的实体类上面。表示创建dao对象，dao对象是能访问数据库的。
2、@Service(用在业务层类的上面)：放在service的实体类上面。创建service对象。service对象是做业务处理，可以有事务等功能的
3、@Controller(用在控制器的上面)：放在控制器(处理器)类的上面，创建控制器对象的。控制器对象：能够接收用户提交的参数，显示请求的处理结果
以上三个注解的使用语法和@Component一样的，都能创建对象，但是这三个注解还有额外的功能。
@Repository、@Service、@Controller是给项目的对象分层的。
2.4.2 简单类型属性注入@Value
需要在属性上使用注解@Value，该注解的value属性用于指定要注入的值。
使用该注解完成属性注入时，类中无需setter。若属性有setter，则也可以将其加到setter上。
代码语言：javascript复制@Component("student")
public class Student {
@Value("李四")
String name;
@Value("18")
Integer age;
}2.4.3 byType自动注入@Autowired
需要在引用属性上使用注解@Autowired，该注解默认使用按类型自动装配bean的方式。
使用该注解完成属性注入时，类中无需setter。若属性有setter，则也可以将其加到setter上。
代码语言：javascript复制@Component("student1")
public class Student {
@Value("李四")
private String name;
@Value("18")
private Integer age;
/**
* 引用类型
* @Autowired:spring框架提供的注解，实现引用数据类型赋值
* spring中通过注解给引用数据类型赋值的，使用的是自动注入原理，支持byType、byName
* @Autowired默认使用的是byType自动注入
* 属性：required：是一个boolean类型的，默认为true
* required=true。表示引用类型如果赋值失败，程序报错，并终止执行
* required=false，表示引用类型如果赋值失败，程序正常执行，引用类型是null
* 位置：1、在属性定义的上面，无需set方法，推荐使用
* 2、在set方法上面
* 如果要用byName方式，需要做的是：
* 1、在属性上面加入@Autowired
* 2、在属性上面加入@Qualifier(value="bean的id")
*/
@Autowired
@Qualifier("school")
private School school;
}使用byType自动注入首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。
2.4.4 byName自动注入@Autowired与@Qualifier
需要在引用属性上联合使用注解@Autowired与@Qualifier。@Qualifier的value属性用于指定要匹配的bean的id值。
@Autowired还有一个属性required，是一个boolean类型的，默认为true
required=true。表示引用类型如果赋值失败，程序报错，并终止执行。 required=false，表示引用类型如果赋值失败，程序正常执行，引用类型是null。
2.4.5 JDK注解@Resource自动注入
Spring提供了对jdk中@Resource注解的支持。@Resource注解可以按名称匹配bean。也可以按类型匹配bean。默认是按名称注入。
（1）byType注入引用类型属性
@Resource注解若不带任何参数，采用默认按名称的方式注入，按名称不能注入bean，则会按照类型进行bean的匹配注入。
（2）byName注入引用类型属性
@Resource注解指定其name属性，则name的值即为按照名称进行匹配的bean的id。
代码语言：javascript复制@Component("student2")
public class Student {
@Value("李四")
private String name;
@Value("18")
private Integer age;
/**
* 引用类型
* @Resource 来自jdk中的注解，spring框架提供了对这个注解的功能支持，可以使用
* 他给引用类型赋值。使用是也是自动注入原理，支持byName、byType，默认byName
* 位置：1、在属性定义的上面，无需set方法，推荐使用
* 2、在set方法的上面
* 默认是byName：先使用byName自动注入，如果byName赋值失败，再使用byType
* @Resource只使用byName的方式，需要增加一个属性：name
* name的值是bean的id
*/
@Resource(name = "school1")
private School school;2.5、注解与XML的对比
注解的优点是：方便、直观、高效（代码少，没有配置文件的书写那么复杂）。
注解的缺点是：以硬编码的方式写入到Java代码中，修改是需要重新编译代码的。
XML的优点是：配置文件和代码是分离的；在xml中做修改，无需编译代码，只需重启服务器即可将新的配置加载。
XML的缺点是：编写麻烦，效率低，大型项目过于复杂。
2.6、IoC能实现解耦合
IoC能实现业务对象之间的解耦合，例如service和dao对象之间的解耦合。
三、AOP面向切面编程
3.1、回顾动态代理
实现方式：
jdk动态代理，使用jdk中的Proxy、Method、InvocaitonHanderl创建代理对象。jdk动态代理要求目标类必须实现接口。
cglib动态代理：第三方的工具库，创建代理对象，原理是继承。通过继承目标类，创建子类。子类就是代理对象。要求目标类不能是final修饰的，方法也不能是final的。
动态代理的作用：
1、在目标类源代码不改变的情况下，增加功能。
2、减少代码的重复
3、专注业务逻辑代码
4、解耦合，让你的业务功能和日志，事务等非业务功能分离。
3.2、AOP面向切面编程
AOP（Aspect Orient Programming）：面向切面编程，基于动态代理的，可以使用jdk、cglib两种代理方式。AOP就是动态代理的规范化，把动态代理的实现步骤，方法都定义好了，让开发人员使用统一的方式使用动态代理。
Aspect：切面，给你的目标类增加的功能，就是切面。像日志、事务都是切面。切面的特点：一般都是非业务方法，独立使用的。
Orient：面向、对着。
如何理解面向切面编程：
1、需要在分析项目功能时，找出切面。
2、合理的安排切面的执行时间（在目标方法前，还是目标方法后）
3、合理的安排切面执行的位置，在哪个类，哪个方法增强功能。
使用AOP的好处是可以减少重复代码，专注业务实现。
3.3、AOP的术语
（1）切面（Aspect）
表示增强的功能，就是一堆代码完成某个功能。非业务功能。常见的切面功能有日志，事务，统计信息，参数检查，权限验证等。
（2）连接点（JoinPoint）
连接业务方法和切面的位置。就某类中的业务方法。
（3）切入点（Pointcut）
指多个连接点方法的集合。多个方法
（4）目标对象（Target）
给哪个类的方法增强功能，这个类就是目标对象。
（5）通知（Advice）
表示切面的执行时间，Advice也叫增强。换个角度说，通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行。
切入点定义切入的位置，通知定义切入的时间。
3.4、AOP的实现
AOP是一个规范，是动态的一个规范化，一个标准。
AOP的技术实现框架：
1、Spring：Spring在内部实现了aop规范，能做aop的工作。spring主要在事务处理时使用AOP。我们在项目开发中很少使用spring的aop实现，因为spring的aop比较笨重。
2、AspectJ：一个开源的专门做AOP的框架。spring框架中集成了aspectj框架，通过spring就能使用aspectj的功能。
AspectJ框架实现AOP有两种方式:
1、使用xml的配置文件：配置全局事务
2、使用注解，我们在项目中要做AOP的功能，一般都使用注解，AspectJ有5个注解
3.5、AspectJ框架的使用
3.5.1、AspectJ中常用的通知有五种类型：
1）前置通知 @Before
2）后置通知 @AfterReturning
3）环绕通知 @Around
4）异常通知 @AfterThrowing
5）最终通知 @After
3.5.2、AspectJ的切入点表达式
Aspectj定义了专门的表达式用于指定切入点，表达式原型：
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
？表示可选部分
以上表达式共4个部分：
execution(访问权限 方法返回值 方法声明(参数) 异常类型)
切入点表达式要匹配的对象就是目标方法的方法名。所以execution表达式中明显就是方法的签名。注意，表达式中未加粗文字表示可省略部分，各部分之间用空格隔开。在其中可以使用以下符号：
* 意义：0至多个任意字符
… 意义：用在方法参数中，表示任意多个参数。用在包名后，表示当前包及其子包路径。
例如：
execution(* set*(…)) 指定切入点为：任何一个以“set”开始的方法。
execution(* com.xyz.service.*.*(…)) 指定切入点为：定义在 service 包里的任意类的任意方法。
execution(* com.xyz.service…*.*(…)) 指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“…”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
execution(* *…service.*.*(…)) 指定所有包下的 serivce 子包下所有类（接口）中所有方法为切入点.
3.5.3、AspectJ基于注解的AOP实现
配置文件applicationContext.xml：
代码语言：javascript复制<?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/aop
https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--把对象交给spring容器，由spring容器统一创建、管理对象-->
<!--声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象，
创建代理对象是在内存中实现的，修改目标对象的内存中的功能，创建为代理对象
所以目标对象就是被修改后的代理对象
aspectj-autoproxy:会把spring容器中的所有的目标对象，一次性都生成代理对象
-->
<context:component-scan base-package="com.ba01" />
<aop:aspectj-autoproxy />
</beans>接口和实现类：
代码语言：javascript复制//接口
public interface SomeService {
void doSome(String name,Integer age);
}
//目标类
@Component("someService")
public class SomeServiceImpl implements SomeService {
@Override
public void doSome(String name, Integer age) {
//给doSome这个方法增加一个功能，在doSome()执行之前，输出方法的执行时间
System.out.println("目标方法doSome");
}
}（1）@Before前置通知
切面类：
代码语言：javascript复制/**
* @Aspect: 是aspectj框架中的注解
* 作用：表示当前类是切面类
* 切面类: 是用来给业务方法增加功能的类，在这个类中有切面的功能代码
* 位置：在类定义的上面
*/
@Aspect
@Component("myAspect")
public class MyAspect {
/**
* 定义方法，方法是实现切面功能的
* 方法定义要求：
* 1、公共方法 public
* 2、方法没用返回值
* 3、方法名称自定义
* 4、方法可以有参数，也可以没参数
* 如果有参数，参数不是自定义的，有几个参数类型可以使用
*/
/**
* @Before:前置通知注解
* 属性：value，是切入点表达式，表示切面的功能执行的位置
* 位置：在方法的上面
* 特点：
* 1、在目标方法之前先执行的
* 2、不会改变目标方法的执行结果
* 3、不会影响目标方法的执行
*/
@Before(value = "execution(* *..SomeServiceImpl.doSome(String,Integer))")
public void myBefore() {
//就是切面要执行的代码
System.out.println("3==前置通知，切面功能:在目标方法之前输出执行时间: " new Date());
}
/**
* 指定通知方法中的参数：JoinPoint
* JoinPoint：业务方法，要加入切面功能的业务方法
* 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法实参。
* 如果你的切面功能中需要用到方法的信息，就加入JoinPoint
* 这个JoinPoint参数的值是由框架赋予，必须是第一个位置的参数
*/
@Before(value = "execution(void *..SomeServiceImpl.doSome(String,Integer))")
public void myBefore(JoinPoint jp) {
//获取方法的完整定义
System.out.println("方法的签名(定义)= " jp.getSignature());
System.out.println("方法的名称= " jp.getSignature().getName());
//获取方法的实参
Object[] args = jp.getArgs();
for(Object arg : args) {
System.out.println("参数:" arg);
}
//就是切面要执行的代码
System.out.println("2==前置通知，切面功能:在目标方法之前输出执行时间: " new Date());
}
}（2）@AfterReturning后置通知
目标类的目标方法：
代码语言：javascript复制 @Override
public String doOther(String name, Integer age) {
System.out.println("目标方法doOther()!");
return "abcd";
}切面类：
代码语言：javascript复制@Aspect
@Component("myAspect")
public class MyAspect {
/**
* 后置通知定义方法，方法是实现切面功能的
* 方法定义要求：
* 1、公共方法 public
* 2、方法没用返回值
* 3、方法名称自定义
* 4、方法有参数,推荐使用Object，参数名自定义
*/
/**
* @AfterReturning:后置通知
* 属性:1、value 切入点表达式
* 2、returning 自定义变量，表示目标方法的返回值的
* 自定义变量名必须和通知方法的形参名一样
* 使用位置：方法定义的上面
* 特点：
* 1、在目标方法之后执行的
* 2、能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能
* 3、可以修改这个返回值
*
* 后置通知的执行:
* Object res = doOther();
* myAfterReturning(res);
*/
@AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "res")
public void myAfterReturning(Object res) {
//Object res: 是目标方法执行后的返回值，根据返回值做你的切面的功能处理
System.out.println("后置通知:在目标方法之后执行的，获取的返回值是: " res);
}
}（3）@Around环绕通知
实现类的目标方法：
代码语言：javascript复制 @Override
public String doFirst(String name, Integer age) {
System.out.println("业务方法doFirsst()!");
return null;
}切面类
代码语言：javascript复制@Aspect
@Component("myAspect")
public class MyAspect {
/**
* 环绕通知方法的定义格式
* 1、public
* 2、必须有一个返回值，推荐使用Object
* 3、方法名称自定义
* 4、方法有参数，固定的参数：ProceedingJoinPoint
*/
/**
* @Around:环绕通知
* 属性：value 切入点表达式
* 特点：
* 1、他是功能最强的通知
* 2、可以在目标方法的前和后都能增加功能
* 3、控制目标方法是否被调用执行
* 4、修改原来的目标方法的执行结果，影响最后的调用结果
* 等同于jdk动态代理的 invocationHandler接口
* 参数：ProceedingJoinPoint等同于Method
* 作用:执行目标方法的
* 返回值：就是目标方法的执行结果，可以修改的
* 环绕通知：经常做事务，在目标方法之前开启事务，执行目标方法，在方法执行之后提交事务
*/
@Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
String name = "";
//获取第一个参数值
Object[] args = pjp.getArgs();
if(args!=null && args.length > 1) {
Object arg = args[0];
name = (String) arg;
}
//实现环绕通知
Object result = null;
System.out.println(new Date());
//目标方法调用
if("zhangsan".equals(name)) {
result = pjp.proceed();
}
System.out.println("提交事务");
//在目标方法的前或者后增加功能
//修改目标方法的执行结果，影响方法最后的调用结果
if(result != null) {
result = "Hello AspectJ AOP";
}
return result;
}
}（4）@AfterThrowing异常通知
目标类及其目标方法：
代码语言：javascript复制 @Override
public void doSecond() {
System.out.println("执行业务方法doSecond()!" 10/0);
}切面类：
代码语言：javascript复制@Aspect
@Component("myAspect")
public class MyAspect {
/**
* 异常通知方法的定义格式
* 1、public
* 2、没有返回值
* 3、方法名称自定义
* 4、方法有一个参数是Exception，如果还有是JoinPoint
*/
/**
* @AfterThrowing:异常通知
* 属性：1、value:切入点表达式
* 2、throwing自定义的变量，表示目标方法抛出的异常对象
* 变量名必须和方法的参数名一样
* 特点：
* 1、在目标方法中抛出异常时才执行
* 2、可以做异常的监控程序，监控目标方法执行时是不是有异常
* 如果有异常，可以发生邮件、短信等通知
* 执行流程：
* try{
* SomeServiceImpl.doSecond(..);
* } catch(Exception e) {
* myAfterThrowing(e);
* }
*/
@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
throwing = "ex")
public void myAfterThrowing(Exception ex) {
System.out.println("异常通知，方法发生异常时，执行：" ex);
//发送邮件或者短信
}
}（5）@After最终通知
代码语言：javascript复制@Aspect
@Component("myAspect")
public class MyAspect {
/**
* 最终通知方法的定义格式
* 1、public
* 2、没有返回值
* 3、方法名称自定义
* 4、方法没有参数，如果有就是JoinPoint
*/
/**
* @After:最终通知
* 属性：value 切入点表达式
* 位置：在方法上面
* 特点：
* 1、总是会执行
* 2、在目标方法之后执行的
* 执行流程：
* try{
* SomeServiceImpl.doThird(..);
* } catch(Exception e) {
* } finally {
* myAfter();
* }
*
*/
@After(value = "execution(* *..SomeServiceImpl.doThird(..))")
public void myAfter() {
System.out.println("执行最终通知，总是会被执行的代码");
//一般做资源清除工作的
}
}（6）@Pointcut定义切入点
当较多的通知增强方法使用相同的execution切入点表达式时，编写、维护较为麻烦。AspectJ提供了@Pointcut注解，用于定义execution切入点表达式
代码语言：javascript复制 @After(value = "mypt()")
public void myAfter() {
System.out.println("执行最终通知，总是会被执行的代码");
//一般做资源清除工作的
}
@Before(value = "mypt()")
public void myBefore() {
System.out.println("前置通知，在目标方法之前先执行的");
//一般做资源清除工作的
}
/**
* @Pointcut:定义和管理切入点: 如果你的项目中有多个切入点是重复的，可以复用的
* 可以使用Pointcut
* 属性：value 切入点表达式
* 位置：在自定义方法的上面
* 特点：
* 当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名
* 其他的通知中value就可以使用这个方法的名称来代替切入点表达式
*/
@Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))")
private void mypt() {
//无需代码
}补充：在spring配置文件中：
代码语言：javascript复制 <aop:aspectj-autoproxy /> <!--使用的是jdk动态代理-->
<!--
如果你期望目标类有接口，使用cglib动态代理
proxy-target-class="true":告诉框架，要使用cglib动态代理
-->
<aop:aspectj-autoproxy proxy-target-class="true" />四、Spring集成Mybatis
将Mybatis和Spring进行整合，主要解决的问题就是将SqlSessionFactory对象交由Spring来管理。所以只需要将SqlSessionFactory的对象生成器SqlSessionFactoryBean注册在Spring容器中，再将其注入给Dao的实现类即可。
用的技术是ioc。能把mybatis和spring集成在一起，像一个框架，是因为ioc能创建对象。可以把mybatis框架中的对象交给spring统一创建，开发人员从spring中获取对象。
因此，我们需要让Spring创建以下对象：
1、独立的数据库连接池类对象，使用阿里的druid连接池
2、SqlSessionFactory对象
3、创建出dao对象.
数据库连接池：多个连接Connection对象的集合。
List<Connection> connlist : connList就是连接池。
步骤：
1、新建maven，加入maven依赖 ：
1）spring依赖， 2）mybatis依赖， 3）mysql驱动， 4）spring的事务的依赖 ，5）mybatis和spring集成的依赖：mybatis官方提供的，用来在spring中创建mybatis的SqlSessionFactory，dao对象的。
代码语言：javascript复制<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.idea</groupId>
<artifactId>spring-mybatis</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<!--单元测试的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!--spring依赖-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!--做spring事务用到的-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<!--mybatis的依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.8</version>
</dependency>
<!--mybatis和spring集成的依赖-->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>
<!--阿里公司的数据库连接池-->
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.12</version>
</dependency>
</dependencies>
<build>
<!--目的是把src/main/java目录中的xml文件包含到输出结果中，输出到classes目录中-->
<resources>
<resource>
<directory>src/main/java</directory> <!--所在的目录-->
<includes> <!--包括目录下的.xml，.properties文件都会扫描到-->
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
</project>2、创建实体类
代码语言：javascript复制package com.domain;
public class Student {
//属性和列名一样
private Integer id;
private String name;
private String email;
private Integer age;
public Student() {
}
public Student(Integer id, String name, String email, Integer age) {
this.id = id;
this.name = name;
this.email = email;
this.age = age;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student{"
"id=" id
", name='" name '''
", email='" email '''
", age=" age
'}';
}
}3、创建dao接口和mapper文件
代码语言：javascript复制package com.dao;
import com.domain.Student;
import java.util.List;
public interface StudentDao {
int insertStudent(Student student);
List<Student> selectStudents();
}mapper文件：
代码语言：javascript复制<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.StudentDao">
<select id="selectStudents" resultType="com.domain.Student">
select id,name,email,age from student order by id desc
</select>
<insert id="insertStudent">
insert into student values(#{id},#{name},#{email},#{age})
</insert>
</mapper>4、创建mybatis主配置文件
代码语言：javascript复制<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<!--设置别名-->
<typeAliases>
<!--name：实体类所在的包名。这个包下所有类的类名就是别名-->
<package name="com.domain"/>
</typeAliases>
<!--sql映射文件的位置-->
<mappers>
<!--name是包名，这个包中的所有mapper.xml一次都能加载-->
<package name="com.dao" />
</mappers>
</configuration>5、创建service接口和实现类，属性是dao
代码语言：javascript复制//service接口：
package com.service;
import com.domain.Student;
import java.util.List;
public interface StudentService {
int addStudent(Student student);
List<Student> queryStudents();
}
//service接口实现类
public class StudentServiceImpl implements StudentService {
private StudentDao studentDao;
public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}
@Override
public int addStudent(Student student) {
int nums = studentDao.insertStudent(student);
return nums;
}
@Override
public List<Student> queryStudents() {
List<Student> students = studentDao.selectStudents();
return students;
}
}6、创建spring的配置文件：声明mybatis的对象交给spring创建：
1）数据源，2）SqlSessionFactory，3）Dao对象，4）声明自定义的service，
代码语言：javascript复制<?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: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 https://www.springframework.org/schema/context/spring-context.xsd">
<!--要把数据库的配置信息，写在一个独立的配置文件中，编译修改数据库的配置内容
要让spring知道配置文件的位置
-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--声明数据源DataSource，作用是连接数据库的-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!--set注入给DruidDataSource提供连接数据库信息-->
<!--使用属性配置文件中的数据，语法: ${key}-->
<property name="url" value="${jdbc.url}" /> <!--对应的是setUrl()-->
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!--声明mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
<!--set注入，把数据库连接池赋给了dataSource属性-->
<property name="dataSource" ref="myDataSource" />
<!--mybatis主配置文件的位置
configLocation属性是Resource类型，读取配置文件的
它的赋值，使用value，指定文件路径，使用classpath:表示文件的位置
-->
<property name="configLocation" value="classpath:mybatis.xml" />
</bean>
<!--创建dao对象，使用SqlSession的getMapper(StudentDao.class)
MapperScannerConfigurer:在内部使用getMapper()生成每个dao接口的代理对象。
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" >
<!--指定SqlSessionFactory对象的id-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
<!--指定包名，包名是dao接口所在的类名
MapperScannerConfigurer会扫描这个包中所有的接口，把每个接口都
执行一次getMapper()方法，得到每个接口的dao对象
创建好的dao对象放到spring容器中的,dao对象的默认名称是：接口名首字母小写
-->
<property name="basePackage" value="com.dao" />
</bean>
<!--声明service-->
<bean id="studentService" class="com.service.impl.StudentServiceImpl" >
<!--向service注入-->
<property name="studentDao" ref="studentDao" />
</bean>
</beans>属性配置文件jdbc.properties
代码语言：javascript复制jdbc.url=jdbc:mysql://localhost:3306/数据库名
jdbc.username=数据库名
jdbc.password=数据库密码7、创建测试类，获取service对象，通过service调用dao完成数据库的访问
代码语言：javascript复制package com;
import com.dao.StudentDao;
import com.domain.Student;
import com.service.StudentService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class MyTest01 {
@Test
public void testServiceInsert() {
String config = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//获取容器中的service对象
StudentService service = (StudentService) ac.getBean("studentService");
Student student = new Student(1004, "小六", "xiaoliu@sina.com", 24);
int count = service.addStudent(student);
//Spring和mybatis整合在一起使用，事务是自动提交的，无需使用SqlSession.commit();
System.out.println(count);
}
@Test
public void testServiceSelect() {
String config = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//获取容器中的service对象
StudentService service = (StudentService) ac.getBean("studentService");
List<Student> students = service.queryStudents();
for(Student stu : students) {
System.out.println("stu==== " stu);
}
}
}五、Spring事务
5.1、Spring的事务管理
1、事务是一系列的操作步骤，多个sql语句的集合。
2、在什么时候想到使用事务：当我的操作涉及多个表，或者是多个sql语句的insert、update、delete。需要保证这些语句都是成功才能完成我的功能，或者都失败，保证操作是符合要求的。
在程序中事务是放在service类的方法上面的,因为在service方法里面会使用多个dao，执行多个sql语句。
3、JDBC访问数据库，处理事务 Connection conn; conn.commit(); conn.rollback();
Mybatis访问数据库，处理事务，SqlSession.commit(); SqlSession.rollback();
Hibernate()访问数据库，处理事务，Session.commit(); SqlSession.rollback();
以上中事务的处理方式的不足之处：
- 不同的数据库访问技术，处理事务的对象，方法不同，需要了解不同数据库访问技术使用事务的原理
- 掌握多种数据库中事务的处理逻辑。什么时候提交事务，什么时候回滚事务
- 处理事务的多种方法
总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。
4、解决方法
Spring提供一种处理事务的统一模型，能使用统一步骤、方式完成多种不同数据库访问技术的事务处理。
使用Spring的事务处理机制，可以完成mybatis访问数据库的事务处理
使用Spring的事务处理机制，可以完成Hibernate访问数据库的事务处理。
5.1.1、处理事务需要怎么做，做什么
Spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给Spring就可以了。
1、事务内部提交、回滚事务，使用的事务管理器对象，代替程序员完成commit、rollback。事务管理器是一个接口和它的众多实现类。接口：PlatformTransactionManager，定义了事务重要方法commit，rollback。实现类：Spring把每一种数据库访问技术对应的事务处理类都创建好了。Mybatis访问数据库----Spring创建好的是DataSourceTransactionManager，Hibernate访问数据库—Spring创建好的是HibernateTransactionManager。
如何使用：需要告诉Spring用的是哪种数据库的访问技术
声明数据库访问技术对于的事务管理器实现类，在Spring的配置文件中使用<bean>声明就可以了。例如你要使用mybatis访问数据库，你应该在xml配置文件中 <bean id= “‘xxx’” class="…DataSourceTransactionManager">
2、你的业务方法需要什么样的事务，说明需要事务的类型。
说明方法需要的事务：
（1）事务的隔离级别：有四个值
DEFAULT:采用DB默认的事务隔离级别。Mysql的默认为REPEATABLE_READ; Oracle默认为 READ_COMMITTED.
READ_UNCOMMITTED:读未提交。未解决任何并发问题。
READ_COMMITTED:读已提交。解决脏读，存在不可重复读与幻读。
REPEATABLE_READ:可重复读。解决脏读、不可重复读，存在幻读。
SERIALIZABLE:串行化。不存在并发问题。
（2）事务的超时时间：表示一个方法执行的最长时间，如果方法执行时超过了时间，事务就回滚。单位是秒，整数值，默认是-1
（3）事务的传播行为：控制业务方法是不是有事务的，是什么样的事务的，7个传播行为，表示你的业务方法调用时，事务在方法之间是如何使用的。
PROPAGATION_REQUIRED
指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事物。这种传播行为是最常见的选择，也是Spring默认的事务传播行为。如该传播行为加在doOther()方法上。若doSome()在调用doOther()方法时就是在事务内运行的，则doOther()方法的执行也加入到该事务内执行。若doSome()方法在调用doOther()方法时没有在事务内执行，则doOther()方法会创建一个事务，并在其中执行。
PROPAGATION_REQUIRES_NEW
总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事物执行完毕。
PROPAGATION_SUPPORTS
指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。
这三个需要掌握的！
3、提交事务，回滚事务的时机
（1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。调用事务管理器的commit
（2）当你的业务方法抛出运行时异常或ERROR，spring执行回滚，调用事务管理器的rollback。运行时异常的定义：RuntimeException和它的子类都是运行时异常，例如NullPointException等。
（3）当你的业务方法抛出编译异常时，提交事务。不过对于编译时异常，程序员也可以手工设置其回滚方式。
总结Spring的事务：
1、管理事务的是：事务管理器和它的实现类
2、spring的事务是一个统一模型
（1）指定要使用的事务管理器实现类，使用<bean>
（2）指定哪些类，哪些方法需要加入事务的功能
（3）指定方法需要的隔离级别，传播行为，超时
你需要告诉spring，你的项目中类的信息，方法的名称，方法的事务传播行为。
5.2、Spring框架中提供的事务处理方案
5.2.1、适合中小项目使用的，注解方案
Spring框架自己用AOP实现给业务方法增加事务的功能，使用@Transactional注解增加事务。@Transactional注解是Spring框架自己的注解，放在public方法的上面，表示当前方法具有事务。可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等
使用@Transactional的步骤：
1、需要声明事务管理器对象
<bean id=“xxx” class=“DataSourceTransactionManager”>
2、开启事务注解驱动，告诉spring框架，使用注解的方式管理事务
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。Spring给业务方法加入事务：在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知
3、在你的方法的上面加入@Transactional
举例：
先创建两个数据库表 sales
goods
实现步骤：
1、新建maven
2、加入maven依赖
1）spring依赖
2）mybatis依赖
3）mysql驱动
4）spring的事务的依赖
5）mybatis和spring集成的依赖：mybatis官方提供的，用来在spring中创建mybatis的SqlSessionFactory，dao对象的
3、创建实体类
Sale，Goods
4、创建dao接口和mapper文件
SaleDao接口，Goods接口
SaleDao.xml，GoodsDao.xml
5、创建mybatis主配置文件
6、创建service接口和实现类，属性是saleDao，goodsDao
7、创建spring的配置文件：声明mybatis的对象交给spring创建
1）数据源
2）SqlSessionFactory
3）Dao对象
4）声明自定义的service
8、创建测试类，获取service对象，通过service调用dao完成数据库的访问实体类：
代码语言：javascript复制public class Sale {
private Integer id;
private Integer gid;
private Integer nums;
//setter、getter
}
public class Goods {
private Integer id;
private String name;
private Integer amount;
private Float price;
//setter、getter
}dao接口和mapper文件
代码语言：javascript复制public interface SaleDao {
//增加销售记录
int insertSale(Sale sale);
}
public interface GoodsDao {
//更新库存
//goods表示本次用户购买的商品信息，id，购买数量
int updateGoods(Goods goods);
//查询商品的信息
Goods selectGoods(Integer id);
}<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.SaleDao">
<insert id="insertSale" >
insert into sale(gid,nums) value(#{gid},#{nums})
</insert>
</mapper><?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.GoodsDao">
<select id="selectGoods" resultType="com.domain.Goods">
select id,name,amount,price from goods where id=#{gid}
</select>
<update id="updateGoods">
update goods set amount = amount - #{amount} where id = #{id}
</update>
</mapper>mybatis主配置文件
代码语言：javascript复制<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--设置别名-->
<typeAliases>
<!--name：实体类所在的包名。这个包下所有类的类名就是别名-->
<package name="com.domain"/>
</typeAliases>
<!--sql映射文件的位置-->
<mappers>
<!--name是包名，这个包中的所有mapper.xml一次都能加载-->
<package name="com.dao" />
</mappers>
</configuration>service接口和实现类
代码语言：javascript复制public interface BuyGoodsService {
/**
* 购买商品的方法
* @param goodsId 购买商品的编号
* @param nums 购买的数量
*/
void buy(Integer goodsId,Integer nums);
}public class BuyGoodsServiceImpl implements BuyGoodsService {
private SaleDao saleDao;
private GoodsDao goodsDao;
public void setSaleDao(SaleDao saleDao) {
this.saleDao = saleDao;
}
public void setGoodsDao(GoodsDao goodsDao) {
this.goodsDao = goodsDao;
}
/**
* rollbackFor:表示发送指定的异常一定回滚
*/
/*@Transactional(
propagation = Propagation.REQUIRED,
isolation = Isolation.DEFAULT,
readOnly = false,
rollbackFor = {
NullPointerException.class,NotEnoughException.class
}
)*/
//使用的是事务控制的默认值，默认的传播行为是REQUIRED，默认的隔离级别是DEFAULT
//默认抛出运行时异常，回滚事务
//@Transactional要用在公共方法之上
@Transactional
@Override
public void buy(Integer goodsId, Integer nums) {
//记录销售的信息，向sale表添加记录
Sale sale = new Sale();
sale.setGid(goodsId);
sale.setNums(nums);
saleDao.insertSale(sale);
//更新库存
Goods goods = goodsDao.selectGoods(goodsId);
if(goods == null) {
//商品不存在
throw new NullPointerException("编号是: " goodsId ",商品不存在");
} else if(goods.getAmount() < nums) {
//商品库存不足
throw new NotEnoughException("编号是: " goodsId ",商品库存不足");
}
//修改库存了
Goods buyGoods = new Goods();
buyGoods.setId(goodsId);
buyGoods.setAmount(nums);
goodsDao.updateGoods(buyGoods);
}
}再写个异常类：
代码语言：javascript复制public class NotEnoughException extends RuntimeException{
//自定义的运行时异常类
public NotEnoughException() {
super();
}
public NotEnoughException(String message) {
super(message);
}
}创建JDBC属性配置文件：
代码语言：javascript复制jdbc.url=jdbc:mysql://localhost:3306/数据库名
jdbc.username=用户名
jdbc.password=密码创建spring配置文件：
代码语言：javascript复制<?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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--要把数据库的配置信息，写在一个独立的配置文件中，编译修改数据库的配置内容
要让spring知道配置文件的位置
-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--声明数据源DataSource，作用是连接数据库的-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!--set注入给DruidDataSource提供连接数据库信息-->
<!--使用属性配置文件中的数据，语法: ${key}-->
<property name="url" value="${jdbc.url}" /> <!--对应的是setUrl()-->
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!--声明mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
<!--set注入，把数据库连接池赋给了dataSource属性-->
<property name="dataSource" ref="myDataSource" />
<!--mybatis主配置文件的位置
configLocation属性是Resource类型，读取配置文件的
它的赋值，使用value，指定文件路径，使用classpath:表示文件的位置
-->
<property name="configLocation" value="classpath:mybatis.xml" />
</bean>
<!--创建dao对象，使用SqlSession的getMapper(StudentDao.class)
MapperScannerConfigurer:在内部使用getMapper()生成每个dao接口的代理对象。
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" >
<!--指定SqlSessionFactory对象的id-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
<!--指定包名，包名是dao接口所在的类名
MapperScannerConfigurer会扫描这个包中所有的接口，把每个接口都
执行一次getMapper()方法，得到每个接口的dao对象
创建好的dao对象放到spring容器中的,dao对象的默认名称是：接口名首字母小写
-->
<property name="basePackage" value="com.dao" />
</bean>
<!--声明service-->
<bean id="buyService" class="com.service.impl.BuyGoodsServiceImpl" >
<property name="goodsDao" ref="goodsDao" />
<property name="saleDao" ref="saleDao" />
</bean>
<!--使用Spring的事务处理-->
<!--声明事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
<!--连接的数据库，指定数据源-->
<property name="dataSource" ref="myDataSource" />
</bean>
<!--开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
transaction-manager:事务管理器对象的id
-->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>测试类测试执行结果
代码语言：javascript复制public class MyTest {
@Test
public void test01() {
String config = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取service对象
BuyGoodsService service = (BuyGoodsService) ac.getBean("buyService");
System.out.println("service是代理: " service.getClass().getName());
//调用方法
//service.buy(1001,10);
//service.buy(1005,10);
//service.buy(1001,1000);
//执行到这块，数据库编号变为7了，因为id用的是自动递增，所以5，6操作在执行过程中已经
//用过了，所以不会在用，因为抛出异常采取了回滚，所以数据库中没有记录
//service.buy(1001,10);
service.buy(1001,100);
}
}5.2.2、适合大型项目，使用AspectJ框架功能
在大型项目中，有很多类、方法，需要大量的配置事务，使用AspectJ框架功能，在Spring配置文件中声明类，方法需要的事务。这种方式业务方法和事务配置完全分离
实现步骤：都是在xml配置文件中实现
1、要使用的是aspectj框架，需要在Maven的pom.xml中加入它的依赖
2、声明事务管理器对象
<bean id=“xx” class=“DataSourceTransactionManager”>
3、声明方法需要的事务类型（配置方法的事务属性[隔离级别、传播行为，超时]）
4、配置aop：指定哪些类要创建代理
上面例子中只需要改下service实现类和Spring的属性配置文件
代码语言：javascript复制public class BuyGoodsServiceImpl implements BuyGoodsService {
private SaleDao saleDao;
private GoodsDao goodsDao;
public void setSaleDao(SaleDao saleDao) {
this.saleDao = saleDao;
}
public void setGoodsDao(GoodsDao goodsDao) {
this.goodsDao = goodsDao;
}
@Override
public void buy(Integer goodsId, Integer nums) {
//记录销售的信息，向sale表添加记录
Sale sale = new Sale();
sale.setGid(goodsId);
sale.setNums(nums);
saleDao.insertSale(sale);
//更新库存
Goods goods = goodsDao.selectGoods(goodsId);
if(goods == null) {
//商品不存在
throw new NullPointerException("编号是: " goodsId ",商品不存在");
} else if(goods.getAmount() < nums) {
//商品库存不足
throw new NotEnoughException("编号是: " goodsId ",商品库存不足");
}
//修改库存了
Goods buyGoods = new Goods();
buyGoods.setId(goodsId);
buyGoods.setAmount(nums);
goodsDao.updateGoods(buyGoods);
}
}<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx" 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/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--要把数据库的配置信息，写在一个独立的配置文件中，编译修改数据库的配置内容
要让spring知道配置文件的位置
-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--声明数据源DataSource，作用是连接数据库的-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<!--set注入给DruidDataSource提供连接数据库信息-->
<!--使用属性配置文件中的数据，语法: ${key}-->
<property name="url" value="${jdbc.url}" /> <!--对应的是setUrl()-->
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!--声明mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
<!--set注入，把数据库连接池赋给了dataSource属性-->
<property name="dataSource" ref="myDataSource" />
<!--mybatis主配置文件的位置
configLocation属性是Resource类型，读取配置文件的
它的赋值，使用value，指定文件路径，使用classpath:表示文件的位置
-->
<property name="configLocation" value="classpath:mybatis.xml" />
</bean>
<!--创建dao对象，使用SqlSession的getMapper(StudentDao.class)
MapperScannerConfigurer:在内部使用getMapper()生成每个dao接口的代理对象。
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" >
<!--指定SqlSessionFactory对象的id-->
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
<!--指定包名，包名是dao接口所在的类名
MapperScannerConfigurer会扫描这个包中所有的接口，把每个接口都
执行一次getMapper()方法，得到每个接口的dao对象
创建好的dao对象放到spring容器中的,dao对象的默认名称是：接口名首字母小写
-->
<property name="basePackage" value="com.dao" />
</bean>
<!--声明service-->
<bean id="buyService" class="com.service.impl.BuyGoodsServiceImpl" >
<property name="goodsDao" ref="goodsDao" />
<property name="saleDao" ref="saleDao" />
</bean>
<!--声明式事务处理，和源代码完全分离的-->
<!--声明事务管理器对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
<property name="dataSource" ref="myDataSource" />
</bean>
<!--声明业务方法它的事务属性(隔离级别，传播行为，超时时间)
id:自定义名称，表示 <tx:advice> 和 </tx:advice>之间的配置内容的
transaction-manager:事务管理器对象的id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager" >
<!--tx:attributes:配置事务属性-->
<tx:attributes>
<!--tx:method:给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
name是方法名称: 1)完整的方法名称，不带有包和类
2)方法可以使用通配符，*表示任意字符
propagation:传播行为，枚举值
isolation:隔离级别
rollback-for:你指定的异常类名，全限定类名。发生异常一定回滚
-->
<tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
rollback-for="java.lang.NullPointerException,com.excep.NotEnoughException"/>
</tx:attributes>
</tx:advice>
<!--配置aop-->
<aop:config>
<!--配置切入点表达式，指定哪些包中类，要使用事务，aspectj会创建代理对象-->
<aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
<!--配置增强器:关联advice和pointcut
advice-ref:通知，上面tx:advice那里的配置
pointcut-ref:切入点表达式的id
-->
<aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
</aop:config>
</beans>由此可见，service类的业务方法并没有发生任何改动，只是在Spring的属性配置文件实现，实现了业务方法和事务属性配置完全分离。
