Spring的相关知识

一、概述

1、Spring是轻量级的开源的JavaEE框架。

2、Spring可以解决企业应用开发的复杂性。

3、Spring有两个核心部分：IOC和Aop：

  （1）IOC：控制反转，把创建对象过程交给Spring来管理；

  （2）Aop：面向切面，不修改源代码的情况下进行功能增强。

4、Spring特点

  （1）方便解耦，简化开发

  （2）Aop编程支持

  （3）方便程序的测试

  （4）方便继承各种优秀框架

  （5）方便进行事务操作

  （6）降低API开发难度

---

二、入门案例

1、Spring下载；

下载链接：Spring

2、创建一个普通的Java项目；

3、导入Spring相关jar包；

4、创建一个普通类，并定义一个方法；

public class Person {
    void eat(){
        System.out.println("I'm eating");
    }
}

5、创建Spring配置文件，在配置文件中配置创建的对象。

注：Spring配置文件使用xml格式

	<!-- 配置Person对象创建 -->
  <bean id="person" class="Person"></bean>

6、测试代码编写

public class TestClass {
    @Test
    public void testEat(){
        //1.加载Spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean_xml.xml");

        //2.获取配置创建的对象
        Person person = context.getBean("person", Person.class);

        System.out.println(person);

        person.eat();
    }
}

---

三、IOC容器

1、IOC底层原理

（1）什么是IOC

• 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理；
• 使用IOC目的：为了降低耦合度；

（2）IOC底层原理

• xml解析
• 工厂模式
• 反射

（3）图解

• 原始方式

• 工厂模式

• IOC过程

---

2、IOC接口

（1）IOC思想基于IOC容器实现，IOC容器底层就是对象工厂；

（2）Spring提供IOC容器两种实现方式（两个接口）：

• BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用；

加载配置文件时不会创建对象，在获取对象（使用时）才去创建对象。

• ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用；

加载配置文件时就会把配置文件对象进行创建。

（3）ApplicationContext接口的实现类：

FlieSystemXmlApplicationContext：对应盘符路径（绝对路径）

ClassPathXmlApplicationContext：对应类路径

---

3、IOC操作（Bean管理）概述

• 什么是Bean管理

Bean管理指的是两个操作：

• Spring创建对象
• Spring注入属性

• Bean管理操作的两种方式

• 基于xml配置文件方式实现
• 基于注解方式实现

4、基于xml方式的Bean管理

（1）基于xml方式创建对象

	<!-- 配置Person对象创建 -->
    <bean id="person" class="Person"></bean>

• 在Spring配置文件中，使用bean标签，标签里面添加对应的属性，从而实现对象的创建；
• 在bean标签中有很多属性，常用的有

id属性：唯一标识

class属性：类的全路径（包、类路径）

• 创建对象的时候，默认是执行无参构造方法完成对象创建

---

（2）基于xml方式注入属性

DI：依赖注入（注入属性）

DI是IOC的一种具体实现，需要在创建对象的基础上进行完成！

• 第一种注入方式，使用set方法进行注入

  代码示例：

  定义一个Book类，添加对应的set方法，分别在Spring配置文件和测试类中添加相应内容。

public class Book {
    private String name;
    private String author;

    public void setName(String name) {
        this.name = name;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                '}';
    }
}

	<!-- set方法注入属性 -->
    <bean id="book" class="Book">
        <!-- 使用property完成属性注入
             name：类里面属性的名称
             value：向属性中注入的值
         -->
        <property name="name" value="we three"></property>
        <property name="author" value="YangJiang"></property>
    </bean>

	@Test
    public void testBook(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean_xml.xml");

        Book book = context.getBean("book", Book.class);

        System.out.println(book);
    }

• 第二种注入方式，使用有参构造方法进行注入

  代码示例：

  定义一个Orders类，添加有参构造方法，分别在Spring配置文件和测试类中添加相应内容。

public class Orders {
      private String name;
      private String address;
  
      public Orders(String name, String address) {
          this.name = name;
          this.address = address;
      }
  
      @Override
      public String toString() {
          return "Orders{" +
                  "name='" + name + '\'' +
                  ", address='" + address + '\'' +
                  '}';
      }
  }

	<!-- 有参构造方法注入属性 -->
    <bean id="order" class="Orders">
        <constructor-arg name="name" value="001"></constructor-arg>
        <constructor-arg name="address" value="ShangHai"></constructor-arg>
     
<!--    也可以通过index索引的方式为其赋值    -->
<!--    <constructor-arg index="0" value="002"></constructor-arg>        -->
<!--    <constructor-arg index="1" value="BeiJing"></constructor-arg>    -->
    </bean>

	@Test
    public void testOrders(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean_xml.xml");

        Orders order = context.getBean("order", Orders.class);

        System.out.println(order);
    }

• 第三种注入方式，p名称空间（了解）

​ 代码示例：
​ 在beans标签中添加xmlns:p，并在bean标签中直接添加p:属性

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       
       xmlns:p="http://www.springframework.org/schema/p"
         
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
         
         
			 <bean id="book" class="Book" p:name="we three" p:author="YangJiang"></bean>

</beans>

---

（3）基于xml方式注入空值和特殊符号

• 注入null值

	<bean id="book" class="Book">
        <property name="name" value="we three"></property>
        <property name="author" value="YangJiang"></property>
        <property name="address">
            <null></null>
        </property>
    </bean>

• 属性值包含特殊符号

  1、把<>进行转义，使用 &lt; &gtl;

  2、把带特殊符号内容写到CDATA中。

	<bean id="book" class="Book">
        <property name="name" value="we three"></property>
        <property name="author" value="YangJiang"></property>
        <property name="address">
            <value>
                <![CDATA[<<南京>>]]]>
            </value>
        </property>
    </bean>

（4）基于xml方式注入外部bean

创建UserService类和UserDao接口，并创建UserDaoImplement实现类继承该接口；在UserService中调用UserDao的方法，并在Spring配置文件中进行配置。

该方式使用了set方法进行注入，在UserService类中添加UserDao属性，并生成对应的set方法，之后在Spring配置文件中采用外部bean注入的方式完成实现过程。

代码示例：

UserDao.java

public interface UserDao {
    void update();
}

UserDaoImplement.java

public class UserDaoImplement implements UserDao{
    @Override
    public void update() {
        System.out.println("UserDao update......");
    }
}

UserService.java

public class UserService {

    //创建UserDao类型的属性，并生成相应的set方法
    private UserDao udao;

    public void setUdao(UserDao udao) {
        this.udao = udao;
    }

    public void add(){
        System.out.println("UserService add......");

        udao.update();
    }
}

Bean2.xml

	<!--为service和dao创建对象-->
    <bean id="uservice" class="service.UserService">

        <!--注入udao对象
            name属性：类里面的属性名称
            ref属性：创建udao对象bean标签的id值
        -->
        <property name="udao" ref="udaoimple"></property>
    </bean>

    <bean id="udaoimple" class="dao.UserDaoImplement"></bean>

TestClass2.java

public class TestClass2 {
    @Test
    public void TestUserService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        UserService uservice = context.getBean("uservice", UserService.class);

        uservice.add();
    }
}

---

（5）基于xml方式注入内部bean和级联赋值

• 内部bean

有一个员工类（Emp）和一个部门类（dept），一个部门可以有多个员工，一个员工只能属于一个部门。此时使用对象类型属性进行表示。

代码示例：

Dept.java

public class Dept {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }
}

Empt.java

public class Emp {
    private String name;
    private String gender;

    //员工属于某一个部门，使用对象进行表示
    private Dept dept;

    public void setName(String name) {
        this.name = name;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

bean3.xml

	<bean id="emp" class="emp_dept.Emp">
        <!--设置两个普通属性-->
        <property name="name" value="minh"></property>
        <property name="gender" value="male"></property>

        <!--设置对象类型属性（内部bean的方式）-->
        <property name="dept">
            <bean id="dept" class="emp_dept.Dept">
                <property name="name" value="营销部"></property>
            </bean>
        </property>

    </bean>

Test.java

	@Test
    public void TestEmp_Dept(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        Emp emp = context.getBean("emp", Emp.class);

        System.out.println(emp);
    }

• 级联赋值

  （1）写法一

在Spring的配置文件中使用外部bean的方式进行赋值。

代码示例：

	<bean id="emp" class="emp_dept.Emp">
        <!--设置两个普通属性-->
        <property name="name" value="minh"></property>
        <property name="gender" value="male"></property>

        <property name="dept" ref="dept"></property>
    </bean>

    <bean id="dept" class="emp_dept.Dept">
        <property name="name" value="财务部"></property>
    </bean>

  （2）写法二

直接在id=“emp” 的bean中添加property name=“dept.name”，但此时需要在Emp类中添加dept的get方法。

代码示例：

Emp.java

	//需要生成dept的get方法
    public Dept getDept() {
        return dept;
    }

bean3.xml

<bean id="emp" class="emp_dept.Emp">
        <!--设置两个普通属性-->
        <property name="name" value="minh"></property>
        <property name="gender" value="male"></property>

        <property name="dept" ref="dept"></property>

        <property name="dept.name" value="技术部"></property>

</bean>

    <bean id="dept" class="emp_dept.Dept">
<!--        <property name=dep"name" value="财务部"></property>-->
    </bean>

---

（6）基于xml方式注入集合属性

分别注入数组、list、set、map属性集合。

代码示例：

Student.java

public class Student {
    //数组类型
    private String[] courses;
    //list类型
    private List<String> list;
    //set类型
    private Set<String> set;
    //map类型
    private Map<String, String> map;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void output(){
        System.out.print(Arrays.toString(courses));
        System.out.println();
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
    }
}

Bean4.xml

	<bean id="student" class="Collection.Student">
        <property name="courses">
            <array>
                <value>java课</value>
                <value>python课</value>
                <value>php课</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>set1</value>
                <value>set2</value>
                <value>set3</value>
            </set>
        </property>

        <property name="map">
            <map>
                <entry key="map1" value="map1"></entry>
                <entry key="map2" value="map2"></entry>
                <entry key="map3" value="map3"></entry>
            </map>
        </property>
    </bean>

Test.java

	@Test
    public void TestStudent(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

        Student student = context.getBean("student", Student.class);

        student.output();
    }

---

（7）基于xml方式注入集合属性（2）

• 集合中为对象类型值

  例如定义一个Student类和一个course类，每一个student有多门course。

代码示例：

course.java

public class course {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "course{" +
                "name='" + name + '\'' +
                '}';
    }
}

Student.java

public class Student {
    private List<course> courseList;
    public void setCourseList(List<course> courseList) {
        this.courseList = courseList;
    }

    public void output(){
        System.out.println(courseList);
    }
}

Bean4.xml

<bean id="student" class="Collection.Student">
   <!--注入list集合类型，值为对象-->
   <property name="courseList">
       <list>
           <ref bean="course1"></ref>
           <ref bean="course2"></ref>
           <ref bean="course3"></ref>
       </list>
   </property>
</bean>

<!--创建多个course对象-->
<bean id="course1" class="Collection.course">
    <property name="name" value="c1"></property>
</bean>
<bean id="course2" class="Collection.course">
    <property name="name" value="c2"></property>
</bean>
<bean id="course3" class="Collection.course">
    <property name="name" value="c3"></property>
</bean>

Test.java

	@Test
    public void TestStudent(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

        Student student = context.getBean("student", Student.class);

        student.output();
    }

• 把集合注入部分提取出来

  需要在Spring配置文件中引入名称空间util，使用util标签完成集合类型属性注入，以list类型集合为例。

代码示例：

Tools.java

public class Tools {
    private List<String> name;

    public void setName(List<String> name) {
        this.name = name;
    }

    public void output(){
        System.out.println(name);
    }
}

Bean5.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:util="http://www.springframework.org/schema/util"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!--提取list集合的属性值-->
    <util:list id="toolsList">
        <value>tool1</value>
        <value>tool2</value>
        <value>tool3</value>
    </util:list>

    <!--完成属性值的注入-->
    <bean id="tools" class="Collection.Tools">
        <property name="name" ref="toolsList"></property>
    </bean>

</beans>

Test.java

	@Test
    public void TestTools(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");

        Tools tools = context.getBean("tools", Tools.class);

        tools.output();
    }

---

5、Bean管理之FactoryBean

Spring中有两种类型Bean，一种普通Bean，另一种为FactoryBean（工厂Bean）。

普通Bean：在配置文件中定义的bean类型（class=…）就是返回类型（测试类中的对象）；

工厂Bean：在配置文件中定义的bean类型可以和返回类型不一样。

实现方法，让自定义的类实现FactoryBean接口，并重写其中的方法。

例：定义一个MyBean类，实现FactoryBean接口，重写其中的getObject()方法，定义返回类型为course，并编写相应的Spring配置文件和测试类，在测试类中返回类型定义为course。

代码示例：

MyBean.java

public class MyBean implements FactoryBean<course> {

    //定义返回bean
    @Override
    public course getObject() throws Exception {
        course c1 = new course();
        c1.setName("java");
        return c1;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

bean6.xml

	<bean id="mybean" class="MyBean">
    </bean>

Test.java

	@Test
    public void TestMyBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");
        course cou = context.getBean("mybean", course.class);
        System.out.println(cou);
    }

---

6、Bean管理之Bean的作用域

bean的作用域是指：在Spring里面，设置创建bean实例是单实例还是多实例。

在Spring里面，默认情况下，bean是单实例对象。

如何设置单实例还是多实例：

（1）在Spring配置文件bean标签中有属性（scope）用于设置单实例还是多实例；

（2）scope属性值有：singleton（默认值）、prototype、request、session

singleton：表示单实例对象

prototype：表示多实例对象

区别：scope设置为singleton，在加载Spring配置文件时就会创建单实例对象；而设置为prototype时，在调用getBean方法时才创建多实例对象。

代码示例：

	<bean id="tools" class="Collection.Tools" scope="prototype">
        <property name="name" ref="toolsList"></property>
    </bean>

---

7、Bean管理之Bean的生命周期

生命周期：从对象创建到对象消亡的过程。

Bean 的生命周期：

（1）通过构造器创建bean实例（无参构造）

（2）为bean的属性设置值和对其他bean引用（调用set方法）

（3）把bean实例传递给bean后置处理器的方法（postProcessBeforeInitialization）

（4）调用bean的初始化的方法（需要进行配置初始化的方法）

（5）把bean实例传递给bean后置处理器的方法（postProcessAfterInitialization）

（6）使用bean（获取到了对象）

（7）当容器关闭时，调用bean的消亡方法（需要进行配置消亡的方法）

代码示例：

创建一个commodity类，设置一个无参构造方法，以及初始化和消亡方法；

在Spring配置文件中进行相应的配置，初始化和消亡方法分别有对应的属性（init-method、destroy-method）；

新建一个类（BeanPost），实现BeanPostProcessor（bean后置处理器）接口，重写其中的两个方法，并在Spring配置文件中配置对应的后置处理器；

最后在Test测试类中使用bean，并手动销毁bean实例（((ClassPathXmlApplicationContext)context).close();）

Commodity.java

public class commodity {
    private String name;

    //无参构造方法
    public commodity() {
        System.out.println("第一步：创建bean实例");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步：调用set方法设置属性值");
    }

    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("第四步：执行初始化的方法");
    }

    //创建执行的消亡方法
    public void destoryMethod(){
        System.out.println("第七步：执行消亡方法");
    }

}

BeanPost.java

public class BeanPost implements BeanPostProcessor {

    //执行初始化之前执行的方法
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步：执行初始化之前执行的方法");
        return bean;
    }

    //执行初始化之后执行的方法
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步：执行初始化之后执行的方法");
        return bean;
    }
}

Bean7.xml

	<bean id="commodity" class="BeanLifeCycle.commodity" init-method="initMethod" destroy-method="destoryMethod">
        <property name="name" value="iphone"></property>
    </bean>

    <!--配置后置处理器-->
    <bean id="beanpost" class="BeanLifeCycle.BeanPost"></bean>

Test.java

	@Test
    public void TestCommodity(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");

        commodity com = context.getBean("commodity", commodity.class);

        System.out.println("第六步：获取创建的bean实例对象");

        //手动销毁bean实例
        ((ClassPathXmlApplicationContext)context).close();
    }

---

8、Bean管理之基于xml方式的自动装配

自动装配是指根据指定装配规则（属性名称/属性类型），Spring自动将匹配的属性值进行注入。

代码示例：

（1）根据属性名称自动注入(byName)

（2）根据属性类型自动注入(byType)

代码示例：

Bean8.xml

	<!--自动装配
    bean标签autowire，配置自动装配
    autowire属性常用两个值：byName、byType
    byName：根据属性名称注入，注入值bean的id值和类属性名称一样
    byType：
    -->
    <bean id="one" class="AutoWire.one" autowire="byName">

    </bean>

    <bean id="two" class="AutoWire.two"></bean>

---

9、Bean管理之外部属性文件

常见在数据库文件配置中。

以配置druid数据库信息为例。（需要引入druid连接池jar包）

原本的方式：直接配置数据库信息

	<!--直接配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc,Driver"></property>
        <property name="url" value="jdbc://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

引入外部属性方式：引入外部属性文件方式配置数据库信息

首先，创建外部属性文件（.properties格式）;

再把外部properties属性文件引入到Spring配置文件中。

引入context名称空间

jdbc.properties

prop.driverClassName=com.mysql.jdbc,Driver
prop.url=jdbc://localhost:3306/userDb
prop.username=root
prop.password=root

Bean9.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置连接池-->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

</beans>

---

10、基于注解方式的Bean管理

注解是代码的特殊标记，使用注解是为了简化xml配置。

Spring针对Bean管理中创建对象提供下列注解：@Component，@Service，@Controller，@Repository

注：上述四个注解功能一样，都可以用来创建bean实例，但实际开发中习惯每个有各自用途。

（1）基于注解方式创建对象

过程：

• 引入注解

• 开启组件扫描

  需要引入context名称空间

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

    <!--开启组件扫描
        当需要扫描多个包的时候
        1、多个包用逗号隔开          ->base-package="AnnotationTest.dao, AnnotationTest.service"
        2、使用扫描的多个包的上层目录  ->base-package="AnnotationTest"
    -->
    <context:component-scan base-package="AnnotationTest"></context:component-scan>
    
</beans>

• 在创建的类上面添加创建对象注解

/*
    在注解里面value属性值可以省略不写，
    如果省略不写，则默认值为首字母小写的类名
 */
@Component(value = "userService")       //value相当于bean中的id属性
public class UserService {
    public void add(){
        System.out.println("Service add......");
    }
}

• 使用测试类进行测试

 	@Test
    public void TestService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean10.xml");

        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }

---

补充

上述的组件扫描扫描的是包里的所有带注解的类/方法/属性，若想要只扫描指定部分，有以下两种方式：

use-default-filters=“false”：表示现在不使用默认filter，自己配置filter

• context:include-filter：设置扫描哪些内容

• context:exclude-filter：设置哪些内容不扫描

  代码示例：

	<!--示例1
        use-default-filters="false" 表示现在不使用默认filter，自己配置filter
        context:include-filter      设置扫描哪些内容
    -->
    <context:component-scan base-package="AnnotationTest" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

    <!--示例2
        下面配置扫描包的所有内容
        context:exclude-filter  设置哪些内容不扫描
    -->
    <context:component-scan base-package="AnnotationTest" use-default-filters="false">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

---

（2）基于注解方式注入属性

i、@Autowired

根据属性类型进行自动装配。

示例：创建service和dao两个类，分别添加创建对象注解，在service中注入dao对象，添加dao类型属性，在属性上面使用注解。此时不需要添加set方法

代码示例：

UserService.java

@Service
public class UserService {

    //定义dao类型属性
    @Autowired	//根据类型进行注入
    private UserDao userdao;

    public void add(){
        System.out.println("Service add......");
        userdao.add();
    }
}

ii、@Qualifier

根据属性名称进行注入。

@Qualifier注解需要和@Autowire配合一起使用！

示例：一个接口可以有多个实现类，若仅根据类型注入，无法确定为哪个类，而在@Autowire的基础上添加@Qualifier，就可以确定是哪一个具体的实现类。

此时需要分别在接口实现类的创建对象注解和@Qualifier注解中添加value值，二者要一致。

代码示例：

UserDaoImplement.java

@Repository(value = "userDaoImp1")
public class UserDaoImplement implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDao add......");
    }
}

UserService.java

@Service
public class UserService {

    //定义dao类型属性
    @Autowired
    @Qualifier(value = "userDaoImp1")	//根据名称进行注入
    private UserDao userdao;

    public void add(){
        System.out.println("Service add......");
        userdao.add();
    }
}

iii、@Resource（不建议使用）

既可以根据类型注入，又可以根据名称注入。

		@Resource		//根据类型进行注入
		//@Resource(name = "userDaoImp1")		//根据名称进行注入
		private UserDao userdao;

iiii、@Value

注入普通类型属性

代码示例：

		@Value(value = "myValue")
		private String name;

---

11、完全注解开发

（1）创建配置类，替代xml配置文件

代码示例：

@Configuration
@ComponentScan(basePackages = {"AnnotationTest"})
public class SpringConfig {

}

（2）重新编写测试类

将之前的ClassPathXmlApplicationContext替换为AnnotationConfigApplicationContext，并添加创建的配置类。

代码示例：

public class TestClass1 {
    @Test
    public void TestService(){
        ApplicationContext context = new AnnotationConfigApplicationContext(config.SpringConfig.class);

        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}

---

四、AOP

1、基本概念

AOP（面向切面编程），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度江都，提高程序的可重用性，同时提高了开发的效率。

通俗理解就是不通过修改源代码的方式，在主干功能里添加新的功能。

以登录流程为例：

---

2、底层原理

AOP底层使用动态代理。

动态代理分为两种：

（1）有接口情况，使用JDK动态代理

创建接口实现类代理对象，增强类的方法

（2）没有接口情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法

---

3、JDK动态代理的实现

需要使用Proxy类中的方法创建代理对象，调用其中的newProxyInstance方法。

该方法有三个参数：

（1）ClassLoader：类加载器；

（2）类[] interfaces：增强方法所在的类，这个类实现的接口，支持多个接口；

（3）InvocationHandler：实现这个接口，创建代理对象，写增强的部分。

代码示例：

（1）创建接口，定义方法；

（2）创建接口实现类，实现方法；

（3）使用Proxy类创建接口代理对象。

UserDao.java

public interface UserDao {
    public int add(int a, int b);

    public String update(String s);
}

UserDaoImplement.java

public class UserDaoImplement implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行");
        return a+b;
    }

    @Override
    public String update(String s) {
        System.out.println("update方法执行");
        return s;
    }
}

JDKProxy.java

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};

        //第一种，new InvocationHandler()直接通过匿名内部类重写其中的invoke方法
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });

        //第二种，通过创建一个类，该类继承InvocationHandler，再创建该类的对象
        UserDaoImplement userDao = new UserDaoImplement();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(1, 2);
        System.out.println("result:"+result);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

    //把需要创建代理对象的类传递过来
    //方式：有参构造
    //为了通用性，使用Object代替具体的类（相当于用Object代替了UserDao）
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //被增强的方法之前要执行的代码
        System.out.println("在方法之前执行"+method.getName()+"  参数："+ Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(obj, args);

        //被增强的方法之后要执行的代码
        System.out.println("在方法之后执行"+obj);

        return res;
    }
}

---

4、AOP操作术语

（1）连接点

一个类里面可以被增强的方法，就称为连接点。

（2）切入点

一个类里面实际被真正增强的方法，称为切入点。

（3）通知（增强）

实际增强的逻辑部分，称为通知（增强）。

通知有多种类型：

前置通知

后置通知

环绕通知

异常通知

最终通知

（4）切面

把通知应用到切入点的过程，就称为切面。切面是一个动作过程。

---

5、AOP操作之简要介绍

（1）Spring框架一般是基于AspectJ实现AOP操作

AspectJ不是Spring组成部分，独立于AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

（2）基于AspectJ实现AOP操作

• 基于xml配置文件实现
• 基于注解方式实现（推荐）

（3）在项目工程中引入AOP相关依赖

以maven方式引入：

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9.1</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

（4）切入点表达式

• 作用：

  知道对哪个类的什么方法进行增强。

• 语法结构

  execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))

举例1：对java.SpringTest.JDKProxy类里面的update方法进行增强

execution(* java.SpringTest.JDKProxy.update(…))

*表示任意

举例2：对java.SpringTest.JDKProxy类里面的所有方法进行增强

execution(* java.SpringTest.JDKProxy.*(…))

举例3：对java.SpringTest包里所有的类，以及类里面的所有的方法进行增强

execution(* java.SpringTest..(…))

---

6、基于注解方式的AOP操作

（1）创建类，在类中定义方法

//被增强的类
@Component
public class User {

    public void add(){
        System.out.println("add......");
    }
}

（2）创建增强类（编写增强逻辑）

//增强的类
@Component
@Aspect     //生成代理对象
public class UserProxy {

    //前置通知
    //@before表示作为前置通知
    @Before(value = "execution(* AOPAnnotation.User.add(..))")
    public void before(){
        System.out.println("before......");
    }

    //最终通知
    @After(value = "execution(* AOPAnnotation.User.add(..))")
    public void after(){
        System.out.println("after......");
    }

    //后置通知
    @AfterReturning(value = "execution(* AOPAnnotation.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }

    //异常通知
    @AfterThrowing(value = "execution(* AOPAnnotation.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }

    //环绕通知
    @Around(value = "execution(* AOPAnnotation.User.add(..))")
    public void around(){
        System.out.println("around......");
    }
}

（3）进行通知配置

• 在Spring配置文件中，开启注解扫描
• 使用注解创建两个类对象
• 在增强类上面添加注解@Aspect
• 在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"

       xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="AOPAnnotation"/>

    <!-- 开启AspectJ生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

（4）抽取相同的切入点

当若干个切入点都相同时，可以对这若干个切入点做一个抽取。

代码示例：

	@Pointcut(value = "execution(* AOPAnnotation.User.add(..))")
    public void point(){
    }

    @Before(value = "point()")
    public void before(){
        System.out.println("before......");
    }

（5）设置增强类优先级

当有多个增强类对同一个方法进行增强时，可以设置增强类的优先级。

• 在增强类上面添加注解@Order（int类型值）

  值越小，优先级越高

---

7、基于xml文件的AOP操作（不推荐）

代码示例：

//增强类
public class Book {
    public void name(){
        System.out.println("book name");
    }
}

//被增强的类
public class BookProxy {
    public void before(){
        System.out.println("before......");
    }
}

	<!-- 创建对象 -->
    <bean id="book" class="AOPxml.Book"></bean>
    <bean id="bookProxy" class="AOPxml.BookProxy"></bean>

    <!-- 配置aop增强 -->
    <aop:config>
        <!-- 配置切入点 -->
        <aop:pointcut id="p" expression="execution(* AOPxml.Book.name())" />

        <!-- 配置切面 -->
        <aop:aspect ref="bookProxy">
            <!-- 配置增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>

 		@Test
    public void TestAOPxml(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean02.xml");

        Book book = context.getBean("book", Book.class);

        book.name();
    }

---

8、完全注解开发

代码示例：

@Configuration
@ComponentScan(basePackages = {"AOPxml"})       //开启注解扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)    //开启Aspect生成代理对象
public class ConfigAOP {
}

	@Test
    public void TestAOPxml(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AOPxml.ConfigAOP.class);

        Book book = context.getBean("book", Book.class);

        book.name();
    }

---

五、JdbcTemplate

1、基本概念

JdbcTemplate：Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库的操作。

---

2、准备工作

（1）引入相关jar包（maven方式）

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.3.19</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.29</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.9</version>
        </dependency>

（2）在Spring配置文件中配置数据库连接池

	<!-- 数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc,Driver"></property>
        <property name="url" value="jdbc:mysql:///user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

（3）配置JdbcTemplate对象，注入DataSource

	<!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

（4）创建Service和Dao类，在Dao注入jdbcTemplate对象

• 配置文件

	<!-- 开启组件扫描 -->
    <context:component-scan base-package="JdbcTest"></context:component-scan>

• BookService

@Service
public class BookService {

    //注入属性
    @Autowired
    private BookDao bookDao;
}

• BookDaoImplement

@Repository
public class BookDaoImplement implements BookDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

---

3、JdbcTemplate操作数据库

（1）添加功能

• 新建一个Book类（与数据库表中的字段对应），并添加对应的set和get方法

public class Book {
    private String userId;
    private String userName;
    private String ustatus;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

• 在BookService和BookDao中添加对应的方法

	//添加的方法
    public void addBook(Book book){
        bookDao.add(book);
    }

public interface BookDao {
    //添加的方法
    public void add(Book book);
}

• 调用JdbcTemplate对象中的update方法实现添加操作

  该方法有两个参数：

  1：sql语句

  2：可变参数，用于设置sql语句值

public class BookDaoImplement implements BookDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        //创建sql语句
        String sql = "insert into t_book values(?,?,?)";	//？表示占位符

        //调用update方法
        Object[] args = {book.getUserId(), book.getUserName(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);

    }
}

• 编写测试类进行测试

	@Test
    public void TestJdbc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        Book book = new Book();
        book.setUserId("100");
        book.setUserName("we three");
        book.setUstatus("sold out");
        bookService.addBook(book);
    }

---

（2）修改和删除功能

先分别在BookService和BookDao中添加对应的修改和删除方法，在BookDaoImplement实现类中重写该方法，再进行测试。

BookDaoImplement.java

	//修改
    @Override
    public void modify(Book book) {
        String sql = "update t_book set username=?,ustatus=? where user_id = ?";
        Object[] args = {book.getUserName(), book.getUstatus(), book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    //删除
    @Override
    public void delete(String id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

---

（3）查询功能

i、查询返回某个值

例如：查询表中的记录数

先分别在BookService和BookDao中添加对应的查询方法，在BookDaoImplement实现类中重写该方法。在重写的方法中调用jdbcTemplate对象中的queryForObject方法。

该方法之一有两个参数：

1：sql语句

2：返回类型的class

BookDaoImplement.java

	//查询表的记录数
    @Override
    public int count() {
        String sql = "select count(1) from t_book";
        Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
        return integer;
    }

ii、查询返回对象

例如：查询商品详情

先分别在BookService和BookDao中添加对应的查询方法，在BookDaoImplement实现类中重写该方法。在重写的方法中调用jdbcTemplate对象中的queryForObject方法。

该方法之二有三个参数：

1：sql语句

2：RowMapper（一个接口），返回不同类型数据，使用这个接口里面的实现类可以完成数据封装

3：sql语句值

BookDaoImplement.java

	//查询返回对象
    @Override
    public Book find(String id) {
        String sql = "select * from t_book where user_id = ?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

Test.java

	@Test
    public void TestJdbc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        Book one = bookService.findOne("1");
        System.out.println(book);
    }

iii、查询返回集合

例如：查询一页商品

先分别在BookService和BookDao中添加对应的查询方法，在BookDaoImplement实现类中重写该方法。在重写的方法中调用jdbcTemplate对象中的query方法。

该方法有三个参数：

1：sql语句

2：RowMapper（一个接口），返回不同类型数据，使用这个接口里面的实现类可以完成数据封装

3：sql语句值（可以省略不写）

BookDaoImplement.java

	//查询返回集合
    @Override
    public List<Book> findall() {
        String sql = "select * from t_book";
        List<Book> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return query;
    }

Test.java

	@Test
    public void TestJdbc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        List<Book> all = bookService.findAll();
        System.out.println(all);
    }

---

（4）批量功能

一次可以操作表里的多条记录。

先分别在BookService和BookDao中添加对应的批量方法，在BookDaoImplement实现类中重写该方法。使用的是jdbcTemplate对象中的batchUpdate方法。

该方法有两个参数：

1：sql语句

2：list集合，添加多条记录数据

以批量添加为例，批量修改，批量删除都同理。

BookImplement.java

	//批量添加
    @Override
    public void batchAdd(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

Test.java

	@Test
    public void TestJdbc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        BookService bookService = context.getBean("bookService", BookService.class);

        //批量添加
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"1", "2", "3"};
        Object[] o2 = {"4", "5", "6"};
        Object[] o3 = {"7", "8", "9"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);
    }

---

六、事务

1、基本概念

事务是数据库操作最基本的单位，逻辑上一组操作，要么全做要么全不做，是一个不可分割的基本单位。

典型场景：银行转帐。

事务四个特性（ACID）：

原子性

一致性

隔离性

持久性

---

2、搭建事务操作环境

以银行转帐为例。

（1）创建数据库表，添加两条记录；

（2）创建service和dao类，完成对象创建和注入关系；

   service中注入dao，dao中注入JdbcTemplate，在JdbcTemplate中注入DataSource

（3）在dao中创建两个方法（多钱和少钱），在service创建方法（转账）；

（4）编写测试类进行测试。

代码示例：

Bean.xml

	<!-- 开启组件扫描 -->
    <context:component-scan base-package="JdbcTest"></context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${prop.driverClassName}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

    <!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

UserService.java

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    //转账
    public void SendMoney(){
        userDao.reduceMoney();
        userDao.addMoney();
    }
}

UserDaoImplement.java

@Repository
public class UserDaoImplement implements UserDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;

    //多钱
    @Override
    public void addMoney() {
        String sql = "update t_account set money = money + ? where username = ?";
        jdbcTemplate.update(sql, "b");
    }

    //少钱
    @Override
    public void reduceMoney() {
        String sql = "update t_account set money = money - ? where username = ?";
        jdbcTemplate.update(sql, "a");
    }
}

Test.java

	@Test
    public void TestTransaction(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        UserService userService = context.getBean("userService", UserService.class);

        userService.SendMoney();
    }

注：

上述代码，在使用转账时，因为一方少钱，另一方多钱为两个事务，因此可能出现一方钱少了，而另一方钱没有多的情况，为了避免这类情况的发生，引入事务。

---

3、Spring事务管理

（1）事务一般添加在JavaEE三层结构中的Service层（业务逻辑层）；

（2）在Spring进行事务管理操作有两种方式；

编程式事务管理（不推荐）

声明式事务管理

（3）声明式事务管理的方式；

基于注解方式（推荐）

基于xml配置文件方式

（4）Spring进行声明式事务管理时，底层使用 AOP原理；

（5）Spring事务管理API提供类一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类。

---

4、基于注解方式的声明式事务管理

（1）在Spring配置文件中配置事务管理器；

（2）在配置文件中开启事务注解，需引入 名称空间tx；

（3）在service类或者具体的方法上添加事务注解 @Transactional；

添加到类上就是整个类的所有方法都添加事务；

添加到方法上就是只有这个方法添加事务

代码示例：

	<!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

@Service
@Transactional()
public class UserService {
  //方法体
}

---

5、声明式事务管理之事务参数

在注解@Transactional里面可以添加配置事务的相关参数。

（1）propagation：事务传播行为

多事务方法直接进行调用，这个过程中事务是如何进行管理的。通俗理解就是当在一个方法中调用另一个方法时，Spring是如何处理的。

最常用的两种是：REQUIRED（默认）、REQUIRES_NEW

REQUIRED：先看看当前存不存在事务，假如存在事务的话就加进去，不存在就新建一个事务；

REQUIRES_NEW：不管当前有没有事务，都会创建一个新事物。

（2）isolation：事务隔离级别

事务有隔离性，指的是多个事物之间互不影响，若没有隔离性会产生一系列问题。例如：脏读、不可重复读、虚/幻读。

脏读：一个未提交的事务读取到了另一个未提交的事务的数据。

不可重复读：一个未提交事务读取到另一提交事务修改后的数据。

虚读：一个未提交数据读取到另一个提交事务添加的数据。

名称	数据的状态	实际行为	产生原因
脏读	未提交	打算提交但数据回滚，读取了提交后的数据	数据的读取
不可重复读	已提交	读取了修改前的数据	数据的修改
幻读	已提交	读取了插入前的数据	数据的插入

解决办法：设置事务隔离级别

名称	结果	脏读	不可重复读	幻读
READ UNCOMMMITTED（读未提交）	都未解决	Y	Y	Y
READ COMMITTED（读已提交）	解决了脏读问题	N	Y	Y
REPEATABLE READ（可重复读）默认方式	解决了不可重复读问题	N	N	Y
SERIALIZABLE（序列化）	解决了所有问题	N	N	N

（3）timeout：超时时间

规定事务在设置的时间内提交，假如没有提交就回滚，默认值为-1，即不设置时间。

（4）readOnly：是否只读

read：读，即查询操作。

readOnly默认为false，表示可以查询，添加修改删除操作；readOnly 为true，表示只能查询操作。

（5）rollbackFor：回滚

设置出现哪些异常进行事务回滚。

（6）noRollbackFor：不回滚

设置出现哪些异常不进行事务回滚。

---

6、基于xml方式的声明式事务管理（不推荐）

需在Spring配置文件中进行配置：

（1）配置事务管理器

（2）配置通知

（3）配置切入点和切面

代码示例：

<?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:aop="http://www.springframework.org/schema/aop"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="JdbcTest"></context:component-scan>

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${prop.driverClassName}" />
        <property name="url" value="${prop.url}" />
        <property name="username" value="${prop.username}" />
        <property name="password" value="${prop.password}" />
    </bean>

    <!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 创建事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入dataSource -->
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 配置通知 -->
    <tx:advice id="txadvice">
        <!-- 配置事务参数 -->
        <tx:attributes>
            <!-- 指定在什么方法上添加事务-->
            <tx:method name="SendMoney" propagation="REQUIRED" isolation="REPEATABLE_READ"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置切入点和切面 -->
    <aop:config>
        <!-- 配置切入点 -->
        <aop:pointcut id="p" expression="execution(* Transaction.Service.UserService.*(..))" />

        <!-- 配置切面 -->
        <aop:advisor advice-ref="txadvice" pointcut-ref="p" />
    </aop:config>

</beans>

---

7、完全注解开发

创建配置类，使用配置类替代xml配置文件。

包括创建数据库连接池、JdbcTemplate对象、事务管理器。

txConfig.java

@Configuration                                  //配置类
@ComponentScan(basePackages = "Transaction")    //组件扫描
@EnableTransactionManagement                    //开启事务
public class txConfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/user_db?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到IOC容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

Test.java

	@Test
    public void TestTransaction2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(txConfig.class);

        UserService userService = context.getBean("userService", UserService.class);

        userService.SendMoney();
    }

---