Spring之IOC

已于 2023-11-04 21:11:06 修改
阅读量61 收藏
点赞数
文章标签： spring
于 2023-11-04 21:10:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63377494/article/details/134051752
版权

        小案例

        Spring是一个很优秀的框架，是后端开发不可避免需要提到的技术，现在我来学习这项技术。首先，在编写代码之前我需要声明，我使用的是专业版的IDEA。创建一个Spring Initializr的项目并且利用maven添加了Spring Web依赖，这就是我在编写代码之前所做的准备工作。

        首先，我创建了一个User类，为了理解方便，我会加上它所在的包的信息。

package com.spring;

public class User {

    public void add(){
        System.out.print("test01");
    }
}

一般情况下，如果我们要调用User类中的add()方法，就需要声明一个User对象并且通过这个对象来调用add()方法。但是我们要使用Spring风格的方法来达到这个效果，在resources文件下声明一个xml文件命名为bean1，并且添加User配置<bean id="user" class="com.spring.User"></bean>：

<?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="user" class="com.spring.User"></bean>

</beans>

然后就可以着手写一个测试代码了：

package com.test;

import com.spring.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class springtest {
    @Test
    public void test1(){
    //加载Spring配置文件
        //ApplicationContext context =new FileSystemXmlApplicationContext("bean1.xml的绝对路径");
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
    //获取配置创建的对象
        User user=context.getBean("user",User.class);
        System.out.println(user);
        user.add();
    }
}

        需要注意的是加载配置文件的部分，ClassPathXmlApplicationContext 是 Spring 框架中的一个应用上下文（Application Context）实现类，用于从类路径下的 XML 配置文件中加载和管理 Bean，传入的是相对路径并且是要在类路径下，FileSystemXmlApplicationContext需要传入的是配置文件的绝对路径。而以上操作，就是IOC的实现操作，以下是IOC的理论部分。

        什么是IOC？是控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理。目的是什么？为了降低耦合度。

1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
2、Spring 提供 IOC 容器实现两种方式：（两个接口）
（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
* 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人
员进行使用
* 加载配置文件时候就会把在配置文件对象进行创建

类的嵌套实现

        接下来再看一个使用案例：我声明一个接口并让一个类实现它

public interface people {
    public void update();
}
public class peopleimpl implements people{
    @Override
    public void update() {
        System.out.println("peopleimpl start");
    }
}

        然而这个我决定将这个类的一个对象作为另一个类的属性：

public class student {
    private peopleimpl stu1;
    public void setStu1(peopleimpl stu1){
        this.stu1=stu1;
    }
    public void add(){
        System.out.println("student start");
        stu1.update();
    }
}

        好了，接下来就创建一个新的xml文件名字叫bean2：

<?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="peopleid" class="com.spring.peopleimpl"></bean> 

    <bean id="studentid" class="com.spring.student">
        <property name="stu1" ref="peopleid"></property>
    </bean>

</beans>

        先配置第一个类，自定义其id，再配置第二个类，其中的第一个类的示例对象需要注入，就用上一条的配置中的自定义的id填入ref。需要注意的是，name字段需要跟第二个类中的属性对象名一致。测试代码就不放了。

一对多关系的演示

        接下来我将演示如何表示实体类中一对多关系的表现,有teacher类如下:

package com.spring;

import java.util.Map;

public class teacher {
    private int[] classnum;
    private Map<Integer,String> map;

    public int[] getClassnum() {
        return classnum;
    }

    public void setClassnum(int[] classnum) {
        this.classnum = classnum;
    }

    public Map<Integer, String> getMap() {
        return map;
    }

    public void setMap(Map<Integer, String> map) {
        this.map=map;
    }
}

        修改xml配置文件bean2：

<?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="teacherid" class="com.spring.teacher">
        <property name="classnum">
            <array>
                <value>1</value>
                <value>2</value>
            </array>
        </property>

        <property name="map">
            <map>
                <entry key="1" value="张三"></entry>
                <entry key="2" value="李四"></entry>
            </map>
        </property>
    </bean>
</beans>

  名称空间引入 

        在这个基础上，我们还可以通过名称空间util引入的方式来注入数据，结果类似：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/beans"
       xmlns:util="http://www.springframework.org/schema/util"
       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
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <util:map id="maputil">
        <entry key="1" value="张三"></entry>
        <entry key="2" value="李四"></entry>
        <entry key="3" value="王五"></entry>
    </util:map>

    <bean id="teacherid" class="com.spring.teacher">
        <property name="classnum">
            <array>
                <value>1</value>
                <value>2</value>
            </array>
        </property>
        <property name="map" ref="maputil"></property>
    </bean>
</beans>

设置单实例或多实例

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
（2）scope 属性值第一个值 默认值，singleton，表示是单实例对象第二个值 prototype，表示是多实例对象。我们以User类为例，有测试代码如下：

 @Test
    public void test1(){
        //ApplicationContext context =new FileSystemXmlApplicationContext("E:\\IDEAworks\\works\\demo\\src\\main\\java\\bean1.xml");
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        User user1=context.getBean("user",User.class);
        User user2=context.getBean("user",User.class);
        System.out.println(user1);
        System.out.println(user2);
    }
}

        如果对bean不做修改，那么两个输出的值是完全一致的。

        如果修改bean代码如下，即设置scope属性为prototype：

<?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="user" class="com.spring.User" scope="prototype">
        <property name="uname" value="志愿者一号"></property>
        <property name="uage" value="22"></property>
    </bean>
</beans>

        运行结果为：

bean的生命周期

（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（4）bean 可以使用了（对象获取到了）
（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

        有示例代码：

public class Orders {
 //无参数构造
 public Orders() {
 System.out.println("第一步 执行无参数构造创建 bean 实例");
 }
 private String oname;
 public void setOname(String oname) {
 this.oname = oname;
 System.out.println("第二步 调用 set 方法设置属性值");
 }
 //创建执行的初始化的方法
 public void initMethod() {
 System.out.println("第三步 执行初始化的方法");
 }
 //创建执行的销毁的方法
 public void destroyMethod() {
 System.out.println("第五步 执行销毁的方法");
 }
}

        在xml文件中添加的代码：

<bean id="orders" class="com.spring.Orders" init-method="initMethod" destroy-method="destroyMethod">
 <property name="oname" value="手机"></property>
</bean>

         就可以书写测试代码啦:

@Test
 public void test4() {
 ClassPathXmlApplicationContext context =
 new ClassPathXmlApplicationContext("bean4.xml");
 Orders orders = context.getBean("orders", Orders.class);
 System.out.println("第四步 获取创建 bean 实例对象");
 System.out.println(orders);
 //手动让 bean 实例销毁
 context.close();
 }

如果添加了后置处理器，那么周期就有七步：

（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization 
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）
（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6）bean 可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

        如何添加呢？就需要创建一个类实现接口 BeanPostProcessor，创建后置处理器。

public class MyBeanPost implements BeanPostProcessor {
 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) 
throws BeansException {
 System.out.println("在初始化之前执行的方法");
 return bean;
 }
 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) 
throws BeansException {
 System.out.println("在初始化之后执行的方法");
 return bean;
 }
}

        在xml文件中添加代码如下（最好在最后段）就可以为以上的添加后置器啦：

<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

        运行上一个测试代码，就会发现结果不一样了。

XML自动装配

        自动装配是根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入。（1）根据属性名称自动注入bean 标签属性 autowire，配置自动装配 autowire 属性常用两个值：(1)byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样(2)byType 根据属性类型注入

        根据属性名称(名称需要与对象名一致)：

<bean id="emp" class="com.spring.Emp" autowire="byName">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.spring.Dept"></bean>

        根据属性类型(只能创建一个bean，创建多个会无法识别选择哪一个而报错)：

<bean id="emp" class="com.pring.Emp" autowire="byType">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.spring.Dept"></bean>

bean管理外部属性文件(以配置德鲁伊数据库连接池为例)

        首先就是引入druid依赖的jar包，然后创建properties属性文件：

t.user=数据库用户名
t.password=数据库密码
t.url=jdbc:mysql://localhost:3306/数据库名
t.driverClass=com.mysql.cj.jdbc.Driver

        然后就是引入名称空间context

<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:util="http://www.springframework.org/schema/util" 
 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/util 
http://www.springframework.org/schema/util/spring-util.xsd 
 http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd">

        然后就是引入外部文件和配置连接池了:

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="${t.driverClass}"></property>
 <property name="url" value="${t.url}"></property>
 <property name="username" value="${t.userName}"></property>
 <property name="password" value="${t.password}"></property>
</bean>

基于注解的方式创造对象

          Spring 针对 Bean 管理中创建对象提供注解
（1）@Component
（2）@Service
（3）@Controller
（4）@Repository
* 上面四个注解功能是一样的，都可以用来创建 bean 实例

        首先，要导入相关的依赖包，即Spring-AOP中RELEASE包。其次就是创建配置文件bean4.xml并且开启组件扫描，引入context名称空间:

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

        <context:component-scan base-package="com.spring"></context:component-scan>

</beans>

         然后我们就可以任选一个类在其类名上添加注解来创建了，这里我选择写过的Class类:

@Component(value = "zjClass")//value可看为bean操作中的自定义id
public class Class {
    private String claname;

    public String getClaname() {
        return claname;
    }

    public void setClaname(String claname) {
        this.claname = claname;
    }
}

        最后有测试方法并且成功打印：

    @Test
    public void test4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Class zjClass =context.getBean("zjClass", Class.class);
        System.out.println(zjClass);
    }

        组件扫描有个细节

<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.spring" use-default-filters="false">
 <context:include-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
//只扫描Controller标签

<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.spring">
 <context:exclude-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
//Controller标签不扫描，其余都扫描

基于注解方式注入属性

       1. @Autowired：根据属性类型进行自动装配
第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service
public class UserService {
 //定义 dao 类型属性
 //不需要添加 set 方法
 //添加注入属性注解
 @Autowired 
 private UserDao userDao;
 public void add() {
 System.out.println("service add.......");
 userDao.add();
 }
}

        2.@Qualifier：根据名称进行注入
这个@Qualifier 注解的使用，和上面@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

        3.@Resource：可以根据类型注入，可以根据名称注入

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

        4.@Value：注入普通类型属性

@Value(value = "abc")
private String name;

完全注解开发

        如果想使用纯注解开发，我们可以创建一个配置类来替代配置文件。

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.spring"})
public class SpringConfig {
}

        另外就是测试类中的

ApplicationContext context = new ClassPathXmlApplicationContext("？？.xml");

        需要替换成：

 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);

        其余不变即可。

Spring中IOC详解
qq_41359998的博客
02-06 1万+
一、IOC的原型 IOC ----控制反转 比如我们有一个功能是获取用户数据，我们使用Dao层实现这个功能，再在Service层调用这个功能。但是我们每增加一个接口，比如获取mysql中的数据，就要修改原来的代码，如果再增加一个新的接口，又需要去service实现类中修改对应的实现。 解决方法 用户实际调用的是业务层，dao层他们不需要接触 UserServiceImpl userService = new UserServiceImpl(); userSe
Spring之IOC示例
04-19
在IT行业中，Spring框架是Java开发领域中一个极为...通过阅读《Spring之IOC示例》这篇博客（博文链接：https://huangminwen.iteye.com/blog/1041298），可以更深入地理解Spring的IOC机制，并学习如何在实际项目中应用。
Spring之IOC容器
tq02的博客
03-28 1297
本文讲解的SpringIoc的知识点，对比传统代码，SpringIoc的优点，通过控制反转，如何获取Bean的两种方法，以及配置的xml文件
Spring之IOC概念
肥羊的博客
11-27 1058
IOC就是控制反转，把对象创建和对象之间的调用过程交给Spring进行管理。
Spring之IOC自动装配
热门推荐
楠黎倾风的博客
10-11 3万+
Spring之IOC自动装配
Spring之IoC容器篇
kissship的博客
08-17 1398
Spring是一个开源的应用程序开发框架，它由Rod Johnson创建，主要用于构建企业级Java应用程序。它提供了一个全面的编程和配置模型，可以简化Java开发过程，提高开发效率和可维护性。即为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，
Spring之IOC底层实现原理
Tough_dxx的博客
01-26 1万+
一、Spring框架概述 Spring框架是轻量级的开源的JavaEE框架 Spring框架可以解决企业应用开发的复杂性 Spring框架有两个核心部分：IOC和AOP Spring框架特点：方便解耦，简化开发；AOP编程支持；方便程序测试；方便和其它框架进行整合；方便事务事务操作；降低API开发难度 IOC概念和原理 1、什么是IOC？ 控制反转，把对象创建和对象之间的调用过程交给Spring框架进行管理 使用IOC的目的：为了耦合度降低 做入门案例就是IOC实现 2、IOC底
3、Spring 之IOC 容器 详解
一切总会归于平淡
09-03 1905
IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。
Spring之IOC的注入方式
LuoLiangDSGA的博客
05-09 3876
Spring之IOC的注入方式 在java中，要使用一个对象，必须先创建一个实例，但是有了IOC之后，对象的创建与销毁都交给了IOC容器，不用我们手动创建，而是直接从IOC容器中获取，达到了解耦的效果。IOC是一种思想，在Spring中，实现IOC的方式是DI（依赖注入），本文会介绍Spring依赖注入的几种方式。 Spring的依赖注入 对象，在Spring中叫做bean，即使...
高频面试Spring之IOC
闲来也无事
09-02 2424
1、简介 IOC的目的：控制反转和依赖注入 2、IOC过程简析（针对单例Bean） 该问题考察是否读过Spring IOC 源码，以下列举部分流程，应对面试是没问题的： 解析配置文件、或注解元数据，将bean的定义转换为BeanDefinition 调用getBean()方法获取bean。首先查找缓存，若存在，返回；否则，做创建bean的准备工作，合并BeanDefinition、实例化依赖bean 调用doCreateBean方法，创建bean的实例 通过createBeanInstance方法并根据
Spring之IOC详解
08-31
Spring之IOC详解 IOC（Inversion of Control，控制反转）是一种重要的面向对象编程法则，用于削减计算机程序的耦合问题。它是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection...
简单理解Spring之IOC和AOP及代码示例
08-28
Spring之IOC和AOP详解 Spring是一个开源框架，主要实现两件事，IOC（控制反转）和AOP（面向切面编程）。在本文中，我们将详细了解Spring之IOC和AOP，及其代码示例。 一、IOC（控制反转） IOC控制反转，也可以...
Spring之IOC和DI(三)
01-21
(一)IOC的概念和作用 (二)前期准备 (三)基于XML的IOC环境搭建和入门 (四)ApplicationContext的三个实现类 (五)BeanFactory和ApplicationContext的区别 (六)Bean的细节：三种创建Bean对象的方式 (七)Bean的细节：作用...
spring-security（记住密码，CSRF）
2302_79087378的博客
11-10 654
PersistentTokenRepository实现类InMemoryTokenRepositoryImpl基于内存实现JdbcTokenRepositoryImpl基于数据库实现@Bean。
javax.mail-SpringBoot实现邮件发送
最新发布
张刚的博客
11-14 286
javax.mail实现邮件发送 SpringBoot邮件发送 1、邮件发送环境准备 2、POP3/IMAP/SMTP协议区别 3、java实现邮件发送 工具类可以开箱即用，工具类很全面，支持以下几点： 1、支持抄送人 2、支持密送人 3、支持附件 4、支持html格式的邮件
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 728
Rest请求处理
spring -第十四章 spring事务
m0_74606902的博客
11-11 814
要在spring中实现事务有两种方式编程式事务：编写代码手动的开启、提交、回滚事务。声明式事务：使用注解或xml配置文件进行事务管理。
基于Java+SpringBoot在线考试系统
源码好优多
11-12 385
项目编号：springbootA004传统的教育方式受限于时间和空间，无法满足人们的灵活学习需求。而在线教育通过利用互联网技术，打破了传统教育的限制，提供了更加灵活、自主、便捷和高效的学习途径。在线考试作为在线教育的一部分，成为了评估学生学习成果的重要手段。传统的考试方式存在很多缺点，如需要纸质试卷、人工评分、时间和空间限制等。这些问题不仅增加了教师的工作量，也限制了考试的效率和准确性1.管理员。
Spring IOC 容器深度解析
"Spring_ioc_infoq.pdf" Spring的IoC（Inversion of Control，控制反转）容器是Spring框架的核心组成部分，它负责管理对象的生命周期和依赖关系。在本迷你书中，作者王福强深入讲解了Spring框架的发展历程、IoC的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值