spring-Study

最新推荐文章于 2024-06-14 10:17:52 发布

星 ~ 程 @

最新推荐文章于 2024-06-14 10:17:52 发布

阅读量87

点赞数

分类专栏： Java java入门文章标签： spring java

本文链接：https://blog.csdn.net/m0_59133441/article/details/126162940

版权

Java 同时被 2 个专栏收录

23 篇文章 1 订阅

订阅专栏

java入门

6 篇文章 0 订阅

订阅专栏

1.Spring

1.1、简介

Spring：春天 ----------> 给软件行业带来了春天！
2002，首次推出了Spring框架的雏形：interface21 框架！
Spring 框架即以 interface21 框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。
Rod Johnson ，Spring Framework创始人，著名作者。很难想象 Rod Johnson 的学历，真的让好多人大吃一惊，他是悉尼大学博士，然而他的专业不是计算机，而是音乐学。
spring理念：使现有技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
ssh：Struct2 + Spring + Hibernate
SSM：SpringMVC + Spring + Mybatis

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

官方下载地址：http://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.3.21</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.21</version>
</dependency>

1.2、优点

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

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

1.3、组成

1.4、拓展

在spring官网有这个介绍：现代化的java开发！说白就是基于spring的开发！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0u2Jy2oc-1659603837814)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20220718102010621.png)]

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

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

2、IOC理论推导

1、UserDao 接口

2、UserDaoImpl 实现类

3、UserService 业务接口

4、UserServiceImpl 业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

在这里插入图片描述

我们使用一个 Set 接口实现，已经发生了革命性的变化！

private UserDao userDao;

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

之前，程序的主动创建对象！控制权在程序员手上！
使用 Set 注入后，程序不在具有主动性，而是变成了被动的接受对象！

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了，系统的耦合性大大降低~，可以更加专注业务的实现上！这是IOC的原型！

在这里插入图片描述

IOC 本质

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

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

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

3、Hello Spring

public class Hello {

    private String str;

    public String getStr() {
        return str;
    }

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

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

配置 Beans.xml

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

    <!--  使用 Spring 来创建对象，在 Spring 这些都称为 Bean

     类型    变量名   =  new 类型（）；
     Hello   hello = new Hello（）；

     id = 变量名
     class = new 的对象
     property 相对于给对象中的属性设置一个值！
     value ：具体的值， 基本数据类型！
     ref ：  引用 Spring 容器中创建好的对象
     -->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

测试 MyTest

public class MyTest {

    public static void main(String[] args) {
        // 获取 Spring 的上下文对象
        // 解析 Beans.xml 文件，生成管理相应的 Bean 对象
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 我们的对象现在都在 Spring 中管理了，我们要使用，直接去里面取出来就可以了！
        // getBean:	参数即为 Spring 配置文件中的 bean 的 id
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());

    }

}

在这里插入图片描述

4、IOC创建对象的方式

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

2、假设我们要使用有参构造创建对象。

1、下标赋值

<!-- 第一种方式：下标赋值   -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="又下雨了"/>
</bean>

2、类型

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

3、参数名

<!--  第三种方式：直接通过参数名来设置  -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="Word"/>
</bean>

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

5、Spring配置

5.1、别名

<!-- 别名，如果添加了别名，我们也可以使用别名获取到这个对象   -->
<alias name="user" alias="user2New"/>

5.2、Bean 的配置

    <!--
      id：bean 的唯一标识符，也就是相当于我们学的对象名
      class： bean 对象所对应的全限定名：包名 + 类型
      name：也是别名，而且 name 可以同时取多个别名
      -->
    <bean id="userT" class="com.kuang.pojo.UserT" name="t">
        <property name="name" value="牛肉面"/>
    </bean>

5.3、import

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

假设，现在项目中有多个人开发，这每一个人都负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用 import 将所有人的 beans.xml 合并为一个总的！

A
B
C
…
applicationContext.xml

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

使用的时候，直接使用总的配置就可以了。

6、依赖注入

6.1、构造器注入

前面已经说过了

6.2、Set方式注入【重点】

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

【环境搭建】

1、复杂类型

public class Address {

    private String address;


    public String getAddress() {
        return address;
    }

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

2、真实测试对象

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;
}

3、beans.xml

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

    <bean id="student" class="com.kuang.pojo.Student">
        <property name="name" value="张天魁"/>
    </bean>

</beans>

4、测试类

public class MyTestDI {

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

}

5、完善注入信息！

<?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.kuang.pojo.Address">
        <property name="address" value="兰州"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--  第一种：普通只注入，value      -->
        <property name="name" value="张天魁"/>

        <!--  第二种：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>
            </list>
        </property>

        <!--  第五种：Map      -->
        <property name="card">
            <map>
                <entry key="身份证" value="111111222233334444"/>
                <entry key="银行卡" value="622164879/87/74785157"/>
            </map>
        </property>

        <!--  第六种：Set      -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>联盟</value>
                <value>王者</value>
            </set>
        </property>

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

        <!--  第八种：Properties  -->
        <property name="info">
            <props>
                <prop key="driver">20220612102</prop>
                <prop key="Sex">男</prop>
            </props>
        </property>
        
    </bean>

</beans>

6.3、拓展方式注入

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

官方解释：

在这里插入图片描述

使用：

<?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.kuang.pojo.User" p:name="李天威" p:age="150"/>

    <!-- c 命名空间注入，通过构造器注入：construct-args   -->
    <bean id="user2" class="com.kuang.pojo.User" c:name="王天放" c:age="1800"/>

</beans>

测试：

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

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

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.4、bean 的作用域

在这里插入图片描述

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

<bean id="user2" class="com.kuang.pojo.User" c:name="王天放" c:age="1800" scope="singleton"/>

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

<bean id="user2" class="com.kuang.pojo.User" c:name="王天放" c:age="1800" scope="prototype"/>

3、其余的 request、session、application、这些个只能在web开发中使用到！

7、Bean 的自动装配

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

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

在xml中显示的配置
在 java 中显示配置
隐式的自动装配 bean 【重点】

7.1、测试

一个人有两个宠物

7.2、ByName自动装配

<!--
    byName : 会自动在容器上下文中查找，和自己对象 Set 方法后面的值对应的 Bean id！
 -->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
    <property name="name" value="张三"/>
</bean>

7.3、Bytype自动装配

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

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

7.4、使用注解自动装配

JDK 1.5 支持注解，Spring 2.5就支持注解了！

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

使用注解须知：

1、导入约束：context 约束

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

2、配置注解的支持：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>

@Autowired

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

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

科普：

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

public @interface Autowired {
    boolean required() default true;
}

测试代码：

public class People {

    private String name;
    // 如果显示定义了 Autowired 的 required 熟悉为 false ，说明这个对象可以为 null ，否则不允许为空
    @Autowired(required = false)
    private Dog dog;
    @Autowired
    private Cat cat;
}

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value=“xxx”) 去配置 @Autowired的使用，指定唯一的 bean对象注入！

public class People {

    private String name;
    // 如果显示定义了 Autowired 的 required 熟悉为 false ，说明这个对象可以为 null ，否则不允许为空
    @Autowired(required = false)
    @Qualifier(value = "dog111")
    private Dog dog;
    @Autowired
    @Qualifier(value = "cat111")
    private Cat cat;
}

@Resource

public class People {

    private String name;
    @Resource(name = "dog11")
    private Dog dog;
    @Resource
    private Cat cat;
}

小结：

@Resource 和 @Autowired 的区别：

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

8、使用注解开发

在 Spring 4 之后，要使用注解开发，必须要保证 aop 的包导入了

在这里插入图片描述

使用注解需要导入 context 约束，增加注解的支持！

1、bean

2、属性如何注入

// @Component 相当于 <bean id="user" class="com.kuang.pojo.User">
@Component
public class User {

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

}

3、衍生的注解

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

dao 【@Repository】
service 【@Service】
controller 【@Controller】

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

4、自动装配置

## 注解说明
- @Autowired：自动装配，通过类型，名字
    如果@Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "dog111")
- @Nullable 	字段标记了这个注解，说明这个字段可以为 null；
-  @Resource：自动装配，通过名字，类型

5、作用域

// @Component 相当于 <bean id="user" class="com.kuang.pojo.User">
@Component
// @Scope("singleton") 作用域 单例模式
@Scope("singleton")
public class User {

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

}

6、小结

xml 与注解：

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

xml 与注解最佳实践：

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

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

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

9、使用Java的方式配置Spring

我们现在要完全不使用 Spring 的 xml 配置了，全权交给 Java 来做！

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

在这里插入图片描述

实体类

// 这里这个注解的意思，就是说明这个类被Spring接管了，注册到容器中
@Component
public class User {

    private String name;

    public String getName() {
        return name;
    }
    
    @Value("万疆")
    public void setName(String name) {
        this.name = name;
    }

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

配置文件

// 这个也会交给 Spring容器托管，注册到容器中，因为它本来就是 @Component
// @Configuration 代表这是一个配置类，就和我们之前看到 beans.xml 一样
@Configuration
@ComponentScan("com.kuang.pojo")
@Import(Myconfig2.class)
public class MyConfig {

    //注册一个 bean，就相当于我们之前写的一个 bean 标签
    //这个方法的名字，就相当于 bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class 属性
    @Bean
    public User user(){
        return new User();  // 就是要返回注入到 bean的对象！
    }

}

测试类

public class MyTest {

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

    }

}

这个纯java的配置方式，在Sprintboot中随处可见！

10、代理模式

为什么要学习代理模式？因为这就是SpringAOP 的底层！【SpringAOP 和 SpringMVC】

代理模式的分类：

静态代理
动态代理

在这里插入图片描述

10.1、静态代理

角色分析：

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

代码步骤：

1、接口

//租房
public interface Rent {

    public void rent();

}

2、真实角色

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

3、代理角色

//代理角色 中介
public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

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

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

    // 看房
    public void  seeHost(){
        System.out.println("中介带你去看房子！");
    }

    // 签合同
    public void heTong(){
        System.out.println("中介和你签订租赁合同！");
    }

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

4、客户端访问代理角色

public class Client {

    public static void main(String[] args) {

        // 房东要出租房子
        Host host = new Host();
        // 代理，中介帮房东租房子，但是呢，代理角色一般会有一些附属操作！
        Proxy proxy = new Proxy(host);

        // 你要租房子
        // 你不用面对房东，直接找中介租房即可！
        proxy.rent();

    }

}

代理模式的好处：

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

缺点：

一个真实角色就会产生一个代理对象；代码量会翻倍_{开发效率会变低}

10.2、加深理解

聊聊Aop

在这里插入图片描述

10.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 ------- JDK 动态代理【我们在这里使用】
- 基于类 -------- cglib
- java字节码实现：javasist

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

动态代理的好处：

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

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:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mmR2GJ66-1582098145036)(https://blog.kuangstudy.com/usr/uploads/2019/10/904133406.png)]

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

11.3、使用Spring 实现 AOP

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

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

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

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

方式三：使用注解实现

12、整合Mybatis

步骤：

1、导入相关 jar 包

- Junit
- Mybatis
- mysql 数据库
- spring 相关
- aop 织入
- Mybatis - spring 【new】

2、编写配置文件

3、测试

12.1、回忆 Mybatis

1、编写实体类

2、编写核心配置文件

3、编写接口

4、编写 Mapper.xml

5、测试

12.2、Mybatis-Spring

1、编写数据源配置

2、SqlSessionFactory

3、SqlSessionTemplate

4、需要给接口加实现类

5、将自己写的实现类注入到 Spring 中

6、测试使用即可！

13、声明式事务

1、回顾事务

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

事务的 ACID 原则：

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

2、Spring 中的事务管理

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

思考：

为什么需要事务？

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

星 ~ 程 @

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring-Study

spring-study
复制链接

扫一扫

专栏目录

spring-Study

1.Spring

1.1、简介

1.2、优点

1.3、组成

1.4、拓展

2、IOC理论推导

IOC 本质

3、Hello Spring

配置 Beans.xml

4、IOC创建对象的方式

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

2、假设我们要使用有参构造创建对象。

1、下标赋值

2、类型

3、参数名

5、Spring配置

5.1、别名

5.2、Bean 的配置

5.3、import

6、依赖注入

6.1、构造器注入

6.2、Set方式注入【重点】

6.3、拓展方式注入

6.4、bean 的作用域

7、Bean 的自动装配

7.1、测试

7.2、ByName自动装配

7.3、Bytype自动装配

7.4、使用注解自动装配

8、使用注解开发

1、bean

2、属性如何注入

3、衍生的注解

4、自动装配置

5、作用域

6、小结

9、使用Java的方式配置Spring

10、代理模式

10.1、静态代理

10.2、加深理解

10.3、动态代理

11、AOP

11.1、什么是AOP

11.2、AOP 在Spring 中的作用

11.3、使用Spring 实现 AOP

12、整合Mybatis

12.1、回忆 Mybatis

12.2、Mybatis-Spring

13、声明式事务

1、回顾事务

2、Spring 中的事务管理

“相关推荐”对你有帮助么？