Spring学习

1、Spring

1.1、简介

相当于简历模板，可以应用于任何java应用

百度

理念：使现有技术更容易使用，整合了现有技术框架！

SSH:
SSM: SpringMvc + Spring + Mybatis!

官网：Spring Framework

官方下载地址：

GitHub:GitHub - spring-projects/spring-framework: Spring Framework

导入这个spring-webmvc包会帮助我们导入很多jar包

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

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

因为我的jdk是1.8，和Spring 6.x不兼容，故换成Spring 5.x

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

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

1.2、优点

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

Spring是一个轻量级的控制反转（IOC），和面向切面编程（AOP）的框架！！

1.3、组成

1.4、拓展

在Spring官网：现代化java开发，基于Spring的开发！

Spring Boot:构建一切

快速开发的脚手架
基于Spring Boot 可以快速开发单个微服务
约定大于配置

Spring Cloud：协调一切

基于Spring Boot实现的

Spring Cloud Data Flow ：连接一切

学习Spring Boot的前提，需要完全掌握Spring，Spring MVC

弊端：发展太久，违背了原来理念，配置十分繁琐！！

2、IOC理论推导

IOC是一种设计思想：控制反转（获取依赖对象的方式反转了）

IOC是Spring框架的核心内容

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

UserDao接口

public interface UserDao {
    void getUser();
}

UserDaoImpl实现类

public class UserDaoImpl implements UserDao{
    public void getUser(){
        System.out.println("默认获取用户信息");
    }
}

public class UserDaoMysqlImpl implements UserDao{

    public void getUser() {
        System.out.println("调用Mysql");
    }
}

UserService业务接口

public interface UserService {
    void getUser();
}

UserServiceImpl业务实现类

public class UserServiceImpl implements UserService{
    //业务层调用dao层，把dao层的东西引到业务层实现类///真正调用的方法是dao层的方法！！！
//    private UserDao userDao = new UserDaoImpl();

    private UserDao userDao = new UserDaoMysqlImpl();

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

小结：

Dao层：UserDao接口，UserDaoImpl实现类实现UserDao接口；
业务层：UserService接口和UserDao接口方法一致，UserServiceImpl实现类实现UserService接口（业务层调用dao层，把dao层的东西引到业务层实现；真正调用的方法是dao层的方法！！）；
添加功能，dao层添加一个UserDaoMysqlImpl实现类；业务层：修改UserServiceImpl业务实现类

在之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求来修改原代码！

优化代码：

使用一个set接口实现！！(改变UserServiceImpl实现类：不用管理对象的创建了，接收对象)

private UserDao userDao;//声明一个UserDao接口类型的成员变量
    //利用set进行动态实现值的注入（接收外部传入的UserDao实现类，赋值给成员变量）
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

依赖关系：

MyTest (测试类)
  └── UserService (接口)
        └── UserServiceImpl (实现类，依赖 UserDao)
              └── UserDaoMysqlImpl (DAO层实现)

总结：在dao层添加功能（添加实现类），不会影响业务层的原代码，只需要修改用户层的需求。（IOC原型）

代码：(添加功能：添加Dao层实现类，修改测试类输入对象（接收用户的需求）即可；UserServiceImpl代码不用变)

public class UserDaoMysqlImpl implements UserDao{

    public void getUser() {
        System.out.println("调用Mysql");
    }
}

public class UserServiceImpl implements UserService{
    //业务层调用dao层，把dao层的东西引到业务层实现类///真正调用的方法是dao层的方法！！！

    private UserDao userDao;//声明一个UserDao接口类型的成员变量
    //利用set进行动态实现值的注入（接收外部传入的UserDao实现类，赋值给成员变量）
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

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

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层，dao层他们不需要接触！！
        UserService userService = new UserServiceImpl();//创建业务层对象

        ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
        userService.getUser();
    }
}

3、HelloSpring

到了现在我们彻底不用在程序中修改代码了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓IOC，一句话：对象由Spring创建，管理，装配！

Hello主体类

package com.yang.pojo;

public class Hello {
    public String str;

    public String getStr() {
        return str;
    }

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

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

bean.xml(开头这些，去官网学习文档上复制下来：容器概述：： Spring Framework)

property标签中，ref:引用Spring容器中创建的对象；value：具体的值，基本数据类型

<?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">

   <!--使用Spring来创建对象，在Spring这些都称为Bean-->
    <!--传统创建对象：Hello hello = new Hello（）/// 类型 变量名 = new 类型（）-->
    <!--bean标签创建对象：id = 变量名；class = new 的对象；name = 属性名；value = 属性值-->
    <bean id="hello" class="com.yang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象(固定写法）
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //我们的对象现在都在Spring中管理，我们要使用，直接去取出来。
        Hello hello = (Hello)  context.getBean("hello");
        System.out.println((hello.toString()));

    }
}

4、IOC创建对象的方式

使用无参构造创建对象，默认！！

实体类

package com.yang.pojo;

public class User {
    private String name;

    public User(){
        System.out.println("User的无参构造！");
    }

// public User(String name){
// this.name = name;
// }

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

public String getName() {
    return name;
}
public void show(){
    System.out.println("name="+name);
}

}

bean.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="user" class="com.yang.pojo.User">
        <property name="name" value="shshi"/>
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

        User user = (User) context.getBean("user");
        user.show();

    }
}

使用有参构造创建对象(3种方式)------和无参差不多，bean.xml文件不一样

<!--第一种：下标赋值！！-->
    <bean id="user" class="com.yang.pojo.User">
        <constructor-arg index="0" value="yangshi"/>
    </bean>

    <!--第二种：通过类型创建，不建议使用！！-->
    <bean id="user" class="com.yang.pojo.User">
        <constructor-arg type="java.lang.String" value="yangshi"/>
    </bean>

    <!--第三种：直接通过参数名来设置（建议使用！！！！！）-->
    <bean id="user" class="com.yang.pojo.User">
        <constructor-arg name="name" value="yangshi"/>
    </bean>

总结：在配置文件加载的时候，容器管理的对象已经初始化了！

5、Spring配置

5.1、别名

    <!--别名：如果添加了别名，也可以通过别名获取这个对象-->
    <alias name="user" alias="usernew"/>

5.2、Bean的配置

    <!--第三种：直接通过参数名来设置（建议使用！！！！！）-->
    <!--bean的配置：1.id——bean的唯一标识符，相当于我们学的对象名
                   2.class——bean 对象所对应的全限定名（包名+类型）
                   3.name——也是别名，而且name可以同时取多个别名（比 alias 更高级 ），可以逗号，空格分割-->
    <bean id="user" class="com.yang.pojo.User">
        <constructor-arg name="name" value="yangshi"/>
    </bean>

5.3、Import

一般用于团队开发，可以将多个配置文件，导入合并为一个。

假设，三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以用import将所有人的bean.xml 合并为一个总的！

applicationContext.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">

    <import resource="bean.xml"/>
    <import resource="bean2.xml"/>
    <import resource="bean3.xml"/>

</beans>

使用的时候，直接使用applicationContext.xml文件

6、依赖注入

6.1、构造器注入

前面说过了-----第四点 IOC创建对象的方式

6.2、Set方式注入（重点）

依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，有容器来注入！

环境搭建

复杂类型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

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

真实测试对象

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

applicationContext.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="student" class="com.yang.pojo.Student">
        <property name="name" value="yangshi"/>
    </bean>

</beans>

测试类

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

完善代码：

applicationContext.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.yang.pojo.Address">
        <property name="address" value="fdjsgfdmjnfjkn"/>
    </bean>


    <bean id="student" class="com.yang.pojo.Student">
        <!--第一种：普通值注入 ，value——具体值 -->
        <property name="name" value="yangshi"/>

        <!--第二种：Bean注入，ref——引用对象  -->
        <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>
                <value>玩游戏</value>
            </list>
        </property>

        <!--第五种：Map-->
        <property name="map">
            <map>
                <entry key="身份证" value="111111111111111111"/>
                <entry key="银行卡" value="2222222222222222222"/>
            </map>
        </property>

        <!--第六种：Set-->
        <property name="games">
            <set>
                <value>皇帝养成游戏</value>
                <value>皇后养成游戏</value>
                <value>皇子养成游戏</value>
                <value>嫔妃养成游戏</value>
            </set>
        </property>

        <!--第七种：null-->
        <property name="wife">
            <null/>
        </property>

        <!--第八种：Properties-->
        <property name="info">
            <props>
                <prop key="学号">123456</prop>
                <prop key="性别">女</prop>
                <prop key="姓名">shishi</prop>
            </props>
        </property>

    </bean>


</beans>

测试：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}
//Student{name='yangshi',
// address=Address{address='fdjsgfdmjnfjkn'},
// books=[三国演义, 红楼梦, 甄嬛传, 我有一个朋友],
// hobbys=[唱歌, 拍照, 跳舞, 玩游戏],
// map={身份证=111111111111111111, 银行卡=2222222222222222222},
// games=[皇帝养成游戏, 皇后养成游戏, 皇子养成游戏, 嫔妃养成游戏], wife='null',
// info={学号=123456, 性别=女, 姓名=shishi}}

6.3、拓展方式注入

我们可以使用p命令空间和c命令空间进行注入

User实体类

package com.yang.pojo;

public class User {
    private String name;
    private int id;

    public User(){}

    public User(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

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

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.yang.pojo.User" p:name="yangshi" p:id="18"/>

    <!--c命名空间注入，通过构造器注入：construct-args -->
    <bean id="user2" class="com.yang.pojo.User" c:id="19" c:name="liushi"/>
</beans>

注意导入(xml约束)xmlns:p以及xmlns:c(直接IDEA打出来，剩下的部分会显示给你选择)
不要忘记实体类要加上无参构造以及有参构造，不然会报红

测试：

@Test
    public void UserTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("UserBean.xml");
        User user = context.getBean("user2",User.class);//加多一个类型可以不用强转换了
        System.out.println(user);

    }

6.4、bean作用域

单例模式（Spring默认机制）：

 <!--c命名空间注入，通过构造器注入：construct-args -->
    <bean id="user2" class="com.yang.pojo.User" c:id="19" c:name="liushi" scope="singleton"/>

@Test
    public void UserTest(){
        ApplicationContext context = new ClassPathXmlApplicationContext("UserBean.xml");
        User user = context.getBean("user2",User.class);//加多一个类型可以不用强转换了
        User user1 = context.getBean("user2",User.class);
        System.out.println(user==user1);

    }

scope="singleton"

单例模式：只有一个实例（user和user1访问的是同一个实例，内容相同////////很多个dao层，但只有一个实例）

原型模式：每一次从容器get的时候，都会产生一个新对象！

 <!--c命名空间注入，通过构造器注入：construct-args -->
    <bean id="user2" class="com.yang.pojo.User" c:id="19" c:name="liushi" scope="prototype"/>

测试代码和上面单例模式一致

其余的 request，session，application 这些只能在web开发中使用到。

7、Bean自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文自动寻找，并自动给bean装配属性

在Spring中有三种装配方式：

在xml中显示的装配
在java中显示装配
隐式的自动装配bean（重要！！！！）

7.1、测试

环境搭建：一个人有两个宠物！

没有自动装配的代码：

主体类

people

package com.yang.pojo;

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 Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.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 + '\'' +
                '}';
    }
}

Cat

package com.yang.pojo;

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

}

Dog

package com.yang.pojo;

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

applicationContext.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="cat" class="com.yang.pojo.Cat"/>
    <bean id="dog" class="com.yang.pojo.Dog"/>
    <bean id="people" class="com.yang.pojo.People">
        <property name="name" value="shishi"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        People people = context.getBean("people",People.class);
        people.getCat().shout();
        people.getDog().shout();
    }
}

7.2、ByName自动装配

<bean id="cat" class="com.yang.pojo.Cat"/>
    <bean id="dog" class="com.yang.pojo.Dog"/>
    <!--
    byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id  ！！！
    （People中有setcat以及setdog方法，cat和dog满足上文容器，则自动装配
    -->
    <bean id="people" class="com.yang.pojo.People" autowire="byName">
        <property name="name" value="shishi"/>
    </bean>

7.3、ByType自动装配

<bean class="com.yang.pojo.Cat"/>
    <bean class="com.yang.pojo.Dog"/>
    <!--
    byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id ！！！
    byType:会自动在容器上下文中查找，和自己对象 属性 类型相同的bean  ！！！
    -->
    <bean id="people" class="com.yang.pojo.People" autowire="byType">
        <property name="name" value="shishi"/>
    </bean>

小结：

byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性set方法的值一致！
byname的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

7.4、使用注解自动装配

jdk 1.5开始支持注解；Spring 2.5开始支持注解。

要使用注解须知：

导入约束：context约束
配置注解支持------------context:annotation-config(不要忘记加这个注解的支持啦！！！)

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

    <!--开启注解的支持-->
    <context:annotation-config/>

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

</beans>

其他和上面没有自动装配代码一致！

@Autowired（最常用）

直接在属性上使用即可，也可以在set方法上使用！

使用Autowired，我们可以不用写Set方法，前提是自动装配属性在IOC（Spring）容器中存在，且符合名字byname！

@Nullable：字段标记了这个注解，说明这个字段可以为Null

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成时候，可以使用@Qualif去配置@Autowired的使用，指定一个bean对象注入！

    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog2")
    private Dog dog;
    private String name;

@Resource

@Autowired
    private Cat cat;
    @Resource(name = "dog2")
    private Dog dog;
    private String name;

小结：

@Autowired和@Resource的区别：

都是自动装配，都可以放在属性字段上
@Autowired 通过Bytype方式实现，而且必须要求这个对象存在（常用）
@Resource 默认通过Byname方式实现，如果找不到名字，则通过Bytype实现，如果两个都找不到，就报错！（常用）
实行顺序不同

学习方法：可以在项目里面建一个.md文件，记录一些常用依赖，注解说明这些；

8、使用注解开发

(在spring_study中的spring-06-anno项目)

在Spring 4 之后，要使用注解开发，必须导入aop包（导入spring-webmvc可以帮助我们导入很多包）

使用注解需要导入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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.yang.pojo"/>
    <!--开启注解的支持-->
    <context:annotation-config/>

</beans>

8.1、bean

8.2、属性如何注入

//@Component 组件   使用了之后默认id为类名小写
//等价于 <bean id="user" class="com.yang.pojo.User"/>
@Component
public class User {

    //相当于<property name = "name" value = "yanghi"/>
    @Value("yangshi")
    private String name;


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

    public String getName() {
        return name;
    }
}

一些简单的可以这样注解使用，复杂的还是建议.xml配置文件

8.3、衍生的注解

@Component 有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！

dao： @Repository
service ：@Service
controller：@Controller

这四个注解功能是一样的，都是代表将某个类注册到Spring中，装配Bean！！！

8.4、自动装配

上面有写

8.5、作用域

@Scope（）

8.6、小结

xml与注解：

xml更万能，适用于任何场合，维护简单
注解不是自己的类使用不了，维护相对复杂

xml和注解最佳实践：

xml 用来管理bean
注解只负责属性的注入

在使用过程中，只需要注意一个问题，必须要让注解生效，开启注解的支持

<!--指定扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.yang.pojo"/>
    <!--开启注解的支持-->
    <context:annotation-config/>

9、使用java的方式配置Spring

完成不使用Spring的xml配置了，全权交给java

javaConfig 是Spring的一个子项目，在Spring 4 之后，他成为了一个核心功能

主体类

package com.yang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

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

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

配置文件

package com.yang.config;

import com.yang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

//这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
//@Configuration  代表一个配置类，和bean.xml一样
@Configuration
@ComponentScan("com.yang.pojo")//扫描包
public class UserConfig {
    //注册一个bean就相当于我们之前写的一个bean标签
    //这个方法的名字就相当于bean标签的id
    //这个方法的返回值就是相当于bean标签的class属性
    @Bean
    public User getUser(){
        return new User();
    }

}

测试

import com.yang.config.UserConfig;
import com.yang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用配置类方式去做，只能通过 AnnotationConfig 上下文来获取资源，通过配置类的class对象加载！
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
        User user = context.getBean("getUser",User.class);
        System.out.println(user.getName());
    }
}

这种纯java配置方式，在springBoot中随处可见！

10、代理模式（SpringAOP的底层）

为什么学习代理模式？因为这既是SpringAOP的底层！（SpringAOP和SpringMVC面试考）

代理模式的分类：

静态代理
动态代理

10.1、静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类
真实角色：被代理角色
代理角色：代理真实角色，代理真实角色后，我们会做一些附属操作
客户：访问代理角色的人

代理模式的好处：

可以使真实角色的操作更加纯粹，不用关注一些公共业务
公共业务交给代理角色，实现业务的分工
公共业务发生扩展的时候，方便集中管理

缺点：

一个真实角色会产生一个代理角色，代码量翻倍，开发效率变低。

代码步骤：

接口

//租房(抽象角色）
public interface Rent {
    public void rent();
}

真实角色

//房东（真实角色）
public class Host implements Rent{
    public void rent(){
        System.out.println("房东要出租房子！");
    }
}

代理角色

package com.yang.demo01;

//中介（代理角色）
public class Proxy implements Rent{
    private  Host host;

    public Proxy(){

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

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        heTong();
        fare();
    }

    public void seeHouse(){
        System.out.println("中介带客户看房子！");
    }

    public void heTong(){
        System.out.println("签租房合同！");
    }

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

}

4. 客户端访问代理角色

```java
public class MyTest {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，并且代理角色一般会有一些附属操作！
        Proxy proxy = new Proxy(host);

        //客户不用面对房东，直接找中介租房子
        proxy.rent();
    }
}

10.2、加深理解

代码：对应spring-08-proxy 下的demo2

理解：开发程序，有一个接口UserService（抽象角色-出租），有一个实现类UserServiceImpl（真实角色-房东），这个时候，假设如果要在原有代码基础上添加一个功能，那么，可以用代理模式，编写一个UserServiceProxy（代理角色-中介），帮助UserServiceImpl（真实角色-房东）实现方法，并且添加新的功能！！！

10.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口---JDK 动态代理（下面代码实现的是这个）
- 基于类---cglib
- java字节码实现：javasist

需要了解两个类：Proxy ， InvocationHandler（调用处理程序）

代码步骤：

接口

//抽象角色   租房
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

真实角色

//真实角色    房东
public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("添加一个用户！");
    }

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

    @Override
    public void query() {
        System.out.println("查看一个用户！");
    }

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

动态生成代理类（代理的是一个接口------即是抽象角色（出租）【真实角色（房东）实现的接口！！！！】）

//我们用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public ProxyInvocationHandler(){}

    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }

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

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    //处理代理实例（代理角色--中介帮助真实角色--房东 处理），并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //动态代理的本质，利用反射机制实现
        Object result = method.invoke(target,args);

        return null;
    }

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

}

4. 客户端（代理实现同一个接口的多个类，只需要在客户端修改  真实角色  即可）

```java
package com.yang.demo04;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userServiceImpl = new UserServiceImpl();

        //代理角色，不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userServiceImpl);//设置要代理的对象
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();

    }
}

动态代理模式的好处：

可以使真实角色的操作更加纯粹，不用关注一些公共业务
公共业务交给代理角色，实现业务的分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口；一般就是对应一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

11、AOP

11.1、什么是AOP

面向切面编程

11.2、Aop在Spring中的作用

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

横切关注点：日志，安全，缓存，事务等等，与业务逻辑无关的

切面（ASPECT）：一个类

通知（ADvice）：类中的一个方法

目标（Target)：被通知对象

代理（Proxy）：

切入点（Point Cut）：切面通知执行的地方（地点）

连接点：

11.3、使用Spring实现Aop

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

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

方式一：使用Spring的API接口【主要是Spring的API接口实现】

（spring_study目录下，spring-09-aop）

接口

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

真实角色

package com.yang.service;

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

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

    @Override
    public void query() {
        System.out.println("查找用户");
    }

    @Override
    public void update() {
        System.out.println("更改用户");
    }
}

横切关注点，日志功能（切面类）

public class Log implements MethodBeforeAdvice {
    //method   要执行的对象的方法
    //args   参数
    //target  目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

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

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

    <!--注册bean-->
    <bean id="userServiceImpl" class="com.yang.service.UserServiceImpl"/>
    <bean id="log" class="com.yang.log.Log"/>
    <bean id="afterLog" class="com.yang.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置AOP：需要导入AOP的约束-->
    <aop:config>
        <!--切入点：expression：表达式  execution（要执行的位置！* * * * * ）-->
        <aop:pointcut id="pointcut" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是一个接口
        UserService userService = context.getBean("userServiceImpl",UserService.class);
        userService.add();
    }
}

方式二：自定义类来实现AOP【主要是切面实现】（建议）

自定义类（横切关注点）(切面类)

public class NoYes {
    public void sayHello(){
        System.out.println("欢迎使用！！");
    }

    public  void  sayGoodBy(){
        System.out.println("结束咯，再见！");
    }
}

    <!--第二种方式：自定义类-->
    <bean id="noYes" class="com.yang.yes.NoYes"/>
    <aop:config>
        <!--自定义切面，ref为要引用的类-->
        <aop:aspect ref="noYes">
            <!--切入点(地点）-->
            <aop:pointcut id="point" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
            <!--通知（类中的一个方法）-->
            <aop:before method="sayHello" pointcut-ref="point"/>
            <aop:after method="sayGoodBy" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

其他代码和上面一致！

方式三：使用注解实现

切面类：

//第三种方式：：使用注解的方式实现AOP
@Aspect   //标注这个类是一个切面
@Component
public class AnnotationPointCut {

    @Before("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=========方法执行前==============");
    }
    @After("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===========方法执行后=============");
    }

    //在环绕增强中，可以定一个参数，代表我们要获取处理切入点
    @Around("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        //执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }

}

applicationContext.xml

    <!--指定扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.yang.yes"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>

其他代码和方式一一致！

12、整合mybatis

步骤：

导入相关jar包

junit
mybatis
mysql数据库
spring相关
aop织入
mybatis-spring(新知识)

    <!-- 导入依赖 -->
    <dependencies>
        <!-- mysql 驱动 /////新坐标    -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>  <!-- 注意 artifactId 也变了 -->
            <version>8.0.33</version>
        </dependency>
        <!-- mybatis -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.16</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.23</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.23</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>3.0.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.34</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

编写配置文件
测试

12.1、回忆mybatis

编写实体类

package com.yang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

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

编写核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration核心配置文件 -->
<configuration>

    <typeAliases>
        <package name="com.yang.pojo"/>
    </typeAliases>

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

    <mappers>
        <mapper resource="com./yang/mapper/UserMapper.xml"/>
    </mappers>

</configuration>

编写接口

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

编写Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.yang.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from mybatis.user
    </select>

</mapper>

工具类

package com.yang.utils;


import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//sqlSessionFactory
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //使用mybatis第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //有了sqlSessionFactory,从中获取sqlSession实例。////////加上true，自动提交事务commit().
   public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }



}

测试

public class MyTest {
    @Test
    public void queryBlogIFTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper blogMapper = sqlSession.getMapper(UserMapper.class);
        List<User> blogs = blogMapper.selectUser();
        for (User blog : blogs) {
            System.out.println(blog);
        }
        sqlSession.close();
    }
}

12.1.1、注意防止资源导出失败问题

   <!--在build中配置resources,防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

12.1.2、防止xml文件编码有误问题

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

12.2、Mybatis-spring

编写数据源
sqlSessionFactory
sqlSessionTemplate
需要给接口加实现类
将自己写的实现类，注入到Spring中
测试

spring-dao.xml---(取代mybatis核心配置文件的内容)

<?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">

    <!--DateSource :使用Spring 的数据源替换Mybatis的位置， c3p0 dbcp druid
        我们这里使用Spring提供的 JDBC ：org.springframework.jdbc.datasource-->
    <!--连接数据库，里面的 name 都是固定的 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&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"/>
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/yang/mapper/UserMapper.xml"/>
    </bean>

    <!--SqlSessionTemplate :就是我们使用的sqlSession -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory ，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

注意：可以任意数据源，只要注册进来就可以；sqlSessionFactory需要导入数据源；除了数据源，其他的都是固定不变的了！！

mybatis-config.xml----(留下别名以及settings标签在这个xml)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration核心配置文件 -->
<configuration>

    <typeAliases>
        <package name="com.yang.pojo"/>
    </typeAliases>

</configuration>

applicationContext.xml----(总的xml文件，把spring的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">

    <!--这个标签只能引进Spring的xml配置文件-->
    <import resource="spring-dao.xml"/>

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

</beans>

User

package com.yang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

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

UserMapper

package com.yang.mapper;

import com.yang.pojo.User;

import java.util.List;

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

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.yang.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from mybatis.user
    </select>

</mapper>

UserMapperImpl

package com.yang.mapper;

import com.yang.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{

    //我们的所有操作，都是用sqlSession来执行，现在都使用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

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

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

注意：创建实例类，把sqlSession私有，注入applicationContext.xml文件，不要忘记把它的属性一起注入进去！！！

测试

import com.yang.mapper.UserMapper;
import com.yang.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

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.selectUser()){
            System.out.println(user);
        }
    }

}

代码简化操作：

UserMapperImpl的简化 (继承SqlSessionDaoSupport类)

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser(){
        SqlSession sqlSession = getSqlSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

applicationContext.xml (注入UserMapperImpl；但要加一个sqlSessionFacyory 属性)

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

spring-dao.xml (下面的sqlSession代码可以删掉)

<!--SqlSessionTemplate :就是我们使用的sqlSession -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory ，因为它没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

13、声明式事务

1、回顾事务

那一组业务当成一个业务来做，要么都成功，要么都失败
事务在项目开发过程中，涉及到数据一致性问题
确保完整性和一致性

事务的ACID原则：

原子性
一致性
隔离性
- 多个事务可能操作同一个资源，防止数据损坏
持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响到，被持久化地写道存储器中

2、spring中的事务管理

声明式事务：AOP
编程式事务：（不建议）

声明式事务：横切点切入（AOP）

不改变原有代码的情况下

思考：为什么需要事务？

如果不配置事务，可能存在数据提交不一致的情况
如果我们不在Spring中配置声明事务，就需要在代码中手动配置事务
事务在项目开发中十分重要，涉及到一致性完整性

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

    <!--结合AOP实现事务织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--給哪一些方法配置事务-->
        <tx:attributes>
            <tx:method name="addUser" propagation="REQUIRED"/>
            <tx:method name="deleteUser" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

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

小结：在spring-dao.xml配置文件添加这段代码，只需要改变配置事务切入的expreesion(即使在哪个地方切入事务)

理解：举个例子：

public List<User> selectUser(){
        User user = new User(12,"yangshitao222","123456");
        addUser(user);
        deleteUser(12);
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }

在这个方法里面，添加一个用户，删除一个用户，查看用户；如果删除用户功能里面代码有错，执行失败了，但前面的添加用户没出错，那么数据库里面，就会添加了用户却没有删除用户。但是，如果配置事务之后，一旦其中一个功能代码出错，数据库就不会有改变！！！（既不会添加用户也不会删除用户）避免了数据提交不一致的情况。

14、重点

重点理解这四个！！！！！

posted @ 2025-04-19 17:05 蟹堡博阅读(28) 评论(0) 收藏举报

刷新页面返回顶部