spring的IOC,控制反转

已于 2022-04-25 21:45:15 修改
阅读量389 收藏
点赞数
分类专栏： Spring 文章标签： spring java maven
于 2022-04-25 21:41:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zimuxs/article/details/124414836
版权

spring的IOC,控制反转

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期.

入门案例:(xml配置文件的方式)

1.定义行为规范的接口Pet
package com.jt.demo1;

public interface Pet {
    void hello();
}
2.定义接口的实现类:Dog类
package com.jt.demo1;

public class Dog implements Pet {
    public Dog(){
        System.out.println("我是无参构造~~~");
    }

    @Override
    public void hello() {
        System.out.println("小狗汪汪汪~~~");
    }
}
3.在resources目录下配置xml文件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">
    
		<!--
            1. IOC的机制管理Dog对象
            id: 对象的唯一标识符. 不能重复 见名知意 首字母小写
            class: 类路径
        -->
    <bean id="dog" class="com.jt.demo1.Dog"></bean>
</beans>
4.创建测试类User,查看程序运行效果
public class User {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        Dog dog = (Dog) app.getBean("dog");
        dog.hello();
    }
}

IOC机制的原理

容器的数据结构: K-V Map<K,V> key=bean中的ID, value=实例化的对象
程序执行过程:

  1. 指定配置文件的名称.
  2. 当Spring容器加载配置文件时.当按照顺序执行bean标签时,开始创建对象.
  3. Spring通过bean标签中的class属性获取类型的路径,之后通过反射机制,实例化对象(必须有无参构造)
  4. bean中的Id当做Map中的key, 将实例化的对象保存到Map中,当做value. 至此Spring容器启动成功!!!
  5. 当用户需要获取对象时,可以通过key/或者类型 获取对象.

spring注解开发(改造入门案例)

1.定义行为规范的接口Pet
package com.jt.demo1;

public interface Pet {
    void hello();
}
2.定义接口的实现类:Dog类
package com.jt.demo1;

public class Dog implements Pet {
    public Dog(){
        System.out.println("我是无参构造~~~");
    }

    @Override
    public void hello() {
        System.out.println("小狗汪汪汪~~~");
    }
}
3.定义配置类SpringConfig
package com.jt.demo4;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

@ComponentScan("com.jt.demo4") //包扫描注解,让Spring注解生效!!!
@Configuration //标识当前类是配置类
public class SpringConfig {
    //作用:和配置文件类似,管理对象
    /*
    IOC-写法
    1.@Bean 告诉Spring容器,当前方法的名称,为Map中的key
    返回值是Map中的value
    2.特殊用法:常规条件下,Spring通过反射实例化对象,也可以由用户自己创建
     */
    @Bean
    public Dog dog(){
        return new Dog();
    }
}
4.创建测试类User,查看程序运行效果
package com.jt.demo4;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class User {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        Dog dog = context.getBean(Dog.class);
        dog.hello();
    }
}

Spring管理对象 方式一:(@Bean)

Bean容器对象的生命周期方法

package com.jt.demo6;

/*
Day03
spring对象的生命周期
 */

/**定义User类*/
public class User {
    //1.对象创建,Bean创建对象自动调用
    public User(){
        System.out.println("用户对象创建成功");
    }

    //2.进行初始化
    @PostConstruct  //初始化注解
    public void init(){
        System.out.println("为属性赋值");
    }

    //3.进行业务调用,业务方法,用户手动调用
    public void hello(){
        System.out.println("我爱java");
    }

    //4.销毁方法
    @PreDestroy   //标记为销毁方法
    public void destroy(){
        System.out.println("调用销毁方法,释放资源");
    }
}


/**创建配置类*/
@Configuration  //标识配置类
public class SpringConfig {

    @Bean  //把对象控制权交给Bean
    public User user(){
        return new User();
    }
}

/**测试类*/
public class TestUser {
    public static void main(String[] args) {
        //ApplicationContext app1 = new AnnotationConfigApplicationContext(SpringConfig.class);
        AnnotationConfigApplicationContext app2 = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = app2.getBean(User.class);
        //调用业务方法
        user.hello();
        //如果需要执行销毁方法,则需要先关闭容器对象
        //知识点:容器的接口,没有提供关闭容器的操作,需要调用实现类的关闭方法
        //设计思想:销毁动作是敏感行为,特殊处理,实现类中有关闭方法
        //app1.close();//报错,接口中没有关闭方法
        app2.close();//先调用销毁方法,然后关闭容器

    }
}

Spring管理对象 方式二:(@Component)

容器对象的生命周期方法

package com.jt.demo6;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
/*spring自动为该注解标识的类,通过反射实例化对象,
交给spring容器管理,
key:类名首字母小写user
value:反射机制创建出来的对象
类似于@Bean注解

@Component/@Bean区别:
1.@component spring容器通过反射自动创建对象
  @Bean 是用户自己手动创建的对象
2.@component  是标识类的
  @Bean 标识配置类中的方法
3.@component 对象的Id是类名的首字母小写
  @Bean 对象的Id是方法名
*/
@Component
public class User {
    //1.对象创建,Bean创建对象自动调用
    public User(){
        System.out.println("用户对象创建成功");
    }

    //2.进行初始化
    @PostConstruct  //初始化注解
    public void init(){
        System.out.println("为属性赋值");
    }

    //3.进行业务调用,业务方法,用户手动调用
    public void hello(){
        System.out.println("我爱java");
    }

    //4.销毁方法
    @PreDestroy   //标记为销毁方法
    public void destroy(){
        System.out.println("调用销毁方法,释放资源");
    }
}


/**配置类*/
@Configuration  //标识配置类
@ComponentScan("com.jt.demo6")
public class SpringConfig {

}


/**测试类*/
public class TestUser {
    public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = app.getBean(User.class);
        //调用业务方法
        user.hello();
    }
}

总结:Component和Bean都可以标识把对象交给spring容器管理
@Component/@Bean区别:
1.@component spring容器通过反射自动创建对象
@Bean 是用户自己手动创建的对象
2.@component 是标识类的
@Bean 标识配置类中的方法
3.@component 对象的Id是类名的首字母小写
@Bean 对象的Id是方法名

Spring中依赖注入

依赖注入就是将spring容器中管理对象,赋值给对象的属性
核心机制:如果需要使用依赖注入,则对象的属性必须有setXxx()方法

xml配置文件写法
(1)为普通属性赋值

1.定义类(类里必须有set方法)

package com.jt.demo7_di;

public class Person {
    //定义属性
    private Integer id;
    private String name;

    //依赖注入,为属性赋值,必须有set方法
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void sayHi(){
        System.out.println("你好:"+id+":"+name);
    }

}

2.在resources目录下配置xml文件spring_di.xml(依赖注入,通过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">

<!--  xml配置文件  为属性赋值 -->
    <bean id="person" class="com.jt.demo7_di.Person">
        <!-- 通过Bean的property属性为类的属性赋值 -->
        <property name="id" value="100"/>
        <property name="name" value="春节"/>
    </bean>
</beans>

3.创建测试类,查看程序运行效果

public class TestPerson {
    public static void main(String[] args) {
        String resource = "spring_di.xml";
        ApplicationContext app = new ClassPathXmlApplicationContext(resource);
        Person person = app.getBean(Person.class);
        person.sayHi();
    }
}
(2)spring为对象赋值

1.定义Person类(类里必须有set方法)

package com.jt.demo7_di;

public class Person {
    //定义属性
    private Integer id;
    private String name;
    private Car car;  //spring容器为属性赋值

    //依赖注入,为属性赋值,必须有set方法
    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void sayHi(){
        System.out.println("你好:"+id+":"+name);
    }
    public void toGo(){
        car.go();
    }

}

2.在resources目录下配置xml文件spring_di.xml(依赖注入,通过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">

<!-- 1.让spring容器管理car -->
    <bean id="car" class="com.jt.demo7_di.Car"></bean>

<!--  2.xml配置文件,让spring管理Person,并且为属性赋值 -->
    <bean id="person" class="com.jt.demo7_di.Person">
<!-- 通过Bean的property属性为类的普通属性赋值 -->
        <property name="id" value="2100"/>
        <property name="name" value="春节111"/>
<!-- 3.如果将对象赋值给属性,使用ref属性
        ref:引用的id
		相当于把spring管理的car对象传给person类的car属性,
		实现松耦合-->
        <property name="car" ref="car"/>
    </bean>
</beans>

3.创建测试类,查看程序运行效果

package com.jt.demo7_di;

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

public class TestPerson {
    public static void main(String[] args) {
        String resource = "spring_di.xml";
        ApplicationContext app = new ClassPathXmlApplicationContext(resource);
        Person person = app.getBean(Person.class);
        person.sayHi();
        person.toGo();
    }
}
Zimuxs
关注
专栏目录
Spring学习（3）——IoC控制反转（Inversion of Control）
weixin_43721056的博客
04-25 368
spring的第一个核心功能 IoCIoC在学习Spring之前的体现依赖注入（DI）基于XML的DIset方式注入 IoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。 描述：把对象的创建，赋值，管理工作都交给代码之外的容器实现， 也就是对象的创建是由其它外部资源完成。 控制： 创建对象，对象的属性赋值，对象之间的关系管理。 反转： 把原来的开发人员管理、创建对象的权限转移给代码之外的容器实现。 由容器代替开发人员管理对象。创建对象，给属性赋值。 正转：由开发人员
(一)Spring中IOC相关知识
博客的博客
07-15 283
一、IOC（概念及原理） 1.什么是IOC 控制反转（Inversion of Control），是面向对象编程中的一种设计原则 把对象创建和对象之间的调用过程，交给spring进行管理， 2.使用IOC的目的 降低计算机代码之间的耦合度。 3.IOC底层原理 xml解析、工厂模式、反射 ⚪原始方式 ⚪工厂模式 最终的目的是降低耦合度，但是工厂模式并没有将耦合度降到最低 ⚪IOC过程 🐟第一步：xml配置文件，配置创建的对象 🐟第二步：有service类和dao类，.....
Spring IOC知识总结
Black_Me的博客
03-25 1074
文章目录1.什么是IOC/DI1.1IOC（控制反转）1.1.1控制反转(IoC)有什么作用1.1.2IOC的优点是什么？1.1.3Spring IoC 的实现机制1.2DI（依赖注入）1.2.1什么是Spring的依赖注入1.2.2依赖注入的优势2.IOC/DI的实现方式2.1IOC的三种实现方式2.1.1xml配置2.1.2Java配置2.1.3注解配置2.2DI的三种实现方式2.2.1setter方式2.2.2构造方法注入（Construct注入）2.2.3注解注入3.Spring IOC体系结构3.
Spring中IOC的理解（通俗易懂版）
热门推荐
qq_48508278的博客
05-11 1万+
文章目录1.IOC提出背景2:IOC的核心概念3:IOC的实现方式4:IOC的入门案例(1):思路分析(2):代码解析5:DI入门案例(1):思路分析(2):代码解析 1.IOC提出背景 代码书写现状:耦合度太高，我们修改一处代码，往往要修改很多出相关联的代码。 举例如下:当我们在数据层中不满足BookDaoImpl2中提供的方法了,我们写了新的实现类BookImpl,那么当业务层想要调用数据层中的实现方法的时候,我们就要修改 new 的对象。那么引发问题 我们该一处代码，就要修改与其相关联的代.
类和类之间属性复制，必须存在get和set方法的属性才可以复制
千寻啊千寻
09-11 932
package com.hjzx.common.util; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ModelCopy { /** * 类和类之间属性复制，必须存在get和set方法的属性才可以复制 * @param source 源对象 * @param ta
对Spring IOC控制反转的详细理解
qq_53999369的博客
06-10 913
Spring中对IOC控制反转的理解，关于生成的对象的生成、生命周期、线程安全和循环依赖问题。
Spring IOC控制反转原理详解
2301_76166241的博客
01-31 810
查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在 Spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如 ListableBeanFactory 接口表示这些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的，也就是每个Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。
Spring学习：IOC控制反转
sssxlxwbwz的博客
02-01 1787
一、Spring概述： Spring是一个开源框架，其存在的根本使命就是简化JAVA开发。为了降低JAVA开发的复杂性，Spring采取了以下四种关键策略： 基于POJO的最轻量级和最小侵入性编程； 通过依赖注入和面向接口实现松耦合； 基于切面和惯例进行声明式编程； 通过切面和模板减少样板式代码。 1.1 Spring有两个核心部分：IOC和AOP: (1) IOC: 控制反转，把创建对象过程交给Spring进行管理； (2) AOP: 面向切面，不修改源代码，...
Spring IOC 控制反转
10-24
### Spring IOC控制反转详解 #### 一、Spring框架简介 Spring框架是一个开源的Java平台，提供了全面的基础架构支持，让开发者能够轻松地开发出松耦合的应用程序。它通过依赖注入（Dependency Injection, DI）和...
helloIoc.zip spring ioc控制反转简单测试代码
01-13
Spring框架的核心特性之一就是依赖注入（Dependency Injection，简称DI），它通过控制反转（Inversion of Control，简称IOC）实现。这个"helloIoc.zip"压缩包包含的是一组用于演示Spring IOC基本概念和使用的测试...
Spring IOC控制反转 1
04-13
**Spring IOC控制反转详解** 在Java开发中，Spring框架的核心特性之一就是IOC（Inversion of Control，控制反转），它改变了传统程序设计中的对象依赖管理方式，使得开发者可以更专注于业务逻辑，而不是对象的创建...
spring IOC控制反转 xmind
10-15
spring IOC控制反转 spring IOC控制反转 spring IOC控制反转
第二讲：2.1 spring IOC控制反转与传统代码对比
Cruise的博客
11-02 560
1， spring IOC 介绍 IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系...
SpringMVC入门详解
ning的博客
11-02 757
SpringMVC是一个基于Java的实现了MVC设计模式的Web框架，它通过将Web层进行模块化，使得Web应用程序的开发变得更加灵活和可维护。简化开发：通过注解的方式简化了配置，减少了代码量。强大的集成能力：可以很容易地与其他Spring模块集成。灵活的配置：支持零配置启动，也支持通过XML或Java配置进行详细配置。可重用性高：可以轻松地将一个项目中的代码重用到另一个项目中。
SpEL（Spring Expression Language）入门指南
最新发布
kersixy的博客
11-05 587
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
spring中bean的四种创建方式
QQ903275718的博客
10-31 402
spring创建bean的四种方式
在Springboot中更好的打印日志
nullPoninter的博客
11-02 258
1
Java项目：164 springboot校园资产管理
舒克日记的博客
11-04 373
人事管理系统分为管理员和用户两部分操作角色主要的功能有资产报废管理、用户管理、入库管理、资产借用管理、校园资产管理、个人信息管理。
SpringSession源码分析
lkr_lkr的博客
11-01 417
默认对常规Session的理解和使用，如何使用Set-Cookie。
Spring IoC控制反转深度解析与优化
本文档《20190608_SpringIoC回顾和拓展_田超凡.docx》主要围绕Spring IoC（Inversion of Control）的控制反转概念进行深入探讨。作者田超凡从2019年6月8日的分享开始，回顾了Spring框架中依赖注入（Dependency ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值