Spring之IOC与DI

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

Spring之IOC与DI


【概念】
什么是IOC?
Inversion of Control,即控制反转
将创建对象的控制权（控制），交给spring去创建并且管理（反转）
什么是DI?
Dependency Injection,即依赖注入
将创建好的对象通过注入维护关系
解释：
使用spring创建的对象，通常都是单例模式。假设有两个类是组合关系，类B是类A的成员变量，若我们要用到A中的B，那么是否要每一个A对象都实例化一个类B呢？当类A处于单例模式的时候效率最高的时候，这种做法是不合适的。
于是spring采用了注入，将处于单例模式的A注入到B中，从而提高效率。

【用法】
IOC和DI存在3种开发模式：

  1. 纯xml形式
  2. 半注解形式
  3. 全注解形式

其中，半注解模式 属于过渡期的产物，就不多做介绍了，重点介绍纯xml形式和全注解形式。
一、纯xml形式
1.新建maven项目
2.通过pom.xml导入相关依赖（所需的jar包）

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.neusoft</groupId>
  <artifactId>SpringDemo1</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>SpringDemo1</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>4.3.18.RELEASE</version>
	</dependency>
  </dependencies>
  <build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>${java.version}</source>
					<target>${java.version}</target>
					<encoding>${project.build.sourceEncoding}</encoding>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

3.创建测试类，包括Dao层的User,UserDao类
User.java

package com.neusoft.SpringDemo1.bean;

import org.springframework.stereotype.Repository;

@Repository
public class User {
	private String userName;

	public User() {
		System.out.println("constructor User");
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getUserName() {
		return userName;
	}
	
}

UserDao.java

package com.neusoft.SpringDemo1.Dao;

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

import com.neusoft.SpringDemo1.bean.User;

@Repository("ud")
public class UserDao {
	@Autowired
	private User user;
	public UserDao(){
		System.out.println("contructor UserDao");
	}
	public void setUser(User user) {
		this.user = user;
	}
	public User getUser() {
		return user;
	}
}

4.创建配置文件 app.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

		<bean name="userDao" class="com.neusoft.SpringDemo1.Dao.UserDao" scope="singleton">
			<property name="user" ref="user"></property>
		</bean>
		<bean name="user" class="com.neusoft.SpringDemo1.bean.User">
			<property name="userName" value="李四"></property>
		</bean>
				

</beans>

bean:创建对象
		id:给对象取名,从容器中拿的时候会用到
		class:类的全路径,用于给spring去反射生成对象
		scope:使用什么模式创建对象
			  singleton:单例
			  prototype:多例

property:给属性赋值
		name:属性名
		value:给普通属性赋值,int,String等等
		ref:给成员变量是对象赋值,其他引用对象
//value实现普通属性的注入
//ref实现引用对象的注入

5.测试

Test.java

package com.neusoft.SpringDemo1.Test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.neusoft.SpringDemo1.Dao.UserDao;
import com.neusoft.SpringDemo1.bean.User;

public class Test1 {
	public static void main(String[] args) {
		//获取配置文件信息
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("app.xml");
		//spring通过反射创建实例
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		//输出通过配置文件注入的String属性
		System.out.println(userDao.getUser().getUserName());
	}
}

一、全注解形式
1.新建maven项目
2.通过pom.xml导入依赖
3.创建配置文件app.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置自动扫包 -->
	<context:component-scan base-package="com.neusoft.SpringDemo1"/>
</beans>

4.创建测试类（使用注解配置bean,使用注解进行注入）

4.1 使用注解配置bean有4种形式：

  1. Component,注解在类上，上spring创建对象
  2. Respository,注解在dao层
  3. Service,注解在service层上
  4. Controller,注解在Controller层上（即servlet）

四种注解在效果上没有区别，只是语义不同，可提高代码可读性
若使用注解时，形式为：
@Component、@Respository、@Service、@Controller,则其bean对象名字默认为类名首字母小写。
若采用@Respository(“test”),则其bean对象名字为设置内容。

4.2 注入有2种形式

  1. @Autowired,自动注入
  2. @Resorce

二者的区别：
Autowired是spring提供的注解，Resource是jdk提供的注解。
Autowired采用按类型注入，搭配@Qualifier(“name”)注解可以按名字注入
@Autowired(required = false)表示当找不到注入内容时，不必须注入，但会抛出空指针异常。
Resource按照属性名去注入，使用@Resource(“name”)可以按名字注入，找不到名字再按照类型注入
注意：当注入的属性为接口时，且其实现类有多个，必须要指定名字注入。

测试代码：
UserServlet.java

package com.neusoft.SpringDemo1.Controller;

import org.springframework.stereotype.Controller;

@Controller
public class UserServlet {
	public UserServlet(){
		System.out.println("constructor UserServlet");
	}
}

UserDaoInte.java

package com.neusoft.SpringDemo1.Dao;

public interface UserDaoInte {
	void add();
}

UserImpl1.java

package com.neusoft.SpringDemo1.Impl;

import org.springframework.stereotype.Repository;

import com.neusoft.SpringDemo1.Dao.UserDaoInte;
@Repository
public class UserImpl1 implements UserDaoInte{

	@Override
	public void add() {
		System.out.println("this is UserImpl1");
	}
	
}
//public class UserImpl1{
//
//	
//}

UserImpl2.java

package com.neusoft.SpringDemo1.Impl;

import org.springframework.stereotype.Repository;

import com.neusoft.SpringDemo1.Dao.UserDaoInte;
@Repository
public class UserImpl2 implements UserDaoInte{

	@Override
	public void add() {
		System.out.println("this is UserImpl2");
	}
	
}
//public class UserImpl2{
//
//	
//}

UserService.java

package com.neusoft.SpringDemo1.Service;

import javax.annotation.Resource;

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

import com.neusoft.SpringDemo1.Dao.UserDaoInte;

@Service
public class UserService {

//	@Autowired(required=false)
	@Autowired
	@Qualifier("userImpl1")
//	@Resource(name="userImpl2")
	private UserDaoInte userDaoInte;
	public UserService(){
		System.out.println("constructor UserService");
	}
	public void add(){
		userDaoInte.add();
	}
	public UserDaoInte getUserDaoInte() {
		return userDaoInte;
	}
	public void setUserDaoInte(UserDaoInte userDaoInte) {
		this.userDaoInte = userDaoInte;
	}
}

5.测试
Test2.java

package com.neusoft.SpringDemo1.Test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.neusoft.SpringDemo1.Controller.UserServlet;
import com.neusoft.SpringDemo1.Dao.UserDao;
import com.neusoft.SpringDemo1.Service.UserService;
import com.neusoft.SpringDemo1.bean.User;

public class Test2 {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("app.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("ud");
		UserService userService = (UserService) applicationContext.getBean("userService");
		UserServlet userServlet = (UserServlet) applicationContext.getBean("userServlet");
		userService.add();
	}
}

【补充内容】
一、MVC模式

  • M model: 数据模型,bean,dao,service（业务层）
  • V view:视图,jsp
  • C controller:控制器,负责前后台交互,servlet

调用模式：
controller调用service,service调用dao
spring框架中，
spring创建userService
spring创建userDao对象
并把userDao对象注入到userService的成员属性中

二、maven依赖
2.1 pom.xml:项目构建的配置文件，在此文件中描述编译版本,所依赖的jar包等等信息,maven负责给你做依赖（即导入）
2.2 当maven中存在依赖传递 a --> b --> c
导入a时，b、c也都会导入

三、spring配置文件中对象的加载
spring配置文件中的所有对象默认在spring调用时全部实例化（无论使用xml还是标注）
但是，可以对其设置懒加载，在使用时再进行实例化。

喜鹊先生Richard
关注
专栏目录
请简述什么是spring的ioc和di_Spring中的IoC与DI的理解
weixin_30099989的博客
12-28 1792
1.IoC是什么？IoC(Inversion of Control)控制反转，IoC是一种新的Java编程模式，目前很多轻量级容器都在广泛使用的模式。2.IoC解决了什么问题？在IoC出现以前，组件之间的协调关系是由程序内部代码来控制的，或者说，以前我们使用New关键字来实现两组间之间的依赖关系的。这种方式就造成了组件之间的互相耦合。IoC(控制反转)就是来解决这个问题的，它将实现组件间的关系从程...
请简述什么是spring的ioc和di_理解Spring中的IoC和DI
weixin_42497593的博客
12-28 3120
什么是IoC和DIIoC(Inversion of Control 控制反转)：是一种面向对象编程中的一种设计原则，用来减低计算机代码之间的耦合度。其基本思想是：借助于“第三方”实现具有依赖关系的对象之间的解耦。DI(Dependence Injection 依赖注入)：将实例变量传入到一个对象中去(Dependency injection means giving an object its i...
Spring IOC 和 DI详解
m0_61876562的博客
04-22 1237
IOC 是Spring的核心思想。其实IOC在前面 Spring MVC 部分我们就已经用到了。代码部分，我们在类上添加@RestController 和 @Controller 注解, 就是把这个对象交给Spring管理Spring 框架启动时就会加载该类。把对象交给Spring管理, 就是IoC思想。IOC: Inversion of Control (控制反转), 也就是说 Spring 是一个"控制反转"的容器.什么是控制反转呢?也就是控制权反转。什么的控制权发生了反转?
spring中IoC和DI浅析
ldcaws的专栏
08-16 1063
IoC和DI都是spring框架中的重要概念，通常也是成对出现的，下面对IoC和DI及其关系进行简单分析。
Spring——IoC和DI
浪漫不死的博客
03-02 3603
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
Spring--IoC与DI
qq_33807380的博客
03-21 1095
IoC（Inversion of Control，控制反转）是Spring框架的核心部分，是一个设计模式，它允许将对象的创建和依赖关系的管理从应用程序代码中分离出来，交给外部容器处理。这种模式的核心思想是“控制”的反转，即由传统的由对象自己创建依赖转变为由外部容器在运行时注入依赖。IoC容器是Spring框架中实现IoC概念的核心组件，主要负责实例化、配置和组装应用程序中的对象，并管理它们的生命周期。
SpringIOC/DI详解
qq_63688997的博客
07-19 1197
SpringIOC/DI详细讲述，概念，包含内容实例化bean常用注解实现方式等等。
Spring IoC & DI（笔记）
最新发布
LHY537200的博客
07-30 881
什么是容器？生活中的水杯,垃圾桶,冰箱等等这些都是容器，我们接触的容器有哪些?List/Map->数据存储容器Tomcat-> Web 容器。什么是IoC？IoC是Spring的核⼼思想，其实IoC我们在前⾯已经使⽤了,我们在前⾯讲到,在类上⾯添加@RestController和@Controller 注解。就是把这个对象交给Spring管理,Spring框架启动时就会加载该类.把对象交给Spring管理,就是IoC思想.
Spring IOC&DI
zhuge_long的专栏
05-31 1100
Resource注解与@Autowired注解的作用是一样的，都是用来为bean对象注入值的，唯一的区别是@Resource注解要根据实例化的bean名称为bean对象注入值。@Resource(name = “userDaoImpl2”)//name属性设置注入对象的属性名，如果属性名和name注入的名称一致的，name可以不赋值。Spring5.0开始，倡导以注解方式完成对象的管理，如果对象无法使用注解，就将对象交给spring的配置统一管理，而不再推荐使用xml配置的方式！
spring IOC和DI 理解
zhang2383906154的博客
11-15 2866
IOC(控制反转)和DI（依赖注入）是spring中的重要组成部分，下面是个人的一些理解，不代表官方。 1、IOC是什么？ IOC:全名是Inversion of Controller 中文解释是控制反转，不是什么技术，是一种设计思想。在java开发中IOC意味着你设计好的对象交给容器控制，而不是传统的在你对象内部直接控制。如何理解好IOC那？理解IOC的关键是要明确：“谁控制谁”、“控制什么”、为何是反转（有反转就应该有正转）哪些方面反转了，我们来分析一下： 1）谁控制谁，控制什么：传统的java
spring核心IOC以及DI
01-21
【Spring核心IOC以及DI】是Spring框架中的关键概念，它们是Spring实现控制反转（Inversion of Control，简称IOC）和依赖注入（Dependency Injection，简称DI）的基石。这两个概念是Spring框架的核心，使得应用程序的...
Spring之IOC和DI(三)
01-21
(九)DI的概念和作用 (十)构造函数注入 (十一)set方法注入 (十二)注入复杂类型数据 (十三)业务层实现类调用持久层的方法 (一)IOC的概念和作用 IOC：Inversion of Control，是控制反转的意思 我们之前想new谁就new谁，...
Spring IOC和DI实现原理及实例解析
08-19
依赖注入（DI）是指IoC容器在运行期间，动态地将某种依赖关系注入到对象之中。例如，将对象B注入（赋值）给对象A的成员变量。 IoC与DI的实现可以通过setter方法注入和构造方法注入两种方式实现。setter方法注入是指...
SpringBoot打jar包失败问题解决（无主清单属性或无依赖文件）
Cactus_Lrg的博客
12-02 764
一、问题背景 使用maven对SpringBoot项目打jar包，jar包无法正常运行，出现如下问题： 问题1： xxx.jar中没有主清单属性 问题2： Error: A JNI error has occurred, please check your installation and try again Caused by: java.lang.ClassNotFoundException: XXX 表面上报错是找不到依赖包的某一类，实际上解压jar包发现相关依赖并没有打进去 二、问题解决
SpringBoot项目，配置Redis多数据源
Cactus_Lrg的博客
06-08 500
一、maven依赖 Springboot版本: 1.5.6.RELEASE <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!--多数据源--> <depend
Spring高级话题-@Enable*注解的工作原理
Cactus_Lrg的博客
12-09 471
一、@Enable*注解的工作原理 我们通过使用@Enable*来开启某一项功能的支持，从而避免配置大量大麦，降低使用难度 通过观察源码，@Enable*注解都使用了@Import注解，@Import是用来导入配置类的，这就意味着@Enable*的实现是通过导入了一些自动配置的Bean来实现的 二、导入配置方式的三种类型 1. 直接导入配置类 如：@EnableScheduling @Ta...
Spring常用配置 - EL及使用资源文件
Cactus_Lrg的博客
10-15 344
一、Spring EL是什么？ Spring表达式语言，支持在xml和注解中使用表达式，类似于JSP的el表达式语言。 二、怎么使用？ Spring主要在 @Value注解 使用表达式， 实现资源的注入。 可以注入包括以下内容： 普通字符 操作系统属性 表达式运算结果 其他Bean的属性 文件内容 网址内容 属性文件 三、ELDemo 一个憨憨的Bean package com.cac...
Spring 概述
Cactus_Lrg的博客
10-11 312
一、Spring概述 The Spring Framework is an application framework and inversion of control container for the Java platform. The framework’s core features can be used by any Java application, but there are ...
理解Spring的IOC与DI原理
Spring框架的核心概念之一就是IOC（Inversion of Control，控制反转）或DI（Dependency Injection，依赖注入）。这两者在实际应用中是密切相关的，可以说是同一概念的不同表述方式。理解Spring的IOC/DI原理是深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喜鹊先生Richard

随缘~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值