Spring中IOC容器

已于 2022-12-09 14:41:18 修改
阅读量937 收藏 3
点赞数 1
分类专栏： spring 文章标签： java spring mybatis
于 2022-12-09 14:39:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bubbleJessica/article/details/128245344
版权

IOC入门案例思路分析

1.管理什么（Service和Dao）

2.如何将管理的对象存放到IOC容器（配置applicationContext.xml）第二步

3.将管理的对象存放到IOC容器，如何获取IOC容器 第三步

4.获取到IOC容器后，如何从容器中获取bean（即管理的对象）第四步

5.使用Spring导入坐标（pom.xml）第一步

基本内容

package com.huhu.dao;

public interface BookDao {
    void save();
}


package com.huhu.dao.impl;

import com.huhu.dao.BookDao;

public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("Bookdao save ....");
    }
}

package com.huhu.service;

public interface BookService {
    void save();
}

package com.huhu.service.impl;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao=new BookDaoImpl();
    public void save() {
        System.out.println("BookService save ....");
        bookDao.save();
    }
}

第一步：导入坐标

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

第二步：配置bean

  <bean id="bookDao" class="com.huhu.dao.impl.BookDaoImpl"/>

  <bean id="bookService" class="com.huhu.service.impl.BookServiceImpl"/>

第三步：获取IOC容器和 第四步：获取bean 

package com.huhu;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        System.out.println();
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

实现结果： 

 

DI 入门案例

基本内容与上面差不多，唯一修改的就是BookServiceImpl类

package com.huhu.service.impl;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("BookService save ....");
        bookDao.save();
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

bean配置 ref中bookDao与bookDaoImpl类注入bean定义id属性值bookDao一致

    <bean id="bookDao" class="com.huhu.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.huhu.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>

 测试结果依旧不变

bean起别名添加name属性 

获取bean可以使用name属性值也可以id属性值（建议id）

<bean id="bookDao" name="dao" class="com.huhu.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.huhu.service.impl.BookServiceImpl">
        <property name="bookDao" ref="dao"/>
    </bean>

bean作用范围配置默认单例

package com.huhu;

import com.huhu.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        BookDao bookDao2 = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        System.out.println(bookDao2);
    }
}

修改单例的话在配置文件编辑scope域=prototype

<bean id="bookDao" name="dao" class="com.huhu.dao.impl.BookDaoImpl" scope="prototype"/>

    <bean id="bookService" class="com.huhu.service.impl.BookServiceImpl">
        <property name="bookDao" ref="dao"/>
    </bean>

 

bean创建方式

第一种：默认无参构造方法（可不写） （private也可以被调用使用反射）一旦加了有参就必须写上无参构造方法

<bean id="bookDao" name="dao" class="com.huhu.dao.impl.BookDaoImpl"/>
public class BookDaoImpl implements BookDao {
    private BookDaoImpl(int i){
        System.out.println("Bookdao constructor is running...");
    }
    public void save() {
        System.out.println("Bookdao save ....");
    }
}

没有无参构造方法后，报错Caused by: java.lang.NoSuchMethodException: com.huhu.dao.impl.BookDaoImpl.<init>() 

第二种：静态工厂 （早期使用最多，了解即可）（基本内容如下）

package com.huhu.dao;

public interface OrderDao {
    void save();
}

package com.huhu.dao.impl;

import com.huhu.dao.OrderDao;

public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("OrderDao save ...");
    }
}

package com.huhu.factory;

import com.huhu.dao.OrderDao;
import com.huhu.dao.impl.OrderDaoImpl;

public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

package com.huhu;

import com.huhu.dao.OrderDao;
import com.huhu.factory.OrderDaoFactory;

public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();
    }
}

使用静态工厂实例化bean

<!--使用静态工厂实例化bean-->
    <bean id="orderDao" class="com.huhu.factory.OrderDaoFactory" factory-method="getOrderDao"/>
package com.huhu;

import com.huhu.dao.OrderDao;
import com.huhu.factory.OrderDaoFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
//        OrderDao orderDao = OrderDaoFactory.getOrderDao();
//        orderDao.save();

        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
        orderDao.save();
    }
}

 

第三种：实例工厂 （基本内容如下） 

package com.huhu.dao;

public interface UserDao {
    void save();
}

package com.huhu.dao.impl;

import com.huhu.dao.UserDao;

public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("UserDao save ...");
    }
}

package com.huhu.factory;

import com.huhu.dao.UserDao;
import com.huhu.dao.impl.UserDaoImpl;

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

package com.huhu;

import com.huhu.dao.UserDao;
import com.huhu.factory.UserDaoFactory;

public class AppForInstanceUser {
    public static void main(String[] args) {
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();
    }
}

 使用实例工厂实例化bean

<!--使用实例工厂实例化bean-->
    <bean id="userFactory" class="com.huhu.factory.UserDaoFactory"/>
    <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
package com.huhu;

import com.huhu.dao.UserDao;
import com.huhu.factory.UserDaoFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceUser {
    public static void main(String[] args) {
//        UserDaoFactory userDaoFactory = new UserDaoFactory();
//        UserDao userDao = userDaoFactory.getUserDao();
//        userDao.save();

        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

 

优化创建UserDaoFactoryBean类代替UserDaoFactory类（实用）

package com.huhu.factory;

import com.huhu.dao.UserDao;
import com.huhu.dao.impl.UserDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    //获取对象类型
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

<!--使用FactoryBean实例化bean-->
    <bean id="userDao" class="com.huhu.factory.UserDaoFactoryBean"/>

bean生命周期 

暴力关闭容器（实际开发不使用）

package com.huhu.dao.impl;

import com.huhu.dao.BookDao;

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("Bookdao save ....");
    }

    public void init(){
        System.out.println("init ...");
    }

    public void destroy(){
        System.out.println("destroy ...");
    }
}

<bean id="bookDao" name="dao" class="com.huhu.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>
ClassPathXmlApplicationContext子类型替代ApplicationContext父类型，才可关闭容器
package com.huhu;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("dao");
        bookDao.save();
        ctx.close();
    }
}

 设置关闭钩子（哪个位置都可以）在虚拟机退出前先关闭容器在退出虚拟机

package com.huhu;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("dao");
        bookDao.save();
//        ctx.close();
        ctx.registerShutdownHook();
    }
}

优化篇实现接口（了解即可）

<bean id="bookService" class="com.huhu.service.impl.BookServiceImpl">
        <property name="bookDao" ref="dao"/>
    </bean>
package com.huhu.service.impl;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void save() {
        System.out.println("BookService save ....");
        bookDao.save();
    }

    public void setBookDao(BookDao bookDao) {
        System.out.println("set...");
        this.bookDao = bookDao;
    }

    public void destroy() throws Exception {
        System.out.println("BookService destroy ...");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("BookService init ...");
    }
}

package com.huhu;

import com.huhu.dao.BookDao;
import com.huhu.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("dao");
        bookDao.save();
//        ctx.close();
        ctx.registerShutdownHook();
    }
}

结果如下：

总结：初始化容器

步骤：1创建对象 2执行构造方法 3执行属性注入（set）4执行bean初始化方法 

使用bean：执行业务操作

关闭/销毁容器：执行bean销毁方法（容器关闭前触发bean的销毁）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  bubbleJessica
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    3
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
详解Spring IOC 容器启动流程分析

				
			

			

				

					08-25
				

			

		

		

			
				
BeanFactory 是 IOC 容器的操作工具，它提供了许多方法来操作容器中的 Bean，例如 getBean() 方法和 containsBean() 方法。  Spring IOC 容器的启动流程是一个复杂的过程，它涉及到许多步骤和组件。...

			
		

	



                

              
                



	

		

			

				
					
获取Spring IOC容器对象：

				
			

			

				

					qq_45525848的博客
				

				

					02-25
					
					1055
					
				

			

		

		

			
				
获取Spring IOC容器对象

			
		

	



                


  
              

                


	

		

			

				
					
如何手动获取spring/springboot中的IOC容器（全局上下文对象）？

				
			

			

				

					siaok的博客
				

				

					11-08
					
					2280
					
				

			

		

		

			
				
众所周知，在Spring框架中的全局上下文对象通常被称为ApplicationContext。这是Spring容器的一种表现形式，负责管理和控制应用程序中的对象（Bean）。它本质上维护了Bean的定义以及对象间的协作关系。当项目运行时，ApplicationContext会自动装载所有在Handler中的信息到内存。此外，Spring上下文也是一种配置文件，能向Spring框架提供上下文信息。

			
		

	





	

		

			

				
					
获取 IOC 容器的用途包括：

					
最新发布

				
			

			

				

					m0_75115621的博客
				

				

					04-08
					
					106
					
				

			

		

		

			
				
IOC 容器通过依赖注入的方式，将对象之间的依赖关系注入到对象中，从而实现了松耦合的设计。开发人员可以专注于编写业务逻辑，而不用关心对象之间的依赖关系，提高了代码的灵活性和可测试性。IOC 容器负责管理对象的生命周期，包括对象的创建、初始化、使用和销毁。这样可以确保对象的生命周期得到合理管理，避免因为对象生命周期管理不当而引起的问题。通过 IOC 容器，可以将对象的配置信息集中管理在配置文件中，而不是分散在代码中。这样可以避免手动管理对象的创建和销毁，提高了代码的简洁性和可维护性。

			
		

	



		

			
		



	

		

			

				
					
Spring BeanFactory、ApplicationContext IOC 容器获取与使用

				
			

			

				

					蚩尤后裔-汪茂雄
				

				

					08-03
					
					3705
					
				

			

		

		

			
				
目录

BeanFactory ( IOC 容)概述

BeanFactoryAware

ApplicationContextAware

BeanFactory ( IOC 容)概述

1、org.springframework.beans.factory.BeanFactory 是一个 Factory（工厂），也就是 IOC 容器/对象工厂，Spring 中所有的 bean 都是由 Bean...

			
		

	





	

		

			

				
					
Springboot获取IOC容器的方式

				
			

			

				

					GuYan的博客
				

				

					08-13
					
					5534
					
				

			

		

		

			
				
在Springboot项目中如果要获取IOC容器目前有两种方法。
方法一（不实用，不推荐）：
 在Springboot项目中都会存在一个SpringApplication的启动类，我们通过以下代码启动IOC容器。
    其实run方法会将创建的IOC容器作为返回值返回，那么我们就可以通过声明一个ApplicationContext对象来接收run方法的返回值。
    但是，使用这种方法会遇到各种各样的问题，所以我们通常使用第二种方法。

			
		

	





	

		

			

				
					
获取IOC容器对象总结

				
			

			

				

					weixin_40695328的博客
				

				

					03-27
					
					1316
					
				

			

		

		

			
				
在项目中如果不能直接autowired依赖注入的时候(例如利用了其他框架的监听器)，需要自己注入IOC容器，来获取容器管理的bean对象，以下总结了两个个方法~
方法1
ContextLoaderListener 监听器在服务器启动的时候会监听ServletContext对象的创建，去创建IOC容器对象，并且将IOC容器对象放在Application域中
所以可以通过以下方式获取
	Applica...

			
		

	





	

		

			

				
					
Spring为IOC容器注入Bean的五种方式详解

				
			

			

				

					08-25
				

			

		

		

			
				
Spring为IOC容器注入Bean的五种方式详解   Spring 框架中，IOC（Inverse of Control，控制反转）容器是核心组件之一，用于管理 Bean 的生命周期。在 Spring 中，IOC 容器可以通过五种方式来注入 Bean，本文将对这五...

			
		

	





	

		

			

				
					
Spring中的IoC容器

				
			

			

				

					02-24
				

			

		

		

			
				
所以在程序开发中应该尽量的降低耦合，提高内聚。也就是设计原则中的开闭原则和单一职责原则。工厂模式就是用来解决程序间耦合的一种设计模式。可以把所有要创建的对象放在工厂的一个集合里，当需要使用这个对象的...

			
		

	





	

		

			

				
					
spring在IoC容器中装配Bean详解

				
			

			

				

					08-28
				

			

		

		

			
				
Spring 在 IoC 容器中装配 Bean 详解  Spring 框架中的 IoC 容器是一个核心组件，它提供了 Bean 的装配、管理和依赖注入等功能。在 Spring 框架中，IoC 容器是 Bean 的容器，负责创建、管理和装配 Bean。在本文中，...

			
		

	





	

		

			

				
					
Spring创建IOC容器的方式解析

				
			

			

				

					08-25
				

			

		

		

			
				
主要介绍了Spring创建IOC容器的方式解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

			
		

	





	

		

			

				
					
Spring中IoC优点与缺点解析

				
			

			

				

					08-28
				

			

		

		

			
				
IoC(Inversion of Control)是 Spring 框架中的一种设计模式，它的主要思想是将对象的创建和管理交给容器，从而解耦合对象之间的依赖关系。今天，我们将详细解析 IoC 的优点和缺点。  优点  1. 简化对象的创建：IoC ...

			
		

	





	

		

			

				
					
Spring实现一个简单的SpringIOC容器

				
			

			

				

					08-30
				

			

		

		

			
				
本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。  首先，控制反转是一种设计模式，它将对象的创建和管理从对象本身转移到一个外部容器，即IOC容器。Spring的IOC容器通过读取配置文件（如...

			
		

	





	

		

			

				
					
Spring-ioc容器

				
			

			

				

					02-26
				

			

		

		

			
				
ioc容器的理解与使用

			
		

	





	

		

			

				
					
手写一个SpringIoc容器

				
			

			

				

					04-12
				

			

		

		

			
				
本项目"手写一个SpringIoc容器"旨在模仿Spring的IOC（Inversion of Control，控制反转）功能，帮助开发者深入理解Spring的工作原理，提升对依赖注入（Dependency Injection）模式的认识。  在实现自定义的Spring IOC...

			
		

	





	

		

			

				
					
spring中ioc是什么

				
			

			

				

					08-29
				

			

		

		

			
				
在 Spring 框架中，IoC 容器是通过 ApplicationContext 来实现的。ApplicationContext 是 Spring 框架的核心接口，提供了 bean 的创建、装配和生命周期管理等功能。  在使用 IoC/DI 容器时，需要准备的工具包括 ...

			
		

	





	

		

			

				
					
Spring之IOC容器（带你一篇文章搞定IOC）

				
			

			

				

					浩泽学编程的博客
				

				

					07-24
					
					1030
					
				

			

		

		

			
				
Spring框架的核心就是IOC和AOP，本篇文章就讲述一下其中的IOC容器。（这是听尚硅谷课程总结的）IOC是控制反转的意思。使用对象时候由主动new对象转换成由外部提供对象,此过程中对象的创建权由程序转移到外部，这种思想叫做控制反转。即把对象创建和对象的调用过程交给spring进行管理。目的：降低耦合度。底层原理：xml配置，反射，工厂模式。Spring提供IOC容器两种实现方式（两个接口）（1）BeanFactory：Spring内部使用的接口，不提倡开发人员使用。

			
		

	





	

		

			

				
					
6.spring框架-----容器的创建方式 Bean的获取方式 BeanFactory的使用

				
			

			

				

					qq_46235384的博客
				

				

					10-27
					
					483
					
				

			

		

		

			
				
ApplicationContext要想成为延迟加载，在配置文件中 添加。使用BeanFactory来创建IOC容器。

			
		

	





	

		

			

				
					
012-Spring DAO 数据访问对象

				
			

			

				

					这个需求，做不了
				

				

					07-28
					
					339
					
				

			

		

		

			
				
数据源
JDBC数据源DriverManagerDataSource
主要参数如下：

jdbcDriver：jdbc驱动
url：数据库连接
username：用户名
password：密码

DBCP数据源BasicDataSource
该数据源依赖于 commons-dbcp.jar， commons-pool对象池机制的数据库连接池。BasicDataSource提供了close()方法关闭数据源，所以必须设定destroy-method=”close”属性， 以便Spring容器关闭时，数据源能够

			
		

	





	

		

			

				
					
Spring的ioc容器

				
			

			

				

					05-14
				

			

		

		

			
				
Spring的IoC容器是Spring框架的核心，它负责管理应用程序中的对象，即在应用程序运行期间动态地将对象组装起来，形成一个完整的应用程序。  Spring的IoC容器通过读取配置文件或注解，创建对象并将它们注入到应用程序...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值