Spring IOC详细用法

最新推荐文章于 2024-06-12 23:20:19 发布
最新推荐文章于 2024-06-12 23:20:19 发布
阅读量692 收藏
点赞数
分类专栏： Spring 文章标签： spring ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Victor_Cindy1/article/details/50013585
版权

1.    简介

IOC-全称Inversion of Control，中文解释：控制反转。另外，IOC又称DI(全称)Dependency Injection，中文解释：依靠注入。

2.     注入类型

a)setter（重要）

b)构造方法（可以忘记）

c)接口注入（可以忘记）

3.     id vs. name

a)name可以用特殊字符

4.简单属性的注入

a)<property name=… value=…>

5.<bean 中的scope属性

a)singleton 单例

b)proptotype 每次创建新的对象

6.集合注入

a)很少用，不重要！参考程序

7.自动装配

a)byName

b)byType

c)如果所有的bean都用同一种，可以使用beans的属性：default-autowire

8.生命周期

a)lazy-init (不重要)

b)init-method destroy-methd 不要和prototype一起用（了解）

9.Annotation第一步：

a)修改xml文件，参考文档<context:annotation-config />

10.@Autowired

a)默认按类型by type

b)如果想用byName，使用@Qulifier

c)写在private field（第三种注入形式）（不建议，破坏封装）

d)如果写在set上，@qualifier需要写在参数上

11.@Resource（重要）

a)加入：j2ee/common-annotations.jar

b)默认按名称，名称找不到，按类型

c)可以指定特定名称

d)推荐使用

e)不足：如果没有源码，就无法运用annotation，只能使用xml

12.@Component @Service @Controller @Repository

a)初始化的名字默认为类名首字母小写

b)可以指定初始化bean的名字

以下是详细测试代码，部分代码已经被注释，方便测试

xml测试：

1、model

package dhp.model;

public class User {
	private String username;
	private String password;
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

2、dao 

package dhp.dao;

import dhp.model.User;

public interface UserDao {
	public void save(User user);
}

3、daoimpl 

package dhp.dao.impl;

import java.util.List;
import java.util.Map;
import java.util.Set;

import dhp.dao.UserDao;
import dhp.model.User;

public class UserDaoImpl implements UserDao {
	private int daoId;
	//private String daoStatus;
	
	public int getDaoId() {
		return daoId;
	}

	public void setDaoId(int daoId) {
		this.daoId = daoId;
	}

	/*public String getDaoStatus() {
		return daoStatus;
	}

	public void setDaoStatus(String daoStatus) {
		this.daoStatus = daoStatus;
	}
  */
	private Set<String> sets;
	private List<String> lists;
	private Map<String, String> maps;
	
	public Set<String> getSets() {
		return sets;
	}
	public void setSets(Set<String> sets) {
		this.sets = sets;
	}
	public List<String> getLists() {
		return lists;
	}
	public void setLists(List<String> lists) {
		this.lists = lists;
	}
	public Map<String, String> getMaps() {
		return maps;
	}
	public void setMaps(Map<String, String> maps) {
		this.maps = maps;
	}
	@Override
	public void save(User user) {
		System.out.println("user saved!");
		//System.out.println("daoId:==="+daoId+"daoStatus:==="+daoStatus);
	}
	@Override
	public String toString() {
		
		/*return "sets size:" + sets.size() + "| lists size:" + lists.size() + 
				"| maps size:" + maps.size();*/
		return "daoId:"+daoId;
	}

}

4、service 

package dhp.service;

import dhp.dao.UserDao;
import dhp.model.User;

public class UserService {
	private UserDao userDao;
	//构造方法注入
	/*public UserService(UserDao userDao) {
		super();
		this.userDao = userDao;
	}*/
	
	public void init(){
		System.out.println("=========init");
	}
	
	public void add(User user){
		userDao.save(user);
	}
	public UserDao getUserDao() {
		return userDao;
	}
	//set方式注入
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	public void destroy(){
		System.out.println("==========destroy");
	}
}

5、test 

package dhp.service;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dhp.dao.UserDao;
import dhp.model.User;

public class UserServiceTest {

	@Test
	public void testAdd() {
		
	   //ClassPathXmlApplicationContext继承自ApplicationContext，而ApplicationContext继承自BeanFactory
		//推荐使用
		//创建IOC容器
		ClassPathXmlApplicationContext ctx =new ClassPathXmlApplicationContext("beans.xml");
		//从IOC容器中得到bean的对象实例
		UserService userService = (UserService) ctx.getBean("userService");
	
		//UserService userService2 = (UserService) ctx.getBean("userService");
		//System.out.print("验证singleton和prototype：");
		//System.out.println(userService==userService2);//为 true，说明我们取出的是同一个对象
		
		ctx.destroy();   //destroy必须手动指定，因为web环境下会自动destroy，必须是ClassPathXmlApplicationContext,不会监控prototype，只会监控singleton
		
		
		/*BeanFactory applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");*/
		
		User user = new User();
		user.setUsername("dhp");
		user.setPassword("123456");
		
		userService.add(user);
		
		
		//测试collection
		/*UserDao userDao = (UserDao) ctx.getBean("userDao");
		System.out.println(userDao);*/
		
		//测试byName和byType
		System.out.println("=========="+userService.getUserDao());
		
	}

}

6、beans.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"
            >
            <!-- 放在beans里面 -->
<!-- default-lazy-init="default"全局不启动 --> 
<!-- default-autowire="default" 全局的自动注入-->

  <bean id="userDao" class="dhp.dao.impl.UserDaoImpl"><!-- id也可以写出name， 只不过name是可以支持特殊字符的 -->
  <!-- 简单属性注入，很少使用 -->
      <!-- <property name="daoId" value="10"></property>
      <property name="daoStatus" value="working"></property> -->
      
      <!-- 集合 -->
 <!--<property name="sets"> 相当于调用了setSets(Set<String> sets)
          <set>
             <value>1</value>
             <value>2</value>
          </set>
      </property>
      
      <property name="lists">相当于调用了setLists(List<String> lists)
          <list>
             <value>A</value>
             <value>B</value>
             <value>C</value>
          </list>
      </property>
      
      <property name="maps"> 相当于调用了setMaps(Map<String, String> maps)
          <map>
             <entry key="1" value="map1"></entry>
             <entry key="2" value="map2"></entry>
             <entry key="3" value="map3"></entry>
             <entry key="4" value="map4"></entry>
          </map>
      </property> -->
      
      <!-- <property name="">
           <props>
              <prop key="">...</prop>
              <prop key="">...</prop>
              <prop key="">...</prop>
           </props>
      </property> -->
      <property name="daoId" value="100"></property>
      
  </bean>

  <bean id="userDao2" class="dhp.dao.impl.UserDaoImpl" lazy-init="true"><!--设为true, new 的时候不启动 -->
      <property name="daoId" value="200"></property>
  </bean>
<!-- 自动注入时，不能有构造方法 -->
<!-- byName要求必须id和service里的属性一致 -->

<!-- byName:在容器中寻找和需要自动装配的属性名相同的Bean(或ID),如果没有找到相符的Bean,该属性就没有被装配上。 -->
<!-- byType:在容器中寻找一个与需要自动装配的属性类型相同的Bean;
         如果没有找到相符的Bean,该属性就没有被装配上,如果找到超过一个相符的Bean抛出异常 -->
<!-- constructor 与byType方式类似，不同之处在于它应用于构造器参数。
                                        如果容器中没有找到与构造器参数类型一致的bean，
                                        那么抛出异常。 -->
<!-- default: <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"
            default-autowire="default">
            -->                
   <!-- scope默认是 singleton -->
  <bean id="userService" class="dhp.service.UserService" scope="singleton" autowire="byName" init-method="init" destroy-method="destroy">
     <!-- 方式1.1 -->
     <!-- <property name="userDao" ref="userDao"></property> -->
     
     <!-- 方式1.2 -->
     <!-- <property name="userDao">
        <ref bean="userDao"/>
     </property> -->
     
     <!-- 方式2 -->
     <!-- <constructor-arg>
        <ref bean="userDao"/>
     </constructor-arg> -->
  </bean>

</beans>




       注解测试：

1、daoimpl

package dhp.dao.impl;

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.stereotype.Component;

import dhp.dao.UserDao;
import dhp.model.User;
@Component("userDaoImpl")
public class UserDaoImpl implements UserDao {
	private int daoId;
	//private String daoStatus;
	
	public int getDaoId() {
		return daoId;
	}

	public void setDaoId(int daoId) {
		this.daoId = daoId;
	}

	/*public String getDaoStatus() {
		return daoStatus;
	}

	public void setDaoStatus(String daoStatus) {
		this.daoStatus = daoStatus;
	}
  */
	private Set<String> sets;
	private List<String> lists;
	private Map<String, String> maps;
	
	public Set<String> getSets() {
		return sets;
	}
	public void setSets(Set<String> sets) {
		this.sets = sets;
	}
	public List<String> getLists() {
		return lists;
	}
	public void setLists(List<String> lists) {
		this.lists = lists;
	}
	public Map<String, String> getMaps() {
		return maps;
	}
	public void setMaps(Map<String, String> maps) {
		this.maps = maps;
	}
	@Override
	public void save(User user) {
		System.out.println("user saved!");
		//System.out.println("daoId:==="+daoId+"daoStatus:==="+daoStatus);
	}
	@Override
	public String toString() {
		
		/*return "sets size:" + sets.size() + "| lists size:" + lists.size() + 
				"| maps size:" + maps.size();*/
		return "daoId:"+daoId;
	}

}

2、service 

package dhp.service;

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

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

import dhp.dao.UserDao;
import dhp.model.User;

@Component("userService")
public class UserService {
	private UserDao userDao;
	//构造方法注入
	/*public UserService(UserDao userDao) {
		super();
		this.userDao = userDao;
	}*/
	@PostConstruct
	public void init(){
		System.out.println("=========init");
	}
	
	public void add(User user){
		userDao.save(user);
	}
	public UserDao getUserDao() {
		return userDao;
	}
	//set方式注入
	/*@Autowired//默认通过byType
	public void setUserDao(@Qualifier("userDao2") UserDao userDao) {
		this.userDao = userDao;
	}*/
	//@Resource(name="userDao2")//默认按名称，名称找不到时，通过byType
	@Resource(name="userDaoImpl") //name的指定配合@Component("userDaoImpl")的使用
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	@PreDestroy
	public void destroy(){
		System.out.println("==========destroy");
	}
}

3、test 

package dhp.service;

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import dhp.dao.UserDao;
import dhp.model.User;

public class UserServiceTest {

	@Test
	public void testAdd() {
	   //ClassPathXmlApplicationContext继承自ApplicationContext，而ApplicationContext继承自BeanFactory
		//推荐使用
		ClassPathXmlApplicationContext ctx =new ClassPathXmlApplicationContext("beans.xml");
		UserService userService = (UserService) ctx.getBean("userService");
		
		userService.add(new User());
		System.out.println(userService.getUserDao());
		
		ctx.destroy();
	}

}

4、beans.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"
        xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">
         
  <!--  初始化了AutowiredAnnotationBeanPostProcessor, CommonAnnotationBeanPostProcessor,
     PersistenceAnnotationBeanPostProcessor,RequiredAnnotationBeanPostProcessor -->
     
<context:annotation-config/> <!-- 初始化4个 -->       <!-- @autowired, @resource -->
<context:component-scan base-package="dhp"/>     <!-- 扫描@Component @Service @Controller @Repository 减少bean配置  -->

  <!-- <bean id="userDao" class="dhp.dao.impl.UserDaoImpl">
     <property name="daoId" value="100"></property>
  </bean>
  
   <bean id="userDao2" class="dhp.dao.impl.UserDaoImpl">
      <property name="daoId" value="200"></property>
   </bean> -->

 <!--  <bean id="userService" class="dhp.service.UserService">

  </bean>
 -->
</beans>


附：

1.bean的自动装配和自动检测的区别

启用注解装配，在xml配置文件里添加：<context:annotation-config/>

启用自动扫描注解，在xml配置文件里添加：<context:component-scan base-package="dhp"/>

二者的区别： 自动装配表示通过@Autowired, @Inject, @Resource等实现对属性或构造函数的自动注入；仍然需要在配置文件里定义bean，只是通过

自动装配省去了property和constructor-arg的配置。 自动检测是扫描特定的注解（包括：@Component, @Controller, @Service, @Repository)，将注

解过的类自动定义为bean，自动检测是自动装配的超集，通过自动检测，可以省去在xml配置文件里定义bean了。


2. 通过自动装配和注解实现注入

在xml配置文件里启动注解装配：<context:annotation-config/>

定义bean：

<bean id="userDao" class="dhp.dao.impl.UserDaoImpl">
     <property name="daoId" value="100"></property>
  </bean>

然后在需要注入的属性上或者其setter方法上，或者构造函数上，添加@Autowired, @Inject, @Resource等注解实现自动注入：

//set方式注入
//@Autowired
       //@Inject
       @Resource
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

@Autowired, @Inject, @Resource的区别：@Autowired是Spring 3.0的注解，是通过byType形式实现注解，可以通过@Qualifier根据bean的id进行限定；使用@Autowired注解即引入了对Spring的依赖。@Inject是JSR 330的注解，使用该注解需要导入包javax.inject，@Named(value=”“)可以根据bean的id进行限定；@Resource是JSR 250的注解，可以通过value限定bean的id，如@Resource(value=””);


西楚小羽的窝窝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中IOC详解
qq_41359998的博客
02-06 1万+
一、IOC的原型 IOC ----控制反转 比如我们有一个功能是获取用户数据，我们使用Dao层实现这个功能，再在Service层调用这个功能。但是我们每增加一个接口，比如获取mysql中的数据，就要修改原来的代码，如果再增加一个新的接口，又需要去service实现类中修改对应的实现。 解决方法 用户实际调用的是业务层，dao层他们不需要接触 UserServiceImpl userService = new UserServiceImpl(); userSe
springIoc实现原理
04-20
**Spring Ioc 实现原理详解** Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由...
Spring系列--IOC详解
qq_42194397的博客
11-25 2340
IOC笔记总结
第 2 章：Spring Framework 中的 IoC 容器
最新发布
Binge毕设
06-12 1571
在介绍 Spring Framework 的 IoC 容器前，我们有必要先理解什么是“控制反转”。控制反转是一种决定容器如何装配组件的模式。只要遵循这种模式，按照一定的规则，容器就能将组件组装起来。这里所谓的容器，就是用来创建组件并对它们进行管理的地方。它牵扯到组件该如何定义、组件该何时创建、又该何时销毁、它们互相之间是什么关系等——这些本该在组件内部管理的东西，被从组件中剥离了出来。
spring简介，IOC详解
PiggyOne123的博客
05-02 1288
Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用Spring 框架来创建性能好、易于测试、可重用的代码。Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。
Spring IoC实现及原理
Guo_Liwei的博客
07-01 2567
快速了解spring实现与底层原理
Spring的IOC和AOP原理
热门推荐
子冉冰清的博客
09-26 2万+
Spring的IOC和AOP原理 本文讲的是面试之Spring框架IOC和AOP的实现原理， IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所。 IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 AbstractApplicationContext 的 refresh 方法开始，详细分析 Spring IOC 容器的启动流程。 在 Spring 框架中，ApplicationContext 是 IOC 容器的...
SpringIOC DI循环依赖实例详解
08-24
在 getSingleton() 方法中，SpringIOC 使用 beforeSingletonCreation() 和 afterSingletonCreation() 两个方法来标记 Bean 的初始化过程。在 beforeSingletonCreation() 方法中，将 Bean 名称添加到 ...
实验四_SpringIoC.rar
04-13
在实际应用中，Spring IoC不仅可以管理简单的Java对象，还可以处理复杂的对象图，包括集合、工厂方法、原型Bean、接口实现等。此外，Spring的AOP（面向切面编程）特性也常与IoC结合使用，提供事务管理、日志记录等跨...
spring ioc
03-06
在提供的 "src" 压缩包文件中，如果包含的是 Spring 框架的源码，那么我们可以详细研究每个类和方法，了解 Spring 如何处理 Bean 的生命周期、解析配置、创建依赖关系等。这将帮助我们成为 Spring 框架的专家，更...
IOC的基本使用
Breese_的博客
05-14 428
控制反转（IOC，Inversion of Control）是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。以前我们在代码中，使用new 构造方法创建对象，现在不用了， 由容器代替开发人员管理对象。
【Spring】史上最全的spring IoC使用讲解
小七的博客
04-09 1069
一篇文章带小白快速上手Spring框架
后端-框架-Spring-IoC-property-设值注入
CaediosViolet的博客
10-28 182
后端-框架-Spring-IoC设值注入 预先写好spring的类 package cn.springdemo; public class HellowSpring { private String who; public String getWho() { return who; } //此处的setWho的who为xml中的name public void setWho(Str...
Spring IOC详细配置与使用
青元子的博客
06-08 1万+
前言：复习了解下Spring，顺便记录下这个过程以供日后翻阅。SpringIoc：    按照我个人的理解来说，SpringIOC（Inversion of Control）控制反转：指就是说原先在对象中要使用另一个对象就必须要显式的去创建另一个对象的实例，例如通过构造方法或者是调用工厂方法（工厂方法最终也是需要new，因为这是Java创建对象所必须的）来获得。而Spring提供了IOC容器来帮我...
Spring之IOC基本用法
mr_liM的博客
09-18 2426
声明：小弟最近正在学习spring下面内容是自己的一些理解，如果有不对的地方请及时留言告知，以免误导了后面的spring学习者，谢谢大家配合。 什么是spring： Spring是轻量级开源框架，以IOC（控制反转）和AOP（面向切面编程）为内核。 Spring的出现代替了ejb的臃肿、低效、脱离现实是什么： 简单点明：IOC控制反转：从容器的角度来说的，就是创建实例的工作交给容器管理。D
Spring框架的Ioc使用
wearewell258369的博客
06-02 224
文章目录一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('igno
Spring核心知识-Ioc简述（概念和使用）
weixin_42425732的博客
02-20 1623
spring核心两大核心内容为ioc和aop。 本章节讲ioc的概念、作用和使用方式。 ioc简单介绍： 概念：控制反转，把对象创建和对象之间的调用过程，交给Spring管理 目的是降低耦合 底层原理：xml解析、工厂模式、反射 .过程： 1 xml解析得到类的全路径 ApplicationContext applicationContext =new ClassPathXmlApplicationContext("bean.xml"); 2 通过反射创建对象 3
Spring的IOC容器使用方法（配置bean）
zzd的博客
05-12 959
因为最近疫情在家，家里又没有相关的书籍，所以只能通过网上的教学视频来学习相关技术。但是，看视频只是快速入门的好方法，并不能做到对技术的深入理解，要深入理解还是要看书。因此，本文就是对于如何使用Spring框架的介绍，说得比较浅显，深入的内容不多。 首先，说一下什么是Spring。 Spring 是什么 •Spring 是一个开源框架. •Spring 为简化企业级应用开发而生. 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能. •Spring 是一个 IO
深入理解Spring IOC容器及其实现
"Spring_IOC详解" Spring IOC（Inversion of Control，控制反转）是Spring框架的核心特性，它将对象的创建和组装过程从应用程序代码中解耦...掌握Spring IOC的概念和实现细节，是成为Spring框架熟练使用者的重要步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值