Spring学习笔记（摘自狂神）

本笔记摘抄自狂神说 Spring 笔记，结合B站学习视频 https://www.bilibili.com/video/BV1WE411d7Dv

1、Spring概述

1.1、简介

2002年，首次推出了Spring框架的雏形：interface21框架。
Spring框架以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。
Rod Johnson, Spring Framework创始人，著名作者，很难想象Rod Johnson学历，他是悉尼大学的博士，但是并不是计算机，而是音乐学。
Spring概念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。

官网：https://spring.io/projects/spring-framework#overview

官方下载地址：https://repo.spring.io/release/org/springframework/spring

Github: https://github.com/spring-projects/spring-framework

Maven引用：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.16.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.16.RELEASE</version>
</dependency>

1.2、优点

Spring是一个开源的免费的框架（容器）！
Spring是一个轻量级的非入侵式的框架！
控制反转（IOC）,面向切片编程（AOP）!
支持事务的处理，对框架整合的支持！

总结一句话：Spring是一个轻量级的控制反转（IOC）和面向切片编程（AOP）的框架！

1.3、组成

1.4、拓展

Spring Boot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速开发单个微服务。
- 约定大于配置！
Spring Cloud
- SpringCloud是基于SpringBoot实现的。

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC!承上启下的作用。

弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”

2、IOC理论推导

2.1、看个例子

我们先创建一个空的项目，项目结构见下图：

dao层

我们在dao中创建一个用户接口UserDao, 然后编写三个实现类UserDaoImpl, UserDaoMongoDBImpl, UserDaoMysqlImpl,对应着从默认路径获取用户、从MongoDB中获取用户和从Mysql中获取用户（这里只是个示例，没有写具体的实现）。各个文件的内容如下：

UserDao.java

package com.luca.dao;

public interface UserDao {
    void getUser();
}

UserDaoImpl.java

package com.luca.dao;

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

UserDaoMongoDBImpl.java

package com.luca.dao;

public class UserDaoMongoDBImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("MongoDB获取用户的数据");
    }
}

UserDaoMysqlImpl.java

package com.luca.dao;

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Mysql获取用户的数据");
    }
}

service层

在dao层实现之后，我们从service层调用dao层。

UserService.java

package com.luca.service;

public interface UserService {
    void getUser();
}

UserServiceImpl.java

package com.luca.service;

import com.luca.dao.UserDao;
import com.luca.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{
    UserDao userDao = new UserDaoImpl();

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

test测试

完成了service层后，我们就可以在test下进行测试了：

MyTest.java

import com.luca.dao.UserDaoImpl;

public class MyTest {
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        userDao.getUser();
    }
}

我们运行测试方法，可以正常的输出“默认获取用户的数据”，说明我们的程序是可以正常运行的。

2.2、拓展场景

上面的测试方法中，我们调用了方法获取默认用户数据，如果要查询MySQL中的用户信息呢？

我们可以修改service层中UserServiceImpl, new UserDaoImpl需要改成new UserDaoMysqlImpl，测试方法MyTest中new UserDaoMysqlImpl这样就可以满足新的用户需要。

但是如果用户又需要修改成MongoDB呢，或者新增Oracle或者Redis呢？每次更新都要修改service层的代码，客户端也要修改调用的代码，这样的方式太麻烦，维护的成本太高，换句话说，这样的代码耦合性太强！

换个方式

我们换一种方式来组织代码，在service层中，我们增加一个UserDao的set方法：

UserServiceImpl.java

package com.luca.service;

import com.luca.dao.UserDao;

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

相应的我们修改下MyTest中调用的方式：

import com.luca.dao.UserDaoImpl;
import com.luca.dao.UserDaoMongoDBImpl;
import com.luca.dao.UserDaoMysqlImpl;
import com.luca.service.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoImpl());
        userService.getUser();
        userService.setUserDao(new UserDaoMongoDBImpl());
        userService.getUser();
        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();
    }
}

我们再跑一下测试方法，发现可以正常的执行，三种获取用户的方式都正常执行。

我们对比两种方式：

第一种方式中选择从哪里获取用户，这个操作是service来执行的，客户端（即上面的测试方法）发出指令，service来执行。

第二种方法中做了改动，客户端可以自行选择使用哪种方式获取用户（借助了set方法），service层只负责统一处理。

其中最主要的改变：第二种方式把选择和操作的权力，转移给了客户端，而不是写死在service层，这里选择权转移（控制转移）的过程，就是__控制反转__。

2.3、IOC本质（借用狂神）

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、快速上手Spring

3.1、简单例子

在pojo中新建一个Hello实体类

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

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

上面说到，Spring中对象的创建管理都交由容器实现，这就需要让Spring知道有这个类，并让它管理。

注意：记得引入Spring需要用到的maven依赖。

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

在resources中创建一个Spring的配置文件 beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--bean就是java对象 , 由Spring创建和管理-->
    <bean id="hello" class="com.luca.pojo.Hello">
        <property name="str" value="HelloSpring"/>
    </bean>

</beans>

然后我们就可以去测试了，在test中创建一个测试类：

public class MyTest {
    public static void main(String[] args) {
        //解析beans.xml文件 , 生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean : 参数即为spring配置文件中bean的id
        //在执行getBean的时候, user已经创建好了 , 通过无参构造
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

这个例子的结构如图

3.2、思考

Hello 对象是由谁创建的（由Spring创建）
Hello 对象的属性是怎么设置的？（由Spring设置的，这里通过beans.xml配置文件注入）

这其中的过程就是控制反转：

控制：原先对象的创建都是由代码控制的，现在统一交给Spring管理
反转：程序本身不创建对象，而是变成对象的接收者

3.3、IOC创建对象的方式

一、通过无参构造创建（即上面例子中的方式）

二、通过有参构造创建

beans.xml有三种编写方式：

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.luca.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="luca"/>
</bean>

<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.luca.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="luca"/>
</bean>

<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.luca.pojo.UserT">
   <constructor-arg type="java.lang.String" value="luca"/>
</bean>

3.4、Spring配置

一、别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

二、Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.luca.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

三、import

团队的合作通过import来实现

<import resource="{path}/beans.xml"/>

4、依赖注入 DI

4.1、概念

依赖注入（Dependency Injection,DI）。
依赖 : 指Bean对象的创建依赖于容器，Bean对象的依赖资源
注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配

4.2、构造器注入

在上面的例子中已经见过

4.3、Set注入（重点）

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is

下面是各种数据类型的注入示例：

pojo/Address.java

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

pojo/Student.java（在Student这个类中设置了各种类型的属性，后面的beans配置文件也是针对Student的）

package com.luca.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="address" class="com.luca.pojo.Address">
        <property name="address" value="上海"/>
    </bean>

    <bean id="student" class="com.luca.pojo.Student">
        <!--普通值注入-->
        <property name="name" value="Luca"/>
        <!--Bean注入-->
        <property name="address" ref="address"/>
        <!--数组注入-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--List注入-->
        <property name="hobbys">
            <list>
                <value>听音乐</value>
                <value>看电影</value>
                <value>敲代码</value>
            </list>
        </property>
        <!--Map注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="111111222222223333"/>
                <entry key="银行卡" value="12345678910"/>
            </map>
        </property>
        <!--Set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="姓名">张三</prop>
                <prop key="性别">男</prop>
                <prop key="学号">20220504001</prop>
            </props>
        </property>
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}

测试结果

Student{name='Luca', address=Address{address='上海'}, books=[红楼梦, 西游记, 水浒传, 三国演义], hobbys=[听音乐, 看电影, 敲代码], card={身份证=111111222222223333, 银行卡=12345678910}, games=[LOL, COC, BOB], wife='null', info={学号=20220504001, 性别=男, 姓名=张三}}

Process finished with exit code 0

4.4、p命名和c命名注入

一、P命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:p="http://www.springframework.org/schema/p"
 
 <!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.luca.pojo.User" p:name="Luca" p:age="18"/>

二、c 命名空间注入 : 需要在头文件中加入约束文件

 导入约束 : xmlns:c="http://www.springframework.org/schema/c"

 <!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
 <bean id="user" class="com.luca.pojo.User" c:name="Luca" c:age="18"/>

4.5、Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象。

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

5、自动装配

5.1、自动装配说明

自动装配是使用spring满足bean依赖的一种方法
spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：

在xml中显式配置
在java中显式配置
隐式的bean发现机制和自动装配

这里我们主要讲第三种：自动化的装配bean。

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

推荐不使用自动装配xml配置 , 而使用注解 .

5.2、测试环境搭建

1、新建一个项目

2、新建两个实体类，Cat Dog 都有一个叫的方法

public class Cat {
    public void shout(){
        System.out.println("Miao~");
    }
}

public class Dog {
    public void shout() {
        System.out.println("Wang~");
    }
}

3、新建一个人物类 People

public class People {
    
    private Cat cat;
    private Dog Dog;
    private String name;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public com.luca.pojo.Dog getDog() {
        return Dog;
    }

    public void setDog(com.luca.pojo.Dog dog) {
        Dog = dog;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", Dog=" + Dog +
                ", name='" + name + '\'' +
                '}';
    }
}

4、编写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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

<!--    <context:annotation-config/>-->

    <bean id="cat" class="com.luca.pojo.Cat"/>
    <bean id="dog" class="com.luca.pojo.Dog"/>
    <bean id="people" class="com.luca.pojo.People">
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
        <property name="name" value="Luca"/>
    </bean>

</beans>

5、测试

public class MyTest {
    @Test
    public void TestAutoWired() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people = context.getBean("people", People.class);
        people.getCat().shout();
        people.getDog().shout();
    }
}

结果正常输出，环境OK.

5.3、byName

autowire byName (按名称自动装配)

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。

采用自动装配将避免这些错误，并且使配置简单化。

测试：

1、修改bean配置，增加一个属性 autowire="byName"

<bean id="people" class="com.luca.pojo.People" autowire="byName">
    <property name="name" value="Luca"/>
</bean>

2、再次测试，结果依旧成功输出！

3、我们将 cat 的bean id修改为 catXXX

4、再次测试，执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
去spring容器中寻找是否有此字符串名称id的对象。
如果有，就取出注入；如果没有，就报空指针异常。

5.4、byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

NoUniqueBeanDefinitionException

测试：

1、将user的bean配置修改一下： autowire="byType"

<bean id="people" class="com.luca.pojo.People" autowire="byType">
    <property name="name" value="Luca"/>
</bean>

2、测试，正常输出

3、再注册一个cat 的bean对象！

<bean id="cat" class="com.luca.pojo.Cat"/>
<bean id="cat2" class="com.luca.pojo.Cat"/>
<bean id="dog" class="com.luca.pojo.Dog"/>
<bean id="people" class="com.luca.pojo.People" autowire="byType">
    <property name="name" value="Luca"/>
</bean>

这时idea会直接提示有错误！

4、删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。

这就是按照类型自动装配！

5.5、使用注解

jdk1.5开始支持注解，spring2.5开始全面支持注解。

准备工作：利用注解的方式注入属性。

1、在spring配置文件中引入context文件头

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

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解支持！

<context:annotation-config/>

@Autowired

@Autowired是按类型自动转配的，不支持id匹配。
需要导入 spring-aop的包！

测试：

1、将People类中的set方法去掉，使用@Autowired注解

public class People {

    @Autowired
    private Cat cat;
    @Autowired
    private Dog Dog;
    private String name;

    public Cat getCat() {
        return cat;
    }

    public com.luca.pojo.Dog getDog() {
        return Dog;
    }

    public String getName() {
        return name;
    }
}

2、此时配置文件内容

<context:annotation-config/>

<bean id="cat" class="com.luca.pojo.Cat"/>
<bean id="dog" class="com.luca.pojo.Dog"/>
<bean id="people" class="com.luca.pojo.People"/>

3、测试，成功输出结果！

@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

@Qualifier

@Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
@Qualifier不能单独使用。

测试实验步骤：

1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="cat1" class="com.luca.pojo.Cat"/>
<bean id="cat2" class="com.luca.pojo.Cat"/>
<bean id="dog1" class="com.luca.pojo.Dog"/>
<bean id="dog2" class="com.luca.pojo.Dog"/>
<bean id="people" class="com.luca.pojo.People"/>

2、没有加Qualifier测试，直接报错

3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat1")
private Cat cat;
@Autowired
@Qualifier(value = "dog1")
private Dog Dog;

测试，成功输出！

@Resource

@Resource如有指定的name属性，先按该属性进行byName方式查找装配；
其次再进行默认的byName方式进行装配；
如果以上都不成功，则按byType的方式自动装配。
都不成功，则报异常。

实体类：

@Resource(name = "cat2")
private Cat cat;
@Resource
private Dog Dog;

beans.xml

<bean id="cat1" class="com.luca.pojo.Cat"/>
<bean id="cat2" class="com.luca.pojo.Cat"/>
<bean id="dog1" class="com.luca.pojo.Dog"/>
<bean id="people" class="com.luca.pojo.People"/>

测试：结果OK

配置文件2：beans.xml ，删掉cat2

<bean id="cat1" class="com.luca.pojo.Cat"/>
<bean id="dog1" class="com.luca.pojo.Dog"/>
<bean id="people" class="com.luca.pojo.People"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog Dog;

结果：OK

结论：先进行byName查找，失败；再进行byType查找，成功。

5.6、小结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired 默认按类型装配，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource 默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，默认取字段名进行按照名称查找，当找不到与名称匹配的bean时才按照类型进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

6、使用注解开发

6.1、说明

在spring4之后，想要使用注解形式，必须得要引入aop的包

在配置文件当中，还得要引入一个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">

</beans>

6.2、Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！

1、配置扫描哪些包下的注解

<context:component-scan base-package="com.luca.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
public class User {
    public String name = "Luca";;
}

3、测试

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        System.out.println(user.name);
    }
}

6.3、属性注入

使用注解注入属性

1、可以不用提供set方法，直接在直接名上添加@value("值")

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {

    @Value("Luca233")
    // 相当于配置文件中 <property name="name" value="Luca233"/>
    public String name;
}

2、如果提供了set方法，在set方法上添加@value("值");

@Component("user")
public class User {

    public String name;

    @Value("LUCA")
    public void setName(String name) {
        this.name = name;
    }
}

6.4、衍生注解

我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

@Controller：web层
@Service：service层
@Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

6.5、作用域

@scope

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Component("user")
@Scope("prototype")
public class User {

    public String name;

    @Value("LUCA")
    public void setName(String name) {
        this.name = name;
    }
}

6.6、小结

XML与注解比较

XML可以适用任何场景，结构清晰，维护方便
注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

xml管理Bean
注解完成属性注入
使用过程中，可以不用扫描，扫描是为了类上的注解

<context:annotation-config/>

作用：

进行注解驱动注册，从而使注解生效
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
如果不扫描包，就需要手动配置bean
如果不加注解驱动，则注入的值为null！

6.7、基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能。

测试：

1、编写一个实体类，User

@Component
public class User {
    @Value("Luca")
    private String name;

    public String getName() {
        return name;
    }

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

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

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration //代表这是一个配置类
@ComponentScan("com.luca")
public class MyConfig {

    @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
    public User user() {
        return new User();
    }
}

3、测试

@Test
public void myTest() {
    ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
    User user = (User) context.getBean("user");
    System.out.println(user.getName());
}

4、成功输出结果！

5、导入其他的配置类（替代XML中的import功能）

@Import(MyConfig2.class)

7、静态/动态代理模式

为什么要学习代理模式，因为AOP的底层机制就是动态代理！

代理模式：

静态代理
动态代理

学习aop之前 , 我们要先了解一下代理模式！

7.1、静态代理

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现
真实角色 : 被代理的角色
代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
客户 : 使用代理角色来进行一些操作

下面使用一个租房的例子来演示，代码实现：

Rent . java 即抽象角色

//真实的业务：租房
public interface Rent {
    public void rent();
}

Host.java 真实角色房东

//真实业务，房东要租房子
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

Proxy . java 即代理角色

public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    //中介代理了房东进行租房，并提供其他的服务
    @Override
    public void rent() {
        look();
        host.rent();
        write();
        money();
    }

    public void look() {
        System.out.println("中介带你看房！");
    }

    public void write() {
        System.out.println("中介带你签合同！");
    }

    public void money() {
        System.out.println("中介收中介费！");
    }

}

Client . java 即客户

public class Client {
    public static void main(String[] args) {
        //租客只需要和中介打交道，不需要管房东是谁
        Host host = new Host();

        Proxy proxy = new Proxy(host);

        proxy.rent();
    }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式。

静态代理的好处:

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便。

缺点 :

类多了 , 多了代理类，工作量变大了，开发效率降低。

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

7.2、静态代理再理解

练习步骤：

1、创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！

//抽象角色：增删改查业务
public interface UserService {
   void add();
   void delete();
   void update();
   void query();
}

2、我们需要一个真实对象来完成这些增删改查操作

//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {

   public void add() {
       System.out.println("增加了一个用户");
  }

   public void delete() {
       System.out.println("删除了一个用户");
  }

   public void update() {
       System.out.println("更新了一个用户");
  }

   public void query() {
       System.out.println("查询了一个用户");
  }
}

3、需求来了，现在我们需要增加一个日志功能，怎么实现！

思路1 ：在实现类上增加代码【麻烦！】
思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！

4、设置一个代理类来处理日志！代理角色

//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
   private UserServiceImpl userService;

   public void setUserService(UserServiceImpl userService) {
       this.userService = userService;
  }

   public void add() {
       log("add");
       userService.add();
  }

   public void delete() {
       log("delete");
       userService.delete();
  }

   public void update() {
       log("update");
       userService.update();
  }

   public void query() {
       log("query");
       userService.query();
  }

   public void log(String msg){
       System.out.println("执行了"+msg+"方法");
  }
}

5、测试访问类：

public class Client {
   public static void main(String[] args) {
       //真实业务
       UserServiceImpl userService = new UserServiceImpl();
       //代理类
       UserServiceProxy proxy = new UserServiceProxy();
       //使用代理类实现日志功能！
       proxy.setUserService(userService);

       proxy.add();
  }
}

OK，到了现在代理模式大家应该都没有什么问题了，重点大家需要理解其中的思想；

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想

7.3、动态代理

动态代理的角色和静态代理的一样
动态代理的代理类是动态生成的；静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理----cglib
- 现在用的比较多的是 javasist 来生成动态代理，百度一下javasist
- 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy

代码实现

真实业务接口（租房）Rent.interface:

public interface Rent {
    public void rent();
}

真实业务（房东租房）Host.java:

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

动态代理通用类 ProxyInvocationHandler.java（固定用法可作为工具类）：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setRent(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(target, args);
        return result;
    }
}

客户端调用（租客租房） Client.java:

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

其中：

Proxy -> 用来生成动态代理类
InvocationHandler -> 执行动态代理方法并返回结果

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

7.4、动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口！

8、AOP

8.1、什么是AOP

百度百科的解释：

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

8.2、Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

以下名词需要了解下：

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ....
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 Aop 在不改变原有代码的情况下 , 去增加新的功能（与上面静态代理动态代理做的事情一样）。

8.3、使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

第一种方式

通过 Spring API 实现

首先编写我们的业务接口和实现类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强一个后置增强

public class BeforeLog implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"方法被执行了！");
    }
}

public class AfterLog implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束！

<bean id="userService" class="com.luca.service.UserServiceImpl"/>
<bean id="beforeLog" class="com.luca.log.BeforeLog"/>
<bean id="afterLog" class="com.luca.log.AfterLog"/>

<!--方式一：使用原生Spring API接口-->
<!--配置aop:需要导入aop的约束-->
<aop:config>
    <!--切入点配置-->
    <aop:pointcut id="pointcut" expression="execution(* com.luca.service.UserServiceImpl.*(..))"/>
    <!--执行环绕增强-->
    <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

测试：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

代码结构见下图：

Aop的重要性 : 很重要，一定要理解其中的思路 , 主要是思想的理解这一块。

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理。

第二种方式

自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

public class DiyPointCut {
    public void before() {
        System.out.println("==========方法执行前==========");
    }

    public void after() {
        System.out.println("==========方法执行后==========");
    }
}

去spring中配置

<!--方式二：自定义类-->
<bean id="diy" class="com.luca.diy.DiyPointCut"/>
<aop:config>
    <!--自定义切面：ref 要引用的类-->
    <aop:aspect ref="diy">
        <!--定义切入点-->
        <aop:pointcut id="point" expression="execution(* com.luca.service.UserService.*(..))"/>
        <!--定义通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

第三种方式

注解实现

第一步：编写一个注解实现的增强类

//方式三：注解
@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.luca.service.UserService.*(..))")
    public void before() {
        System.out.println(">>>Annotation方法执行前<<<");
    }
    @After("execution(* com.luca.service.UserService.*(..))")
    public void after() {
        System.out.println(">>>Annotation方法执行后<<<");
    }

    @Around("execution(* com.luca.service.UserService.*(..))")
    public void arount(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕前");
        System.out.println("Signature: "+pj.getSignature());
        pj.proceed();
        System.out.println("环绕后");
    }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--方式三：注解-->
<bean id="annotationPointCut" class="com.luca.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

最后附上代码结构参考：

9、整合MyBatis

9.1、依赖导入

1、导入相关jar包

junit

<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
</dependency>

mybatis

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.2</version>
</dependency>

mysql-connector-java

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.47</version>
</dependency>

spring相关

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

aspectJ AOP 织入器

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

mybatis-spring整合包【重点】

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.2</version>
</dependency>

配置Maven静态资源过滤问题！

<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>true</filtering>
       </resource>
   </resources>
</build>

9.2、回忆Mybatis

1、创建实体类

pojo/User.java

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

mapper/UserMapper.java

public interface UserMapper {
    List<User> getUsers();
}

mapper/UserMapper.xml

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace绑定一个dao接口-->
<mapper namespace="com.luca.mapper.UserMapper">
    <!--id相当于重写方法的名字-->
    <select id="getUsers" resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

2、编写配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.luca.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicodetrue&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper class="com.luca.mapper.UserMapper"/>
    </mappers>

</configuration>

3、测试

public class MyTest {
    @Test
    public void test() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
}

可以正常从数据库中查询出用户数据。

9.3、MyBatis-Spring

mybatis-spring http://www.mybatis.org/spring/zh/index.html

什么是 MyBatis-Spring？

MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.2</version>
</dependency>

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

在 MyBatis-Spring 中，可使用SqlSessionFactoryBean来创建 SqlSessionFactory。要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 <property name="dataSource" ref="dataSource" />
</bean>

SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。

模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
 <constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession 属性，就像下面这样：

public class UserDaoImpl implements UserDao {

 private SqlSession sqlSession;

 public void setSqlSession(SqlSession sqlSession) {
   this.sqlSession = sqlSession;
}

 public User getUser(String userId) {
   return sqlSession.getMapper...;
}
}

按下面这样，注入 SqlSessionTemplate：

<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
 <property name="sqlSession" ref="sqlSession" />
</bean>

9.4、整合实现一

1、创建Spring配置文件 spring-dao.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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">

    <!--数据源配置，代替mybatis的数据源配置-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicodetrue&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/luca/mapper/*.xml" />
    </bean>

    <!--sqlSessionTemplate，就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>

    <bean id="userMapper" class="com.luca.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>

2、增加Dao接口的实现类；私有化sqlSessionTemplate

UserMapperImpl.java

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> getUsers() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUsers();
    }
}

3、将UserMapperImpl实现类注册到bean中

<bean id="userMapper" class="com.luca.mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

4、测试

public class MyTest {
    @Test
    public void test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.getUsers()) {
            System.out.println(user);
        }
    }
}

结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.luca.pojo"/>
    </typeAliases>
</configuration>

9.5、整合实现二

官方文档截图 :

dao继承Support类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory . 比起方式1 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看

测试：

1、将我们上面写的UserDaoImpl修改一下

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List<User> getUsers() {
        return getSqlSession().getMapper(UserMapper.class).getUsers();
    }
}

2、修改bean的配置

<bean id="userMapper2" class="com.luca.mapper.UserMapperImpl2">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

3、测试

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
for (User user : userMapper.getUsers()) {
    System.out.println(user);
}

代码结构如图：

10、声明式事务

10.1、回顾事务

事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！
事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

事务四个属性ACID

原子性（atomicity）
- 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用
一致性（consistency）
- 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
隔离性（isolation）
- 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏
持久性（durability）
- 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中

10.2、Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

将事务管理代码嵌到业务方法中来控制事务的提交和回滚
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

一般情况下比编程式事务好用。
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

使用Spring管理事务，注意头文件的约束导入 : tx

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

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

事务管理器

无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。
就是 Spring的核心事务管理抽象，管理封装了一组独立于技术的方法。

JDBC事务

<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="dataSource" />
</bean>

配置好事务管理器后我们需要去配置事务的通知

<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪些事务配置事务-->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

配置AOP

注意：导入aop的头文件！

<!--配置事务切入-->
<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.luca.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

为什么需要配置事务？

如果不配置，就需要我们手动提交控制事务；
事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！

posted @ 2021-11-30 10:20 LucaZ 阅读(80) 评论(0) 编辑收藏举报

刷新页面返回顶部

Luca Z

Spring学习笔记（摘自狂神）

1、Spring概述

1.1、简介

1.2、优点

1.3、组成

1.4、拓展

2、IOC理论推导

2.1、看个例子

dao层

service层

test测试

2.2、拓展场景

换个方式

2.3、IOC本质（借用狂神）

3、快速上手Spring

3.1、简单例子

3.2、思考

3.3、IOC创建对象的方式

3.4、Spring配置

4、依赖注入 DI

4.1、概念

4.2、构造器注入

4.3、Set注入（重点）

4.4、p命名和c命名注入

4.5、Bean的作用域

5、自动装配

5.1、自动装配说明

5.2、测试环境搭建

5.3、byName

5.4、byType

5.5、使用注解

@Autowired

@Qualifier

@Resource

5.6、小结

6、使用注解开发

6.1、说明

6.2、Bean的实现

6.3、属性注入

6.4、衍生注解

6.5、作用域

6.6、小结

6.7、基于Java类进行配置

7、静态/动态代理模式

7.1、静态代理

7.2、静态代理再理解

7.3、动态代理

7.4、动态代理的好处

8、AOP

8.1、什么是AOP

8.2、Aop在Spring中的作用

8.3、使用Spring实现Aop

第一种方式

第二种方式

第三种方式

9、整合MyBatis

9.1、依赖导入

9.2、回忆Mybatis

9.3、MyBatis-Spring

9.4、整合实现一

9.5、整合实现二

10、声明式事务

10.1、回顾事务

10.2、Spring中的事务管理

公告