SpringIOC、DI依赖注入、Spring整合MyBatis

最新推荐文章于 2022-07-09 15:47:16 发布
最新推荐文章于 2022-07-09 15:47:16 发布
阅读量221 收藏
点赞数
分类专栏： 知识点 概念 理论知识 文章标签： mybatis SpringIOC DI依赖注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45290168/article/details/108697464
版权
知识点 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
理论知识
30 篇文章 0 订阅
订阅专栏
概念
17 篇文章 0 订阅
订阅专栏

1.框架的概念：

不同的项目会使用相同的代码进行开发。而这部分代码如果要进行封装不是一个类或者一个方法

就能搞定的，需要封装出来很多的类文件，于是为了方便其他人使用，我们再次将这些代码封装

为jar包，所以，框架其实就是不同的项目都会使用的代码的封装，软件的半成品。

2.框架的本质：

就是别人封装好的功能代码。不同项目之间要使用的重复代码。封装的代码是用来解决功能开发

的，不是一个具体的功能，还需要结合调用代码以及功能自己的独立代码来使用，框架也称为软

件的半成品。

3.框架的具体表现形式

一堆jar包：封装好了要使用的代码。

4.框架的使用

① 将jar包导入到自己的项目中

② 查阅API文档，调用jar包中的资源完成功能开发

③ 配置框架的配置文件(框架代码运行需要的常量数据)

数据和代码的解耦，使用者可以通过配置文件来自定义数据。

配置文件不能乱写，必须按照API的说明的格式来配置，因为框架的底层

已经将配置文件的解析代码提前封装了。

5.Spring框架原理

作用:

实现了代码层与层之间的解耦

原理：
在这里插入图片描述

6.SpringIOC

作用：

IOC将耦合性非常高的对象进行解耦

基本流程：

6.1 创建项目然后配置web的相关依赖以及项目结构的配置

创建java工程, 导入jar包

spring核心jar包: 4个

日志包: commons-logging.jar, 被spring-core.jar所依赖.

6.2在src下创建并配置applicationcontext.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">    
   <!--配置要让Spring容器对象通过反射创建的对象的权限定路径：业务层对象-->
    <bean id="us" class="com.bjsxt.service.impl.UserServiceImpl2">
    </bean>
</beans>

6.3.在业务层中创建UserService接口及其实现类

UserService接口

package com.bjsxt.service;
public interface UserService {
    //声明功能方法
    String testIOCService();
}

UserServiceImpl实现类

package com.bjsxt.service.impl;
import com.bjsxt.service.UserService;
public class UserServiceImpl implements UserService {
    //测试IOC
    @Override
    public String testIOCService() {
        return "SpringIOC  Study";
    }
}
6.4.在项目中创建MVC的包结构，并创建IOCServlet，并在Service方法中获取Spring的容器对象，并从容器对象中获取业务层对象，完成业务操作。
@WebServlet("/ioc")
public class IOCServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置请求编码格式
        //设置响应编码格式
        //获取请求信息
        //处理请求
            //创建Spring的容器对象
            ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
            //获取容器中的业务层对象
            UserService us = (UserService) ac.getBean("us");
            //处理请求
            String s = us.testIOCService();
        //响应结果
            resp.getWriter().write(s);
    }
}

控制：创建对象的过程

反转：创建对象这个操作本身是程序完成的，现在反交给spring 进行管理创建

7.SpringIOC创建对象的三种方式

7.1 通过构造器方式

①无参数构造器(创建一个没有初始化数据的对象)

②有参数构造器(创建一个带有初始化数据的对象)

applicationcontext.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">
    <!--创建student的bean对象-->
    <!--构造器方式-->
    <!--
    无参构造器
    特点：Spring容器默认使用无参构造方式创建对象
    使用：在配置文件中直接使用bean标签配置即可，无需过多声明
    -->
    <bean id="stu" class="com.bjsxt.pojo.Student"></bean>
    <!--有参数的构造器
    特点：Spring容器对根据配置调用的有参构造器创建一个带有初始化数据的对象
    使用：constructor-arg：使用bean的字标签来声明调用的构造器的形参的个数
    一个字标签表示一个参数
    属性：index：参数的下标
          type：参数的类型，全限定路径
          name：参数的形参名
          value：参数要给的值
    -->
    <bean id="stu2" class="com.bjsxt.pojo.Student">
        <constructor-arg index="0" type="java.lang.Integer" name="sid" value="1"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" name="sname" value="张三"></constructor-arg>
    </bean> 
</beans>

TestObject代码示例

import com.bjsxt.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testStu {
    public static void main(String[] args) {
        //创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationcontext.xml");
        //获取容器中的对象
        //无参构造器方式
        Student student = (Student) ac.getBean("stu");
        System.out.println("无参构造："+student);
        //有参构造器
        Student student1= (Student) ac.getBean("stu2");
        System.out.println("有参构造："+student1);
    }
}

7.2 属性注入方式

示例

<!--
    2.使用属性注入方式:
    注意:必须提供属性的set方法，底层通过反射调用set方法给属性赋值。
    一个property子标签表示一个属性赋值
        name属性的值为属性名，value属性为要赋的值
   此方式相对于构造器方式使用面更广，更灵活，因为不需要声明对应的构造器
-->
    <bean id="stu3" class="com.bjsxt.pojo.Student">
        <property name="sid" value="2"></property>
        <property name="sname" value="李四"></property>
    </bean>

7.3 通过工厂模式

本质:

就是封装对象的创建过程的一种代码的编程思想

静态工厂:

生产对象的方法是静态方法

动态工厂:

生产对象的方法是非静态方法

applicationcontext.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">
    <!--创建student的bean对象-->
    <!--工厂设计模式-->
    <!--动态工厂-->
        <bean id="factory" class="com.bjsxt.pojo.StudentFactory"></bean>
        <!--生产Student对象-->
        <bean id="stu4" factory-bean="factory" factory-method="newIntance"></bean>
    <!--静态工厂-->
    <!--可以理解为静态方法直接用类名调用-->
        <bean id="stu5" class="com.bjsxt.pojo.StudentFactory2" factory-method="newIntance"></bean>
</beans>

8.DI依赖注入

存在依赖关系的类被实例化时，其依赖属性必须有值！

流程总结:

① 配置bean

  1. 当前要使用的对象

  2. 当前对象依赖的对象的bean

  3. 当前对象依赖的对象的依赖对象的bean........

② 组装

  1. 构造器方式在constructor-arg标签上使用ref属性

  2. 属性注入方式在property标签上使用ref属性

注意：ref的属性值为要赋值的bean的id

三种方式：

<?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">
    <!--1.1无参构造器-->
    <bean id="stu" class="com.bjsxt.pojo.Student"></bean>
    <!--1.2有参构造器-->
    <bean id="stu2" class="com.bjsxt.pojo.Student">
        <constructor-arg index="0" name="sid" type="java.lang.Integer" value="1"></constructor-arg>
        <constructor-arg index="1" name="sname" type="java.lang.String" value="张三"></constructor-arg>
        <constructor-arg index="2" name="fvg" type="java.lang.String" value="玩"></constructor-arg>
    </bean>
    <!--
       2.使用属性注入方式:
       注意:必须提供属性的set方法，底层通过反射调用set方法给属性赋值。
       一个property子标签表示一个属性赋值
           name属性的值为属性名，value属性为要赋的值
      此方式相对于构造器方式使用面更广，更灵活，因为不需要声明对应的构造器
   -->
    <bean id="stu3" class="com.bjsxt.pojo.Student">
        <property name="sid" value="3"></property>
        <property name="sname" value="张三"></property>
    </bean>
    <!--3.使用工厂模式-->
    <!--3.1动态工厂-->
    <bean id="stuFactory" class="com.bjsxt.factory.StudentFactory" ></bean>
    <bean id="stu4" factory-bean="stuFactory" factory-method="newInstance"></bean>
    <!--3.2静态工厂-->
    <bean id="stu5" class="com.bjsxt.factory.StudentFactory2" factory-method="newInstance"></bean>
    <!--4.DI依赖注入:创建存在依赖关系的对象-->
    <!--4.1有参数构造器方式-->
    <bean id="stu6" class="com.bjsxt.pojo.Student">
        <constructor-arg index="0" name="sid" type="java.lang.Integer" value="1"></constructor-arg>
        <constructor-arg index="1" name="sname" type="java.lang.String" value="项王"></constructor-arg>
        <constructor-arg index="2" name="fvg" type="java.lang.String" value="喜欢打架"></constructor-arg>
        <constructor-arg index="3" name="teacher" type="com.bjsxt.pojo.Teacher" ref="tea"></constructor-arg>
    </bean>
    <bean id="tea" class="com.bjsxt.pojo.Teacher">
        <property name="tid" value="1"></property>
        <property name="tname" value="老夫子"></property>
    </bean>
    <!--属性注入方式-->
    <bean id="stu7" class="com.bjsxt.pojo.Student">
        <property name="teacher" ref="tea"></property>
    </bean>
    <!--自动注入方式-->
    <bean id="stu8" class="com.bjsxt.pojo.Student" autowire="byName">
        <property name="sname" value="赵丽颖"></property>
    </bean>
    <bean id="teacher" class="com.bjsxt.pojo.Teacher">
        <property name="tid" value="2"></property>
        <property name="tname" value="王安石"></property>
    </bean>
</beans>

9.IOC之Bean的单例和多例

​ scope 属性设置对象的域

​ singleton 表示单例（默认）

​ 1、Spring容器在创建的时候，就会创建Bean对象

​ 2、每次调用getBean都返回spring容器中的唯一一个对象

​ prototype 表示多例

​ 1、多例在Spring容器被创建的时候，不会跟着一起被创建。

​ 2、每次调用getBean都会创建一个新对象返回

10.Spring整合MyBatis（重要）

① 导入jar包

(1) MyBatis的jar

(2) SpringIOC的jar

(3) mysql的jar

(4) Spring-jdbc和Spring-tx和Spring-aop的jar

(5) spring-web的jar

(6) spring整合Mybatis的jar

② 创建web项目，并在src下创建MVC的包结构

(1) com.bjsxt.controller

(2) com.bjsxt.service

(3) com.bjsxt.mapper

(4) com.bjsxt.pojo

③ 在src下创建并配置applicationcontext.xml文件

(1) 数据源bean，并使用属性注入完成数据库参数的声明

(2) 工厂bean，使用依赖注入将数据源bean注入到工厂bean中

(3) mapper扫描bean，使用依赖注入将工厂bean注入到mapper的bean中，并使用属性注入声明mapper扫描路径

注意:

mapper接口扫描的实例化对象，会直接存储到Spring容器对象中，默认其id为接口名首字母小写。比如“UserMapper”“userMapper”

(4) 声明业务层的bean，并使用依赖注入将mapper接口对象注入到业务层bean中

注意:

必须在业务层的代码中声明Mapper接口属性，并提供get/set方法

(5) 配置其它bean

④ 在 mapper层声明数据库操作代码

⑤ 在service层声明业务逻辑代码，并声明mapper层属性以及提供get/set方法

⑥ 在controller层声明Servlet代码，并声明业务层属性，同时使用init方法完成Spring容器内资源的初始化加载，也就是获取业务层对象，并赋值给业务层属性。

⑦ 在web.xml文件中配置Spring容器对象配置文件的路径参数，并配置监听器

诗酒趁少年の
关注
专栏目录
【Spring框架】Spring中的DI介绍
Sampson_S的博客
06-18 5471
Spring中的DI介绍 DI（Dependency Injection），即“依赖注入”，组件之间依赖关系由容器在运行期决定，即容器动态的将某个依赖关系注入到组件当中。它是是 Spring 框架核心IOC技术的具体实现。 依赖注入是控制反转最常用的方式，通过控制反转可以减低计算机代码之间的耦合度。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。 DI理解的关键点“谁依赖谁，为什么需要依赖” 谁依赖谁：应用程序依赖IOC容器
【Spring】Spring对IoC的实现和依赖注入专题
最新发布
qq_68993495的博客
02-06 1162
本章内容: 依赖注入的俩种方式, set注入专题包括简单类型,数组,list,map,set,properties注入和特殊字符注入等重点知识汇总, 很想对你有帮助!
整合Spring IoC与MyBatis
CupOnDesk的博客
01-09 1285
MyBatis作为一个优秀的持久化框架，简化了开发者访问数据库的操作，节省了开发者的时间。Spring是一个以依赖注入IoC闻名，后来又有了事务管理器，Spring MVC等功能。 下面，我们以银行转账功能的例子，介绍如何使用MyBatis访问数据库，并使用Spring的IoC进行依赖注入。
Spring(DI)
xasasaa的博客
03-20 1252
DI（Dependency Injection）即依赖注入，对象之间的依赖由容器在运行期决定，即容器动态的将某个依赖注入到对象自重 基于XML配置注入依赖 有参构造函数注入依赖 bean类实现有参构造函数 public class Student { private Integer id; private String name; /** * 有参构造函数 */ public Student(Integer id, String name) {
MyBatis:基于XML版本的DI注入和注解版本的IOC和DI
weixin_45874909的博客
02-17 225
1.基于XML版本的DI注入 1.1 基于setter方法注入属性 <!--基于Setter方法注入，属性必须有set方法，setStuName--> <bean id="student" class="com.wdksoft.Student"> <property name="stuName" value="柴英杰"/> <prope...
【Spring】学习二（依赖注入和整合mybatis）
韧锋zzZ的Blog
04-13 479
目录 一：Spring 之 DI（依赖注入） 二：使用 Spring简化、整合Mybatis 一：Spring 之 DI（依赖注入） 1、DI：中文名称：依赖注入 2、英文名称（Dependency Injection） 3、DI 是什么？ 3.1 DI 和 Ioc...
spring整合Mybatis
10-24
首先，Spring框架是一个开源的应用程序框架，它简化了Java EE应用的开发，提供了依赖注入（DI）和面向切面编程（AOP）等功能。在Spring中，我们可以使用IoC（Inversion of Control）容器来管理对象的生命周期和对象...
Spring整合Mybatis+SpringIOC
08-08
Spring通过依赖注入（Dependency Injection，简称DI）实现了IOC。它根据配置信息，将对象之间的依赖关系在运行时自动装配。有三种主要的注入方式：构造器注入、setter注入和接口注入。 3. **Bean定义** 在Spring...
实验四增强版（spring+mybatis）SpringIoC小程序.rar
04-15
Spring框架以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IoC）特性，简化了对象之间的耦合，而MyBatis则是一个轻量级的持久层框架，专注于SQL映射，使得数据库操作...
Spring整合Mybatis
09-15
Spring整合Mybatis是Java开发中常见的一种技术组合，它结合了Spring框架的IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）特性，以及Mybatis轻量级持久层框架的灵活性，...
Spring之DI
四八殇
01-18 280
Dependency Injection：依赖注入。 依赖注入 目的是解决JAVA对象间的紧耦合关系。 例如一个JAVA类，构造函数里new了另一个类，那么这两个类就是紧耦合的。紧耦合的弊端就是难以测试。（我不懂测试方法，所以这里不懂） 但是如果构造函数传入的是另一个类的引用，更抽象一些，传入的是一个接口引用，那这个类就可以和所有实现了该接口的JAVA类产生联系。 这样一种构造时
spring的DI
玩垃圾的人
12-05 713
前言 技术分析之依赖注入（DI） 1. IOC和DI的概念 * IOC -- Inverse of Control，控制反转，将对象的创建权反转给Spring！！ * DI -- Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！ 2. DI（依赖注入）
Spring DI
zuozhiyoulaisam的专栏
02-20 330
参考文章:http://sishuok.com/forum/blogPost/list/2454.html#7084 Spring DI: 1.Bean属性: lazy-init(延迟初始化Bean): 延迟初始化也叫惰性初始化,并不提前初始化Bean,而是只有真正使用时才创建及初始化Bean 容器每个Bean只有一个实例 配置文件:lazy-init="true" 默认为fal
Spring中的DI(依赖注入)
m0_46853673的博客
12-25 407
Spring中DI介绍 DI-Dependency Injection：依赖注入 bean对象中需要依赖一些其他组件或者对象，依赖关系由容器在运行时决定 两种方式处理依赖注入： 基于配置形式 基于注解形式 基于配置形式注入依赖 有参构造函数注入依赖 public class User { private String name; private UserInfo userInfo; public User(String name,UserInfo userInfo) {
Spring入门（三）Spring的DI
jwang的博客
12-28 382
前言      本章学习Spring的DI的相关知识 方法 1.概念 DI，英文名称为dependency injection，中文名称为依赖注入。 它指的是一个类的属性是对象的时候，将该对象进行注入的过程 它实质上就是IOC，我们可以把它理解为一个特殊的IOC，因为我们之前注入的都是基本数据类型以及String 2.Spring IOC属性注入的两种方式 1）构造器注入 这个前...
Spring 之 DI 详解
岁月安然
05-30 2653
概念 DI(Dependency Injection)依赖注入：依赖注入是指在程序运行期间,由外部容器动态地将依赖对象注入到组件中如：一般，通过构造函数注入、Setter注入、注解注入。 Setter注入与注解注入类似，区别在于：Setter 注入是通过 Set 方法对属性进行赋值，而注解注入是通过反射为属性赋值。 时机 当 Spring IOC 容器完成了 Bean 定义资源的定位、载入、解析和注册以后，IOC 容器中已经管理类 BeanDefinition 的相关数据，但是此时 IOC 容器还没有对所管
【Spring】使用注解实现IOC/DI的开发入门（含整合MyBatis及Junit）
jiliangjiyin的博客
07-09 293
使用注解Spring开发入门，包括如何管理第三方Bean、整合MyBatis以及Junit
Spring IoC与DI：依赖注入与容器配置详解
本文主要介绍了Spring框架中的依赖对象注入（Dependency Injection, DI）及其配置方法。Spring是一个广泛应用于企业级开发的开源框架，它采用控制反转（Inversion of Control, IoC）和面向切面编程（Aspect Oriented...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值