Spring介绍和控制反转IOC

已于 2022-07-21 14:30:50 修改
阅读量101 收藏 1
点赞数
分类专栏： Spring框架 文章标签： java spring maven intellij-idea
于 2022-07-18 21:26:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57697501/article/details/125715391
版权

说明 ：IOC部分：参考网上课程，自己写的总结，如有侵权，联系删除。

目录

spring简介

spring框架体系架构

IOC_控制反转思想

IOC_自定义对象容器

IOC_Spring 实现IOC

 IOC_Spring容器类型

容器接口：

容器实现类

IOC_对象的创建方式 

1.使用构造方法

2.使用工厂类的方法

3.使用工厂类的静态方法 

IOC_对象的创建策略

IOC_对象的销毁时机

IOC_生命周期方法

 IOC_获取Bean对象的方式

通过id/name获取

通过类型获取 

通过类型+id/name获取

spring简介

Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制 反转）和AOP（面向切面）为思想内核，提供了控制层 SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。

Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：https://spring.io/

spring框架体系架构

Spring框架根据不同的功能被划分成了多个模块：

Core Container:Spring 的核心模块，任何功能使用都离不开这个模块，其他模块建立的基础

Data Access/Integration: 该模块提供了数据持久化的相应功能

web: web开发响应功能

AOP: 提供了面向切面编程实现

Aspects: 提供与AspectJ框架的集成，该框架是面向切面编程框架

Instrumentation: 提供了类工具的集成和类加载器的实现，可以在特定应用服务器使用

Messaging: 为spring框架集成一些基础的报文传送应用

Test: 提供与测试框架的集成。

IOC_控制反转思想

IOC(Inversion of Control) :程序将创建对象的权利交给框架管理，之前开发的时候，对象实例的创建由调用者管理。

之前写法的缺点：

1.浪费资源：每次Service调用方法的时候就会创建对象，一直调用会创建大量的dao层对象

2.代码耦合度高：假如创建了StudentDao另一个更加完善的实现类StudentDaoImpl2,想在Service层使用StudentDaoImpl2，必须改源代码

而IOC思想是将创建对象的权力交给框架，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。IOC可以完美的解决以上两个问题。

IOC_自定义对象容器

通过自定义容器来模拟IOC思想。创建一个集合容器，先将对象创建出来放到容器，需要使用对象时，只需要从容器中获取对象即可，而不需要重新创建，此时容器就是对象的管理者。

  1. 创建实体类 
    public class Student {
    private int id;
    private String name;
    private String address;
 // 省略getter/setter/构造方法/tostring
}
  2. 创建Dao接口和实现类 
    public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}

//实现类
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1001,"xxs","北京");
   }
}
public class StudentDaoImpl2 implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        System.out.println("实现类2方法！！！");
        return new Student(1002,"dds","天津");
   }
}
  3. 创建配置文件bean.properties，该文件中定义管理的对象 
    studentDao=com.dream.dao.StudentDaoImpl
  4. 创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。 
    /**
 * 自定义容器类，负责管理对象，在类加载的时候读取配置文件并创建对象
 */
public class Container {
    static Map<String,Object> map=new HashMap<>();

    static {
        //读取配置文件
        InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties");
        Properties properties=new Properties();
        try {
            properties.load(is);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //遍历配置文件中的所有对象
        Enumeration<Object> keys = properties.keys();
        while (keys.hasMoreElements()){
            String key = keys.nextElement().toString();
            String value=properties.getProperty(key);
            //创建对象
            try {
                Object obj=Class.forName(value).newInstance();
                map.put(key,obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
    //从容器中获取对象
    public static Object getBean(String key){
        return map.get(key);
    }
}
  5. 创建Dao对象的调用者StudentService 
    public class StudentService {
    public Student findStudentById(int id){
        // 从容器中获取对象
        StudentDao studentDao =(StudentDao)Container.getBean("studentDao");
        System.out.println(studentDao.hashCode());
        return studentDao.findById(id);
   }
}

这样就通过Container类读取配置文件获得studentDao对象，改对象的时候也方便，直接更改配置文件。这个就类似Spring容器的管理。

IOC_Spring 实现IOC

  1.  创建Maven工程，引入依赖 
        <dependencies>
        <!--spring 核心模块-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.21</version>
        </dependency>
        <!--Junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
  2. 创建POJO类、Dao类和接口 
    public class Student {
    private int id;
    private String name;
    private String address;
 // 省略getter/setter/构造方法/tostring
}

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1001,"xxs","北京");
    }
}

  3. 编写bean.xml配置文件，配置文件中配置需要Spring帮我们创建的对象。

    <?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 id="studentDao" class="com.dream.dao.StudentDaoImpl"></bean>   
</beans>

  4. 测试从Spring容器中获取对象。

    public class TestSpring {
    @Test
    public void t1(){
        //1.创建spring容器
        ApplicationContext ac =new ClassPathXmlApplicationContext("bean.xml");
        //2.从容器获取对象
        StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao");
        StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao");
        System.out.println(studentDao1.hashCode());
        System.out.println(studentDao2.hashCode());//这个是一样的
        System.out.println(studentDao1.findById(1));
    }
}

 IOC_Spring容器类型

容器接口：

BeanFactory：BeanFactory是Spring容器中的顶层接口，可以对Bean对象进行管理。

ApplicationContext：(我们常用的)ApplicationContext是BeanFactory的子接口。它除了继承 BeanFactory的所有功能外，还添加了对国际 化、资源访问、事件传播等方面的良好支持。

容器实现类

ApplicationContext有以下三个常用实现类：

  1. ClassPathXmlApplicationContext：该类可以从项目中读取配置文件
  2. FileSystemXmlApplicationContext：该类从磁盘中读取配置文件 (磁盘路径)
  3. AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解
        //创建spring容器
        //ApplicationContext ac =new ClassPathXmlApplicationContext("bean.xml");
        ApplicationContext ac =new FileSystemXmlApplicationContext("E:\\Idea_Project\\springnb\\spring_ioc1\\src\\main\\resources\\bean.xml");

IOC_对象的创建方式 

1.使用构造方法

Spring默认使用类的空参构造方法创建bean：假如类没有空参构造方法，将无法完成bean的创建。

2.使用工厂类的方法

Spring可以调用工厂类的方法创建bean（其实就是实例工厂）：

  1. 创建工厂类，工厂类提供创建对象的方法： 
    public class StudentDaoFactory {
    public StudentDao getStudentDao(){
        return new StudentDaoImpl();
   }
}

  2. 在配置文件中配置创建bean的方式为工厂方式。

    <!-- id：工厂对象的id，class：工厂类 -->
<bean id="studentDaoFactory" class="com.dream.dao.StudentDaoFactory"></bean>
<!-- id：bean对象的id，factory-bean：工厂对象的id，factory-method：工厂方法 -->
<bean id="studentDao" factory-bean="studentDaoFactory" factory-method="getStudentDao"></bean>

3.使用工厂类的静态方法 

Spring可以调用工厂类的静态方法创建bean（就是静态工厂）：

  1. Spring可以调用工厂类的静态方法创建bean： 
    public class StudentDaoFactory {
    public static StudentDao getStudentDao() {
        return new StudentDaoImpl();
   }
}

  2. 在配置文件中配置创建bean的方式为工厂静态方法。

    <!-- id:bean的id class:工厂全类名 factory-method:工厂静态方法   -->
<bean id="studentDao" class="com.dream.dao.StudentDaoFactory" factory-method="getStudentDao"></bean>

      注意：  spring 不能使用有参构造方法创建bean对象，（我感觉这个是可以依赖注入使用）

IOC_对象的创建策略

Spring通过配置 <bean>中的 scope 属性设置对象的创建策略，共有五 种创建策略：

  • singleton：单例，默认策略。整个项目只会创建一个对象，通 过<bean>中的 lazy-init 属性可以设置单例对象的创建时机：

lazy-init="false"(默认)：立即创建，在容器启动时会创建配 置文件中的所有Bean对象。饿汉式

lazy-init="true"：延迟创建，第一次使用Bean对象时才会创建。饿汉式

<bean id="studentDao" class="com.dream.dao.StudentDaoImpl" scope="singleton" lazy-init="false"></bean>
  • prototype：多例，每次从容器中获取时都会创建对象。 
    <!-- 配置多例策略 -->
<bean id="studentDao" class="com.dream.dao.StudentDaoImpl" scope="prototype"></bean>
  • request：每次请求创建一个对象，只在web环境有效。
  • session：每次会话创建一个对象，只在web环境有效。
  • gloabal-session：一次集群环境的会话创建一个对象，只在web 环境有效。

IOC_对象的销毁时机

对象的创建策略不同，销毁时机也不同：

  • singleton：对象随着容器的销毁而销毁。 (整个项目就一个对象)，正常情况是不会随意销毁的
  • prototype：使用JAVA垃圾回收机制销毁对象。
  • request：当处理请求结束，bean实例将被销毁。
  • session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。
  • gloabal-session：集群环境下的session销毁，bean实例也将被销毁。

IOC_生命周期方法

Bean对象的生命周期包含：创建——使用——销毁，Spring可以配置 Bean对象在创建和销毁时自动执行的方法：

  1. 定义生命周期方法 
    public class StudentDaoImpl implements StudentDao{
     // 创建时自动执行的方法
    public void init(){
        System.out.println("创建了！！！");
   }
    // 销毁时自动执行的方法
    public void destory(){
        System.out.println("销毁了！！！");
   }
}
  2. 配置生命周期方法 
    <!-- init-method:创建对象时执行的方法 
destroy-method:销毁对象时执行的方法 -->
<bean id="studentDao" class="com.dream.dao.StudentDaoImpl"scope="singleton" init-method="init" destroy-method="destory"></bean>

  3. 测试

    @Test
public void t3(){
    // 创建Spring容器
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    // 销毁Spring容器，ClassPathXmlApplicationContext有销毁容器的方法
    ac.close();
}

 IOC_获取Bean对象的方式

Spring有多种获取容器中对象的方式：

通过id/name获取

  1. 配置文件 
    <!--id 和name 都代表对象名字-->
<bean name="studentDao" class="com.dream.dao.StudentDaoImpl2"></bean>
<bean id="studentDao" class="com.dream.dao.StudentDaoImpl2"></bean>

  2. 获取对象

    StudentDao studentDao = (StudentDao)ac.getBean("studentDao");

通过类型获取 

  1.  配置文件 
    <bean name="studentDao" class="com.dream.dao.StudentDaoImpl2"></bean>

  2. 获取对象

    StudentDao studentDao2 = ac.getBean(StudentDao.class);

        可以看到使用类型获取不需要强转。

通过类型+id/name获取

虽然使用类型获取不需要强转，但如果在容器中有一个接口的多个实现类对象，则获取时会报错，此时需要使用类型+id/name获取

  1.  配置文件 
    <!--一个接口的两个实现类-->
<bean name="studentDao" class="com.dream.dao.StudentDaoImpl2"></bean>
<bean name="studentDao1" class="com.dream.dao.StudentDaoImpl"></bean>

  2. 获取对象

    StudentDao studentDao2 = ac.getBean("studentDao",StudentDao.class);

Xxiaododo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring.Net控制反转IoC入门使用
08-30
本文主要关注的是Spring.NET的核心特性——控制反转（Inversion of Control，简称IoC）。 控制反转是一种设计模式，它将对象的创建和依赖关系的管理从应用代码中解耦出来。通过IoC，对象不再负责创建和管理其依赖项...
Spring框架控制反转IOC和依赖注入DI详解
01-20
本文介绍了Spring框架中的控制反转IOC和依赖注入DI，欢迎阅读，共同学习，一起进步。 Spring框架基础参考：深入学习Spring基础 文章目录一.入门程序和IOC简介二.IOC-控制反转三.DI-依赖注入四. IOC和DI五.Spring...
Java spring webmvc如何实现控制反转
08-18
3.控制反转容器：控制反转容器是指 Spring 的 IoC 容器，负责管理 Bean 的生命周期和依赖关系。IoC 容器可以自动地将依赖关系inject 到 Bean 中。 在上面的示例代码中，我们定义了一个 UserService Bean，该 Bean ...
Spring IOC 控制反转
10-24
Spring IOC 控制反转简单过程 1: 导入需要报 2：构建spring的配合文件 3: 将我们创建的类交给spring容器管理 4： 实例化容器 5: 从容器中获取实例
Spring框架IoC控制反转.pdf
09-20
Spring的核心理念包括控制反转（IoC）和面向切面编程（AOP）。作为一个开源框架，Spring适用于Java SE和Java EE环境，其主要目标是降低代码间的耦合度，提高软件的可扩展性和可维护性。 二、IoC控制反转 IoC，即...
golang 接口
m0_70982551的博客
07-24 933
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 507
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 624
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 585
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 358
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 419
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 845
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 93
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 176
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 865
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 268
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Jvm基础（一）
G81948577的博客
07-19 1084
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 770
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
android audio不同音频流，(八)music流音量APK按键调整
五味香的专栏
07-24 433
apk通过监测按键事件，再调用AudioManager函数接口，调节STREAM_MUSIC流音量调节。
理解Spring IOC：控制反转与依赖注入
在Spring框架中，IOC（Inversion of Control，控制反转）是一种核心概念，它改变了传统应用程序中对象之间的依赖关系管理方式。原本，一个类需要依赖另一个类时，通常会自行创建依赖对象，但在IOC的帮助下，这种控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值