Spring入门（包括spring整合mybatis的spring-mybatis）

已于 2022-02-01 22:19:10 修改
阅读量393 收藏
点赞数
文章标签： spring java mybatis
于 2021-10-08 22:39:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/remakeprogramer/article/details/120661548
版权

Spring

一、背景介绍

1、spring理念

  • 使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
  • Spring是一个轻量级控制反转（lOC）和面向切面（AOP）的容器框架

2、轮子理论

不需要重复的“造轮子”，可以使用已经存在的轮子简化开发流程

3、框架

早期为SSH框架，即：Struct2 + Spring + Hibernate

现在多数使用的是SSM框架，即：Spring MVC + Spring + Mybatis

目前Spring 的稳定版本为：5.3.0

4、所需依赖

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

5、Spring的有点

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

一句话概括：

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

6、Spring的七大模块

(img-gIkTMvZ7-1633703901292)(C:\Users\利姆鲁\AppData\Roaming\Typora\typora-user-images\image-20210908203344662.png)]

7、Spring的拓展

  1. 关于目前最火的Spring Boot与Spring Cloud
  • Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
  • Spring Cloud是基于Spring Boot实现的；
  • Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
  • Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
  • Spring Boot在Spring Cloud中起到了承上启下的作用，如果你要学习Spring Cloud必须要学习Spring Boot。

  1. 目前现代化的Java开发，都是基于Spring进行的

    img

  2. 关于Spring boot的特性

  • 一个快速开发的脚手架
  • 基于Spring Boot可以快速的开发单个微服务
  • 约定大于配置！
  • 因为现在大多数公司都在使用Spring Boot进行快速开发，学习Spring boot的前提，需要完全掌握Spring和Spring MVC
  1. Spring Cloud
  • Spring Cloud是基于Spring boot实现的。
  • 约定大于配置！
  1. 原生Spring的弊端
  • 由于发展太久了以后，违背了原来的理念，配置十分繁琐，人称“配置地狱”，才有了Spring boot

二、IOC（控制反转）的基本思想和原理

1、原理解释

在IOC诞生之前的业务编写流程举例：

UserDao数据库接口

UserDaoImpl实体类实现数据库接口方法

UserService业务接口

UserServiceImpl实体类实现业务接口方法

这样的结构乍一看没什么问题，但当用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码! 如果程序代码量十分大，修改一次的成本十分昂贵。

而我们在业务层使用一个针对Dao接口的set方法即可解决这个问题

//原来
private UserDao userDao = new UserDaolmpl();


//改进后
private UserDao userDao;
    // 与方式1的本质区别：利用set进行动态实现值的注入!
    // alt + insert 调出Generate
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

作出这样的改变后，我们可以发现，此时的Dao接口实体化类型的控制权已经从我们程序员手里转移到了用户的手里！

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

2、初次使用IOC思想创建对象（Spring中的方法）

  1. 首先要创建POJO实体类

    package com.xiafan;

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


}

  2. 配置Spring的xml文件

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

    <!--
        bean标签本质上类似于new对象的功能

        id 为变量名
        class 为new的对象
        property 相当于给对象中的属性设置值（set方法）

    -->

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

</beans>

  3. 测试使用

    package com.xiafan;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloTest {

    @Test
    public void Test01(){
        //获取Spring的上下文
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //用Spring创建的对象可以直接取出来用
        Hello hello =(Hello) applicationContext.getBean("hello");
        System.out.println(hello.getStr());
    }
}

3、了解IOC创建对象的具体方式

  1. 默认会使用无参构造方法创建对象

    bean.xml中：        
    <bean id="user1" class="com.xiafan.pojo.User">
        <property name="name" value="faker"/>
    </bean>

java代码中：
        User user1 = (User) context.getBean("user1");
        user1.showName();

  2. 若要实现有参构造，有三种方式（都是用bean中的构造器标签实现的）

    1. 方式一：通过参数下标传递构造方法参数

      bean.xml中：        
    <bean id="user2" class="com.xiafan.pojo.User">
        <!--方法一-->
        <constructor-arg index="0" value="the shy"/>
    </bean>

java代码中：
        User user2 = (User) context.getBean("user2");
        user2.showName();

    2. 方法二：通过参数类型传递构造方法参数（不建议使用，因为如果有两个参数类型相同，则因为只能赋一个值而无法顺利构造）

      bean.xml中：        
    <bean id="user3" class="com.xiafan.pojo.User">
        <!--方法二（不推荐使用）-->
        <constructor-arg type="java.lang.String" value="rookie"/>
    </bean>

java代码中：
        User user3 = (User) context.getBean("user3");
        user3.showName();

    3. 方法三：类似java语言创建对象时一样传递参数，即对应参数名直接传参

      bean.xml中：        
    <bean id="user4" class="com.xiafan.pojo.User">
        <!--方法三-->
        <constructor-arg type="java.lang.String" value="rookie"/>
    </bean>

java代码中：
        User user4 = (User) context.getBean("user4");
        user4.showName();

以上代码的运行结果为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5imxg2gk-1633703901299)(C:\Users\利姆鲁\AppData\Roaming\Typora\typora-user-images\image-20210916223924401.png)]

注意到：

1.通过代码运行结果可以发现，我们所调用的所有对象，都是在beans.xml配置文件加载的时候就已经创建了的，而不是之后需要调用对象的时候再实时的创建，是一开始就全部创建了

2.创建对象的时候，使用的是单例模式

三、Spring中xml配置文件的配置标签说明

1、别名（alias）

    <!--
        name：对象本来的名字
        alias：另外取的别名
    -->	
	<alias name="user1" alias="yonghu1"/>

2、bean

    <!--
        bean标签本质上类似于new对象的功能
        
        id：创建的对象名
        class：创建对象对应的类
        name：所创建对象的别名，可以添加多个别名
        property：相当于给对象中的属性设置值（set方法）
        constructor-arg：有参构造方法标签

    -->
    <!--bean就是java对象 , 由Spring创建和管理-->
    <bean id="user1" class="com.xiafan.pojo.User">
        <property name="name" value="faker"/>
    </bean>

3、import

import一般用于团队开发使用，可以将其他配置文件整合到使用import标签的配置文件，测试或者实际调用的时候直接使用整合的配置文件即可。

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

四、依赖注入

依赖和注入是分开的。

所谓依赖：指的是bean对象的创建依赖于容器

所谓注入：指的是bean对象中的所有属性由容器进行注入

1、构造器注入

在IOC创建对象的部分已经讲过了，不再赘述

2、SET注入（重点）

对于不同类型的数据使用不同的注入方式

<!--工具bean，用于赋值注入-->
    <bean id="address" class="com.xiafan.pojo.Address">
        <property name="address" value="广州"/>
    </bean>

    <bean id="student" class="com.xiafan.pojo.Student">
        <!--第一种注入方式：普通注入，用value-->
        <property name="name" value="letme"/>
        <!--第二种注入方式：bean注入，ref-->
        <property name="address" ref="address"/>
        <!--第三种注入方式：数组注入，array-->
        <property name="books">
            <array>
                <value>龙珠</value>
                <value>火影</value>
                <value>海贼</value>
                <value>死神</value>
            </array>
        </property>
        <!--第四种注入方式：list注入，list-->
        <property name="hobbies">
            <list>
                <value>玩手机</value>
                <value>玩电脑</value>
                <value>玩switch</value>
                <value>玩X-BOX</value>
                <value>玩ipad</value>
            </list>
        </property>
        <!--第五种注入方式：map注入，map和entry-->
        <property name="cards">
            <map>
                <entry key="校园卡" value="201929230163"/>
                <entry key="身份证" value="440982199901463380"/>
            </map>
        </property>
        <!--第六种注入方式：set注入，set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>ralol</value>
                <value>只狼</value>
                <value>cod</value>
                <value>彩虹六号</value>
            </set>
        </property>
        <!--第七种注入方式：null注入，null-->
        <property name="wife">
            <null/>
        </property>
        <!--第八种注入方式：properties注入，props-->
        <property name="info">
            <props>
                <prop key="drive">1</prop>
                <prop key="url">2</prop>
                <prop key="username">3</prop>
                <prop key="password">4</prop>
            </props>
        </property>
    </bean>

3、拓展的P命名空间注入和C命名空间注入（了解即可，方便，但可读性较差）

首先要导入xml约束

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

  1. P命名空间注入：用于对属性property进行注入，对应set注入

        <!--p命名空间注入-->
    <bean id="user1" class="com.xiafan.pojo.User" p:name="ale" p:age="16"/>

  2. C命名空间注入：用于对构造函数的参数进行注入，对应构造器注入

        <!--c命名空间注入-->
    <bean id="user2" class="com.xiafan.pojo.User" c:name="faker" c:age="18"/>

4、关于bean的作用域

​ 可以在bean标签中直接加入scope属性选择作用域

  1. 单例模式singleton（默认为单例模式）

    单例模式即：在bean中以单例模式注册的对象在整个被引用的过程中，引用的是同一个对象，即该对象只创建一次

  2. 原型模式prototyer（需要手动改为原型模式）

    原型模式即：在bean中以原型模式注册的对象每次被引用时会自动创建一个新的对象，这些对象都不是同一个对象，是不同的对象

  3. request、session、application是在web开发中的作用域，在此处不再赘述，可以直接看Javaweb开发基础自行食用

五、Bean的自动装配

1、背景

  1. 自动装配是spring满足bean依赖注入的一种方式
  2. spring会在上下文自动寻找，并给bean装配属性

2、三种装配方式

  1. 直接在xml配置文件中显式的配置（此前所用的方法）
  2. 直接在java文件中显式的配置
  3. 在xml配置文件中隐式的自动装配**（重要，需要掌握）**

3、自动装配的几种方式

  1. byName：在xml配置文件上下文中查找，搜寻对象set方法后对应的值相同的bean的id，并对应赋值。（bean中的id要符合命名规则且id唯一，否则会报错)

        public void setJiaCandy(JiaCandy jiaCandy) {
        this.jiaCandy = jiaCandy;
    }
    public void setDrill(Drill drill) {
        this.drill = drill;
    }

        <bean id="jiaCandy" class="com.xiafan.pojo.JiaCandy"/>
    <bean id="drill" class="com.xiafan.pojo.Drill"/>

    <bean id="person" class="com.xiafan.pojo.Person" autowire="byName">
        <property name="name" value="rookie"/>
    </bean>

  2. byType：在xml配置文件上下文中查找，搜寻与对象的类相同的bean的id，并对应赋值。（每种类只能有一个参数，否则会报错）

        <bean id="jiaCandy" class="com.xiafan.pojo.JiaCandy"/>
    <bean id="drill" class="com.xiafan.pojo.Drill"/>

    <bean id="person" class="com.xiafan.pojo.Person" autowire="byType">
        <property name="name" value="rookie"/>
    </bean>

  3. 使用注解实现自动装配**（重要）**

    首先需要导入支持约束（在xml配置文件中）：

    <beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd">

    再开启注解支持（在xml配置文件中）：

    <context:annotation-config/>

    常用注解：

    1.@Autowired：可在类中的引用属性上直接添加该注解，该注解默认先通过byType方式自动装配，若不符合再通过byName方式进行装配。

    2.@Qualifier：用于配合@Autowired使用的注解，如果@Autowired通过byType和byName方式都无法找到工具bean，则可以使用该注解直接赋值bean的id来准确匹配工具bean。

    有关的Java核心代码和beans.xml关键配置：

        @Autowired
    @Qualifier("jiaCandy")
    private JiaCandy jiaCandy;
    @Autowired
    @Qualifier("drill")
    private Drill drill;

        <bean id="jiaCandy" class="com.xiafan.pojo.JiaCandy"/>
    <bean id="drill" class="com.xiafan.pojo.Drill"/>

    <bean id="person" class="com.xiafan.pojo.Person">
        <property name="name" value="rookie"/>
    </bean>

    3.@Nullable：标记属性可以为空，其作用和@Autowired(false)相同

    4.@Resource：其作用相当于@Autowired和@Qualifier的组合，可以直接使用也可以给注解赋值使用；与@Autowired相反，@Resource默认先通过byName方式自动装配，若不符合再通过byType方式进行装配。

    有关的Java核心代码和beans.xml关键配置：

        @Resource(name = "jiaCandy")
    private JiaCandy jiaCandy;
    @Resource(name = "drill")
    private Drill drill;

        <bean id="jiaCandy" class="com.xiafan.pojo.JiaCandy"/>
    <bean id="drill" class="com.xiafan.pojo.Drill"/>

    <bean id="person" class="com.xiafan.pojo.Person">
        <property name="name" value="rookie"/>
    </bean>

    总结：@Autowired和@Qualifier的组合是目前spring的规范标准，比较推荐使用，而@Resource已被逐步替代

六、使用注解进行开发

环境准备:

  1. 首先需要先导入aop依赖，在之前导入的包里面包含了aop依赖，这里不需要再导入

  2. 然后要在xml配置文件中添加扫描标签

    <!--指定要扫描的包，该包下的注解才会生效-->
    <context:component-scan base-package="com.xiafan.pojo"/>

现在可以开始注解开发了

1、bean

@Component：直接用在类上，起注册作用

//相当于<bean id="user" class="com.xiafan.pojo.User"/>
@Component
public class User {
    private String name;
}

2、属性注入

@Value：直接用在属性上，起注入作用

public class User {
    //相当于<property name="name" value="xiaohu"/>
    @Value("xiaohu")
    private String name;
}

3、衍生注解

类似于@Component，在不同层的Java类中使用的注册注解有区别，作用一样，只因便于区分

dao层：@Repository

pojo层：@Component

service层：@Service

controller层：@Controller

4、自动装配（见第五大点第三小点）

5、作用域

@Scope：直接用在类上，表明该对象注册后的作用域

@Scope("singleton")//单例模式作用域

6、总结

xml配置和注解的优缺点：

  1. xml配置更万能，适用于所有场合，且方便维护
  2. 注解在非本注解的类中就会无效，由于每个类都有自己的注解，维护相对更麻烦

xml配置和注解的取舍：

  1. 一般使用xml配置来管理bean
  2. 注解更注重于完成属性的注入

七、AOP（面向切片编程）

1、代理模式

了解AOP首先要了解代理模式。

代理模式分为静态代理和动态代理。

任何设计模式其实都是对为了解决现实中的问题而提出的：在这里的代理模式则对应于现实中的中介，买家和卖家之间不需要直接进行接触，即可通过中介完成一笔交易，这就是代理模式的思想。这样做可以使得客户端和真实角色的耦合性大大降低。

2、静态代理模式

由四个角色组成：

  1. 抽象角色：用接口或抽象类实现，代表真实角色需要实现的功能
  2. 真实角色：被代理的角色
  3. 代理角色：代理真实角色，不仅能代替完成真实角色功能还能完成额外的功能
  4. 客户端：使用代理对象来进行操作

静态代理模式的优缺点：

​ 优点：

  1. 可以使得真实对象专注与自己所需要做的事，而其他与它无关或者关系很小的公共业务可以由代理对象代替完成
  2. 公共业务可以由代理对象完成，实现了业务分层
  3. 公共业务的拓展变得更加方便，只需修改代理对象即可，而不需要修改所有的真实对象

​ 缺点：

  1. 这样做使得需要管理的类几乎翻倍了，多了许多代理类，使得项目工作量大，开发效率降低

为了解决静态代理模式的缺点，我们提出了动态代理模式

3、动态代理模式

动态代理的核心是反射机制！

与静态代理相同，动态代理也由四个角色组成：

  1. 抽象角色：用接口或抽象类实现，代表真实角色需要实现的功能
  2. 真实角色：被代理的角色
  3. 代理角色：代理真实角色，不仅能代替完成真实角色功能还能完成额外的功能
  4. 客户端：使用代理对象来进行操作

但动态代理的代理角色是动态引入的，而不是像静态代理一样写死在代码中的

动态代理分为两类：

  1. 基于接口的动态代理：JDK动态代理
  2. 基于类的动态代理：cglib
  3. 现在用的比较多的是javassist

JDK动态代理核心的两个类：Proxy类和InvocationHandler接口，查阅JDK文档进行了解

使用动态代理后，除解决静态代码的缺点和继承静态代码的优点外，还有更重要的优点：

  1. 一个动态代理可以代理一类业务而不是原来的一个静态代理只能代理一个业务
  2. 动态代理代理的是接口，意味着动态代理可以代理多个继承该接口的类。而静态代理代理的是实际存在的类

4、关于spring中的AOP

  1. 什么是AOP

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

  2. AOP在spring中所需了解的背景知识

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

    以下名词需要了解下：

    • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …

    • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。

    • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

    • 目标（Target）：被通知对象。

    • 代理（Proxy）：向目标对象应用通知之后创建的对象。

    • 切入点（PointCut）：切面通知 执行的 “地点”的定义。

    • 连接点（JointPoint）：与切入点匹配的执行点。

      img

      五种通知类：

      img

  3. AOP的意义

    AOP的意义跟代理模式很相似：Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来，实现公共业务的重复利用，领域业务更纯粹 , 使得软件工程师可以更专注领域业务 , 其本质还是动态代理的思想。

  4. spring中AOP的三种实现方式

    1. 方法一：让所需添加环绕的类实现spring自带的aop接口进行配置

          <bean id="userService1" class="com.xiafan.service.UserServiceImpl"/>
    <bean id="beforelog" class="com.xiafan.Log.BeforeLog"/>
    <bean id="afterlog" class="com.xiafan.Log.AfterLog"/>

    <!--方法一：让所需添加环绕的类实现spring自带的aop接口进行配置-->
    <aop:config>
        <!--切入点 id:切入点的名字 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.xiafan.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref：环绕bean . pointcut-ref：切入点-->
        <aop:advisor advice-ref="beforelog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
    </aop:config>

      package com.xiafan.Log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice{
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        //method : 要执行的目标对象的方法
        //objects : 被调用的方法的参数
        //Object : 目标对象
        System.out.println(o.getClass().getName() + "调用了" + method.getName());
    }
}
=====================================================================================================
package com.xiafan.Log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] objects, Object target) throws Throwable {
        //returnValue 返回值
        //method被调用的方法
        //args 被调用的方法的对象的参数
        //target 被调用的目标对象
        System.out.println(target.getClass().getName() + "调用了" + method.getName() + "结果返回值为" + returnValue);
    }
}

    2. 方法二：使用AOP标签实现

          <bean id="userService2" class="com.xiafan.service.UserServiceImpl"/>
    <bean id="log" class="com.xiafan.Log.Log"/>

    <!--方法二：使用AOP标签实现-->
    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="logpointcut" expression="execution(* com.xiafan.service.UserServiceImpl.*(..))"/>
            <aop:before pointcut-ref="logpointcut" method="before"/>
            <aop:after pointcut-ref="logpointcut" method="after"/>
        </aop:aspect>
    </aop:config>

      package com.xiafan.Log;

public class Log {
    public void before(){
        System.out.println("我在前面before");
    }
    public void after(){
        System.out.println("我在后面after");
    }
}

    3. 方法三：使用注解实现

          <!--方法三：使用注解实现,在xml配置文件中打开注解自动切片注入即可-->
    <aop:aspectj-autoproxy/>

      package com.xiafan.Log;

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;

@Aspect
public class AnnotationLog {
    @Before("execution(* com.xiafan.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("我是执行前啦");
    }
    @After("execution(* com.xiafan.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("我是执行后啦");
    }
    @Around("execution(* com.xiafan.service.UserServiceImpl.*(..))")
    public void round(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

八、Mybatis-Spring

1、什么是 MyBatis-Spring？

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

2、Mybatis-Spring的兼容问题

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

3、Mybatis-Spring整合的两种方式

方式一：

  1. 把mybatis的核心配置文件中的数据源转移到spring配置文件中

        <!--数据源dataSource：使用spring的配置来代替mybatis的dataSource配置（数据源包括：c3p0，dbcp，druid等，这里使用spring提供的jdbc）-->
    <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?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

  2. 在spring配置文件中配置sqlSessionFactory和sqlSession

        <!--配置sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis的配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/xiafan/dao/*.xml"/>
    </bean>

    <!--SqlSessionTemplate就是mybatis中的sqlSession，只是换了个名字表达-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--该类通过构造函数注入sqlSessionFactory-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

  3. 实现实体类

    public class UserMapperImpl implements UserMapper{
    
    //创建sqlsession对象
    private SqlSessionTemplate sqlSession;

    public SqlSessionTemplate getSqlSession() {
        return sqlSession;
    }

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

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

  4. 在spring配置文件中配置dao实现类

        <!--dao接口实现类bean-->
    <bean id="userMapperImpl" class="com.xiafan.dao.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

  5. 此时的mybatis配置文件只需要配置setting和typeAliases即可

    <configuration>
	
    <typeAliases>
        <package name="com.xiafan.pojo"/>
    </typeAliases>

</configuration>

  6. 测试运行即可

        @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        List<User> user = userMapper.getUser();
        for (User user1 : user) {
            System.out.println(user1);
        }
    }

方式二：多数步骤和方式一相同，不同的地方在于实体类的实现

关键在于继承了SqlSessionDaoSupport类，该类实际上也就是帮我们封装了sqlsession的获取过程而已，完全可以自行编写工具类，但既然有现成的可以直接使用现成的。

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

九、Spring中的事务管理

spring的事务管理分为声明式事务和编程式事务。

编程式事务管理

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

声明式事务管理

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

编程式事务即以前使用的，使用try-catch-finally语句对需要进行事务操作的语句进行包含和操作即可，这里不再详说。

这里主要关注声明式事务如何使用的。

  1. 首先需要在spring配置文件头导入tx约束

  2. 配置事务管理器

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
</bean>

  3. 配置事务通知advice

    <!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="search*" propagation="REQUIRED"/>
        <tx:method name="get" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

  4. 配置aop，将事务通知织入业务中

    <!--配置aop织入事务-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

补充：spring事务的七大传播特性

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

  • propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
  • propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
  • propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
  • propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
  • propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
  • propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！

夏帆er
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring整合mybatis详解
Java学习博客
09-30 3106
spring整合mybatis的步骤详解
Spring 与 MyBatis 的整合
MinSunshine的博客
07-07 528
1.整合思路   思路：将MyBatis框架中使用到的核心组件配置到Spring容器中，交给Spring来创建和管理。   具体来说是将需要自行编码通过SqlSessionFactoryBuilder读取配置文件、构建SqlSessionFactory,进而获得SqlSession实例，满足业务逻辑对象对于数据访问的需要的工作交由Spring来完成，发挥Spring框架Bean容器的作用，接管组件...
spring框架七大模块
weixin_30559481的博客
10-14 1442
1.SpringCore：Core封装包是框架的最基础部分，提供IOC和依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。 2.SpringContext: 构建于Core封装包基础上的Context封装包，提供了一种框架式的对象访问方法，有些象JNDI注册器。Cont...
常用设计模式-Spring、SpringMVC、Mybatis框架中都用到了哪些设计模式
fallwind_of_july的博客
06-29 3889
本文主要对常用的几种设计模式介绍： 设计模式：一套反复使用、经过分类编目的代码设计经验总结； 若想详细了解可参考：https://www.runoob.com/design-pattern/adapter-pattern.html 1.创建型模式： 这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。 单例模式 工厂模式 2.结构型模式： 这些设计模...
Mybatis和Spring主流框架结合
wzEminem的博客CRIQT*zz41(f
07-04 228
Mybatis： 整合过程： 在application.properties中填写datasource： 在mybatis—config.xml中填写具体设置信息： dao层写接口和sql语句，加入@Mapper @Mapper只要是为mapper或者dao产生了一个代理对象，代理对象实现了dao，从而实现里代理接口方法，主要就是查询数...
mybatis-spring-boot-starter-2.1.3.jar
01-10
mybatis-spring-boot-starter-2.1.3.jarmybatis-spring-boot-starter-2.1.3.jarmybatis-spring-boot-starter-2.1.3.jar
mybatis-spring-2.0.0-API文档-中文版.zip
07-13
包含翻译后的API文档：mybatis-spring-2.0.0-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.mybatis:mybatis-spring:2.0.0； 标签：mybatis、spring、中文文档、jar包、java； 使用方法：解压翻译后的API文档...
spring-mybatis整合jar包，spring-mybatis整合jar包
03-17
这个整合包包含了实现Spring Mybatis集成所需的各种依赖库，包括Spring的核心组件、Mybatis以及相关的辅助库。 在提供的文件列表中，我们可以看到以下几个关键的库文件： 1. **aspectjweaver-1.6.11.jar**：这是...
mybatis-spring-boot-starter-2.1.4.jar
01-10
mybatis-spring-boot-starter-2.1.4.jarmybatis-spring-boot-starter-2.1.4.jar
mybatis-spring-boot-starter初探 代码.zip
04-30
关于mybatis的spring boot可执行代码，对应的解说博客地址在：https://blog.csdn.net/heidashou/article/details/105812796，含有全过程截图和解说。
mybatis-4 mybatis与spring结合使用及原理
weixin_30443813的博客
04-10 106
1、创建项目maven，方便依赖下载。使用的jar如下： <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5....
Mybatis最入门---整合Spring
y-yg的博客
05-28 2629
[一步是咫尺，一步即天涯] 最近封闭开发中，于是近乎一个月都没有更新内容，希望各位看官不要在意。本文我们来介绍Mybatis最入门中的最后一文：与Spring的整合。本文仅作为基本Spring+mybatis配置，详细用法及含义需要相关基础知识储配，请各位看官先自行查阅相关资料吧。好了，废话不说，马上开始我们的正文部分吧！ 准备工作： a.操作系统 ：win7 x64
MyBatis快速入门第二讲——MyBatis的快速入门
热门推荐
李阿昀的博客
05-11 1万+
MyBatis框架的架构MyBatis框架的架构如下图： 下面作简要概述： SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句，此文件需要在SqlMapConfig.xml中加载。 通过mybatis环境等配置信息构造SqlSessionFactory(即会
IDEA spring整合mybatis入门（下）
小狐狸的博客
12-21 663
继上一篇博客，添加事务管理 1.在maven工程中添加所需jar包 pom.xml &lt;!--使用AspectJ方式注解需要相应的包--&gt; &lt;dependency&gt; &lt;groupId&gt;org.aspectj&lt;/groupId&gt; &lt;artifactId&gt;aspectjrt&lt;...
IDEA spring整合mybatis入门（上）
小狐狸的博客
12-19 2153
0.项目环境： 使用maven导入工程所需jar包 Spring 4.3.21.RELEASE Mybatis 3.4.6 MySQL 8.0.13 druid 1.1.12 项目的整体结构如下 1.创建一个maven java项目，根据需求填写pom.xml配置文件，以及jdbc.properties和log4j.properties pom.xml &amp;amp;lt;?xml version=&amp;quot;1.0...
Spring-SpringMVC-Mybatis 分模块案例整合步骤
南淮北安的博客
06-06 482
前面已经学习了 SSM的总体整合 和 Maven 分模块创建工程 这次通过一个 ssm 案例对其整个的流程按照分模块的思路重新整合一下。 文章目录一、前期准备1. 整合思路2. 建立 maven 工程的模块结构3. 在父工程SSM_study 中导入 pom.xml4. 建立子工程的传递依赖5. 编写实体类 Product6. 编写业务层接口 ProductService7. 编写持久层 ProductDao二、Spring 环境搭建1. 编写 Spring 配置文件 applicationContext.
spring整合mybatis需要配置哪些东西？
04-08 619
最基本的配置如下： 1.mybatis配置文件 2.数据源 3.pojo包扫描 4.mapper包扫描 5.mapper接口扫描 转载于:https://www.cnblogs.com/Mr-Brown/p/10670443.html
MyBatis快速入门（四） MyBatis和Spring集成
weixin_34044273的博客
02-21 138
导入依赖包 前面介绍了MyBatis的相关知识，现在来介绍一下如何和Spring进行集成。MyBatis和Spring的集成工作是由MyBatis团队完成的。所以我们首先要先引入MyBatis和Spring的集成依赖包。这里我用的是Gradle，如果使用其他构建工具，将下面的语句改为相应的。 compile ...
Spring整合MyBatis
qq_40298175的博客
08-03 317
一、Spring整合MyBatis Spring的IoC和AOP如何为MyBatis提供便利？ 1.1 Spring对MyBatis提供的支持 Spring 对象工厂(IoC)可以完成SqlSessionFactory、sqlSession 、Mapper对象的创建 Spring AOP思想可以完成MyBatis操作中的事务管理 1.2 Spring整合MyBatis配置—IoC支持 1.2.1 创建maven项目，完成MyBatis框架部署 添加依赖 <!-- MySQL数据库驱动jar
mybatis-spring-boot 和 mybatis-spring-boot-starter的区别
最新发布
06-10
其中，mybatis-spring-boot是一个MyBatis的Spring Boot自动配置模块，提供了自动配置MyBatis所需的所有组件，包括SqlSessionFactory、SqlSessionTemplate等。而mybatis-spring-boot-starter则是一个MyBatis的Spring ...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值