勇往无前的梓荣

Spring简介

Spring

1、Spring
综述
- 1.1 简介
- 1.2 优点
- 1.3 组成
- 1.4 拓展
- - 1.4.1 Spring Boot与Spring Cloud
  - - Spring Boot
    - Spring Cloud
2、IOC理论推导
- 2.1 IOC本质
3、 HelloSpring
- - 3.1 编写实体类
  - 3.2 编写application.xml
  - 3.3测试
4、IOC创建对象方式
- 4.1 使用无参构造创建对象
- - 4.1.1 User.java
  - 4.1.2 2、application.xml(beans.xml)
  - 4.1.3 测试
- 4.2 使用有参构造创建对象
- - 4.2.1 第一种下标赋值
  - 4.2.2 第二种通过类型创建,不建议使用
  - 4.2.3 第三种通过参数名创建
5、 Spring配置
- 5.1 别名
- 5.2 Bean配置
- 5.3 import
6、依赖注入
- 6.1 构造器注入
- 6.2 set注入[重点]
- - 6.2.1 环境搭建
- 6.3 拓展方式注入
- 6.4 bean的作用域
- - 6.4.1 Singleton 单例模式（默认）
  - 6.4.2 Prototype 原型模式(每次从容器中get的时候，都产生一个新对象)
  - 6.4.3 其余的Request,Session,application 只能在web开发中使用到
7、Bean 的自动装配
- 7.1 自动装配说明
- 7.2 Spring中bean有三种装配机制
- - 7.2.1 这里我们主要讲第三种：自动化的装配bean。
  - 7.2.2 测试
  - 7.3 ByName 自动装配
  - 7.4 byType 自动装配
  - - 小结
- 7.5 使用注解实现自动装配
- - 7.5.1 使用注解
  - 7.5.2 @Autowired
  - - 科普
  - 7.5.3 @Qualifier
  - - 测试1
  - 7.5.4 @Resource
  - - 测试1
    - 测试2
  - 7.6小结
8、使用注解开发
- 8.1 属性如何注入
- 8.2 衍生注解
- 8.3 自动装配注解
- 8.4 作用域
- 8.3 小结
- - 8.3.1 xml与注解
  - 8.3.1 xml与注解最佳实践：
9、使用java方式配置spring
- 9.1 实体类
- 9.2 配置类(相当于配置文件)
- 9.3 测试
10、代理模式
- 10.1 静态代理
- - 10.1.1 角色分析
  - 10.1.2 代码实现
  - 10.1.3 静态代理的好处:
  - 缺点 :
- 10.2 加深理解
- 10.3 动态代理
- - 10.3.1 代码实现
  - 10.3.2 加深理解工具类
  - 10.3.3 动态代理的好处
11、AOP
- 11.1 什么是AOP
- 11.2 Aop在Spring中的作用
- 11.3 使用Spring实现Aop
- - 11.3.1 第一种方式通过 Spring API 实现
  - - 首先编写我们的业务接口和实现类
    - 然后去写我们的增强类 , 我们编写两个 , 一个前置增强一个后置增强
    - 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .
    - 测试
    - Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .
  - 11.3.2第二种方式自定义类来实现Aop
  - - 第一步 : 写我们自己的一个切入类
    - 去spring中配置
    - 测试：
  - 11.3.3 第三种方式使用注解实现
  - - 第一步：编写一个注解实现的增强类
    - 第二步：在Spring配置文件中，注册bean，并增加支持注解的配置
    - aop:aspectj-autoproxy：说明
- 12、整合MyBatis
- 12.1 回忆mybatis
- - 12.2 MyBatis-spring
  - - 12.2.0 第一种
    - 12.2.1 UserMapperImpl
    - 12.2.2 mybatis-config.xml
    - 12.2.3 spring-dao.xml
    - 12.2.4 applicationContext.xml
    - 12.2.5 测试
  - 12.2.0.0 第二种
  - - UserMapperImpl2
    - spring-dao.xml
    - applicationContext.xml
    - 测试
- 13、声明式事务
- - 13.1 事务
  - 13.2事务的ACID原则：
  - 13.3 Spring中的事务管理
  - - 声明式事务
    - spring-dao.xml
    - mybatis-config.xml
    - applicationContext.xml
    - Mapper 以及实体类

链接:www.kuangstudy.com

1、Spring

综述

所有的类都需要装配到bean中
所有的bean都需要通过容器去取
容器里面取得的bean就是一个对象

1.1 简介

Spring : 春天 —>给软件行业带来了春天
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架
2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版
SSH：Struct2 + Spring + Hibernate
SSM: SpringMVC + Spring + Mybatis
官网： https://spring.io/projects/spring-framework#overview
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
GitHub : https://github.com/spring-projects


<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.2.9.RELEASEversion>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.2.9.RELEASEversion>
dependency>

1.2 优点

Spring是一个开源免费的框架 , 容器
pring是一个轻量级的框架 , 非侵入式的
控制反转 IoC , 面向切面 Aop
对事物的支持 , 对框架的支持

1.3 组成

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4 拓展

1.4.1 Spring Boot与Spring Cloud

Spring Boot

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

Spring Cloud

Spring Cloud是基于Spring Boot实现的
使用Spring Boot进行快速开发,前提: 需要完全掌握Spring和SpringMVC~承上启下的作用!!!

2、IOC理论推导

UserDao 接口
UserDaoImp 实现类
UserSevice 业务接口
UserServiceImp 业务实现类
在之前，用户的需求可能会影响原来的代码。
把Userdao的实现类增加一个需求,紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口
这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型

2.1 IOC本质

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

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）

3、 HelloSpring

3.1 编写实体类

public class Hello {
   private String name;

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

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

3.2 编写application.xml


<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">
    
    
   
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   bean>

beans>

3.3测试

public class MyTest {
    public static void main(String[] args) {
        //解析beans.xml文件 , 生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean : 参数即为spring配置文件中bean的id .
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的

Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

public class MyTest {
    public static void main(String[] args) {
       /* UserService userservice = new UserserviceImpl();
        ((UserserviceImpl)userservice).setUserDao(new UserDaoImpl());
        userservice.getUser();

        ((UserserviceImpl)userservice).setUserDao(new UserDaoOracleImpl());
        userservice.getUser();

        ((UserserviceImpl)userservice).setUserDao(new UserDaoMysqlImpl());
        userservice.getUser();*/
        ApplicationContext Context = new ClassPathXmlApplicationContext("beans.xml");
        UserserviceImpl serviceImpl = (UserserviceImpl) Context.getBean("ServiceImpl");
        serviceImpl.getUser();
    }
}

OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

4、IOC创建对象方式

4.1 使用无参构造创建对象

4.1.1 User.java

public class User {

   private String name;

   public User() {
       System.out.println("user无参构造方法");
  }

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

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

}

4.1.2 2、application.xml(beans.xml)


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

    
    


    <bean id="user" class="com.yx.pojo.User">
    
    
    <property name="name" value="OracleImpl"/>
    bean>
beans>

4.1.3 测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //在执行getBean的时候, user已经创建好了 , 通过无参构造
        User user = (User) context.getBean("user");
        //调用对象的方法 .
        user.show();
    }
}

4.2 使用有参构造创建对象

4.2.1 第一种下标赋值

package com.yx.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

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 void show(){
        System.out.println("name="+ name );
    }


}

  <bean id="user" class="com.yx.pojo.User">
        <constructor-arg index="0" value="yx思密达"/>
    bean>

4.2.2 第二种通过类型创建,不建议使用


    <bean id="user" class="com.yx.pojo.User">
        <constructor-arg type="java.lang.String" value="yx思密达1"/>
    bean>

4.2.3 第三种通过参数名创建

<bean id="user" class="com.yx.pojo.User">
        <constructor-arg name="name" value="yx思密达1"/>
    bean>

结论：在配置文件加载的时候。其中管理的对象都已经初始化了

5、 Spring配置

5.1 别名

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


<alias name="userT" alias="userNew"/>

5.2 Bean配置




<bean id="hello" name="hello2 h2,h3;h4" class="com.yx.pojo.Hello">
   <property name="name" value="Spring"/>
bean>

5.3 import

团队的合作通过import来实现

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

6、依赖注入

6.1 构造器注入

6.2 set注入[重点]

依赖注入 : set注入

  - 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .

  - 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

6.2.1 环境搭建

package com.yx.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 Student() {
    }

    public Student(String name) {
        this.name=name;
    }


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

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

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

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

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

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

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

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

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

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

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

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

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

    public String getWife() {
        return wife;
    }

    public Properties getInfo() {
        return 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 +
                '}';
    }

    public void show(){
        System.out.println("name="+ name
                + ",address="+ address.getAddress()
                + ",books="
        );
        for (String book:books){
            System.out.print("<<"+book+">>\t");
        }
        System.out.println("\n爱好:"+hobbys);

        System.out.println("card:"+card);

        System.out.println("games:"+games);

        System.out.println("wife:"+wife);

        System.out.println("info:"+info);

    }
}

package com.yx.pojo;

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 + '\'' +
                '}';
    }
}


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

    <bean id="address" class="com.yx.pojo.Address"/>

    <bean id="student" class="com.yx.pojo.Student">
        <property name="name" value="yx思密达1"/>
        
        <property name="address" ref="address"/>
        
        <property name="books">
            <array>
                <value>水浒传value>
                <value>西游记value>
            array>
        property>
        
        <property name="hobbys">
            <list>
                <value>听歌value>
                <value>看电影value>
            list>
        property>
        
        <property name="card">
            <map>
                <entry key="生分正" value="1344556412255633414"/>
                <entry key="银行卡" value="655915556632487895"/>
            map>
        property>
        
        <property name="games">
            <set>
                <value>LOLvalue>
                <value>DNFvalue>
            set>
        property>

        
        <property name="wife">
            <null/>
        property>
        
        <property name="info">
            <props>
                <prop key="学号">20192536prop>
                <prop key="性别">男prop>
                <prop key="姓名">张三prop>
            props>
        property>
    bean>

beans>

6.3 拓展方式注入

p标签和c标签

 public class User {
     private String name;
     private int age;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAge(int age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }


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

    
    <bean id="use" class="com.pojo.User" p:name="dong" p:age="10">
    bean>

    
    <bean id="use2" class="com.pojo.User" c:name="kun" c:age="19">bean>
beans>

6.4 bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象
几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境

6.4.1 Singleton 单例模式（默认）

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton，可以这样配置：

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

6.4.2 Prototype 原型模式(每次从容器中get的时候，都产生一个新对象)

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
  或者
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

6.4.3 其余的Request,Session,application 只能在web开发中使用到

7、Bean 的自动装配

7.1 自动装配说明

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

7.2 Spring中bean有三种装配机制

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

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

Spring的自动装配需要从两个角度来实现，或者说是两个操作：
组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

7.2.2 测试

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

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

package com.yx.pojo;

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

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + 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;
    }
}


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

     <bean id="cat" class="com.yx.pojo.Cat"/>
     <bean id="dog" class="com.yx.pojo.Dog"/>
    <bean id="people" class="com.yx.pojo.People">
        <property name="name" value="库里斯"/>
        <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("beans.xml");
        People people = context.getBean("people", People.class);
        people.getCat().shout();
        people.getDog().shout();
    }
}

7.3 ByName 自动装配

会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id

<bean id="people" class="com.kuang.pojo.People" autowire="byName">
   <property name="name" value="思密达"/>
bean>

7.4 byType 自动装配

会自动在容器上下文中查找,和自己对象属性类型相同的bean

<bean id="people" class="com.kuang.pojo.People" autowire="byType ">
   <property name="name" value="思密达"/>
bean>

小结

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

7.5 使用注解实现自动装配

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

7.5.1 使用注解

导入约束
配置注解支持
context:annotation-config/


<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/>
beans>

7.5.2 @Autowired

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

科普

@Nullable 字段标记了这个注解,说明这个字段可以为null
@Autowired(required=false) 说明：false，对象可以为null；true，对象必须存对象，不能为null。

7.5.3 @Qualifier

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

测试1

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

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

2、没有加Qualifier测试，直接报错
3、在属性上添加Qualifier注解

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

7.5.4 @Resource

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

测试1

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User"/>

测试2

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

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

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

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

7.6小结

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

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

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

8、使用注解开发

在spring4之后，必须要保证aop的包导入
使用注解需要导入contex的约束


<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/>
beans>

8.1 属性如何注入

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

    public String getName() {
        return name;
    }

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

8.2 衍生注解

@Component有几个衍生注解，会按照web开发中，mvc架构中分层。

dao （@Repository）
service（@Service）
controller（@Controller）
这四个注解功能一样的，都是代表将某个类注册到容器中

作用域
@Scope(“singleton”)

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

    @Value("dong")
    private String name;

    public String getName() {
        return name;
    }

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

8.3 自动装配注解

@autowired 自动通过类型,名字
- 如果autowired 不能唯一自动装配上属性,则需通过@Qualifier(value = “xxxx”)
@Nullable
@Resource : 自动装配,通过名字,类型
@component : 组件,放在类上面,说明这个类被spring管理了,就是bean

8.4 作用域

@Scope(“singleton”)

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

8.3 小结

8.3.1 xml与注解

xml更加万能，维护简单
注解，不是自己的类，使用不了，维护复杂

8.3.1 xml与注解最佳实践：

xml用来管理bean
注解只用来完成属性的注入
我们在使用的过程中.只需要注意一个问题:必须让注解生效,就需要开启注解的支持


<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/>
    
    <context:component-scan base-package="com.pojo"/>

beans>

9、使用java方式配置spring

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

9.1 实体类

//这里的@Component意思就是说明这个类呗spring接管了,注册到了容器中
@Component
public class User {
    public String name;

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

    public String getName() {
        return name;
    }
    @Value("你爸爸")  //属性注入值
    public void setName(String name) {
        this.name = name;
    }
}

9.2 配置类(相当于配置文件)

@Configuration  //这个也会被Spring容器托管,注册到容器中,因为它本身就是一个component  ,,
                // ,@Configuration代表这是一个配置类,就和我们之前看到的beans.xml是一样的
@ComponentScan("com.yx")
@Import(MyConfig2.class)
public class MyConfig {
    //就相当于我们之前写的一个bean标签
    //这个方法的名字,就相当于bean标签中的id属性
    //这个方法的返回值,就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User(); //就是返回要注入的bean对象
    }
}

9.3 测试

public class MyTest{
    public static void main(String[] args) {
        //如果完全使用配置类去做,我们就只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User getUser = (User) context.getBean("getUser");
        System.out.println(getUser.getName());

    }
}

这种纯java配置方式,在springboot中，随处可见

10、代理模式

代理模式的分类

静态代理
动态代理

10.1 静态代理

10.1.1 角色分析

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

10.1.2 代码实现

Rent 即抽象角色

//租房子(要做的事)
public interface Rent {
    public void rent();
}

FangDong 即真实角色

//真实对象
public class FangDong implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

Proxy 即代理角色

//代理对象
public class Proxy implements Rent{
    private FangDong FangDong;

    public Proxy() {
    }

    public Proxy(FangDong fangDong) {
        this.FangDong = fangDong;
    }

    @Override
    public void rent() {
        FangDong.rent();
        seeHouse();
        hetong();
        shoufei();
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带看房");
    }
    //看房
    public void hetong(){
        System.out.println("中介带签合同");
    }
    //收中介费
    public void shoufei(){
        System.out.println("收中介费");
    }
}

ZuFang 即客户

public class ZuFang {
    public static void main(String[] args) {
        FangDong fangdong = new FangDong();
        //代理
        Proxy proxy = new Proxy(fangdong);

        proxy.rent();

    }
}

10.1.3 静态代理的好处:

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

缺点 :

类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .
我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

10.2 加深理解

抽象角色

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 update() {
        System.out.println("修改用户");
    }

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

代理角色

//代理对象
public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;

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

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

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

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

    @Override
    public void query() {
        log("query");
        userService.add();
    }
    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");
    }
}

客户

//客户
public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
    }
}

10.3 动态代理

动态代理的角色和静态代理的一样 .
动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理–cglib
- 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
- 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！
JDK的动态代理核心 : InvocationHandler : 调用处理程序和 Proxy : 代理，打开JDK帮助文档看看

【InvocationHandler：调用处理程序】需要了解两个类

10.3.1 代码实现

抽象角色

//租房子(要做的事)
public interface Rent {
    public void rent();
}

真实角色

//真实对象
public class FangDong implements Rent {

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

ProxyInvocationHandler. java 即代理角色

//用这个类,自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }
    //处理代理实例,并且返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //动态代理实例,并且返回结果
        Object invoke = method.invoke(rent, args);
        return invoke;
    }
    public void seeHouse(){
        System.out.println("中介带看房子");
    }

}

客户角色

public class Client {
    public static void main(String[] args) {
        //真实角色
        FangDong fangDong = new FangDong();
        //代理角色 :  现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(fangDong);
        //这里的proxy就是动态生成
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

10.3.2 加深理解工具类

//用这个类,自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(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 {

        log(method.getName());
        //动态代理实例,并且返回结果
        Object invoke = method.invoke(target, args);
        return invoke;
    }

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

public class Client {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色  不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);
        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();

        proxy.delete();
    }
}

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

10.3.3 动态代理的好处

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

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

11、AOP

11.1 什么是AOP

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

11.2 Aop在Spring中的作用

提供声明式事务；允许用户自定义切面
以下名词需要了解下：

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

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

即 Aop 在不改变原有代码的情况下 , 去增加新的功能 .

11.3 使用Spring实现Aop

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


<dependency>
   <groupId>org.aspectjgroupId>
   <artifactId>aspectjweaverartifactId>
   <version>1.9.4version>
dependency>

11.3.1 第一种方式通过 Spring API 实现

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

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 update() {
        System.out.println("修改用户");
    }

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

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

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

public class AfterLog implements AfterReturningAdvice {
    @Override
    //o   返回值
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法,返回结果为"+o);
    }
}

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


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


    <bean id="userService" class="com.yx.service.UserServiceImpl"/>
    <bean id="log" class="com.yx.log.Log"/>
    <bean id="afterlog" class="com.yx.log.AfterLog"/>
    
<aop:config>
    
    <aop:pointcut id="pointcut" expression="execution(* com.yx.service.UserServiceImpl.*(..))"/>
    
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
aop:config>
beans>

测试

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

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

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

11.3.2第二种方式自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

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

public class DiyPointcut {

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

去spring中配置

    
    <bean id="diy" class="com.yx.diy.DiyPointCut"/>
    <aop:config>
        
        <aop:aspect ref="diy">
            
            <aop:pointcut id="point" expression="execution(* com.yx.service.UserServiceImpl.*(..))"/>
            
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        aop:aspect>

    aop:config>

测试：

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

11.3.3 第三种方式使用注解实现

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


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

// 方式三:使用注解方式  实现aop
@Aspect   //标注这个类是一个切面
public class AnnotationPointcut {
    @Before("execution(* com.yx.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    }

    @After("execution(* com.yx.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }

    @Around("execution(* com.yx.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

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

    
    <bean id="annotationPointcut" class="com.yx.diy.AnnotationPointcut"/>
    
    <aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被隐藏起来了

有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

12、整合MyBatis

文档： https://mybatis.org/spring/zh/


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-styartifactId>
        <groupId>org.examplegroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>spring-10-mybatisartifactId>

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

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.26version>
        dependency>
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.7version>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.3.9version>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
            <version>5.3.9version>
        dependency>
        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.9.7version>
        dependency>
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatis-springartifactId>
            <version>2.0.6version>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.22version>
            <scope>providedscope>
        dependency>
    dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                    <include>**/*.ymlinclude>
                includes>
                <filtering>falsefiltering>
            resource>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.xmlinclude>
                    <include>**/*.propertiesinclude>
                    <include>**/*.ymlinclude>
                includes>
                <filtering>falsefiltering>
            resource>
        resources>
    build>
project>

12.1 回忆mybatis

编写实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User{
    private int id;
    private String name;
    private String password;

}

编写核心配置文件




<configuration>
    
    <properties resource="db.properties">
    properties>
    <settings>
        
        <setting name="logImpl" value="LOG4J"/>
        
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <setting name="cacheEnabled" value="true"/>
    settings>
    

    <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&useUnicode=true&characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            dataSource>
        environment>

    environments>

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

编写接口

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

编写Mapper.xml

<?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.yx.mapper.UserMapper">

    <!---->
    <select id="seletUser" resultType="com.yx.pojo.User">
        select * from user
    </select>
    
</mapper>

测试

public class MyTest {
    @Test
    public void  test() throws IOException {

        String resource = "mybatis-config.xml";
        InputStream in = Resources.getResourceAsStream(resource);

        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = sessionFactory.openSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.seletUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

12.2 MyBatis-spring

编写数据源
SQLSessionFactory
sqlsessionTemplate
需要给接口加实现类
将自己写的实现类,注入到spring中
测试使用

12.2.0 第一种

12.2.1 UserMapperImpl

package com.yx.mapper;
import com.yx.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper{
    public UserMapperImpl() {
    }
    //我们所有操作,都是用SQLSession来执行,在原来,现在都是用sqlSessionTemplate
    private SqlSessionTemplate sqlSessionTemplate;
    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

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

12.2.2 mybatis-config.xml




<configuration>
    
   <properties resource="db.properties">
    properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="logImpl" value="LOG4J"/>
        
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <setting name="cacheEnabled" value="true"/>
    settings>
    




configuration>

12.2.3 spring-dao.xml


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

    <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?userSSL=true&
                userUnicode=true&characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    bean>

    <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/yx/mapper/UserMapper.xml"/>
    bean>

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

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


beans>

12.2.4 applicationContext.xml


<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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
 <import resource="spring-dao.xml"/>
    <bean id="userMapper" class="com.yx.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    bean>


beans>

12.2.5 测试

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.util.List;

public class MyTest {
    @Test
    public void  test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        List<User> users = userMapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

12.2.0.0 第二种

UserMapperImpl2

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

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

spring-dao.xml


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



    <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?userSSL=true&
                userUnicode=true&characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    bean>

    <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/yx/mapper/UserMapper.xml"/>
    bean>

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

   
beans>

applicationContext.xml


<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
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
 <import resource="spring-dao.xml"/>
    <bean id="userMapper" class="com.yx.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    bean>

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

测试

public class MyTest {
    @Test
    public void  test() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);

        List<User> users = userMapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

13、声明式事务

13.1 事务

要么都成功，要么都失败
十分重要，涉及到数据一致性
确保完整性和一致性

13.2事务的ACID原则：

原子性
一致性
隔离性
- 多个业务可能操作一个资源，防止数据损坏
持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会被影响。

13.3 Spring中的事务管理

声明式事务
编程式事务

声明式事务