重新学习Spring

最新推荐文章于 2024-05-31 11:42:39 发布

编程方面的菜雀雀

最新推荐文章于 2024-05-31 11:42:39 发布

阅读量180

点赞数

分类专栏： Spring Java pom 文章标签： spring java redis

本文链接：https://blog.csdn.net/qq_46104495/article/details/123783920

版权

Spring 同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

Java

2 篇文章 0 订阅

订阅专栏

pom

2 篇文章 0 订阅

订阅专栏

前言：工作了之后，慢慢发现曾经学习过的Spring的相关知识正在慢慢遗忘，为了重新捡起关于Spring相关的知识点，所以对其进行了重新学习与梳理。

Spring

1. 简介

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。

目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean来替代EJB，并提供更多的企业应用功能
范围：任何Java应用

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架

历史：

创始人是Rod Johnson。
2002年，首次推出了Spring框架的雏形：interface21框架
(Spring框架是以interface21框架为基础经过重新设计，并且不断丰富其内涵，最终与2004年3月24日发布1.0正式版。)
Spring的理念：使现有的技术更加容易使用，其本身就是一个大杂烩，整合的现有的技术框架。

两套系统：

SSH：Struct2 + Spring + Hibernate
SSM: SpringMVC + Spring + Mybatis
(Spring 就是一个融合剂)

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

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

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

导包

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


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

spring-jdbc用于和Mybatis整合

优点

Spring是一个开源的免费的框架(容器)
Spring是一个轻量级的，非入侵式的框架
非入侵式：使用了Spring不会改变原来的代码，反而会变得更加简洁
控制反转(IoC)，面向切面编程(AOP)
支持事务处理，对框架整合的支持

总结：Spring就是一个轻量级的控制反转和面向切面编程的框架。

2. Spring的组成和拓展

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X9Qq3dQc-1648393003271)(/Users/duojicheng/Library/Application Support/typora-user-images/image-20220315215046210.png)]

拓展：

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

因为现在大部分企业都在使用SpringBoot进行快速开发，学习SpringBoot的前提是需要完全掌握Spring和SpringMVC。

弊端：发展太久之后，违背了当初的理念。到后期配置十分繁琐，人称配置地狱。

3. IoC理论推导

IoC是一种思想。

原来业务的步骤：

UserDao接口
UserDaoImpl实现类
UserService业务接口
UserServiceImpl业务实现类

在之前的业务中，用户的需求可能会影响到我们原来的代码，因为我们需要根据用户的需求去修改源代码。如果程序的代码量非常庞大，则修改一次的成本代价会非常高昂。

使用一个Set接口实现

private UserDao userDao;

@Override
public void getUserDao(UserDao userDao){
  this.userDao = userDao;
}

之前：程序是主动创建对象，控制权在程序员手上

之后：程序不再主动性，而是变成了被动的接收对象。

本质上解决了问题，程序员不再去管理对象的创建了，系统的耦合性大大降低，可以更专注地在业务的实现上。这是IoC的原型

4. IoC的本质

主动权在用户，用户选择。

控制反转IoC是一种设计思想，DI依赖注入是实现IoC的一种方法。控制反转后将对象的创建转移给第三方。个人认为所谓的控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息和实现是分离开的，而采用注解的方式可以把二者合二为一，Bean的定义信息直接以注解的形式定义在在实现类中，从而达到零配置的目的。

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

5. 项目1：Hello Spring

控制：传统的应用程序对象是由程序本身控制创建的，使用Spring对象是有Spring来创建的。

反转：程序本身不创建对象，而编程被动地接收对象。

依赖注入：就是利用set方法来进行注入的。

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

在spring中，每个对象都被称为一个Bean。

6. IoC创建对象的方式

采用无参构造创建对象，默认方式

<bean id="singer" class="cn.duo.pojo.Singer">
  <property name="name" value="Celine Dion"></property>
</bean>

假设采用有参构造创建对象：有三种方式

方式一：下标赋值

<!--有参构造方式1-->
<bean id="singer1" class="cn.duo.pojo.Singer">
  <constructor-arg index="0" value="Celine Dion"></constructor-arg>
</bean>

方式二： 通过类型赋值

<!--有参构造方式2-->
<bean id="singer2" class="cn.duo.pojo.Singer">
  <constructor-arg type="java.lang.String" value="Celine Marie Dion"/>
</bean>

方式三：通过参数名来设置

<!--有参构造方式3-->
<bean id="singer3" class="cn.duo.pojo.Singer">
  <constructor-arg name="name" value="Celine Claude Dion"/>
</bean>

Spring 会将applicationContext.xml所有注册的Bean实例化，不管是否使用。

而且每个Bean在IoC容器中只有一个实例。

容器就是：ApplicationContext

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

7.Spring 的配置

别名

如果添加了别名，也可以使用别名获取这个对象

<alias name="singer" alias="Non-constructor"></alias>

Bean的配置

Id: bean的唯一标识符，相当于变量名。

class：bean对象对应的类型的路径（全限定名）

name：bean实例的别名，name比alias高级，可以同时取多个别名(用逗号、分号或者空格来间隔多个别名)

scope: 作用域

import

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

<import resource="bean.xml"></import>
<import resource="beans.xml"></import>

假设：一个项目里面有多个人开发，这几个人负责不同的类开发，不同的类需要注册在不同的bean中，可以利用import将所有的xml文件合并为一个中的文件。

8. DI依赖注入

有三种方式注入

构造器注入：上一章

通过set方式注入【重点】

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

【环境搭建】

复杂类型

@Data
@Getter
@Setter
public class Student {
  private String name;
  private Address address;
  private String[] books;
  private List<String> hobbies;
  private Map<String, String> subjects;
  private Set<String> games;
  private Properties info;
  private String nullPointer;
}

@Data
@Getter
@Setter
public class Address {
  private String address;
}

<bean id="student" class="cn.duo.pojo.Student">
  <!--第一种注入方式， 普通注入， value-->
  <property name="name" value="Duo Ji Cheng"></property>

  <!--第二种注入方式，Bean注入 ref-->
  <property name="address" ref="address"></property>

  <!--第三种方式，数组注入-->
  <property name="books">
    <array>
      <value>The Returns</value>
      <value>The Island</value>
      <value>The Thread</value>
      <value>Possession</value>
      <value>The Children's book</value>
      <value>No Higher Honor</value>
    </array>
  </property>

  <!--List注入-->
  <property name="hobbies">
    <list>
      <value>Music</value>
      <value>Ping Pong</value>
      <value>Tennis</value>
      <value>Swimming</value>
      <value>Reading</value>
    </list>
  </property>

  <!--Map注入-->
  <property name="subjects">
    <map>
      <entry key="Principle of Chemistry 1,2" value="Dr.Allison"></entry>
      <entry key="Principle of Chemistry 3" value="Dr.Mottel"></entry>
      <entry key="Organic Chemistry" value="Dr.Deveasher"></entry>
      <entry key="Inorganic Chemistry" value="Dr.Poland"></entry>
      <entry key="Physical Chemistry" value="Dr.Tilstra"></entry>
      <entry key="Analytical Chemistry" value="Dr.Morris"></entry>
    </map>
  </property>

  <!--Set注入-->
  <property name="games">
    <set>
      <value>Sniper Elites 4</value>
      <value>The Sims 4</value>
      <value>Tomb Raider Rise</value>
      <value>Tomb Raider Shadow</value>
      <value>Counter Strike</value>
    </set>
  </property>

  <!--Properties注入-->
  <property name="info">
    <props>
      <prop key="birthday">1992-07-30</prop>
      <prop key="gender">Male</prop>
      <prop key="height">170</prop>
      <prop key="hometown">Chengdu</prop>
    </props>
  </property>

  <!--空值注入-->
  <property name="nullPointer">
    <null/>
  </property>
</bean>

<bean id="address" class="cn.duo.pojo.Address">
  <property name="address" value="208 ShuHan Rd"></property>
</bean>

真实测试对象

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());
    System.out.println(student.getAddress());
    System.out.println(student.getBooks());
    System.out.println(student.getGames());
    System.out.println(student.getHobbies());
    System.out.println(student.getSubjects());
    System.out.println(student.getInfo());
    System.out.println(student.getNullPointer());
  }
}

拓展方式注入(第三方)

p命名空间注入，可以直接注入属性的值。

p = property

<bean id="user" class="cn.duo.pojo.User" p:name="Duo Ji Cheng" p:age="18"/>

c命名空间注入。

c=constructor

使用：

<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="user" class="cn.duo.pojo.User" p:name="Duo Ji Cheng" p:age="18"/>

  <bean id="user2" class="cn.duo.pojo.User" c:name="Duo Ji" c:age="19"></bean>

</beans>

注意点： p命名和c命名空间不能直接使用，需要导入约束。

9. Bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cgZlx0Fw-1648393003273)(/Users/duojicheng/Library/Application Support/typora-user-images/image-20220320010238678.png)]

单例模式(Spring 的默认机制)

<bean id="user2" class="cn.duo.pojo.User" c:name="Duo Ji" c:age="19" scope="singleton"></bean>

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

<bean id="user2" class="cn.duo.pojo.User" c:name="Duo Ji" c:age="19" scope="prototype"></bean>

其余的 request, session, application: 只有在Web开发中使用。

10. Bean的自动装配

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

在Spring中有三种装备的方式：

在XML文件中显示配置
在Java中显示配置
隐式的自动装配Bean【本章节重点】

autowired:

byName: 会自动地在容器上下文中去寻找和自己对象中set方法名后面对应的Bean id。（id == bean id）

<bean id="dog" class="cn.duo.pojo.Dog"></bean>
<bean id="cat" class="cn.duo.pojo.Cat"></bean>

<bean id="person" class="cn.duo.pojo.Person" autowire="byName">
  <property name="name" value="Duo Ji"></property>
</bean>

byType：会自动地在容器上下文中去寻找和自己对象属性类型相同的Bean。（必须保证类型全局唯一）

<bean id="dog123" class="cn.duo.pojo.Dog"></bean>
<bean id="cat123" class="cn.duo.pojo.Cat"></bean>

<bean id="person" class="cn.duo.pojo.Person" autowire="byType">
  <property name="name" value="Duo Ji"></property>
</bean>

小结：

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

10. 使用注解实现自动装配

jdk1.5开始支持注解，Spring是2.5开始支持注解。

要使用注解的须知：

导入约束：context约束

配置注解的支持： context:annotation-config/【重点】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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>

具体步骤：

加一个命名空间将原来配置文件中的第二个xsi改变为context
将后面的beans改为context
修改schemaLocation的约束，将其中的beans改为context

@Autowired

可以直接在属性上使用
可以在Set方法上使用
因为@Autowired注解是通过反射实现的，所以在属性上使用以后可以不用添加set方法，前提是这个自动装配的属性在IoC容器中存在且符合byName

扩展：

@Nullable 字段标记了这个注解，表示这个注解可以为Null。

Autowired属性required为false时，说明这个对象的属性值可以为Null。

@Autowired与@Qualifier(对象名)组合。–>@Qualifier指定唯一的对象(在@Autowired自动装配的环境比较复杂的时候，会导致@Autowired无法完成自动装配，所以需要@Qualifier进行配合)

@Resource

Java自带的注解

先通过属性名在IoC容器寻找匹配，寻找失败后，会再通过类型在IoC容器寻找匹配

小结：

@Resource和@Autowired的区别：

都是用来自动装配的，都可以放在属性字段
@Autowired 默认通过byType的方式实现，而且必须要求对象存在【更常用】
@Resource 默认通过byName的方式实现，若失败，则通过byType进行实现。
执行顺序不同

11. 使用注解开发

在Spring 4之后，要使用注解开发，必须要导入AOP的包，使用注解需要导入context约束，已达到支持注解效果。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       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>

指定要扫描的包，这个包下的注解就会生效
<context:component-scan base-package="cn.duo.pojo"/>
<context:annotation-config/>

@Component ==

@Component：组件，放在类上，说明这个类被Spring管理了，就是Bean。

@Value: 放在属性上或者set方法上。

Bean

属性如何注入

@Component
public class User {

  public String name;

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

衍生的的注解
@Component 有几个衍生的注解，我们在Web开发中，会按照mvc三层架构分层。
- dao: @Repository
- service: @Service
- controller: @Controller+@ResponseBody == @RestController
- 这四个注解在功能上都是等价的，都是代表将某个类注册到Spring中，装配Bean

自动装配

@Autowired
@Nullable
@Qualifier
@Resource

作用域
@Scope -----> @Scope(“singleton”) 或者 @Scope(“prototype”)
小结
xml 与注解:
- xml 更加万能，适用于任何场合，维护简单方便
- 注解：不是自己的类使用不了，维护相对复杂
- 一般Spring Boot项目使用注解，Spring项目还是采用xml的方式
xml和注解的最佳实践：
- xml文件负责管理bean
- 注解只负责完成属性的注入
- 我们在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持。

12. Java Config实现配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KY1Ip8gY-1648393003280)(/Users/duojicheng/Library/Application Support/typora-user-images/image-20220320223429668.png)]

上面的可以替代掉下面的。

可以完全不适用Spring的xml配置，全权交给Java来做。

JavaConfig是Spring的一个子项目，在Spring4之后变成了一个核心功能。

@Component
public class User {
  @Value("Duo Ji Cheng")
  private String name;

  @Value("18")
  private int age;

  public User() {
  }

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

  public String getName() {
    return name;
  }

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

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

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

@Component注解放在User类上，表示这个User类被Spring接管了，并且被注册到了IoC容器中。

@Import(xxx.class) == <import …>

13. 代理模式

为什么要学习代理模式？因为代理模式是Spring AOP的底层。【Spring AOP 和 Spring MVC】

代理模式分类：

静态代理
动态代理

13.1 静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
```
public interface Rent {
  public void rent();
}
```

真实角色：被代理的角色

public class Lessor implements Rent{
  @Override
  public void rent() {
    System.out.println("New rental house available!");
  }
}

代理角色：代理真实角色，代理之后一般还会做一些附属操作

public class Proxy implements Rent{

  private Lessor lessor;

  public Proxy() {
  }

  public Proxy(Lessor lessor) {
    this.lessor = lessor;
  }

  @Override
  public void rent() {
    showAround();
    lessor.rent();
    contract();
    charge();
  }

  public void showAround(){
    System.out.println("As a real estate agency, I'll show you the house or apartment room available");
  }

  public void contract(){
    System.out.println("Provide contract for both tenant and lessor");
  }

  public void charge(){
    System.out.println("Take charge for monthly rental");
  }
}

客户：访问代理对象的人

public class Client {
  public static void main(String[] args) {
    Proxy proxy = new Proxy(new Lessor());
    proxy.rent();
  }
}

代理模式的好处：

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

缺点：

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

13.2 深入理解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-arWJ6tup-1648393003280)(/Users/duojicheng/Library/Application Support/typora-user-images/image-20220321225511688.png)]

13.3 动态代理

动态代理和静态代理角色一样
动态代理的类是动态生成的，不是直接写好的。
动态代理分为两大类：
- 基于接口的动态代理： JDK动态代理
- 基于类的动态代理：CGLIB
- Java字节码：Javasist

需要了解两个类：Proxy 和 InvocationHandler

InvocationHandler是一个接口，用来给代理实例调用处理程序

每一个代理实例都有一个关联的调用处理程序，当在代理实例上调用方法的时候，方法的调用会被进行编码并且分派到其对应调用处理程序的invoke方法。

动态代理的好处：

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

14. AOP

定义：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发的一个热点，也是Spring框架中的一个重要内容。

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

通知类型：

前置通知----方法前
后置通知----方法后
环绕通知—方法前后
异常抛出通知----方法抛出异常
引介通知-----类中增加新的方法属性

方式一：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("查询一个用户");
    }
}

配置文件

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


<!--使用原生的API接口-->
<aop:config>
  <!--切入点：expression：表达式，execution(要执行的位置)-->
  <aop:pointcut id="before" expression="execution(* cn.duo.service.UserServiceImpl.*(..))"/>
  <aop:pointcut id="after" expression="execution(* cn.duo.service.UserServiceImpl.*(..))"/>
  <aop:advisor advice-ref="beforeLog" pointcut-ref="before"/>
  <aop:advisor advice-ref="afterLog" pointcut-ref="after"/>
</aop:config>

测试类

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

方式二：自定义来实现AOP【主要是切面定义】

配置文件

<bean id="service" class="cn.duo.service.UserServiceImpl"></bean>
<bean id="diy" class="cn.duo.log.DIYLog"></bean>

<aop:config>
  <!--自定义切面， ref表示要引用的类-->
  <aop:aspect ref="diy">
    <!--切入点-->
    <aop:pointcut id="point" expression="execution(* cn.duo.service.UserServiceImpl.*(..))"/>
    <!--通知-->
    <aop:before method="before" pointcut-ref="point"/>
    <aop:after method="after" pointcut-ref="point"/>
  </aop:aspect>
</aop:config>

测试类

public class MyTest2 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
UserService service = context.getBean("service", UserService.class);
service.add();
}
}

方式三：注解实现AOP

注解类

@Aspect
public class AnnotationPointCut {
  @Before("execution(* cn.duo.service.UserServiceImpl.*(..))")
  public void before(){
    System.out.println("=========== 执行之前 ===========");
  }

  @Around("execution(* cn.duo.service.UserServiceImpl.*(..))")
  public void around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("++++++++ 环绕之前 +++++++++++");
    System.out.println("签名 "+ joinPoint.getSignature());
    joinPoint.proceed();
    System.out.println("++++++++ 环绕之后 +++++++++++");
  }

  @After("execution(* cn.duo.service.UserServiceImpl.*(..))")
  public void after(){
    System.out.println("================= 执行之后 ==================");
  }
}

配置类

<bean id="service" class="cn.duo.service.UserServiceImpl"></bean>
<bean id="annotation" class="cn.duo.annotation.AnnotationPointCut"></bean>

<!--开启注解支持-->
<aop:aspectj-autoproxy/>

测试类

public class MyTest3 {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext3.xml");
    UserService service = context.getBean("service", UserService.class);
    service.add();

  }
}

注意点：

动态代理代理的是接口而不是类。
环绕包裹 Before 和 After

15. MyBatis 整合

步骤：

导入jar包

junit

<!--Junit-->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.13.1</version>
  <scope>test</scope>
</dependency>

mybatis

<!--MyBatis-->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.6</version>
</dependency>

mysql

<!--MySQL Drive-->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.16</version>
</dependency>

spring相关

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<!-- Spring操作数据库-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.3.14</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.9.RELEASE</version>
</dependency>

aop织入

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.7</version>
</dependency>

mybatis-spring. --> 专门整合Mybatis 和 Spring

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>2.0.6</version>
</dependency>

编写配置文件
测试

15.1 回忆MyBatis

编写实体类
编写核心配置文件
编写接口
编写mapper.xml
测试

15.2 MyBatis-Spring

MyBatis-Spring会帮助用户将MyBatis代码无缝地整合到Spring中。它允许MyBatis参与到Spring的事务管理之中，创建映射器mapper和SqlSession并注入到Bean中，以及将Mybatis异常转换为Spring的DataAceessException。最终，可以做到应用代码不依赖于Mybatis, Spring或者Mybatis-Spring。

注意事项

导入依赖：mybatis-spring
如果要与Spring一起使用MyBatis，需要在Spring上下文中定义至少两样东西：SqlSessionFactory 和 至少一个数据映射类

注意事项：数据映射类指的是一个接口 (必须是一个接口)，而非具体实现类。

具体步骤：

编写数据配置源

<!--DataSource: 使用Spring的数据源替换Mybatis的配置-->
<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/pop_music?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>
  <property name="username" value="root"/>
  <property name="password" value="duojicheng"/>
</bean>

注入SqlSessionFactory

<!--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:cn/duo/dao/*.xml"/>
</bean>

注入SqlSessionTemplate

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

需要给接口添加实现类

public class SingerMapperImpl implements SingerMapper{

  SqlSessionTemplate sqlSession;

  public SingerMapperImpl() {
  }

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

  @Override
  public Singer queryByName(String name) {
    SingerMapper mapper = sqlSession.getMapper(SingerMapper.class);
    Singer singer = mapper.queryByName(name);
    return singer;
  }
}

将实现类注入Spring中

<bean id="singerImpl" class="cn.duo.dao.SingerMapperImpl">
  <property name="sqlSession" ref="sqlSession"></property>
</bean>

测试使用即可

@Test
public void test3(){
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  SingerMapper singerImpl = context.getBean("singerImpl", SingerMapper.class);
  Singer singer = singerImpl.queryByName("Celine Dion");
  System.out.println(singer);
}

如果没有将实现类注入到Spring当中，则在测试类中需要set

@Test
public void test2(){
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  SqlSessionTemplate sqlSession = context.getBean("sqlSession", SqlSessionTemplate.class);
  SingerMapperImpl singerMapper = new SingerMapperImpl();
  singerMapper.setSqlSession(sqlSession);
  Singer targetSinger = singerMapper.queryByName("Celine Dion");
  System.out.println(targetSinger);
}

SqlSessionDaoSupport:

SqlSessionDaoSupport是一个抽象支持类，用来为用户提供SqlSession。调用getSqlSession()方法的时候就会得到一个SqlSessionTemplate,之后就可以用于执行SQL方法。

注：SqlSessionTemplate的注入省去。

实现类

public class SingerMapperImpl2 extends SqlSessionDaoSupport implements SingerMapper {
  @Override
  public Singer queryByName(String name) {
    return getSqlSession().getMapper(SingerMapper.class).queryByName(name);
  }
}

核心配置文件 (SqlSessionDaoSupport的父类需要SqlSessionFactory)

<import resource="spring.dao.xml"/>

<bean id="singerImpl" class="cn.duo.dao.SingerMapperImpl2">
  <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

测试类

@Test
public void test4(){
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
  SingerMapper singerImpl = context.getBean("singerImpl", SingerMapper.class);
  System.out.println(singerImpl.queryByName("Celine Dion"));
}

16. 声明式事务

1. 回顾事务

把一组业务当成一个业务来做；要么都成功，要么都失败
事务在项目开发中，十分的重要，设计到数据的一致性的问题，不能马虎
确保完整性和一致性

事物的ACID原则：

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

事务定义

一个使用MyBatis-Spring的其中一个主要原因是它允许MyBatis参与到Spring的事务管理中。而不是给MyBatis传建一个新的专用事务管理器， MyBatis-Spring接住了Spring中的DataSourceTransactionManager来实现事务管理。

一旦配置好了Spring的事务管理器，你就可以在Spring中按照使用者平时的方式来配置事务。并且支持@Transactional的注解和AOP风格的配置。在事务处理期间，一个单独的SqlSession对象事务配置好了以后，Mybatis-Spring将会透明地管理事务。

2. Spring中的事务管理

声明式事务：AOP
编程式事务：需要在代码中进行事务的管理

为什么需要事务？

如果不配置事务，可能存在数据提交不一致的情况。
如果不再Spring中配置声明式事务，那么就需要在代码中手动配置事务。
数据在项目开发中十分重要，涉及到数据的一致性和完整性的问题，不容马虎

在Spring容器中配置事务

<!--结合AOP实现事务的织入-->
<!--配置事务的通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <!--给那些方法配置事务-->
  <!--配置事务的传播特性-->
  <tx:attributes>
    <tx:method name="addSinger" propagation="REQUIRED"/>
    <tx:method name="delById" propagation="REQUIRED"/>
    <tx:method name="transactional" propagation="REQUIRED"/>
    <tx:method name="query" read-only="true"/>
    <!--<tx:method name="*"/>-->
  </tx:attributes>
</tx:advice>

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

Propagation的七中配置

编程方面的菜雀雀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
重新学习Spring

前言：工作了之后，慢慢发现曾经学习过的Spring的相关知识正在慢慢遗忘，为了重新捡起关于Spring相关的知识点，所以对其进行了重新学习与梳理。Spring1. 简介Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean来替代EJB，并提供更多的企业应用功能范围：任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架历史
复制链接

扫一扫