Spring之ioc控制反转

最新推荐文章于 2023-06-15 16:20:20 发布
最新推荐文章于 2023-06-15 16:20:20 发布
阅读量206 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/continueLR/article/details/122441073
本文详细介绍了Spring的IOC思想，包括控制反转的概念、配置bean、单例与多例模式、懒加载，以及DI依赖注入的实践，通过set注入、构造方法注入和自动注入等方式实现组件间的解耦。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring的IOC思想

1.IOC：控制反转

IOC 是指在程序开发中，实例的创建不在由调用者管理，而是由Spring容器创建。
容器会控制对象之间的关系，而不是由程序代码直接控制。
因此控制权由程序代码转移到了Spring容器中。
控制权发生了反转，这就是Spring的IOC思想。

准备工作：修改pom文件

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.15.RELEASE</version>
    </dependency>

刷新maven即可添加。

2.使用bean标签：

先创建一个preson类

package com.lr.spring.po;

public class Person {
    //属性
    private Integer id;
    private String name;
    private double sal;
    //无参构造方法
    public Person (){
        System.out.println("创建person对象");
    }
}

配置文件

<?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">
<!--
beans是spring中的根标签，在bean标签中配置自己需要的对象
1.bean在spring中相当于java中的对象，需要把该对象对应的类配置到容器中
2.id="":标识，相当于对象名，唯一
3.class="包名.类名（即全限定名）"  包名.类名通过反射创建该类的对象，不能写接口名
  -->
    <bean id="person1" class="com.lr.spring.po.Person"></bean>
<!--  把Person类纳入到spring管理中，当程序执行（默认），在spring容器，创建一个Preson类的对象preson1（反射）  -->
</beans>

 测试类

package com.lr.spring;

import com.lr.spring.po.Person;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppTest{
    @Test
    public void test01(){
        BeanFactory factory = new ClassPathXmlApplicationContext("application.xml");
        Person person = (Person)factory.getBean("person1");
        System.out.println(person);
        //单例模式：对象person是唯一的
        Person person2 = (Person)factory.getBean("person1");
        System.out.println(person2);
    }
}

测试结果

3.：单例模式与多例模式

单例模式：singleton

默认值，单例（不管任何人，多少人过来访问，拿到的都是同一个对象）

    <bean id="person1" class="com.lr.spring.po.Person" scope="singleton"></bean>

 多例模式：prototype

多例，懒加载（延迟加载），读取配置文件的时候不创建对象，只有调用getBean()方法的时候，才创建对象

    <bean id="person1" class="com.lr.spring.po.Person" scope="prototype"></bean>

加入多例模式后，测试结果发生的变化，两个对象地址不一样了

 

4.懒加载

beans是spring中的根标签，在bean标签中配置自己需要的对象
1.bean在spring中相当于java中的对象，需要把该对象对应的类配置到容器中
2.id="":标识，相当于对象名，唯一
3.class="包名.类名（即全限定名）"  包名.类名通过反射创建该类的对象，不能写接口名
  -->
    <bean id="person1" class="com.lr.spring.po.Person" scope="prototype" lazy-init="default"></bean>
<!--  把Person类纳入到spring管理中，当程序执行（默认），在spring容器，创建一个Preson类的对象preson1（反射）  -->
<!--scope="prototype"/"singleton":控制spring容器创建的对象是单例还是多例
singleton：默认值，单例（不管任何人，多少人过来访问，拿到的都是同一个对象）
prototype：多例，懒加载（延迟加载），读取配置文件的时候不创建对象，只有调用getBean()方法的时候，才创建对象
lazy-init="true"/"default"/"false":主要是针对单例模式的
true：懒加载（延迟加载），只有使用的时候才真正创建该类对象
default/false：不懒加载，读取配置文件时就立刻创建对象，default是默认值
-->

 ioc实例

1.创建User类

package com.lr.spring.po;

import java.io.Serializable;

public class User implements Serializable {
    public Integer id;
    private String name;
    private String password;

    public User() {
    }

    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 String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.写入配置文件，用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="user1" class="com.lr.spring.po.User"></bean>
    <bean id="user2" class="com.lr.spring.po.User"></bean>
    <bean id="user3" class="com.lr.spring.po.User"></bean>
</beans>

3.测试程序

测试ApplicationContext()中的几个方法

package com.lr.spring;

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

public class AppTest{
    @Test
    public void test01(){
        //ApplicationContext在实际开发中取代了BeanFactory,功能更加枪法，而且有很多其他功能
        ApplicationContext factory = new ClassPathXmlApplicationContext("application.xml");
        User user1=(User)factory.getBean("user1");
        System.out.println(user1);
        //getBeanDefinitionCount()可以查配置文件里有多少个对象
        int count = factory.getBeanDefinitionCount();
        System.out.println("对象的个数："+count);
        //getBeanDefinitionNames():获取对象的名字
        String[] names =factory.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

//通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例。
        ApplicationContext factory2 =new FileSystemXmlApplicationContext("D:\\code\\spring02\\src\\main\\resources\\application.xml");
        User user1 = (User) factory2.getBean("user1");
        System.out.println(user1);

添加其他类

添加date类

1.配置文件

注意，这里需要绝对路径，date类在其他包里

<?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="user1" class="com.lr.spring.po.User"></bean>
    <bean id="user2" class="com.lr.spring.po.User"></bean>
    <bean id="user3" class="com.lr.spring.po.User"></bean>
    <bean id="date1" class="java.util.Date"></bean>
</beans>

2.测试程序 

ApplicationContext factory = new ClassPathXmlApplicationContext("application.xml"); 
Date date1=(Date) factory.getBean("date1");
      System.out.println(date1);

 

在User加入多参构造方法，与tostring方法，测试默认调用无参构造方法 

 

工厂模式

如果想调用多参构造方法呢？使用工厂模式：写一个UserFactory类，提供方法

1.静态方法创建对象

package com.lr.spring.factory;

import com.lr.spring.po.User;

public class UserFactory {
    //静态方法创建对象（3参构造方法）
    public static User getUserStaticInstance(){
        System.out.println("通过spring调用工厂中的静态方法创建3参User对象：");
        return new User(1111,"龙傲天","1380341");
    }
}

2.配置文件

!--  通过spring调用工厂中的静态方法创建3参User对象  -->
<!--   静态方法 -->
    <bean id="user4" class="com.lr.spring.factory.UserFactory" factory-method="getUserStaticInstance"></bean>

3测试文件 

    @Test
    public void test02(){
        ApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
        User user=(User) app.getBean("user4");
        System.out.println(user);
    }

1.实例方法创建对象 

//实例方法创建对象
    public User getUserInstance(){
        System.out.println("通过spring调用工厂中的静态方法创建3参User对象");
        return new User(2222,"唐三","123456");
    }

 2.配置文件

<!--  使用实例方法  -->
    <bean id="factory" class="com.lr.spring.factory.UserFactory"></bean>
    <bean id="user5" factory-bean="factory" factory-method="getUserInstance"></bean>

 3测试程序

   public void test02(){
        ApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
//        User user=(User) app.getBean("user4");
//        System.out.println(user);
        User user=(User) app.getBean("user5");
        System.out.println(user);
    }

 

4. 补充bean标签属性

init属性（初始化）       destroy属性（销毁）

    <bean id="user1" class="com.lr.spring.po.User" init-method="init" destroy-method="destory"></bean>

测试初始化

 测试销毁方法

ps：需要用到实现类，因为ApplicationContext没有close()方法

 public void test03(){
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
//        User user=(User) app.getBean("user4");
//        System.out.println(user);
        User user=(User) app.getBean("user5");
        System.out.println(user);
        app.close();//关闭Spring容器
    }
}

 

 

使用构造方法创建bean对象

两种方法

通过name属性

通过下标

<?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对象-->
    <bean id="user1" class="com.lr.spring.po.User">
        <constructor-arg name="id" value="1003"></constructor-arg>
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="password" value="123456"></constructor-arg>
    </bean>
    <bean id="user2" class="com.lr.spring.po.User">
        <constructor-arg name="id" index="0" value="1004"></constructor-arg>
        <constructor-arg name="name" index="1" value="李四"></constructor-arg>
        <constructor-arg name="password" index="2" value="654321"></constructor-arg>
    </bean>

</beans>

测试程序

 @Test
    public void test03(){
        ApplicationContext factory = new ClassPathXmlApplicationContext("application2.xml");
        User user01=(User) factory.getBean("user1");
        System.out.println(user01);
        User user02=(User) factory.getBean("user2");
        System.out.println(user02);
    }

测试结果




两种方法都能创建对象



DI：依赖注入



DI—Dependency Injection，即“依赖注入”



是组件之间依赖关系由容器在运行期决定



我们只需要通过 简单的配置，无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，不需要关心具体的资源来自何处，由谁实现？



 



加入数据访问层dao与业务层service



面向接口编程：减少因为Dao层的改变，对业务层代码的修改.



1.业务逻辑



以前我们常用的业务逻辑



//UserService 
package com.lr.spring.service;

public interface UserService {
    void addUser();
}



//UserDao 
package com.lr.spring.dao;

public interface UserDao {
    void addUser();
}



//UserServiceImpl 
import com.lr.spring.dao.UserDaoImpl;

public class UserServiceImpl implements UserService {
    private UserDaoImpl userDao = new UserDaoImpl();
    @Override
    public void addUser() {
        System.out.println("调用UserDao，插入User对象");
        userDao.addUser();
    }
}



//UserDaoImpl 

package com.lr.spring.dao;

public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("Dao中输入User对象");
    }
}




2.人为实现 DI注入



spring可以做到更完美的解耦合，令dao层的改动完全不影响service层，我们需要修改serviceinpl



这个方法就是DI注入



人为实现DI注入代码，有三种方法



第一种：set注入



package com.lr.spring.service;

import com.lr.spring.dao.UserDao;
import com.lr.spring.dao.UserDaoImpl;

public class UserServiceImpl implements UserService {
//    private UserDaoImpl userDao = new UserDaoImpl();
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void addUser() {
        System.out.println("调用UserDao，插入User对象");
        userDao.addUser();
    }
//通过set注入
    public static void main(String[] args) {
        UserServiceImpl userService=new UserServiceImpl();
        userService.setUserDao(new UserDaoImpl());
    }
}



Spring实现DI注入



第一种set注入






set 注入也叫设值注入是指，通过 setter 方法传入被调用者的实例。这种注入方式简单、直观，因而在 



Spring 的依赖注入中大量使用。



1.配置文件



<?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 name="userDao" class="com.lr.spring.dao.UserDaoImpl"></bean>
      <bean name="suerService" class="com.lr.spring.service.UserServiceImp
      <!--    property标签中的name参数跟set方法名字一一对应，跟属性名无关      -->
          <property name="userDao" ref="userDao"></property>
      </bean>

</beans>



 ps：property标签中的name参数跟set方法名字一一对应，跟属性名无关 



2.测试程序



@Test
    public void test04(){
        ApplicationContext factory = new ClassPathXmlApplicationContext("application3.xml");
        UserService userService=(UserService) factory.getBean("userService");
        userService.addUser();
    }






 



第二种：通过构造方法注入 



构造注入是指，在构造调用者实例的同时，完成被调用者的实例化。使用构造器设置依赖关系。



<!--  构造方法注入  -->
<!-- constructor-arg标签中的name参数跟构造方法中的参数名字名字一一对应，跟属性名无关 -->
    <bean name="userService" class="com.lr.spring.service.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>



 



结果一模一样



ps：constructor-arg标签中的name参数跟构造方法中的参数名字名字一一对应，跟属性名无关



扩展 



新增两个dao实现类，我们使用set注入的方式



package com.lr.spring.dao;

public class UserMySQLDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("MySQLDa");
    }
}




package com.lr.spring.dao;

public class UserOracleDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("OracleDao");
    }
}




配置文件 



<bean name="userDao" class="com.lr.spring.dao.UserDaoImpl"></bean>
      <bean name="userMySQLDao" class="com.lr.spring.dao.UserMySQLDaoImpl"></bean>
      <bean name="userOracleDao" class="com.lr.spring.dao.UserOracleDaoImpl"></bean>

      <bean name="userService" class="com.lr.spring.service.UserServiceImpl">
        <property name="userDao" ref="userMySQLDao"></property>
      </bean>



 



如果我们的数据库换成MySQL只需修改配置文件property标签ref属性值为userMySQLDao即可。



第三种：自动注入 



对于引用类型属性的注入，也可不在配置文件中显示的注入。可以通过为标签 



设置 autowire 属性值，为引用类型属性进行隐式自动注入（默认是不自动注入引用类型属 性）。根据 



自动注入判断标准的不同，可以分为两种： 



byName：根据名称自动注入，跟set方法中的方法名对应






byType： 根据类型自动注入，跟属性的类型对应（只有一个的时候使用）



 



 


                

        

    

    
  



    



                



	

		

			

				
					
Spring IOC（控制反转）的概念、原理与应用场景

				
			

			

				

					shangjg3的博客
				

				

					05-23
					
					126
					
				

			

		

		

			
				
通过 Spring IOC，我们可以将这些服务的创建和注入交给 Spring 容器管理，使得订单服务无需关心其他服务的具体实现和创建过程，降低了系统的耦合度，提高了系统的可维护性和可扩展性。在实际开发中，我们应根据项目的具体需求，合理运用 Spring IOC，充分发挥 Spring 框架的优势，打造出高质量、可维护的应用程序。通过 Spring IOC，我们可以将插件定义为 Bean，在系统启动时由 Spring 容器加载和管理这些插件，并根据配置将插件注入到相应的模块中，实现插件的动态加载和使用。

			
		

	



                

            
              



	

		

			

				
					
Spring控制反转（IoC）

					
最新发布

				
			

			

				

					qq_46735055的博客
				

				

					04-23
					
					521
					
				

			

		

		

			
				
Spring容器管理Bean的生命周期，包括Bean的创建、初始化、使用和销毁。Spring的IoC（Inversion of Control，控制反转）是Spring框架的核心概念之一，它通过依赖注入（Dependency Injection，DI）实现。传统的程序中，对象的创建和管理由程序代码直接控制，而在IoC容器中，对象的生命周期由容器控制。当应用程序启动时，Spring容器会读取Bean的定义，并根据这些定义创建和管理Bean的实例。的实例，并通过依赖注入的方式将实例注入到客户类中。

			
		

	



              


  
              

                


	

		

			

				
					
SpringIOC控制反转

				
			

			

				

					weixin_46098984的博客
				

				

					07-17
					
					225
					
				

			

		

		

			
				
框架是一组功能，在功能的基础上构建应用程序spring理念就是粘合剂，将各种框架整合在一起spring核心就是AOP面向切面编程和IOC控制反转Spring框架是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean的方式控制反转IOC依赖倒置DI依赖注入将主动创建对象的方式反转为被动接受实现代码的解耦Spring框架的优点。...

			
		

	





	

		

			

				
					
什么是控制反转[转]

				
			

			

				

					weixin_34198797的博客
				

				

					03-17
					
					156
					
				

			

		

		

			
				
控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。 控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI。
 
起源
早在2004年，Martin Fowler就提出了“哪些方面的控制被反转了？”这个问题。他总结出是依赖对象的获得被反转了。基于这个结论，他为控制反转创造了一个更好的...

			
		

	



		

			
		



	

		

			

				
					
常用注解

				
			

			

				

					Major_S的博客
				

				

					10-26
					
					547
					
				

			

		

		

			
				
01-注解驱动的意义-注解开发的作用与弊端
02-常用注解-bean定义常用注解（定义，作用范围，生命周期）
03-常用注解-注解配置第三方资源（工厂加载bean的形式）
04-常用注解-属性注入常用注解
05-常用注解-加载properties文件中的属性
06-常用注解-纯注解驱动制作
07-常用注解-导入第三方资源对应的配置类
08-加载控制-bean加载控制

...

			
		

	





	

		

			

				
					
【spring教程】3.IoC容器概述

				
			

			

				

					我有满天星辰的博客
				

				

					02-24
					
					355
					
				

			

		

		

			
				
IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。

			
		

	





	

		

			

				
					
Spring框架IoC控制反转.pdf

				
			

			

				

					09-20
				

			

		

		

			
				
【Spring框架IoC控制反转】  一、Spring框架是什么  Spring框架是Java开发中的一款轻量级框架，诞生于2003年，旨在简化企业级应用的开发复杂性。Spring的核心理念包括控制反转（IoC）和面向切面编程（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基本概念和使用的测试...

			
		

	





	

		

			

				
					
Java仿Spring框架IOC控制反转利用反射简单实现(源码)

				
			

			

				

					12-11
				

			

		

		

			
				
Java中的控制反转（IOC，Inversion of Control）和Spring框架是现代企业级应用开发的核心概念。IOC使得应用程序的组件之间解耦，提高了代码的可测试性和可维护性。本篇文章将详细探讨如何通过反射机制来实现一个简单...

			
		

	





	

		

			

				
					
Spring-IOC 控制反转

				
			

			

				

					小凯的博客
				

				

					11-13
					
					449
					
				

			

		

		

			
				
IOC配置的三种方式
依赖注入的三种方式
@Autowired和@Resource以及@Inject等注解注入有何区别？


			
		

	





	

		

			

				
					
SpringIOC 控制反转

				
			

			

				

					一气道盟王富贵儿
				

				

					03-30
					
					269
					
				

			

		

		

			
				
一、相关概念

IOC: Inversion of Control(控制反转)是一种设计思想，就是容器控制应用程序所需要外部资源的创建和管理，然后将其反转给应用程序。反转是指获得依赖对象的方式反转了，由spring来负责控制对象的生命周期和对象间的关系。

IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）...

			
		

	





	

		

			

				
					
聊聊Spring的IoC（DI）

				
			

			

				

					yin_zh0522的博客
				

				

					09-22
					
					234
					
				

			

		

		

			
				
聊聊Spring的IoC（DI）

一、SpringIoC背景

IoC（控制反转），英文全称为 Inversion of Control ，最早由软件专家 Michael Mattson 提出，它是一种思想理论：借助“第三方”容器来实现对具有依赖关系对象之间的解耦，这个第三方容器就是IoC容器。而Spring在技术层面把这个思想做了很好的实现。

二、什么是IoC（控制反转）

那么什么是控制反转呢？从Java开发角度来想，在没有引入IoC容器前，我们如何处理对象之前的依赖问题的；如对象A依赖于对象B，在

			
		

	





	

		

			

				
					
Spring的ioc控制反转

				
			

			

				

					a604435713的博客
				

				

					11-01
					
					555
					
				

			

		

		

			
				
spring介绍
Spring的出现是为了取代EJB（Enterprise JavaBean）的臃肿、低效、脱离现实的缺点。
Spring致力于J2EE应用的各层（表现层、业务层、持久层）的解决方案，Spring是企业应用开发的“一站式”选择。
定义：
Spring是分层的JavaSE/EE应用一站式的轻量级开源框架（官网： http://spring.io/ ），以Ioc（Inverse of ...

			
		

	





	

		

			

				
					
Spring IOC--控制反转

				
			

			

				

					little_____white的博客
				

				

					07-16
					
					251
					
				

			

		

		

			
				
1.Spring IOC
IOC全称Inversion Of Control，被翻译成控制反转
控制反转是指程序中对象的获取方式发生反转，由最初的NEW方式
创建，转变为由第三方框架创建，注入（DI），它降低对象之间的
耦合度
Spring容器采用DI方式实现IOC控制，IOC是Spring框架的基础和
核心
DI全称是Dependency Injection，被翻译成依赖注入，依赖注入的
基本原...

			
		

	





	

		

			

				
					
spring的ioc控制反转

				
			

			

				

					ykallan的博客
				

				

					12-03
					
					162
					
				

			

		

		

			
				
控制反转(ioc)和依赖注入
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
控制反转：在类a...

			
		

	





	

		

			

				
					
Spring中的IOC（控制反转）

				
			

			

				

					m0_71013414的博客
				

				

					06-15
					
					672
					
				

			

		

		

			
				
DI（依赖注入）是一种实现IOC的一种方法，也有人认为DI只是IOC的另一种说法，没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序员自己控制，控制反转后，将对象的创建转移给了第三方，个人认为所谓的控制反转就是，获取依赖对象的方式反转了。采用XML方式配置Bean的时候，Bean的定义信息和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。@Component有几个衍生注解。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值