一篇文章学会Spring的使用

一、Spring概述

• 轻量级开源框架
• Spring可以解决企业应用开发的复杂性
• IOC、AOP
  • IOC：控制反转，把创建对象过程交给Spring进行管理
  • AOP：面向切面，不修改源代码进行功能增强
• 特点：
  • 方便解耦，简化开发
  • AOP编程支持
  • 方便程序测试
  • 方便和其他框架进行整合
  • 方便进行事务操作
  • 降低API开发难度

二、Spring的下载

https://repo.spring.io/release/org/springframework/spring

3.1、Spring的使用前提

3.1.1.导入Srping依赖

<dependencies>
    <!--单元测试：通过单元测试可以测试每一个方法-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
     <!--Spring的依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.2.6.RELEASE</version>
      </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
  </dependencies>

三、IOC接口

• IOC思想基于IOC容器实现，IOC容器底层就是对象工厂
• Spring提供IOC容器实现两种方式：(两个接口)
  • BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用
    • 加载配置文件时候不会创建对象，在获取对象(使用)才去创建对象
  • ApplicationContext:BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
    • 加载配置文件的时候就会把在配置文件中的对象进行创建

3.1. IOC操作Bean管理

3.1.1. 什么是Bean管理

• Bean管理指的是两个操作

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

• Bean管理操作有两种方式

  基于xml配置文件方式实现

  • 基于xml方式创建对象

    • <!-- 配置 User对象创建 -->
      
      <bean id = "user" class="com.zkt.spring5.User"> </bean>
      

    • 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

    • 在bean标签中有很多属性

      • id属性：唯一标识
      • class属性：类全路径(包路径)

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

  • 在Spring配置文件配置对象创建，配置属性注入

    • 使用set方法注入属性（set注入）

        <bean id = "user" class="com.zkt.spring5.pojo.User">
            <property name="name" value="zkt"/>
            <property name="age" value="18"/>
             <!--给属性设置null值-->
            <property name="address">
                <null/>
            </property>
                <!--属性值包含特殊符号
                1. 把<>进行转义
                2. 把带特殊符号内容写到CDATA
            -->
            <property name="address">
                <value><![CDATA[<<南京>>]]></value>
            </property>
        </bean>
    

    • 使用有参数构造注入

        <bean id = "orders" class="com.zkt.spring5.pojo.Order">
            <constructor-arg name="name" value="abc"/>
            <constructor-arg name="address" value="仲恺"/>
        </bean>
    

    • 注入外部Bean

    使用ref属性注入对象

     <bean id = "userService" class="com.zkt.spring5.service.UserService">
            <property name="userDao" ref="userDao"/>
     </bean>
     <bean id = "userDao" class="com.zkt.spring5.dao.UserDaoImpl"/>
    

    • 注入属性-内部Bean和级联赋值

            <!--内部bean-->
    <bean id ="emp" class="com.zkt.spring5.pojo.Emp">
            <property name="name" value="zkt"/>
            <property name="gender" value="男"/>
            <property name="dept">
                <bean id = "dept" class="com.zkt.spring5.pojo.Dept">
                    <property name="name" value="科技部"/>
                </bean>
            </property>
    </bean>
    

        <bean id ="emp" class="com.zkt.spring5.pojo.Emp">
            <!--级联赋值-->
            <property name="name" value="zkt"/>
            <property name="gender" value="男"/>
            <property name="dept" ref="dept"/>
            <!-- dept中属性需要有get方法-->
            <property name="dept.name" value="人才部"/>
        </bean>
        <bean id="dept" class="com.zkt.spring5.pojo.Dept"/>
    

    • 注入数组、List集合、Map集合

    

     <bean id="stu" class="com.zkt.spring5.collectiontype.Stu">
                <property name="courses">
                    <array>
                        <value>高数</value>
                        <value>java</value>
                        <value>数据库</value>
                    </array>
                </property>
                <property name="list">
                    <list>
                        <value>张三</value>
                        <value>李四</value>
                        <value>王五</value>
                    </list>
                </property>
                <property name="maps">
                    <map>
                        <entry key="JAVA" value="java"/>
                        <entry key="PHP" value="pho"/>
                    </map>
                </property>
                <property name="sets">
                    <set>
                        <value>MySQL</value>
                        <value>Redis</value>
                    </set>
                </property>
            </bean>
    

    • 把集合部分提取出来

    1.首先在xml配置文件中首部导入

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

    如图所示：

    2.使用util标签完成list集合注入提取

    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>
    

    3.使用

    <bean id="book" class="com.zkt.spring5.collectiontype.Book">
            <property name="list" ref="bookList"/>
    </bean>
    

    • FactoryBaen

      Spring有两种类型的bean，一种普通bean，另外一种工厂bean(FactoryBean)

      普通bean：在配置文件中定义bean类型就是返回类型。

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

      ​ 第一步 创建类，让这个类作为工厂bean，实现接口FactoryBean

      

      ​ 第二步 实现接口里面的方法，在实现的方法中定义返回的bean类型

          <bean id="myBean" class="com.zkt.spring5.factorybean.MyBean">
      
          </bean>
      

      

       ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config3.xml");
              Course course = (Course)applicationContext.getBean("myBean", Course.class);
              System.out.println(course);
      

  基于注解方式实现

使用注解，注解作用在类上面，方法上面，属性上面

使用注解的目的：简化xml配置

使用步骤：

• 一、引入AOP依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

• 二、开启组件扫描

引入context的名称空间

<!--
开启组件扫描：1. 如果扫描多个包，多个包之间用逗号隔开
             2. 扫描包上层目录
-->
<context:component-scan base-package="com.zkt.spring5">

</context:component-scan>

• 三、创建类，使用@注解

//在注解里面value属性值可以省略不写。
//默认值是类名称,首字母小写

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

<!--
    下面配置扫描包所有内容
    context:exclude-filter：设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.zkt" use-default-filters="false">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
</context:component-scan>

基于注解实现属性注入

• @Autowired：根据属性类型进行自动装配
• @Qualifier：根据属性名称进行注入(与@Autowired配合使用)
• @Resource：可以根据类型注入，可以根据名称注入
• @Value：注入普通类型属性

完全注解开发

@Configuration //作为配置类，替代xml配置文件

①创建配置类，替代xml配置文件

@Configuration
@ComponentScan(basePackages = {"com.zkt.spring5.dao"})
public class SpringConfig {
    
}

②编写测试类

    @Test
    public void test6(){
        ApplicationContext context = new 		AnnotationConfigApplicationContext(SpringConfig.class);			//通过加载配置类创建容器
        UserDao userDao = context.getBean("userDao",UserDao.class);
        System.out.println(userDao);
    }

3.2. Bean的作用域

在Spring里面，设置创建bean实例默认是单实例的。

也就是说在配置文件中一个bean标签或者@Bean注解，就是一个实例，在容器中无论获取多少次，都是同一个实例。

设置Bean的作用域

scope属性值

• singleton，默认值，表示是单实例对象
• prototype，表示是多实例对象

singleton和prototype区别

第一singleton是单实例，prototype多实例

第二 设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象

​ 设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象。

• reques
• session
• global session

3.3. Bean的生命周期

生命周期是从对象创建到对象销毁的过程

• 1.通过构造器创建bean实例(无参构造器)
• 2.为bean的属性设置值和对其他bean引用
• 3.把bean实例传递给bean的后置处理器的方法postProcessBeforeInitialization(在初始化之前执行)
• 4.调用bean的初始化的方法(需要进行配置初始化的方法)
• 5.把bean实例传递给bean的后置处理器的方法postProcessAfterInitialization(在初始化之后执行)
• 6.bean的使用
• 7.当容器关闭的时候，调用bean的销毁的方法(需要进行配置销毁的方法)

3.4. 自动装配

3.4.1. 什么是自动装配？

根据指定装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入

3.4.2. 根据属性名称自动注入

bean标签属性autowire，配置自动装配，autowire属性常用有两个值：

​ byName根据属性名称注入，注入值bean的id值和类属性名称一样

​ byType根据属性类型注入

3.4.3. 根据属性类型自动注入

    <!-- 使用byType时必须只有一个类型匹配，否则会报错-->
	<bean id="emp" class="com.zkt.spring5.autowire.Emp" autowire="byType"/>
    <bean id="dept" class="com.zkt.spring5.autowire.Dept"/>

四、核心配置文件

4.1.配置连接池

• 导入依赖(如druid)

       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>

• 创建配置文件xml及properties文件

在xml文件中引入properties文件

在spring配置文件中引入properties文件如图

<!--引入外部文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

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

    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--    声明数据源DataSource，作用是链接数据库的-->
   	  <!--
      关键字 "classpath:" , 表示类路径，告诉spring到类路径中查找配置文件
  -->
   <!--包含其他的配置文件-->
   <!--
   <import resource="classpath:ba06/spring-school.xml"/>
   <import resource="classpath:ba06/spring-student.xml"/>
   -->
   <!--使用通配符，指定多个配置文件。
       通配符“*”，表示0或多个字符
       注意：总的文件名称（total.xml）,不能包含在通配符的范围内，不能叫做spring-total.xml
   -->
   <!--<import resource="classpath:ba06/spring-*.xml"/>  -->

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-		method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--    声明事务处理：和源代码完全分离的-->
    <!--    声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--   配置事务(xml方式，可以使用注解方式配置) -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!--        配置事务属性-->
        <tx:attributes>
            <!--   tx:method:给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
                    name：方法名称。1)完整的方法名称，不带有包和类。
                                   2）方法可以使用通配符，*表示任意字符 如buy*
                   propagation：传播行为，枚举值
                   isolation：隔离级别
                   rollback-for：指定的异常类名，全限定类名，发生异常一定回滚-->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="NullPointException,NotEnoughException" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <!--    配置aop(使用xml声明事务)-->
    <aop:config>
        <!--        配置切入点表达式：指定哪些包中类，要使用事务
        id:切入点表达式的名称，唯一值
        expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象-->
        <aop:pointcut id="ServicePt" expression="execution(* *..service..*.*(..))"/>
        <!--        配置增强器：关联advice和pointcut-->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="ServicePt"/>
    </aop:config>
</beans>

五、AOP

5.1. 基本概念

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

5.2. 底层原理

5.2.1. AOP底层使用动态代理

有两种动态代理的情况

• 有接口的情况，使用jdk动态代理
• 没有接口的情况，使用CGLIB动态代理

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
        proxyInstance.getBelief();
        proxyInstance.eat("冰淇淋");
    }
}
interface Human{
    public void getBelief();
    public void eat(String food);
}
class SuperMan implements Human{
    public void getBelief() {
        System.out.println("I believe I can fly！");
    }

    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
class ProxyFactory{

    public static Object getProxyInstance(Object obj){

        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        myInvocationHandler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), myInvocationHandler);

    }
}
class MyInvocationHandler implements InvocationHandler{

    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("前增强");
        Object returnValue = method.invoke(obj, args);
        System.out.println("后增强");
        return returnValue;
    }
}

5.3. AOP术语

切点：指实际被增强的方法。

连接点：指所有可以被增强的方法

切面：管理通知和切点，将通知应用到切入点的过程。

通知：

• 前置通知
• 后置通知
• 环绕通知
• 异常通知
• 返回通知

5.4. AOP使用

基于AspectJ实现AOP操作

• 基于xml配置文件实现
• 基于注解方式实现(使用)

5.4.1.切入点表达式

作用：知道对哪个类里面的哪个方法进行增强

语法结构：

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

举例1：对com.zkt.dao.BookDao类里面的add进行增强

execution(* com.zkt.dao.BookDao.add(…))

举例2：对com.zkt.dao.BookDao类里面的所有方法进行增强

execution(* com.zkt.dao.BookDao.*(…))

举例3：对com.zkt.dao包里面的所有类，类里面所有方法进行增强

execution(* com.zkt.dao.*.*(…))

5.4.2.AOP使用

1. 引入依赖

           <!-- AOP相关Jar -->
           <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-aspects</artifactId>
               <version>5.2.6.RELEASE</version>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
           <dependency>
               <groupId>org.aspectj</groupId>
               <artifactId>aspectjweaver</artifactId>
               <version>1.6.8</version>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance -->
           <dependency>
               <groupId>aopalliance</groupId>
               <artifactId>aopalliance</artifactId>
               <version>1.0</version>
           </dependency>
   
           <!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
           <dependency>
               <groupId>net.sourceforge.cglib</groupId>
               <artifactId>com.springsource.net.sf.cglib</artifactId>
               <version>2.2.0</version>
           </dependency>
   

2. 引入约束

xmlns:aop=“http://www.springframework.org/schema/aop”

​ http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"

在配置文件中添加<aop:aspectj-autoproxy/> 开启Aspect生成代理对象，在@Configuration配置类中可以使用

@EnableAspectJAutoProxy(proxyTargetClass = true)代替

3.在需要切面类上加上注解@Aspect并使用@Component创建界面类

4.使用通知、切点表达式对对象进行增强

5.4.3.相同的切入点抽取

在方法上使用@Pointcut注解

在通知中切点表达式中使用该方法

5.4.4.设置多个相同通知的优先级

在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

5.4.5.配置文件实现AOP(了解)

• 在配置文件中配置切入点
• 配置切面
• 配置增强在具体的方法上

六、Spring与事务

6.1.事务操作

事务一般添加到JavaEE三层结构里面的Service层(业务逻辑层)

有两种事务管理操作

1. 编程式事务管理(一般不用)
2. 声明式事务管理

声明式事务管理

• 基于注解方式(使用)
• 基于xml配置文件方式

底层使用的是AOP原理

6.1.1.使用步骤（注解方式）

• 导入依赖

<!--spring的事务-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>
<!--spring访问数据库-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>

• 添加命名空间

• 创建事务管理器

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <!--    声明事务处理：和源代码完全分离的-->
    <!--    声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

• 开启事务注解(注解方式才需要配置)

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

• 在Service类上面(或者service类里面方法上面)添加事务注解@Transactional
  • 如果把这个注解添加到类上面，这个类里面所有的方法都添加事务
  • 如果把这个注解添加方法上面，为这个方法添加事务

6.1.2.使用步骤（配置文件方式）

• 导入依赖（注意需要引入aop的依赖）

<!--spring的事务-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>
<!--spring访问数据库-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>

• 添加命名空间

• 创建事务管理器

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <!--    声明事务处理：和源代码完全分离的-->
    <!--    声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

• 配置通知

<!--   配置事务(可以使用注解方式配置) -->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--        配置事务属性-->
    <tx:attributes>
        <!--   tx:method:给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
                name：方法名称。1)完整的方法名称，不带有包和类。
                               2）方法可以使用通配符，*表示任意字符 如buy*
               propagation：传播行为，枚举值
               isolation：隔离级别
               rollback-for：指定的异常类名，全限定类名，发生异常一定回滚-->
        <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                   rollback-for="NullPointException,NotEnoughException" read-only="false"/>
    </tx:attributes>
</tx:advice>
<!--    配置aop(使用xml声明事务)-->
<aop:config>
    <!--        配置切入点表达式：指定哪些包中类，要使用事务
    id:切入点表达式的名称，唯一值
    expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象-->
    <aop:pointcut id="ServicePt" expression="execution(* *..service..*.*(..))"/>
    <!--        配置增强器：关联advice和pointcut-->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="ServicePt"/>
</aop:config>

6.1.3.使用步骤（完全注解方式）

根据注解+配置文件的方式，使用配置类实现

@Configuration//配置类
@ComponentScan(basePackages = "com.zkt")//组件扫描
public class TxConfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3305/userDB");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("root");
        return druidDataSource;
    }
    //创建jdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

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

6.2.事务属性参数配置

@Transactional 的所有可选属性如下所示：
➢ propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为 Propagation.REQUIRED。
➢ isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为 Isolation.DEFAULT。
➢ readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值 为 false。
➢ timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为 -1，即没有时限。在实际业务开发中一般不设置。
➢ rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有 一个异常类时，可以不使用数组。
➢ rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。 当然，若只有一个异常类时，可以不使用数组。
➢ noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若 只有一个异常类时，可以不使用数组。
➢ noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空 数组。当然，若只有一个异常类时，可以不使用数组。

需要注意的是，@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public 方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该 方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。 若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

6.2.1.propagation:事务传播行为

多事务方法直接进行调用，这个过程中事务是如何进行管理的

注解方式配置

@Transactional(propagation = Propagation.REQUIRED)

6.2.2.isolation:事务隔离级别

事务有隔离性，如果不考虑隔离性，会产生很多问题：如脏读、不可重复度、幻读。

注解方式设置事务的隔离级别：

isolation = Isolation.READ_COMMITTED

6.2.3.timeout:超时时间

事务需要在一定时间内进行提交，如果不提交，则会进行回滚

默认值是-1，设置时间以秒为单位进行计算

注解方式配置超时时间

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1)

6.2.4.readOnly:是否只读

读：查询操作。 写：添加修改删除操作

readOnly默认值为false，表示可以查询，可以添加修改删除操作

设置readOnly值是true之后只能查询。

注解方式配置readOnly

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = true)

6.2.5.rollbackFor:回滚

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

注解方式配置.rollbackFor

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,
        timeout = -1,readOnly = true,rollbackFor = NullPointerException.class,noRollbackFor = IOException.class)

6.2.6.noRollbackFor:不回滚

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

注解方式配置：noRollbackFor

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,
        timeout = -1,readOnly = true,rollbackFor = NullPointerException.class,noRollbackFor = IOException.class)

七、Spring整合日志log4j2

7.1.使用步骤

• 引入相关依赖

<dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.11.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.11.2</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.30</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j-impl</artifactId>
        <version>2.11.2</version>
    </dependency>

• 创建log4j2.xml配置文件(名字固定)

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} 【%t】 %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

八、Spring集成MyBatis

8.1.步骤

• 新建Maven项目
• 导入spring依赖、mybatis依赖、mysql驱动、spring的事务依赖、mybatis和spring继承的依赖。

    <!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<!--spring-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<!--spring的事务-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<!--spring访问数据库-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<!--mybatis的依赖-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>
<!--mybatis整合spring的依赖：创建mybatis对象-->
<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>5.1.42</version>
</dependency>
<!--数据库连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

• 创建实体类
• 创建dao接口和mapper文件
• 创建mybatis主配置文件

<?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>
        <package name="com.zkt.spring5.pojo"/>
    </typeAliases>
    <mappers>
        <!--        <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>-->
        <package name="com.zkt.spring5.mapper"/>
    </mappers>
</configuration>

• 创建service接口和实现类，属性是dao

• 创建spring的配置文件：声明mybatis的对象交给spring创建

  • 数据源

      <context:property-placeholder location="classpath:jdbc.properties"/>
      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
          <property name="url" value="${jdbc.url}"/>
          <property name="username" value="${jdbc.username}"/>
          <property name="password" value="${jdbc.password}"/>
  <!--        <property name="maxActive" value="${jdbc.max}"/>-->
      </bean>
  

  • SqlSessionFactory

      <!--   声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
          <property name="dataSource" ref="dataSource"/>
          <!--mybatis主配置文件的位置
          configLocation属性是Resource类型，读取配置文件
          它的赋值，使用value，指定文件的路径，使用classpath：表示文件的位置
          -->
          <property name="configLocation" value="classpath:mybatis.xml"/>
      </bean>
  

  • Dao对象

      <!--    创建dao对象，使用SqlSession的getMapper(xxx.class),MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。-->
      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
          <property name="basePackage" value="com.zkt.spring5.mapper"/>
      </bean>
  

  • 声明自定义的service（可以使用注解）

  <?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">
      <!--    声明数据源DataSource，作用是链接数据库的-->
      <context:property-placeholder location="classpath:jdbc.properties"/>
      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
          <property name="url" value="${jdbc.url}"/>
          <property name="username" value="${jdbc.username}"/>
          <property name="password" value="${jdbc.password}"/>
  <!--        <property name="maxActive" value="${jdbc.max}"/>-->
      </bean>
      <!--   声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
          <property name="dataSource" ref="dataSource"/>
          <!--mybatis主配置文件的位置
          configLocation属性是Resource类型，读取配置文件
          它的赋值，使用value，指定文件的路径，使用classpath：表示文件的位置
          -->
          <property name="configLocation" value="classpath:mybatis.xml"/>
      </bean>
      <!--    创建dao对象，使用SqlSession的getMapper(xxx.class),MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。-->
      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
          <property name="basePackage" value="com.zkt.spring5.mapper"/>
      </bean>
      <context:component-scan base-package="com.zkt.spring5"/>
      <!--    声明事务处理：和源代码完全分离的-->
      <!--    声明事务管理器对象-->
      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="dataSource"/>
      </bean>
  <!--    <bean id="userService" class="com.zkt.spring5.service.impl.UserServiceImpl">-->
  <!--        <property name="userMapper" ref="userMapper"/>-->
  <!--    </bean>-->
  <!--    &lt;!&ndash;   配置事务 &ndash;&gt;-->
  <!--    <tx:advice id="myAdvice" transaction-manager="transactionManager">-->
  <!--        &lt;!&ndash;        配置事务属性&ndash;&gt;-->
  <!--        <tx:attributes>-->
  <!--            &lt;!&ndash;            tx:method:给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性-->
  <!--                    name：方法名称。1)完整的方法名称，不带有包和类。-->
  <!--                                   2）方法可以使用通配符，*表示任意字符-->
  <!--                   propagation：传播行为，枚举值-->
  <!--                   isolation：隔离级别-->
  <!--                   rollback-for：指定的异常类名，全限定类名，发生异常一定回滚&ndash;&gt;-->
  <!--            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"-->
  <!--                       rollback-for="NullPointException,NotEnoughException" read-only="false"/>-->
  <!--        </tx:attributes>-->
  <!--    </tx:advice>-->
  <!--    &lt;!&ndash;    配置aop(使用xml声明事务)&ndash;&gt;-->
  <!--    <aop:config>-->
  <!--        &lt;!&ndash;        配置切入点表达式：指定哪些包中类，要使用事务-->
  <!--id:切入点表达式的名称，唯一值-->
  <!--expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象&ndash;&gt;-->
  <!--        <aop:pointcut id="ServicePt" expression="execution(* *..service..*.*(..))"/>-->
  <!--        &lt;!&ndash;        配置增强器：关联advice和pointcut&ndash;&gt;-->
  <!--        <aop:advisor advice-ref="myAdvice" pointcut-ref="ServicePt"/>-->
  <!--    </aop:config>-->
  </beans>
  

• 创建测试类，完成数据库访问

如果出现错误，可以导入插件

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory><!--所在的目录-->
                <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <!--指定jdk版本为1.8-->
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>