Spring入门(包括spring整合mybatis的spring-mybatis)

Spring Boot 整合 MyBatis 快速入门超详教程 快速入门 Spring Boot 和 MyBatis! 阅读详情

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 的事务传播机制都工作在同一个事务中。

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

mybatis 与 spring框架整合入门 一、什么是 mybatis-spring? MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中,创建映射器 mapper 和 SqlSession 并注入到 bean 中,以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终,可以做到应用代码不依赖于 MyBatis,Spring 或 MyBatis-Spring。 二、mybatis-spring 入门 阅读详情

相关推荐

Spring Boot与MyBatis整合的简单登录系统实战

在现代企业级应用开发中,快速搭建和维护一个高性能、高可用性的服务系统是每个开发团队追求的目标。Spring Boot作为一种轻量级的Java框架,其自动配置、无代码生成和无XML配置的特性,大大简化了基于Spring的应用开发。与此同时,MyBatis作为一款优秀的持久层框架,以其简单的API和对SQL的强大控制力,在众多Java项目中得到广泛应用。当Spring Boot遇上MyBatis,两者相辅相成,共同提供了一个简单、高效的方式来构建企业的后端服务。

weixin_29301059的博客 648

spring整合mybatis快速入门

maven依赖 3.设置log4j日志文件 在resources目录下创建log4j.properties 4.创建数据源 在resources目录下创建mybatis-config.xml文件

m0_62031247的博客 301

初学Spring+SpringMVC+MyBatis框架(适合初学者看)

这是一份很基础的ssm项目,基于IDEA写的。里面只有添加和查询全部,比较适合初学ssm框架的朋友看。

将 MyBatis3 的支持添加到 Spring

http://www.mybatis.org/spring/zh/index.htmlWhat is MyBatis-Spring? MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。使用这个类库中的类,Spring 将会加载必要的 MyBatis 工厂类和 session 类。这个类库也提供一个简单的方式来注入MyBatis 数据映射器和 ...

xiang__liu的博客 282

单机多环境部署apollo 2.3.0

理解apollo的整体架构后,对比nacos配置中心功能点,其设计的复杂度以及完整度相较nacos而言更为丰富 对于不同的环境,例如 FAT, PRO 在部署时进程已经完全物理隔离,并且每个环境config/adminservice依赖的数据也完全物理隔离(连接不同的db),在数据隔离与安全方面做的很完善,但同时也提升了架构的复杂度 而 portal 可以管理多个环境,单节点部署虽然有单点问题,但并不会影响业务从configservice读取配置, 挂掉只要重启就可以,只是在

Life is a starting point everywhere 1302

从 0 到 1:基于深度学习的图像识别系统开发实战

图像识别是指让计算机能够识别和理解图像中的内容,通常是通过计算机视觉技术来实现。深度学习,尤其是卷积神经网络(CNN),已经成为图像识别中最为流行和有效的技术。数据采集和预处理:获取并处理图像数据,使其适合于模型训练。模型训练:使用深度学习算法(如 CNN)训练模型,以学习图像中的特征。模型评估与优化:评估模型的性能,并通过调整超参数、优化算法等方法提高精度。模型部署与应用:将训练好的模型应用于实际的图像识别任务中。本文将带领你通过一个简单的图像分类问题,开发一个深度学习图像识别系统。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1218

java-spring-mybatis -学习第一天-基础知识讲解

Mybatis是一个优秀的持久层框架,底层基于JDBC实现与数据库的交互;使用此框架程序员只需要通过注解或者修改xml配置文件的方式配置好需要执行的SQL语句,MyBatis框架会根据SQL语句生成对应的JDBC代码并对数据库中数据进行增删改查操作。配置外部属性文件其配置需要包含url,username,password这边是一个实例其中的url 可以复制 需要更改的是端口 mysql默认的是3306还有的是数据库默认的是mysql(这个一定要改)

qq_61549190的博客 1184

核磁干货 | RESTplus实战:静息态fMRI预处理全流程解析

本文详细解析了使用RESTplus工具包进行静息态fMRI数据预处理的完整流程,包括数据准备、环境配置、预处理步骤及高级分析技巧。RESTplus作为基于SPM的批处理工具,以其图形化界面和智能化参数设置显著提升了核磁静息态数据分析的效率,特别适合新手和临床研究人员。文章还分享了实战中的常见问题解决方案和性能优化技巧。

wine的专栏 886

MyBatis -- 1

数据库连接池是个容器,负责分配、管理数据库连接(Connection)程序在启动时,会在数据库连接池(容器)中,创建一定数量的Connection对象允许应用程序重复使用一个现有的数据库连接,而不是再重新建立一个客户端在执行SQL时,先从连接池中获取一个Connection对象,然后在执行SQL语句,SQL语句执行完之后,释放Connection时就会把Connection对象归还给连接池(Connection对象可以复用)

weixin_52234593的博客 307

S4 HANA 1809+折旧过账(AFAB/AFABN)凭证行数据存储逻辑变迁:从BSEG到ACDOCA的深度解析

本文深度解析了S4 HANA 1809+版本中折旧过账(AFAB/AFABN)凭证行数据存储逻辑的变迁,从传统的BSEG表迁移到ACDOCA表。文章详细探讨了这一变更的技术背景、官方设计意图及实际影响,包括数据存储量减小和系统性能提升等优势。同时提供了升级项目的应对策略和最佳实践建议,帮助用户顺利过渡到新的数据存储模型。

weixin_28731223的博客 294

YOLOv5入门实践(2)——手把手教你利用labelimg标注数据集

YOLOv5入门实践第2步,手把手教你使用labelimg标注数据集

路人贾的博客 1万+

Spring-MyBatis基本操作

MyBatis是一款优秀的持久层(Dao层)框架,用于简化JDBC的开发。MyBatis本是Apache的一个开源项目iBatis,2010年这个项目由apache迁移到goole code,并且改名为MyBatis。2013年11月迁移到GitHub。MyBatis中文网持久层:指的是持久化操作的层,通常指的是操作数据的层(Dao层),用来操作数据库的。简单来说MyBatis是更简单完成程序与数据库交互的框架,也就是更简单的操作和读取数据库的工具。

weixin_52159554的博客 1182

Cloud Connector RFC 访问控制深度实践:为 SAP BTP ABAP environment 打通安全、可控的远程连接

本文是一份面向企业ABAP团队与平台工程团队的Cloud Connector RFC访问控制配置指南。文章详细介绍了虚拟主机/实例号、负载均衡、资源白名单等核心概念,并提供了从零开始的配置流程。主要内容包括:通过Cloud Connector建立安全隧道的价值(零暴露、最小权限)、两种连接类型(无负载均衡/带负载均衡)的配置方法、资源白名单设置技巧,以及两个典型应用场景(Custom Code Migration远程检查与BAPI调用)的实操案例。指南基于SAP官方文档,包含落地经验与避坑建议,可帮助团队快

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 147

SSM框架整合—详细整合教程(Spring+SpringMVC+MyBatis)

因为在整个框架整合中,Spring是管理Bean的容器,所以Spring容器要最先初始化,但是SSM是一个WEB项目,在WEB项目里最先启动的是Listener,所以Spring在WEB项目初始化是通过监听器(Listener)来启动,SpringMVC的启动是通过Servlet来启动。另外:SpringMVC是基于Spring开发,所以SpringMVC中也有一个管理自己Bean(@Controller)的容器,这个容器和上面Spring的容器不是一个容器,它只管理自己,所以两个容器之间包的扫描要分开。

打造专业技术博客 859

基于Simulink实现电动汽车电机驱动系统的建模与仿真

通过上述步骤,我们成功实现了基于Simulink的电动汽车电机驱动系统的建模与仿真。该系统能够全面评估电机驱动系统的性能,验证控制策略的有效性,并通过优化设计提高车辆的动力性和效率。引入智能预测:结合人工智能技术,实现更智能的控制策略。扩展功能:增加对多种电机类型的支持,提升系统通用性。实验验证:将仿真模型应用于实际硬件,进行实验验证,评估其在实际工况下的表现。

xiaoheshang_123的博客 319

智能车图像处理12-进阶篇4--环岛辅助判断条件

主函数: 第6行: 含义是当前需要不在坡道和车库状态 第11-12行 : 寻找一下环岛的双断点(在辅助函数中) 第16-66行: 当左右线的方差满足一边很大,一边很小时,truepianfangflag /truepianfangflagforleft 置1,在环岛的判断中使用。 辅助函数: 双断点函数(左与右相似,以做为例): 第13-28行: 第一处断点 第29-40行: 第一处断点后 连续边线 第41-52行: 第一处连续后,第二处断点 第53-64行: 第二处断点后,第二处

taiyuezyh的博客 1万+

spring--整合Mybatis详解

<resource><includes><resource><includes>-- 或者 -->

m0_73856804的博客 1096

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Spring入门

耦合(Coupling):代码书写过程中所使用技术的结合紧密度,用于衡量软件中各个模块之间的互联程度内聚(Cohesion):代码书写过程中单个模块内部各组成部分间的联系,用于衡量软件中各个功能模块内部的功能联系高内聚,低耦合就是同一个模块内的各个元素之间要高度紧密,但是各个模块之间的相互依存度却不要那么紧密使用spring整合mybatis技术,完成账户模块(Account)的基础增删改查功能账户模块对应字段编号:id账户名:name余额:money非spring环境1.实体类与表。

weixin_61611746的博客 1171

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Spring 整合 MyBatis 使用

Mybatis+Spring

IT_laohu的博客 1600

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

SSM框架整合( Spring + Spring MVC + MyBatis)

SSM框架整合 Spring + Spring MVC + MyBatis Spring MVC 负责实现 MVC 设计模式,MyBatis 负责数据持久层,Spring 负责管理 Spring MVC 和 MyBatis 相关对象的创建和依赖注入。 创建 Maven 工程,pom.xml <dependencies> <!-- SpringMVC --> <dependency> <groupId>org.springframew..

weixin_51542566的博客 141

Mybatis的框架以及相关的整合

Mybatis mybatis框架的快速入门 1.添加依赖 下面展示一些 内联代码片。 // A code block var foo = 'bar'; // An highlighted block <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.5</version> </d

xiaojingnb的博客 247

springmvc+spring+mybatis整合实例

开发环境: System:Windows server 2003 WebBrowser:IE6+、Firefox3+ JavaEE Server:tomcat5. IDE:eclipse、MyEclipse 6.5 Database:MySQL 开发依赖库: JavaEE5、Spring 3.0.5、Mybatis 3.0.2、myBatis-spring-1.0.0-rc...

anqubo3824的博客 94

spring mybatis 整合

spring mybatis 整合 1.第一步导包,创建maven项目需要导入以下包 spring-webmvc spring-jdbc spring-aspects mybatis mybatis-spring c3p0 jstl javax.servlet-api mysql-connector-java(注意这里要导入6.0以下的版本,第一次导入6.0版本 的导致连接不上) 下...

qq_38710416的博客 379

Spring和MyBatis环境整合

SSH框架的结合几乎家喻户晓,但是一般的中小项目,使用Spring和MyBatis就够了,而且MyBatis轻便好使,易上手,值得大家尝试一次。   开篇简介:   Spring: Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 两个重要模块:Spring 面向方面编程(AOP)和控制反转 (IOC) 容器。 控制反转模式(也称作依赖性介入)

mrdu_somefun的博客 412

Spring——Spring整合MyBatis

Spring——Spring整合MyBatis

贝尔摩德苦艾酒 2万+

Spring 整合Mybatis。

▶ Junit运行后是基于Spring环境运行的,所以Spring提供了一个专用的类运行器,这个务必要设置,这个类运行器就在Spring的测试专用包中提供的,导入的坐标就是这个东西`SpringJUnit4ClassRunner`○ SqlSessionFactoryBean是前面我们讲解FactoryBean的一个子类,在该类中将SqlSessionFactory的创建进行了封装,简化对象的创建,我们只需要将其需要的内容设置即可。在运行类中,从IOC容器中获取Service对象,调用方法获取结果。

yzh2776680982的博客 2363
上一篇: Error creating bean with name ‘sqlSessionFactory‘ defined in class path reso...报错的解决方法
下一篇: 报错java.lang.IllegalArgumentException: Unsupported class file major version 59
夏帆er
博客等级 码龄7年 154粉丝 102原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值