Spring ICO和DI

五八个 五八个 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 328平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄8年
关注
原创 2022-06-13 10:23:38 328 阅读 AI 写同款· GEO 优化 ›
【Spring系列】 Spring注解方式实现IOC、DI及其Spring其他注解 阅读详情

IoC是什么

　　Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

　　●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

　　●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

　　用图例说明一下，传统程序设计如图2-1，都是主动去创建相关对象然后再组合起来：

IoC和DI

　　DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

　　理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

　　●谁依赖于谁：当然是应用程序依赖于IoC容器；

　　●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

　　●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

　　●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。 

Spring对象的生命周期 

步骤：

1.对象的创建

2.初始化数据

3.调用方法，完成功能

4.销毁对象

核心：生命周期的方法是自动调用的

package com.jt.demo6;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class User {
    //对象的创建
    public User(){
        System.out.println("对象创建成功");
    }
    //数据初始化
    @PostConstruct
    public void init(){
        System.out.println("属性赋值");
    }
    //进行业务调用---->手动调用
    public void hello(){
        System.out.println("学java");
    }
    //销毁方法
    @PreDestroy
    public void destory(){
        System.out.println("销毁");
    }
    
}

@postConstruc：标识初始化方法

@preDestory：标识销毁方法.

编辑测试类：

知识点: 容器的接口,没有提供关闭容器的操作. 如果需要关闭容器则使用实现类中的方法

package com.jt.demo6;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestUser {

        public static void main(String[] args) {
                AnnotationConfigApplicationContext context =
                        new AnnotationConfigApplicationContext(SpringConfig.class);
                User user = context.getBean(User.class);
                //调用业务方法
                user.hello();
                //如果需要执行销毁方法,则需要先关闭容器对象
                //思想:销毁动作是敏感行为,特殊处理 实现类中有关闭方法.
                context.close();
        }
}

Spring管理对象–@Component 

package com.jt.demo6;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;


@Component  //前提：注释了@Bean
 * Spring自动为该注解标识的类通过反射实例化对象,交给Spring容器管理.
 *  Key: 类名首字母小写 user
 *  value: 反射的对象
 *  类似于@Bean注解
public class User {
    //对象的创建
    public User(){
        System.out.println("对象创建成功");
    }
    //数据初始话
    @PostConstruct
    public void init(){
        System.out.println("属性赋值");
    }
    //进行业务调用---->手动调用
    public void hello(){
        System.out.println("学java");
    }
    //销毁方法
    @PreDestroy
    public void destory(){
        System.out.println("销毁");
    }

}

@Compoent和@Bean的区别：

1.@Compoent是spring容器通过反射自动创建对象，@Bean是手动创建对象

2.@Compoent是标识类的，@Bean是标识配置类中的方法

3.@Compoent对象的id是类名首字母小写，@Bean对象的id是方法名

完整代码：

package com.jt.demo6;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class User {
    //对象的创建
    public User(){
        System.out.println("对象创建成功");
    }
    //数据初始话
    @PostConstruct
    public void init(){
        System.out.println("属性赋值");
    }
    //进行业务调用---->手动调用
    public void hello(){
        System.out.println("学java");
    }
    //销毁方法
    @PreDestroy
    public void destory(){
        System.out.println("销毁");
    }

}

package com.jt.demo6;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo6")
public class SpringConfig {
    //@Bean
    //public User user(){
     //   return new User();
    //}

}

package com.jt.demo6;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestUser {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        User user=context.getBean(User.class);
        user.hello();
        context.close();

    }
}

注解说明

@ComponentScan：为了让Spring的注解生效. 需要单独使用包扫描注解.

@Component ：前提：注释了@Bean，Spring自动为该注解标识的类通过反射实例化对象,交给Spring容器管理.

Spring-DI(Dependency Injection)

Spring中依赖注入

依赖注入就是将Spring容器中管理对象(数据),赋值给对象的属性.

属性赋值的方法：

1.set方法

package com.jt.demo7_di;

public class Car {
    private  String name;
    private String color;

    public void go(){
        System.out.println("去任何地方");
    }

}

package com.jt.demo7_di;

public class Persion {
    private Integer id;
    private String name;
    private 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 Car getCar() {
        return car;
    }

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

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

}

 <property name="car" ref="car"></property>

前一个car是persion属性中的，后一个car是<bean id="car" class="com.jt.demo7_di.Car">中的

<?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="car" class="com.jt.demo7_di.Car">

    </bean>

        <bean id="persion" class="com.jt.demo7_di.Persion">
            <property name="id" value="11"></property>
            <property name="name" value="春节"></property>
            <property name="car" ref="car"></property>
        </bean>
</beans>
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 reso="spring_id.xml";
        ApplicationContext context=new ClassPathXmlApplicationContext(reso);
        Persion persion=context.getBean(Persion.class);
        persion.SayHi();
        persion.toGo();
    }
}

2.含参构造注入

package com.jt.demo7_di;

public class Car {
    private  String name;
    private String color;
    public Car(){
        System.out.println("无参构造");
    }
    public Car(String name,String color){
        this.name=name;
        this.color=color;
    }
    public void go(){
        System.out.println("去任何地方"+name+color);
    }

}

package com.jt.demo7_di;

public class Persion {
    private Integer id;
    private String name;
    private 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 Car getCar() {
        return car;
    }

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

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

}

<?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="car" class="com.jt.demo7_di.Car">
        <constructor-arg name="name" value="奔驰"></constructor-arg>
        <constructor-arg name="color" value="黑色"></constructor-arg>
    </bean>

        <bean id="persion" class="com.jt.demo7_di.Persion">
            <property name="id" value="11"></property>
            <property name="name" value="春节"></property>
            <property name="car" ref="car"></property>
        </bean>
</beans>
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 reso="spring_id.xml";
        ApplicationContext context=new ClassPathXmlApplicationContext(reso);
        Persion persion=context.getBean(Persion.class);
        persion.SayHi();
        persion.toGo();
    }
}

注解注入：@Autowired

规则:
     *      1.默认条件下使用set方式注入.按照类型匹配.
     *      2.set方式注入也可以按照name名称进行匹配
     *      3.只要使用注解,默认自动生成SetXX方法
     *  实现原理:
     *      1.类型匹配: 如果是接口,则自动匹配其实现类对象
     *      2.name名称匹配: 根据spring中的key进行注入.

package com.jt.demo8_anno;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.jt.demo8_anno")
public class springConfig {
}

package com.jt.demo8_anno;

public interface Pet {
    void hello();
}

package com.jt.demo8_anno;

import org.springframework.stereotype.Component;

@Component //将对象交给容器管理
public class Tiger implements Pet{
    @Override
    public void hello() {
        System.out.println("咦~，我靠");
    }
}

 使用原理一：类型匹配: 如果是接口,则自动匹配其实现类对象

package com.jt.demo8_anno;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 1.该类主要测试 注解的注入方式.
 * 2.练习对象的嵌套关系
 * 3.注解的写法与xml写法的原理相同,形式不同
 */
@Component //key:user value:反射后的对象
public class User { //用户
    /**
     * 注解说明:
     *  1.@Autowired 自动注入
     *  规则:
     *      1.默认条件下使用set方式注入.按照类型匹配.
     *      2.set方式注入也可以按照name名称进行匹配
     *      3.只要使用注解,默认自动生成SetXX方法
     *  实现原理:
     *      1.类型匹配: 如果是接口,则自动匹配其实现类对象
     *      2.name名称匹配: 根据spring中的key进行注入.
     */
    @Autowired
    private Pet pet;

    public void hello(){
        pet.hello();
    }
}

多实现类情况处理：pig和tiger都实现了pet（代码接上）

使用实现原理2：name名称匹配: 根据spring中的key进行注入

注解说明：

 @Autowired 自动注入
     *  规则:
     *      1.默认条件下使用set方式注入.按照类型匹配.
     *      2.set方式注入 可以按照name名称进行匹配
     *      3.只要使用注解,默认自动生成SetXX方法
     *  实现原理:
     *      1.类型匹配: 如果是接口,则自动匹配其实现类对象
     *      2.name名称匹配: 根据spring中的key进行注入.
 @Qualifier必须和@Autowired联用.
     *      并且需要指定value的名称,就是spring中的key
     *      准则: 一般条件下,Spring都是单实现!!!!

package com.jt.demo8_anno;

import org.springframework.stereotype.Component;

@Component
public class Pig implements Pet{
    @Override
    public void hello() {
        System.out.println("咬老虎");
    }
}

package com.jt.demo8_anno;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class User {
    @Autowired    //自动注入
    @Qualifier(value = "pig")
    private Pet pet;
    public void hello(){
        pet.hello();
    }
}

 Spring属性赋值-@Value注解

编辑properties配置文件

位置：

#1.数据结构 key=value
#2.其中的数据默认都是String类型,数值可以切换为数值类型
#3.程序读取时,默认的字符集ISO-8859-1 不支持中文,
#  如果支持中文,使用utf-8
dept.id=101
dept.name=行政部
dept.id=101
dept.name=行政部
package com.jt.demo9;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo9")
public class SpringConfig {
}

 为属性赋值

package com.jt.demo9;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
//当spring容器启动时,加载指定的配置文件,将数据保存到容器中!!!
@PropertySource(value = "classpath:/dept.properties",encoding = "UTF-8")
public class Dept {

    //取值方式: 从spring容器中获取数据 ${pro中的key}
    @Value("${dept.id}")
    private Integer id;
    @Value("${dept.name}")
    private String name;

    //@Value注解可以为简单属性赋值.
    //@Value("财务部")
    //private String name;

    public void hello(){
        System.out.println("获取数据:"+id+":"+name);
    }
}


package com.jt.demo9;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestDept {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        Dept dept=context.getBean(Dept.class);
        dept.hello();
    }
}

注解：

@Autowired：自动注入

@Qualifie()：指定value的名称,就是spring中的key，必须和@Autowired联用.

@postConstruc：标识初始化方法

@preDestory：标识销毁方法.

@ComponentScan：为了让Spring的注解生效. 需要单独使用包扫描注解.

@Component ：前提：注释了@Bean，Spring自动为该注解标识的类通过反射实例化对象,交给Spring容器管理.

@Value：自己生成set函数

单词：

component：组件

componentScan(components and parts)：零部件

标签
#spring #java #后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
基于Simulink的直流电机双闭环调速系统抗扰动仿真与参数优化 本文详细介绍了基于Simulink的直流电机双闭环调速系统仿真与参数优化方法。通过构建转速外环与电流内环的仿真模型，阐述了利用工程设计法整定PI参数的核心步骤，并重点探讨了如何优化系统参数以增强其抗负载突变等扰动的能力，实现快速、平稳的调速性能。 阅读详情

相关推荐

AD9371实战：如何用ZCU106搭建JESD204B TX时钟链（含关键参数计算）

本文详细解析了如何基于Xilinx ZCU106开发板为AD9371搭建JESD204B TX时钟链。文章从系统需求出发，逐步推导出从IQ采样率到GTH线速率的关键参数计算公式，并提供了在Vivado中配置GTH收发器（包括QPLL选择、分频比设置）的实战步骤与调试技巧，旨在帮助硬件工程师快速实现稳定可靠的JESD204B高速数据传输链路。

weixin_29164843的博客 293

Spring容器之refresh方法源码分析

BeanFactory作为IOC容器的核心接口，ApplicationContext接口包含了BeanFactory的所用功能 来看看两者关系： 既然是继承关系，那么ApplicationContext包含了BeanFactory的所用功能也就不足为奇了 ApplicationContext作为Spring上下文的关键接口，除了BeanFactory的功能，还包括各种环境、参数、BeanFactoryPostProcessors后处理器、事件以及单例bean的初始化等一系列操作，其中以refresh方法为s

持之以恒 1833

评价模型——层次分析法（AHP）与熵权法（EWM）

层次分析法是定性与定量结合的多准则决策、评价方法。将决策的有关元素分解成目标层、准则层和方案层，并通过人们的判断对决策方案的优劣进行排序，在此基础上进行定性和定量分析。它把人的思维过程层次化、数量化，并用数学为分析、决策、评价、预报和控制提供定量的依据。

好好学习 天天向上 2万+

spring(ICO、DI)

一,Spring的IOC –1,概述 IOC是指控制反转,是指把对象创建初始化销毁的权利都交给spring框架 –2,xml实现IOC步骤(不推荐) –创建类 –创建核心配置文件spring-config.xml配置类的信息(bean) –直接测试(从spring里直接getBean) –3,注解实现IOC的步骤 –创建类(@Component) package cn.tedu.spring; public class Hello { } package cn.tedu.spring; import

weixin_56747126的博客 185

VS2022打包C#安装包(最新、最全)

VS2022打包C#安装包(最新、最全)

qq_37959253的博客 9903

AD9371 官方例程构建及单音信号收发

项目构建基本流程和AD9361差不多，由于官方使用的ZCU102，记录下移植遇到的一些问题最终接收到正确的正弦波Errors: 0Errors: 0Errors: 0Errors: 0AD9361。

weixin_44630490的博客 2973

Spring框架《二》ICO和DI续集

ICO和DI续集一、集合属性1.数组与List2.Map3.集合类型bean二、FactoryBean(工厂)三、bean的高级配置1. 配置信息的继承(一般不用，每个对应的bean都是唯一的)2.bean之间的依赖四、bean的作用域五、bean的生命周期六、引用外部属性文件1.直接配置2.使用外部的属性文件七、自动装配八、通过注解配置bean1.使用注解标识组件2扫描组件3.组件装配 一、集合属性 1.数组与List 配置java.util.List类型的属性，需要指定标签，在标签里包含一些元素。这些标

rukang0912的博客 268

【温室气体数据集】CAMS 发布的温室气体（GHG）数据集总结

【温室气体数据集】CAMS 发布的温室气体（GHG）数据集总结

WW、forever的博客 555

(笔记)Spring 中的基本思想 ICO/DI(Dependency Injection)

How to inject the param? There are two way... [color=red][b]The first way:[/b][/color] package Apple; public class Apples { AppleDao apple; public AppleDao getApple() { return appl...

iteye_9635的博客 131

第一章 EB安装

1.DemoWorkspace 是基于EB当前组件配置下的例程，包含了启动文件和中断服务函数以及组件demo。2.Mclsar 下存放的是EB的插件包和静态MCAL的驱动文件。

舊梦的博客 1963

YOLOv11原创改进专栏|原创自研篇|DAA模块手把手添加教程

个人简介：大家好！我是 DAA 注意力机制，堪称深度学习中的“聚光灯”。我的任务是帮助模型聪明地识别关键特征，就像一位经验丰富的侦探，能够在繁杂的数据中找到重要线索。通过结合通道和空间的注意力，我能确保模型把重点放在最有价值的信息上，从而提升识别准确率。简单来说，我就是帮助你的模型变得更加专注、敏锐，让它在一堆数据中轻松找到“宝藏”，为检测精度加分！动态适应性特征提取DAA通过动态生成卷积核来适应输入特征的变化，从而实现针对不同数据的自适应特征提取。

mywhyyds的博客 379

Spring——如何理解Spring，DI和IoC

容器顾名思义是 用来容纳某种物品的装置列如：Spring - > IoC 容器List / Map - > 数据存储容器Tomcat - > Web 容器IoC 翻译成中文 是控制反转的意思，也就是说 Spring 是一个 “控制反转”的容器如何理解这句话呢？我们来看个例子：假如，我们现在构建一辆 “车” 的程序，我们的实现思路是这样子的：}/*** 汽车对象*/// 依赖车身}}/*** 车身类*/// 依赖底盘}}/*** 底盘类。

Biteht的博客 1769

电磁兼容（EMC）整改案例（七）：EFT测试失败都是IC悬空引脚惹的祸

无论任何时候，为了避免这些问题，通常建议对悬空的IO口进行适当的配置，比如设置为强推挽输出低电平、输入带上拉或下拉电阻等，以减少外部电路对IO管脚状态的影响，并提高系统的稳定性和可靠性.

linkking27的博客 1032

Spring核心：IoC与DI全解析

IoC: Inversion of Control (控制反转),也就是说 Spring 是⼀个"控制反转"的容器.什么是控制反转呢?也就是控制权反转.什么的控制权发⽣了反转?

2401_89176842的博客 496

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料，已经经过了本人的筛选和整理，希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助！

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过，这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后，重新检测通过。

Spring IoC与DI

什么是IoC 控制反转，是一种技术思想，不是技术实现只不过spring在技术层次把这个做了非常好的实现 作用：Java开发领域对象的创建、管理问题 传统开发 ：比如类A依赖于类B，需要在类中new 一个类B的对象 IoC开发:开发人员不需要去new 的方式创建对象，而是Ioc容器帮助开发人员实例化对象并且管理它的生命周期， 需要使用哪个对象，去找Ioc窗口要（获取）即可 丧失了一个创建、管理对象的权利 不用考虑对象的创建、管理等事情 为什么叫控制反转？ 控制：对象的创建（实例，管理）的权利 反转：控制权交了

小城我家 272

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

[转]深入浅出讲解Spring IOC和DI的区别

很多人都会把ioc和di说成同一个东西，其实IOC和DI虽然在概念上可以笼统地视为同一事物，但其本质上存在区别。控制反转）从容器的角度描述，而DI（Dependency Injection，依赖注入）则从应用程序的角度描述。换言之，IOC是依赖倒置原则的设计思想，而DI则是该原则的具体实现方式。因此，我们希望能够更加严谨地区分这两个概念，以更好地理解和应用它们。

Admans的专栏 234

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

Spring注解方式 实现 IOC 和DI

1.Spring注解 Spring除了默认的使用xml配置文件的方式实现配置之外，也支持使用注解方式实现配置，这种方式效率更高，配置信息清晰，修改更方便，推荐使用。 所谓注解就是给程序看的提示信息，很多时候都用来作为轻量级配置的方式。 2.Spring引入context名称空间 在MyEclipse中导入spring-context-3.2.xsd约束文件，要求Spring来管理。在applicationContext.xml文件中，引入该schema文件： <?xml version="1.0" e

Ajaxtxdy的博客 309

java spring di_JAVA-Spring注解方式实现IOC和DI

1.Spring注解Spring除了默认的使用xml配置文件的方式实现配置之外，也支持使用注解的方式实现配置，这种方式效率更高，配置信息更清晰，修改更方便，推荐使用。所谓注解就是给程序看的提示信息，很多时候都是用来做为轻量级配置的方式。关于注解的知识点，可以看我上篇随笔内容。2.Spring引入context名称空间在MyEclipse中导入spring-context-3.2.xsd约束文件，要...

weixin_42522912的博客 108

Spring入门知识 ———— Spring_IOC&DI关系概念概述

一、引言 先从IOC容器开始说，IOC也是Spring核心之一。 本章主要是来介绍IOC容器，以及DI的一些概念性的东西。有些童鞋可能会感觉有点晕车，没关系，别慌，正常现象！ 跟着小编，关注点一点，不迷路，哈哈哈哈～～～   二、Spring_IOC&amp;DI概述 官方的解释： IOC，即反转控制(Inversion of Control)，其思想是反转资源获取的方向。 传统的...

贱男 726

ICO,DI,MVC,AOP思想

IOC是什么 IOC(Inversion of Control)控制反转,IOC是一种新的java编程模式, 目前很多轻量级容器都在广泛使用的模式. IOC解决了什么问题? 在IOC出现以前,组件之间的协调关系都是由程序员内部代码来控制的,或者说,以前使用new关键字来实现两组间之间的依赖关系. 这中方式就造成了组件之间的相互耦合.IOC(控制反转...

u013276888的博客 542

Spring IOC以及DI

Spring的IoC(控制反转) 与DI(依赖注入) IOC: 控制反转,所谓控制反转就是把创建对象（bean）和维护对象（bean）之间的关系的权利转移到器Sqring容中去了（ApplicationContext.xml）而程序本身不在维护了 DI: 依赖注入,将类里面的属性在创建类的过程中给属性赋值.。实际上DI和IOC是同一个概念，因为在ApplicationContext.xm...

Snow丶的博客 393

Spring学习第一课 - 什么是IOC？什么是DI？

了解一下ioc和DI

oneouto的博客 768

Soring IOC和DI

在网上看了好多描述IOC和DI和文章，但感觉看他们的描述总感觉差点意思，所以我个人也总结了一些相关的概念，希望对面试或爱学习的小伙伴共勉。 IoC 和 DI： IoC （Inversion of Control）： 大家常说就是控制反转。然而ioc不是一种新的技术，而是 Spring 的一种设计思想，这个相信大家使用过的小伙伴都应该知道。 何为ICO？ 在传统的程序设计，我们直接在对象内部通过 new 来创建对象，是程序主动去创建依赖对象；而在 Spring 中有专门的一个容器来创建和管理这.

Liaryank的博客 370

Spring学习笔记（Ico部分）

开源、轻量级Java开发应用框架生态完善，不管是Spring哪个领域的解决方案都是依附于SpringFramework基础框架的

m0_58568271的博客 466

2018/11/30 依赖倒置DI和控制反转Ico

早上起来占个坑，晚上整理。 依赖注入DI(dependency injection)： 谁依赖谁？谁注入谁？注入什么？ 调用类依赖功能类。 容器注入调用类。 注入了功能类的实例。 控制反转Ioc(inversion of control): 谁控制谁？反转了什么？正转是什么？ ioc容器控制实例的创建和管理、注入。 反转了实例的创建方，由调用类转移到Ioc容器...

a287200940的博客 167

java spring IOC/DI

一、IOC（invovation of control）：控制反转 IOC不是什么技术，而是一种设计思想（spring被创造出来的时候就说了：spring没有新技术，只有新思想）。在java开发中，IOC意味着将你设计好的对象交给容器控制。而不是传统的在你的对象内部直接控制。 理解好IOC的关键是要明确：“谁控制谁，控制了什么，为何是反转，哪些方面反转了” 1、谁控制了谁，控制了什么：在传统的Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IOC是有专门一个容器

lmsnice的博客 1023
上一篇： Spring框架
下一篇： MVC思想、Spring层级代码、AOP
点赞 1
评论 0
书签 书签 0
五八个
五八个
博客等级 码龄8年 638粉丝 41原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值