Spring框架一文详解

Spring

一：Spring概述

Spring全家桶：

​ Spring，SpringMVC，SpringBoot，SpringCloud

Spring：

​ 出现在2002年左右，解决企业开发的难度，减轻对项目模块之间的管理，类和类之间的管理，帮助开发人员创建对象，管理对象之间的关系。

Spring核心技术：

​ ioc（控制反转），aop(面向切面编程)。能够实现模块之间，类之间的解耦合。

依赖：

​ Class A中使用Class B的属性或者方法，叫做Class A依赖Class B。

框架怎么学：

​ 框架是一个软件，其他人写好的软件。

1）：知道框架能做什么，myBatis–>访问数据库的框架，对表中的数据执行增删改查。

2）：框架的语法，框架要完成一个功能，需要一定的步骤支持的。

3）：有工作经验以后，需要学习框架的内部实现，框架内部怎么做，原理是什么？

4）：通过学习，可以自己写一个框架。

二：Ioc 控制反转

1)：Ioc(（Inversion of Control)

**控制反转：**是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。

IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖

注入。应用广泛。

控制： 创建对象，对象的属性赋值，对象之间的关系管理。

**反转：**把原来的开发人员管理，创建对象的权力转移给代码之外的容器实现，由容器代替开发人员管理对象，创建 对象，给属性赋值。

**正转：**由开发人员在代码中，使用new 构造方法创建对象，开发人员主动管理对象。

**容器：**是一个服务器软件，也是一个框架（Spring）。

为什么要使用 ioc：目的就是减少对代码的改动，也能实现不同的功能。实现解耦合。

java中创建对象有哪些方式：

​ 1：构造方法：new Student()

​ 2：反射

​ 3：序列化

​ 4：克隆

​ 5：ioc：容器创建对象

​ 6：动态代理

ioc的体现：

​ servlet 1：创建类继承HttpServlet

​ 2：在Web.xml中注册servlet。

​ 3：我们没有创建过 Servlet对象，没有MyServlet myservlet = new MyServlet();

​ 4：Servlet对象 是Tomcat服务器创建的。Tomcat也称为容器。

​ Tomcat作为容器：里面存放的有Servlet对象，Listener(监听器)，Filter(过滤器)对象等。

ioc的技术实现：

​ DI（Dependency Injection） 是ioc的技术实现。

​ **DI：**依赖注入，只需要在程序中提供要使用的对象名称就可以，至于对象如何在容器中创建，赋值，查找，都 由容器内部实现。

​ Spring是使用的di实现了ioc的功能，spring底层创建对象，使用的是反射机制。

​ Spring是一个容器，用来管理对象，给属性赋值，底层使用反射机制创建对象。

每日一道Java面试题

记得关注我【Java有话说】

2)：Spring的第一个程序

实现步骤：

实现步骤：
    1:创建maven项目

    2:加入maven的依赖
        spring的依赖

    3:创建类
        和没有使用框架一样，就是普通的类。

    4:创建spring需要使用的配置文件。在main目录下的resources目录下创建 Spring Config
        声明类的信息，这些类由spring创建和管理。

    5:测试spring创建的对象。

pom.xml：加入spring依赖

<!--spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.7.RELEASE</version>
</dependency>

Spring Config 配置文件：

<?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通过这个名称来找到这个对象
    calss：类的全限定名称（不能是接口，因为spring是反射机制创建对象，必须使用类）

    spring底层就完成 SomeService someService = new SomeServiceImpl();
    spring是把创建好的对象放入到map中，spring框架有一个map存放对象的。
        springMap.put(id的值，对象);
        例如：springMap.put("someService",new SomeServiceImpl())

    一个bean标签声明一个对象。
-->
    <bean id="someService" class="com.sss.service.impl.SomeServiceImpl"/>
</beans>

<!--
    spring的配置文件
    1.beans：是根标签，spring把java对象称为bean。
    2.spring-beans.xsd 是约束文件，和myBatis中的dtd是一样的。
-->

@Test：

/*测试spring*/
@Test
public void testDoSome2(){
    //使用spring容器创建的对象
    // 1：指定spring配置文件的名称。
    String config = "beans.xml";

    //2：创建表示spring容器的对象，ApplicationContext
    //ApplicationContext就是表示spring容器，就可以通过容器获取对象了。
    //new ClassPathXmlApplicationContext(配置文件路径);
    //ClassPathXmlApplicationContext：表示从类路径中加载spring的配置文件的。
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);

    //3：从容器中获取对象，你要调用对象的方法。
    //ac.getBean("配置文件中的bean的id值");
    //转换成接口类型。
    SomeService service = (SomeService) ac.getBean("someService");
    
}

3)：spring默认创建对象的时间

在创建spring容器时，就会创建配置文件中所有的对象。

spring创建对象：默认调用的是无参数构造方法。

4)：获取spring容器中，java对象的信息

/**
 * 获取spring容器中，java对象的信息。
 */
@Test
public void testDoSome3(){
    String config = "beans.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);

    //使用spring提供的方法，获取容器中定义的对象的数量。
    int count = ac.getBeanDefinitionCount();
    System.out.println("count="+count); //1

    //获取容器中每个定义的对象的名称。
    String[] names = ac.getBeanDefinitionNames();
    for (String name:names){
        System.out.println("name="+name);
    }
}

5)：获取一个非自定义的类对象

<!--
    spring能创建一个非自定义的对象吗？可以 创建一个已经存在的某个类的对象
-->
<bean id="mydate" class="java.util.Date" />

@Test
public void testDoSome4(){
    String config = "beans.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);

    //获取当前的系统时间
    Date date = (Date)ac.getBean("mydate");
    System.out.println(date);
}

三：基于xml的DI

1)：di表示

依赖注入，表示创建对象，给属性赋值

2)：di的注入分类

1）set注入(设值注入)

​ spring调用类的set方法，在set方法可以实现属性的赋值。
​ 80%左右都是使用的set注入。

​ 简单类型的设值注入实现：

<!--声明Student对象
    注入：就是赋值的意思。
    简单类型：spring中规定基本数据类型和字符串都是简单类型。
    di：给属性赋值
        1：set注入（设值注入）：spring调用类的set方法，你可以在set方法中完成属性赋值。
            1）：简单类型的set注入
                <bean id = "" class = "">
                    <property name = "属性名字" value ="属性的值" />
                    一个property只能给一个属性赋值
                </bean>
-->
<bean id="mystudent" class="com.sss.ch01.Student">
    <property name="name" value="小黑"/><!--setName("小黑")-->
    <property name="age" value= "20"/>
</bean>

​ 引用类型的设值注入实现：

​ 当指定 bean 的某属性值为另一 bean 的实例时，通过 ref 指定它们间的引用关系。ref的值必须为某 bean 的 id 值。

<!--声明Student对象-->
<bean id="mystudent" class="com.sss.ch02.Student">
    <property name="name" value="小黑"/>
    <property name="age" value= "20"/>
    <!--引用类型-->
    <property name="school" ref="myschool"/>
</bean>

<!--声明School对象-->
<bean id="myschool" class="com.sss.ch02.School">
    <property name="name" value="青清校园"/>
    <property name="addres" value="河南省开封市"/>
</bean>

​ 设值注入的注意事项：

​ 必须有set方法。

​ 设置注入只是使用set方法。

​ value的值必须使用引号。

2）构造注入

​ spring调用类的有参构造方法，创建对象，在构造方法中完成赋值。

<!--声明Student对象
    构造注入：spring调用类的有参构造方法，创建对象，在构造方法中完成赋值。
        构造注入使用<constructor-arg>标签
        <constructor-arg> 标签：一个<constructor-arg>表示构造方法一个参数
        <constructor-arg> 标签属性：
            name：表示构造方法的形参名
            index：表示构造方法的位置，参数从左往右位置是0，1，2的顺序。
            value：构造方法的形参类型是简单类型，使用value
            ref：构造方法的形参类型是引用类型，使用ref

-->
    <bean id="mystudent" class="com.sss.ch03.Student">
        <constructor-arg name="name" value="小黑"/>
        <constructor-arg name="age" value= "20"/>
        <constructor-arg name="school" ref="myschool"/>
    </bean>

 <!--使用index属性-->
    <bean id="mystudent2" class="com.sss.ch03.Student">
        <constructor-arg index="0" value="小黑"/>
        <constructor-arg index="1" value= "20"/>
        <constructor-arg index="2" ref="myschool"/>
    </bean>

<!--按照位置顺序，可以省略index属性-->
    <bean id="mystudent2" class="com.sss.ch03.Student">
        <constructor-arg value="小黑"/>
        <constructor-arg value= "20"/>
        <constructor-arg ref="myschool"/>
    </bean>

<!--声明School对象-->
    <bean id="myschool" class="com.sss.ch03.School">
        <constructor-arg name="name" value="青清校园"/>
        <constructor-arg name="addres" value="河南省开封市"/>
    </bean>

 <!--小案例：创建File，使用构造方法注入-->
    <bean id="myfile" class="java.io.File">
        <constructor-arg name="parent" value="E:\Ajax_jQuery_maven_mybatis_Spring_Springmvc\Spring\ch01_Spring" />
        <constructor-arg name="child" value="readme.txt"/>
    </bean>

构造注入必须有：带参构造方法

3：引用类型属性自动注入

​ 对于引用类型属性的注入，也可不在配置文件中显示的注入。可以通过为标签

设置 autowire 属性值，为引用类型属性进行隐式自动注入（默认是不自动注入引用类型属

性）。

根据自动注入判断标准的不同，可以分为两种：

byName：根据名称自动注入

byType： 根据类型自动注入

1）byName方式自动注入

根据名称自动注入

<!--
    引用类型的自动注入：spring框架根据某些规则可以给引用类型赋值。不用你再给引用类型赋值
    使用的规则常用的是 byName，byType
    1.byName：按名称注入，java类中引用类型的属性名spring容器中(配置文件)<bean>的id名称一样，
              且数据类型是一致的，这样的容器中的bean，spring能够赋值给引用类型。
      语法：
         <bean id = "xx" class = "yy" autowire="byName">

         </bean>
-->
<bean id="mystudent" class="com.sss.ch04.Student" autowire="byName">
    <property name="name" value="小黑"/>
    <property name="age" value= "20"/>
    <!--<property name="school" value="school"/>-->
</bean>

<!--声明School对象-->
<bean id="school" class="com.sss.ch04.School">
    <constructor-arg name="name" value="青清校园"/>
    <constructor-arg name="addres" value="河南省开封市"/>
</bean>

2）byType方式自动注入

根据类型自动注入

<!--
    byType：按类型注入，java类中引用类型的数据类型和spring容器中被调用者的<bean>的class属性是同源关系，这样的bean能够赋值给引用类型。
    同源：就是一类的意思
          1.java类中引用类型的数据类型和bean的class的值是一样的。
          2.java类中引用类型的数据类型和bean的class的值是父子类的关系。
          3.java类中引用类型的数据类型和bean的class的值是接口和实现类的关系。
    语法：
        <bean id = "xx" class = "yy" autowire="byType">

        </bean>
-->
<bean id="mystudent" class="com.sss.ch05.Student" autowire="byType">
    <property name="name" value="小绿"/>
    <property name="age" value= "20"/>
    <!--<property name="school" value="school"/>-->
</bean>

<!--声明School对象-->
<bean id="myschool" class="com.sss.ch05.School">
    <constructor-arg name="name" value="开封大学"/>
    <constructor-arg name="addres" value="河南省开封市"/>
</bean>

注意：

但这样的同源的被调用 bean 只能有一个。多于一个，容器就不知该匹配

哪一个了。

3）多个spring配置文件

优势：

​ 1：每个文件的大小比一个文件要小很多，效率高。

​ 2：避免多人竞争带来的冲突。

​ 如果你的项目有很多个模块（相关功能在一起），一个模块一个配置文件。

多配置文件的分配方式：

​ 1：按功能模块，一个模块一个配置文件

​ 2：按类的功能，数据库相关的配置一个配置文件，做事务的功能一个配置文件，做service功能的一个配置文件等。

<!--
    包含关系的配置文件：
    spring-total表示主配置文件：包含其他的配置文件的。
        主配置文件，一般是不定义对象的。
        语法：
            <import resource="其他配置文件的路径"/>
        关键字："classpath:"表示类路径（class文件所在目录，在spring的配置文件中要指定其他文件的位置
                需要使用classpath，告诉spring到哪里去加载读取文件。
-->

<!--加载的是文件列表-->
<import resource="classpath:ch06/spring-school.xml"/>
<import resource="classpath:ch06/spring-student.xml"/>

<!--
    在包含关系的配置文件中，可以使用通配符(*：表示任意字符)
    注意：主的配置文件名称不能包含在通配符的范围内（不能叫spring-total.xml）,
          否则将出现循环递归包含
-->
<!--<import resource="classpath:ch06/spring-*.xml"/>-->

注意：

主的配置文件名称不能包含在通配符的范围内（不能叫spring-total.xml）,否则将出现循环递归包含。

使用通配符这种方式，配置文件必须有上级目录，不然读取不到。

4）基于注解的DI

通过注解完成java对象创建，属性赋值。

1.加入maven的依赖 spring-context，在你加入spring-context时，会间接加入spring-aop的依赖。

​ 使用注解必须使用spring-aop依赖。

2.在类中加入spring的注解（多个不同功能的注解）

3.在spring的配置文件中，加入一个组件扫描器的标签。说明注解在你的项目中的位置。

需要学习的注解：

​ 1.@Component

​ 2.@Respotory

​ 3.@Service

​ 4.@Controller

​ 5.@Value

​ 6.@Autowired

​ 7.@Resource

@Component @Repository @Service @Controller

Java：

/**
 * @Component：创建对象的，等同于<bean>的功能
 *      属性：value 就是对象的名称，也就是bean的id值
 *            value的值是唯一的，创建的对象在整个spring容器中就一个。
 *
 *      位置：在类的上面书写
 *
 *      @Component(value = "myStudent")等同于：
 *          <bean id = "myStudent" calss = "com.sss.ch01.Student"/>
 *          表示创建的是Student类的对象，名字叫做myStudent
 *
 *		spring中和@Component 功能一致，创建对象的注解还有：
 *          1.@Repository（用在持久层类的上面）：放在dao的实现类上面，表示创建dao对象，dao对象是能访	*				问数据库的。
 *          2.@Service（用在业务层类的上面）：放在service的实现类上面，创建service对象，service对象	*				是做业务处理的。
 *              可以有事务等功能的。
 *          3:@Controller（用在控制器的上面）：放在控制器(处理器)类的上面，创建控制器对象的，
 *              控制器对象，能够接受用户提交的参数，显示请求的处理结果。
 *
 *          以上三个注解的使用语法和@Component 一样的，都能创建对象，但是这三个注解还有额外的功能。
 *
 *          @Repository，@Service，@Controller 是给项目的对象分层的。
 */
//使用value属性，指定对象的名称
//@Component(value = "myStudent")

//可以省略value，(最常用)
@Component("myStudent")

//不指定对象名称，由spring提供默认名称：类名，首字母是小写
//@Component
public class Student {
    private String name;
    private int age;

    public Student() {
        System.out.println("无参构造执行了！");
    }
}

spring配置文件：

<!--声明组件扫描器(component-scan)，组件就是java对象
    base-package：用来指定注解在你的项目中的包名。
    component-scan工作方式：spring会扫描遍历base-package指定的包，
        把包中和子包中所有的类，全部扫描，然后找到类中的注解，按照注解的功能创建对象，或给属性赋值。

    （了解）加入了 component-scan 标签，配置文件的变化：
        1.加入了一个新的约束文件spring-context.xsd
        2.给这个新的约束文件起个命名空间的名称：xmlns:context="http://www.springframework.org/schema/context"
-->
<context:component-scan base-package="com.sss.ch01"/>

指定多个包的方式

<!--指定多个包的三种方式-->
<!--第一种方式：使用多次组件扫描器，指定不同的包-->
<context:component-scan base-package="com.sss.ch01"/>
<context:component-scan base-package="com.sss.ch02"/>

<!--第二种方式：使用分隔符(;或,)分割多个包名-->
<context:component-scan base-package="com.sss.ch01;com.sss.ch02"/>

<!--第三种方式：指定父包-->
<context:component-scan base-package="com.sss"/>

@Value

给简单类型赋值

@Component("myStudent")
public class Student {

    /**
     * @Value：简单类型的属性赋值
     *      属性：value 是String类型的，表示简单类型的属性值
     *      位置：
     *          1.在属性定义的上面，无需set方法，推荐使用。
     *          2.或者在set方法的上面。
     */

    @Value(value = "小黑")
    private String name;
    @Value(value = "20")
    private int age;

@Autowired

实现引用类型的赋值

@Component("myStudent")
public class Student {

    @Value(value = "小黑")
    private String name;
    @Value(value = "20")
    private int age;

    /**
     * @Autowried：spring框架提供的注解，实现引用类型的赋值，
     *      spring中通过注解给引用类型赋值，使用的是自动注入原理。支持byName，byType
     *
     * @Autowried：默认使用的是byType自动注入
     *
     * @Autowried：属性：required，是一个boolean类型的，默认是true
     *              required = true：表示引用类型赋值失败，程序报错，并终止执行。推荐使用默认true。
     *              required = false：表示引用类型赋值失败，程序正常执行，引用类型是null。
     *
     * 位置：1.在属性定义的上面，无序set方法。推荐使用
     *      2.或者在set方法的上面
     *
     * 如果要使用byName方式，需要做的是俩注解一起写：
     *  1.在属性上面加入@Autowired
     *  2.在属性的上面加入@Quakufier(value="bean的id")：表示使用指定名称完成赋值。
     */

    //byType自动注入
    //@Autowired

    //byNmae自动注入
    @Autowired(required = false)
    @Qualifier("mySchool")
    private School school;

@Resource

JDK注解@Resource自动注入：引用类型属性赋值

@Component("myStudent")
public class Student {

    @Value(value = "小黑")
    private String name;
    @Value(value = "20")
    private int age;

    /**
     * @Resource：来自jdk中的注解，spring框架提供了对这个注解的功能支持，可以使用它给引用类型赋值
     *            使用的也是自动注入原理，支持byName，byType，默认是byName
     *       位置：
     *          1.在属性的上面定义，无需set方法，推荐使用
     *          2.在set方法上面
     *
     *       默认是byName：先使用byName自动注入，如果byName赋值失败，再使用byType
     *
     * @Resource 如果只使用byName方式，需要增加一个属性 name
     *  name的值是bean的id（名称）：@Resource(name = "mySchool")
     *
     */
    @Resource
    private School school;

四：AOP面向切面编程

动态代理：

​ 实现方式：jdk动态代理，使用jdk中的Proxy，Method，InvocationHandler创建代理对象。

​ jdk动态代理要求目标类必须实现接口。

​ cglib动态代理：第三方的工具库，创建代理对象，原理是继承，通过继承目标类，创建子类。

​ 子类就是代理对象，要求目标类不能是final的，方法也不能是final的。

​ 动态代理的作用：

​ 1）在目标类源代码不改变的情况下，增加功能。

​ 2）减少代码的重复。

​ 3）专注业务逻辑代码。

​ 4）解耦合，让你的业务功能和日志，事务等非业务功能分离。

1）AOP简介

AOP（Aspect Orient Programming），面向切面编程。面向切面编程是从动态角度考虑程序运行过程。

**Aspect 切面：**给你的目标类增加的功能，就是切面。

切面的特点：一般都是非业务方法，独立使用的。

**Orient ：**面向，对着。

**Programming：**编程。

AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB的动态代理。

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，可通过运行期动态代理实现程序功能的统一维护的一种技术。说白了：Aop就是动态代理的规范化，把动态代理的实现步骤，方法都定义好了，让开发人员都使用统一的方式。

AOP 是 Spring 框架中的一个重要内容。利用 AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2）怎么理解面向切面编程？

​ 1）需要在分析项目功能时，找出切面。

​ 2）合理的安排切面的执行时间（在目标方法前，还是在目标方法后）。

​ 3）合理的安排切面的位置，在那个类，那个方法增加增强功能。

3）术语

​ 1）Aspect：切面，表示增强的功能，就是一堆代码完成某一个功能。非业务功能。

​ 常见的切面功能有日志，事务，统计信息，参数检查，权限验证。

​ 2）JoinPoint：连接点，连接业务方法和切面的位置。就是某类中的业务方法。

​ 3）Pointcut：切入点，指多个连接点方法的集合。多个方法。

​ 4）目标对象：给那个类的方法增加功能，这个类就是目标对象。

​ 5）Advice：通知，通知表示切面功能执行的时间。

一个切面有三个关键的要素：

​ 1）切面的功能代码，切面干什么。

​ 2）切面的执行位置，使用Pointcut表示切面执行的位置。

​ 3）切面的执行时间，使用Advice表示时间，在目标方法之前，还是目标方法之后。

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个注解。

5）学习AspectJ框架的使用

1）切面的执行时间

​ 这个执行时间在规范中叫做Advice(通知，增强)

​ 在aspectJ框架中使用注解表示的。也可以使用xml配置文件中的标签。

​ 1）@Before

​ 2）@AfterReturning

​ 3）@Around

​ 4）@AfterThrowing

​ 5）@After

2）AspectJ的切入点表达式

​ AspectJ 定义了专门的表达式用于指定切入点。表达式的原型是：

execution(modifiers-pattern? ret-type-pattern 
declaring-type-pattern? name-pattern(param-pattern)
throws-pattern?)

解释：

modifiers-pattern] 访问权限类型

ret-type-pattern 返回值类型

declaring-type-pattern 包名类名

name-pattern(param-pattern) 方法名(参数类型和参数个数)

throws-pattern 抛出异常类型

？表示可选的部分

以上表达式共 4 个部分。

execution(访问权限 方法返回值 方法声明(参数) 异常类型)

6）AspectJ基于注解的AOP实现步骤(掌握)

实现步骤：

使用aop：目的是给已经存在的一些类和方法，增加额外的功能。前提是不改变原来的代码。

使用AspectJ实现aop的基本步骤：
    1.新建项目
    2.加入依赖
        1）spring依赖
        2）aspectJ依赖
        3）junit单元测试
    3.创建目标类：有接口和它的实现类
        要做的是给类中的方法增加功能。

    4.创建切面类：普通类
        创建要求：
            1）在类的上面加入 @Aspect
            2）在类中定义方法，方法就是切面要执行的功能代码
                在方法的上面加入aspectJ中的通知注解，例如@Before
                还需要指定切入点表达式execution()

    5.创建spring配置文件，声明对象，把对象交给容器统一管理。
        声明对象可以使用注解，或者xml配置文件<bean>
        1）声明目标对象
        2）声明切面对象
        3）声明aspectJ框架中的自动代理生成器标签。
            自动代理生成器：用来完成代理对象的自动创建功能的。

    6.创建测试类，从spring容器中获取目标对象（实际上就是代理对象）
        通过代理执行方法，实现aop的功能增强。

实现代码：

接口：

public interface SomeService {
    void doSome(String name,Integer age);
}

目标类：

/*使用注解：声明目标类对象*/
@Service("someserviceimpl")
public class SomeServiceImpl implements SomeService {

    @Override
    public void doSome(String name,Integer age) {
        //给doSome方法增加一个功能，在doSome()执行之前，输出方法的执行时间。
        System.out.println("=======目标方法doSome=======");
    }
}

@Before：前置通知

切面类：

**
 * @Aspect 是AspectJ框架中的注解。
 *  作用：表示当前类是切面类
 *  切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码。
 */
/*使用注解：声明切面类对象*/
@Component("myaspect")
@Aspect
public class MyAspect {

    /**
     * 定义方法：实现切面功能的。
     * 方法的定义要求：
     *  1.公共方法 public
     *  2.方法没有返回值
     *  3.方法名称自定义
     *  4.方法可以有参数，也可以没有参数。如果有参数，参数不是自定义的，
     *      有几个参数类型可以使用，后面会讲。
     */

    /**
     * @Before：前置通知注解
     *  属性：value：是切入点表达式，表示切面的功能执行的位置。
     *  位置：方法的上面
     *  例如：@Before(value = "execution(* com.sss.ch01.SomeServiceImpl.doSome(..))")
     *  特点：
     *      1.在目标方法之前先执行的
     *      2.不会改变目标方法的执行结果
     *      3.不会影响目标方法的执行。
     */

    /**
     * 指定通知方法中的参数：JoinPoint
     *  JoinPoint：业务方法，要加入切面功能的业务方法。
     *      作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法的实参。
     *      如果你的切面功能需要用到方法的信息，就加入JoinPoint。
     *      这个JoinPoint参数的值是由框架赋予的，必须是第一个位置的参数。
     */
    @Before(value = "execution(* com.sss.ch01.SomeServiceImpl.doSome(..))")
    public void someDate(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("输出日志时间："+new Date());
    }
}

spring配置文件：

<!--声明组件扫描器-->
<context:component-scan base-package="com.sss.ch01"/>

<!--声明自动代理生成器：使用aspectJ框架内部的功能，创建目标对象的代理对象。
    创建代理对象是在内存中实现的，修改目标对象的内存中的结构。创建为代理对象。
    所以目标对象就是一个被修改后的代理对象。

    aspectj-autoproxy：会把spring容器中的所有的目标对象，一次性都生成代理对象。
-->
<aop:aspectj-autoproxy/>

Test：

public class Test01 {
    @Test
    public void test01(){
        String config = "ch01/applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        SomeService service = (SomeService) ac.getBean("someserviceimpl");

        //com.sun.proxy.$Proxy14：jdk动态代理，目标类必须有接口。
        System.out.println(service.getClass().getName());

        service.doSome("小黑",20);
    }
}

@AfterReturning：后置通知及JoinPoint

@Component("myaspect")
@Aspect
public class MyAspect {

    /**
     * 后置方法定义方法：实现切面功能的。
     * 方法的定义要求：
     *  1.公共方法 public
     *  2.方法没有返回值
     *  3.方法名称自定义
     *  4.方法可以有参数的，推荐是Object，参数名是自定义的
     */

    /**
     * @AfterReturning 后置通知
     *  属性：1.value 切入点表达式
     *        2.returning 自定义的变量，表示目标方法的返回值的。
     *          自定义的变量名必须和通知方法的形参名一样。
     *  位置：在方法定义的上面
     *  特点：
     *      1.在目标方法之后执行的。
     *      2.能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能。
     *      3.可以修改这个返回值。
     *
     *  后置通知的执行：
     *      先执行：Object res = doOther();
     *      后执行：someDate(Object res);
     * @param res
     */
    @AfterReturning(value = "execution(* com.sss.ch02.SomeServiceImpl.doOther(..))",returning = "res")
    public void someDate(Object res){
        //Object res：是目标方法执行后的返回值，根据返回值做你的切面的功能处理。

        System.out.println("后置通知：在目标方法之后输出日志时间："+new Date());
        System.out.println("返回值是："+res);
    }
}

@Around：环绕通知

/*使用注解：声明切面类对象*/
@Component("myaspect")
@Aspect
public class MyAspect {

    /**
     * 环绕通知方法的定义格式
     *  1.public
     *  2.必须有一个返回值，推荐使用Object
     *  3.方法名称自定义
     *  4.方法有参数，固定的参数 ProceedingJoinPoint
     * @param res
     */
    /**
     * @Around：环绕通知
     *  属性：value 切入点表达式
     *  位置：在方法的定义上面
     * 特点：
     *  1.它是功能最强的通知
     *  2.在目标方法的前和后都能增强功能
     *  3.控制目标方法是否被调用执行
     *  4.可以修改原来的目标方法的执行结果。影响最后的调用结果。
     *
     *  环绕通知，等同于jdk动态代理，InvocationHandler接口。
     *
     *  参数：ProceedingJoinPoint 就等同于Method
     *      作用：执行目标方法的。
     *  返回值(Object)：就是目标方法的执行结果，可以被修改。
     *
     *  环绕通知：经常做事务，在目标方法之前开启事务，执行目标方法，在目标方法之后提交事务。
     * @param
     */
    @Around(value = "execution(* com.sss.ch03.SomeServiceImpl.doOther(..))")
    public Object someDate(ProceedingJoinPoint pj) throws Throwable {

        String name = "";
        //获取目标方法第一个参数的值
        Object[] args = pj.getArgs();
        if (args != null && args.length > 1){
            name = (String) args[0];
        }

        //实现环绕通知
        Object result = null;
        System.out.println("环绕通知：在目标方法之前，输出时间："+new Date());

        if ("小黑".equals(name)){
            //1.表示目标方法的调用，result相当于目标方法的执行结果。
            result = pj.proceed();   //method.invoke()
        }

        //2.在目标方法的前或者后加入功能。
        System.out.println("环绕通知：在目标方法之后，提交事务！");

        return result;
    }
}

@AfterThrowing：异常通知

/**
     * 异常通知方法的定义格式：
     *  1.public
     *  2.没有返回值
     *  3.方法名称自定义
     *  4.方法有一个Exception参数，如果还有，就是JoinPoint
     */

    /**
     * @AfterThrowing 异常通知
     *  属性：1.value 切入点表达式
     *        2.throwing 自定义的变量，表示目标方法抛出的异常
     *          变量名必须和参数的变量名一样。
     *  特点：
     *      1.在目标方法抛出异常时执行的。
     *      2.可以做异常的监控，监控目标方法执行时是不是有异常。
     *          如果有异常，可以发送邮件，短信进行通知。
     */
    @AfterThrowing(value = "execution(* com.sss.ch03.SomeServiceImpl.dofrist())",throwing = "ex")
    public void myAfterThrowing(Exception ex){
        System.out.println("异常通知：方法发生异常时，异常原因："+ex.getMessage());
    }

@After：最终通知

​ 无论目标方法是否抛出异常，该增强均会被执行。

/**
 * 最终通知方法的定义格式：
 *  1.public
 *  2.没有返回值
 *  3.方法名称自定义
 *  4.方法没有参数，如果还有，就是JoinPoint
 */

/**
 * @After：最终通知
 *  属性：value 切入点表达式
 *  位置：在方法的上面
 *
 * 特点：
 *  1.无论目标方法是否抛出异常，该增强均会被执行。
 *  2.在目标方法之后执行。
 */
@After(value = "execution(* com.sss.ch03.SomeServiceImpl.dofrist2())")
public void myAfter(){
    System.out.println("执行最终通知，总是会被执行！");
    //一般是做资源清除工作的。
}

@Pointcut 定义切入点

当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。AspectJ 提供了@Pointcut 注解，用于定义 execution 切入点表达式。

**用法：**将@Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。这个使用@Pointcut 注解的方法一般使用 private 的标识方法，即没有实际作用的方法。

@After(value = "mypt()")
public void myAfter(){
    System.out.println("执行最终通知，总是会被执行！");
    //一般是做资源清除工作的。
}

@Pointcut(value = "execution(* com.sss.ch03.SomeServiceImpl.dofrist2())")
private void mypt(){
    //无需代码
}

7）动态代理的使用方式

<!--
    如何你期望目标类有接口，使用cglib动态代理
    proxy-target-class="true"：告诉框架，你要使用cglib动态代理
-->
<aop:aspectj-autoproxy proxy-target-class="true"/>

五：Spring集成myBatis

​ 用的技术是：ioc。

​ 为什么ioc：能够把myBatis和spring集成在一起，像一个框架，是因为ioc能够创建对象。可以把myBatis框架中的对象交给spring统一创建，开发人员从spring中获取对象。开发人员就不用同时面对两个或多个框架了，就面对一个spring框架。

mybatis使用步骤，对象
1.定义dao接口 ，StudentDao
2.定义mapper文件 StudentDao.xml
3.定义mybatis的主配置文件 mybatis.xml
4.创建dao的代理对象， StudentDao dao = SqlSession.getMapper(StudentDao.class);

List students = dao.selectStudents();

要使用dao对象，需要使用getMapper()方法，
怎么能使用getMapper()方法，需要哪些条件
1.获取SqlSession对象， 需要使用SqlSessionFactory的openSession()方法。
2.创建SqlSessionFactory对象。 通过读取mybatis的主配置文件，能创建SqlSessionFactory对象

需要SqlSessionFactory对象， 使用Factory能获取SqlSession ，有了SqlSession就能有dao ， 目的就是获取dao对象
Factory创建需要读取主配置文件

我们会使用独立的连接池类替换mybatis默认自己带的， 把连接池类也交给spring创建。

主配置文件：

1.数据库信息 
<environment id="mydev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--数据库的驱动类名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--连接数据库的url字符串-->
                <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                <!--访问数据库的用户名-->
                <property name="username" value="root"/>
                <!--密码-->
                <property name="password" value="123456"/>
            </dataSource>

2. mapper文件的位置
   <mappers>
        <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
        <!--<mapper resource="com/bjpowernode/dao/SchoolDao.xml" />-->
    </mappers>

==============================================================
通过以上的说明，我们需要让spring创建以下对象
1.独立的连接池类的对象， 使用阿里的druid连接池
2.SqlSessionFactory对象
3.创建出dao对象

需要学习就是上面三个对象的创建语法，使用xml的bean标签。

spring和myBatis的集成：

ch07-ioc-myBatis：spring和myBatis的集成

步骤：
    1.新建maven项目
    2.加入maven的依赖
        1）spring依赖
        2）mybatis依赖
        3）mysql驱动
        4）spring的事务依赖
        5）mybatis和spring集成的依赖，mybatis官方提供的，用来在spring项目中创建mybatis
            的SqlSessionFactory，dao对象的。

    3.创建实体类
    4.创建dao接口和mapper文件
    5.创建mybatis主配置文件
    6.创建Service接口和实现类，属性是dao
    7.创建spring的配置文件：声明mybatis的对象交给spring创建
        1）数据源
        2）SqlSessionFactory
        3）dao对象
        4）声明自定义的service

    8.创建测试类，获取Service对象，通过service调用dao完成数据库的访问。

实际步骤代码：

加入maven依赖：

<!--导入阿里镜像，方便下载-->
  <repositories>
    <repository>
      <id>aliyunmaven</id>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </repository>
  </repositories>

<!--单元测试-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

<!--myBatis依赖-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.5</version>
</dependency>

<!--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>5.1.49</version>
</dependency>

<!--spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--做spring事务用到的-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--阿里公司的数据库的连接池-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.12</version>
</dependency>

<build>
 <resources>
      <resource>
        <!--所在的目录-->
        <directory>src/main/java</directory>
        <includes><!--包括目录下的.properties，.xml文件都会被扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <!--filtering 选项 false 不启用过滤器，*.property 已经起到过滤的作用了-->
        <filtering>false</filtering>
      </resource>
    </resources>

  </build>

创建实体类：

public class Student {
    private Integer id;
    private String name;
    private Integer age;
	//构造和set，get方法省略
}

Dao接口和mapper文件：

public interface StudentDao {

    /*插入学生*/
    int insertStudent(Student student);

    /*查询学生*/
    List<Student> selectList();
}

<?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.sss.dao.StudentDao">
    <!--插入信息-->
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{age})
    </insert>
    
    <!--查询学生信息-->
    <select id="selectList" resultType="com.sss.entity.Student">
        select id,name,age from student
    </select>
</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：控制myBatis全局行为-->
    <settings>
        <!--设置myBatis输出日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--设置别名-->
    <typeAliases>
        <!--name：实体类所在的包名-->
        <package name="com.sss.entity"/>
    </typeAliases>

    <!-- sql mapper（sql映射文件）的位置-->
    <mappers>
        <!--
            name：是包名，这个包中的所有mapper.xml文件都能够加载。
        -->
        <package name="com.sss.dao"/>
    </mappers>
</configuration>

Service接口和实现类:

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //使用set注入，赋值
    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> queryStudent() {
        List<Student> students = studentDao.selectList();
        return students;
    }
}

public interface StudentService {

    /*添加学生*/
    int addStudent(Student student);

    /*查询学生信息*/
    List<Student> queryStudent();
}

spring配置文件：

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

   <!--
        把数据库的配置信息，写在一个独立的文件，便于修改数据库的配置内容
        让spring知道jdbc.properties文件的位置。
    -->
    <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:mysql://localhost:3306/springdb"/>
        <property name="username" value="root"/>
        <property name="password" value="999"/>
        <!--最大连接数-->
        <property name="maxActive" value="20"/>
    </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(Student.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.sss.dao"/>
    </bean>

    <!--声明service-->
    <bean id="studentService" class="com.sss.service.Impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"/>
    </bean>
</beans>

测试类：

@Test
public void test04(){
    String config = "applicationContext.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    //获取spring容器中的service对象
    StudentService studentService = (StudentService) ac.getBean("studentService");

    List<Student> students = studentService.queryStudent();
    for (Student stu : students){
        System.out.println(stu);
    }

}

六：Spring事务

1）问题

1.什么是事务？

​ 在mysql的时候，提出了事务。事务是一组sql语句的集合，集合中有多条sql语句，可能是insert，update，select，delete，我们希望这些多个sql语句都能够成功，或者都失败。这些sql语句的执行是一致的，作为一个整体执行。

2.在什么时候使用事务？

​ 当我的操作，涉及到多个表，或者是多个sql语句的insert，update，delete。需要保证这些sql语句都是成功的，才能完成我的功能，或者都失败，来保证操作是符合要求的。

​

​ 在java代码中写程序，控制事务，此时事务应该放在哪里呢？

​ 应该放在service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句。

3.通常使用JDBC访问数据库，还有myBatis访问数据库怎么处理事务？

​ jdbc访问数据库，处理事务 Connection conn; conn.commit(); conn.rollback();

​ mybatis访问数据库，处理事务，sqlSession.commit(); sqlSession.rollback();

​ hibernate访问数据库，处理事务，Session.commit(); Session.rollback();

​

4.第三个问题中事务的处理方式，有什么不足？

​ 1）不同的数据库访问技术，处理事务的对象，方法不同。

​ 需要了解不同的数据库访问技术使用事务的原理。

​ 2）需要掌握多种数据库中事务的处理逻辑，什么时候提交事务，什么时候回滚事务。

​ 3）处理事务的多种方法。

​ 总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。

5.怎么解决不足？

​ spring提供一种处理事务的统一模型，能使用统一步骤，方式完成多种不同数据库访问技术的事务处理。

​ 使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理。

​ 使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理。

2）处理事务，需要怎么做，做什么？

spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给spring就可以了

1）事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback

​ 事务管理器是一个接口和他的众多实现类。
​ 接口：PlatformTransactionManager ，定义了事务重要方法 commit ，rollback
​ 实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了。
​ mybatis访问数据库—spring创建好的是DataSourceTransactionManager
​ hibernate访问数据库----spring创建的是HibernateTransactionManager

怎么使用：你需要告诉spring 你用是那种数据库的访问技术，怎么告诉spring呢？
声明数据库访问技术对于的事务管理器实现类， 在spring的配置文件中使用声明就可以了
例如，你要使用mybatis访问数据库，你应该在xml配置文件中
<bean id=“xxx" class="…DataSourceTransactionManager">

2）你的业务方法需要什么样的事务，说明需要事务的类型。

​ 说明方法需要的事务：
​ 1）事务的隔离级别：有4个值。
​ DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
​ ➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
​ ➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
​ ➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
​ ➢ SERIALIZABLE：串行化。不存在并发问题。

2) 事务的超时时间： 表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。
 	 单位是秒， 整数值， 默认是 -1. 

​ 3）事务的传播行为 ： 控制业务方法是不是有事务的， 是什么样的事务的。
​ 7个传播行为，表示你的业务方法调用时，事务在方法之间是如果使用的。

​ PROPAGATION_REQUIRED
​ PROPAGATION_REQUIRES_NEW
​ PROPAGATION_SUPPORTS
​ 以上三个需要掌握的

​ PROPAGATION_MANDATORY
​ PROPAGATION_NESTED
​ PROPAGATION_NEVER
​ PROPAGATION_NOT_SUPPORTED

3）spring提交事务，回滚事务的时机

​ 1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit
​ 2）当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback
​ 运行时异常的定义： RuntimeException 和他的子类都是运行时异常， 例如NullPointException , NumberFormatException

3. 当你的业务方法抛出非运行时异常， 主要是受查异常时，spring默认提交事务
   受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException

总结spring的事务
1.管理事务的是 事务管理器和他的实现类
2.spring的事务是一个统一模型
1）指定要使用的事务管理器实现类，使用
2）指定哪些类，哪些方法需要加入事务的功能
3）指定方法需要的隔离级别，传播行为，超时

你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。

3）spring框架中提供的事务处理方案

1.适合中小项目使用的， 注解方案。
spring框架自己用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务。
@Transactional注解是spring框架自己注解，放在public方法的上面，表示当前方法具有事务。
可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等

使用@Transactional的步骤：
1.需要声明事务管理器对象

<!--使用spring的事务处理-->
    <!--声明事务管理器-->
    <bean id="TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>

2.开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务。

<!--声明事务注解驱动，告诉spring使用注解管理事务，创建代理对象
    transaction-manager：事务管理器的id
-->
<tx:annotation-driven transaction-manager="TransactionManager"/>

3.在你的方法的上面加入@Trancational

@Transactional(
        /*事务的传播行为*/
        propagation = Propagation.REQUIRED,
        /*隔离级别*/
        isolation = Isolation.DEFAULT,
        /*：用于设置该方法对数据库的操作是否是只读的，false表示不是只读，true为只读，用在查询语句上*/
        readOnly = false,
        /*指定需要回滚的异常类，类型为 Class[]，数组*/
        rollbackFor = {
                NullPointerException.class,
                NotEnoughException.class
        }
)
//如果只写这个，使用的是事务控制的默认值，与上边的一堆代码一致。默认抛出运行时异常时，回滚事务。
@Transactional	
@Override
public void buy(Integer goodsId, Integer nums) {
    System.out.println("buy方法的开始===============");
    //记录销售信息，向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);
    System.out.println("buy方法的结束===============");
}

spring内部使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
spring给业务方法加入事务：
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，内部使用aop的环绕通知

如下方代码：

 @Around("你要增加的事务功能的业务方法名称")
 Object myAround(){
   开启事务，spring给你开启
	  try{
	     buy(1001,10);
		  spring的事务管理器.commit();
	  }catch(Exception e){
     spring的事务管理器.rollback();
	  }
	 
 }

**2.适合大型项目，**有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中
声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。

实现步骤： 都是在xml配置文件中实现。
1)要使用的是aspectj框架，需要加入依赖

<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>5.2.5.RELEASE</version>
	</dependency>

2）声明事务管理器对象

<!--声明事务管理器-->
<bean id="TransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--连接的数据库-->
    <property name="dataSource" ref="myDataSource"/>
</bean>

​

3. 声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）

<!--声明业务方法它的事务属性（隔离级别，传播行为，超时时间）
    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.sss.exce.NotEnoughException"/>
        <!--使用通配符，指定很多的方法-->
       <!-- <tx:method name="add*" propagation="REQUIRED"/>-->
    </tx:attributes>
</tx:advice>

4. 配置aop：指定哪些哪类要创建代理。

<!--配置aop ：通知应用的切入点-->
<aop:config>
    <!--配置切入点表达式，指定那些包中的类，要应用事务
        id：切入点表达式的名称，唯一值
        expression：切入点表达式，指定那些类要应用事务
    -->
    <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

    <!--配置增强器，用来关联advice和pointcut
            advice-ref：通知，上面的tx:advice哪里的配置的id
            pointcut-ref：切入点表达式的id
        -->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
</aop:config>

七：spring与Web

1.做的是javase项目有main方法的，执行代码是执行main方法的，
在main里面创建的容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”);

2.web项目是在tomcat服务器上运行的。 tomcat一起动，项目一直运行的。

需求：
web项目中容器对象只需要创建一次， 把容器对象放入到全局作用域ServletContext中。

怎么实现：
使用监听器 当全局作用域对象被创建时 创建容器 存入ServletContext

监听器作用：
1）创建容器对象，执行

ApplicationContext ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”);

2）把容器对象放入到ServletContext， ServletContext.setAttribute(key,ctx)

监听器可以自己创建，也可以使用框架中提供好的ContextLoaderListener

web.xml中使用监听器：

<!--注册监听器ContextLoaderListener
    监听器被创建对象后，会读取[/WEB-INF/applicationContext.xml]这个文件。
    为什么要去读取这个文件？
        因为在监听器中要创建ApplicationContext对象，需要加载配置文件。
        [/WEB-INF/applicationContext.xml]就是监听器默认读取的spring配置文件路径。

        可以修改默认的文件位置，使用context-parm重新执行文件的位置

配置监听器：目的是创建容器对象，创建了容器对象，applicationContext.xml配置文件中所有的对象都创建好
-->
<context-param>
    <!--contextConfigLocation：表示配置文件的路径-->
    <param-name>contextConfigLocation</param-name>
    <!--自定义配置文件的路径-->
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

源码：

private WebApplicationContext context;
public interface WebApplicationContext extends ApplicationContext

 ApplicationContext:javase项目中使用的容器对象
WebApplicationContext：web项目中的使用的容器对象

把创建的容器对象，放入到全局作用域
 key： WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
       WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
 value：this.context

 servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

每日一道Java面试题

记得关注我【Java有话说】