Spring中IOC容器

已于 2022-12-09 14:41:18 修改
阅读量1k 收藏 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容器注入Bean的五种方式详解

				
			

			

				

					08-25
				

			

		

		

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

			
		

	



                

              
                



	

		

			

				
					
Spring中的IoC容器

				
			

			

				

					02-24
				

			

		

		

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

			
		

	



                


  
              

                


	

		

			

				
					
Spring之IOC容器

				
			

			

				

					tq02的博客
				

				

					03-28
					
					1112
					
				

			

		

		

			
				
本文讲解的SpringIoc的知识点，对比传统代码，SpringIoc的优点，通过控制反转，如何获取Bean的两种方法，以及配置的xml文件

			
		

	





	

		

			

				
					
JAVA-Spring中IOC容器是什么？

				
			

			

				

					向诸位大佬虚心学习
				

				

					08-17
					
					940
					
				

			

		

		

			
				
本文主要为各位佬介绍了Spring中IOC和IOC容器

			
		

	



		

			
		



	

		

			

				
					
Spring之IoC容器篇

				
			

			

				

					kissship的博客
				

				

					08-17
					
					945
					
				

			

		

		

			
				
Spring是一个开源的应用程序开发框架，它由Rod Johnson创建，主要用于构建企业级Java应用程序。它提供了一个全面的编程和配置模型，可以简化Java开发过程，提高开发效率和可维护性。即为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，

			
		

	





	

		

			

				
					
spring中ioc容器与aop之间的关系

				
			

			

				

					qq_43517448的博客
				

				

					12-26
					
					1588
					
				

			

		

		

			
				
spring中ioc容器与aop之间的关系
​		spring的ioc 容器中默认都是原生对象，只有通过aop增强的对象才是代理对象。
配置了aop的类或者类中方法上有@Transactional注解的（因为@Transactional注解的原理就是基于aop的）。
​		当出现了aop增强，在ioc容器当中的对象是代理的对象，但里面的属性对象为null，
代理对象如何调用该对象中的方法呢？
​		使用的生成代理对象之前的target对象，该对象里面其他对象属性就有值，不会出现空指针，
问题1：
​	自身调

			
		

	





	

		

			

				
					
Spring中IOC容器初始化过程解析

				
			

			

				

					踩踩踩从踩的博客
				

				

					12-22
					
					1783
					
				

			

		

		

			
				
本篇文章主要解析spring框架ioc容器初始过程，包含启动过程中，涉及到的一些类，ApplicationContext继承体系，以及各个部分涉及到的一部分功能，BeanFactory继承体系 对比着之前设计的ioc上差别部分，功能更加全面；本篇文章主要是解析其源码，而不是单纯的记那是那里，而是理解设计思路才是最重要的。

			
		

	





	

		

			

				
					
什么是Spring IOC容器

				
			

			

				

					hefangxuxing的博客
				

				

					05-16
					
					4442
					
				

			

		

		

			
				
SpringIoc的介绍

			
		

	





	

		

			

				
					
Spring中IOC容器概念作用及其基本应用

				
			

			

				

					qq_44286009的博客
				

				

					06-13
					
					505
					
				

			

		

		

			
				
spring学习

			
		

	





	

		

			

				
					
一文搞懂 Spring 中的 IOC 容器到底是什么

				
			

			

				

					Z99263的博客
				

				

					06-03
					
					1183
					
				

			

		

		

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

			
		

	





	

		

			

				
					
Spring中IOC容器常用的接口和具体的实现类。

				
			

			

				

					weixin_44050355的博客
				

				

					10-27
					
					1664
					
				

			

		

		

			
				
1. BeanFactory  SpringIOC容器的基本设置，是最底层的实现， 面向框架本身的.
2. ApplicationContext  BeanFactory的子接口, 提供了更多高级的特定. 面向开发者的.
3. ConfigurableApplicationContext, ApplicationContext的子接口，扩展出了 close 和 refresh等 关闭 刷新容器的方法
4.ClassPathXmlApplicationContext：从classpath的XML配置文件中读取

			
		

	





	

		

			

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

				
			

			

				

					08-25
				

			

		

		

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

			
		

	





	

		

			

				
					
spring在IoC容器中装配Bean详解

				
			

			

				

					08-28
				

			

		

		

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

			
		

	





	

		

			

				
					
golang 接口

				
			

			

				

					m0_70982551的博客
				

				

					07-24
					
					952
					
				

			

		

		

			
				
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。

			
		

	





	

		

			

				
					
Swagger使用Map接受参数时，页面如何显示具体参数及说

				
			

			

				

					a1058926697的博客
				

				

					07-26
					
					516
					
				

			

		

		

			
				
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。

			
		

	





	

		

			

				
					
springboot之自动装配

				
			

			

				

					weixin_50153914的博客
				

				

					07-23
					
					648
					
				

			

		

		

			
				
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。

			
		

	





	

		

			

				
					
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比

					
最新发布

				
			

			

				

					訾博（ZiBo）的博客
				

				

					07-27
					
					595
					
				

			

		

		

			
				
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。

			
		

	





	

		

			

				
					
Java代码基础算法练习-数的特性-2024.07.25

				
			

			

				

					Sakurapaid的博客
				

				

					07-25
					
					367
					
				

			

		

		

			
				
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;

			
		

	





	

		

			

				
					
深入理解Spring：IOC容器解析

				
			

			

				

					
				

			

		

		

			
				
"深入理解Spring框架的源代码分析，包括IOC容器的核心概念和功能"  Spring框架是Java开发中广泛使用的轻量级应用框架，它的核心特性之一是Inversion of Control（控制反转，简称IOC）。在Spring中，IOC容器是整个...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值