什么是spring && ioc（控制反转/依赖注入）

亣柒

已于 2022-06-01 15:06:45 修改

阅读量491

点赞数 1

分类专栏： spring 文章标签： spring java 后端

于 2021-10-22 12:48:53 首次发布

本文链接：https://blog.csdn.net/m0_58525944/article/details/120889868

版权

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、什么是spring，它能够做什么?

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

通俗来讲，其他框架能做的，spring也能做，spring有全家桶这一概念，因为它旗下有很多框架，能代替很多框架（如下框架今年来慢慢被spring所取代）

架构方案层面
spring struts Hibernate
spring springmvc mybatis
springboot   dubbox
SpringCloud

技术层面
安全技术方面：Shiro   springSecurity
数据库层面：hibernate、mybatis   SpringDataJpa
消息中间件：activityMQ、RabbitMQ、kaffka   spring..MQ

中间层框架、万能胶                容器框架
struts2 JavaBean   项目中的一个个类
spring    IOC和AOP
hibernate

如图：便于理解spring框架

spring包含的模块

2、什么是控制反转(或依赖注入)

控制反转（IoC=Inversion of Control）IoC：

用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。
IoC还有一个另外的名字：“依赖注入 (DI=Dependency Injection)” ，即由容器动态的将某种依赖关系注入到组件之中

通俗理解：

作用：创建对象，处理对象的依赖关系。

使用IOC：比如我们去找房子，我们不需要自己一个一个去看，去找，IOC相当于一个中介，管理着很多房子，我们提出自己的需求就行，然后中介给我们相对应的房子，我们直接使用就行。

一、IOC的具体体现

1/1，导入jar包，pom.xml中配置

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lgs</groupId>
  <artifactId>T269LGS_spring</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>T269LGS_spring Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
	<properties>
		<spring.version>5.0.1.RELEASE</spring.version>
		<javax.servlet.version>4.0.0</javax.servlet.version>
		<junit.version>4.12</junit.version>
	</properties>
  
	<dependencies>
        <dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
		<!-- 2、导入spring依赖 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- 5.1、junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>
		<!-- 5.2、servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${javax.servlet.version}</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
	
  <build>
    <finalName>T269LGS_spring</finalName>
    <plugins>
    	<plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.7.0</version>
         <configuration>
             <source>1.8</source>
             <target>1.8</target>
             <encoding>UTF-8</encoding>
         </configuration>
    	</plugin>
    </plugins>
  </build>
  
</project>

1/2，创建spring的配置文件spring-context.xml文件

1/3，写一个接口类UserBiz.java

package com.lgs.ioc.biz;

public interface UserBiz {

//	上传功能
	public void upload();
	
}

IOC展示分析：

假设做一个上传功能
现在提出整改要求：1，限定上传文件大小 2，限定上传文件类别

现在有几个版本的要求：
action1 不需要加限制 action2 需要加限制

假设你有开发一个游戏，原版本action1不需要加限制，当你开发出了一个新功能，需要更新版本action2，如果更新给游戏其他功能带来问题，我们需要要回到上一个版本，这是IOC的功能就体现出来了

总结：1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险

1/4，写UserBiz.xml的实现类UserBizImpl1.java实现基础功能

package com.lgs.ioc.biz.impl;

import com.lgs.ioc.biz.UserBiz;

public class UserBizImpl1 implements UserBiz{

	/**
	 * 假设做一个上传功能
	 *   现在提出整改要求：
	 * 1，限定上传文件大小	2，限定上传文件类别
	 * 
	 * 现在有几个版本的要求：
	 * action1 不需要加限制
	 * action2  需要加限制
	 * 
	 * 假设你有开发一个游戏，原版本action1不需要加限制，当你开发出了一个新功能，需要更新版本action2，
	 * 如果更新给游戏其他功能带来问题，我们需要要回到上一个版本，这是IOC的功能就体现出来了
	 * 
	 * 总结：1.更新版本需要改动原有代码	2.相关调用此方法的模块伴随着巨大风险
	 * 
	 */
	
	public void upload() {
		System.out.println("按要求开发功能");
	}
	
}

1/5，写UserBiz.xml的实现类UserBizImpl2.java实现优化性能功能

package com.lgs.ioc.biz.impl;

import com.lgs.ioc.biz.UserBiz;

public class UserBizImpl2  implements UserBiz{

	public void upload() {
		System.out.println("做条件判断，加限定，不符合要求的不给予上传");
		System.out.println("按要求开发功能");
	}
	
}

1/6，UserAction1、UserAction2、UserAction3 三个类是一样的，方便测试

package com.lgs.ioc.web;

import com.lgs.ioc.biz.UserBiz;
import com.lgs.ioc.biz.impl.UserBizImpl1;

public class UserAction1 {

	private UserBiz userBiz;
	
	public UserBiz getUserBiz() {
		return userBiz;
	}

	public void setUserBiz(UserBiz userBiz) {
		this.userBiz = userBiz;
	}

	public void upload() {
		userBiz.upload();
	}
	
	public static void main(String[] args) {
		UserAction1 userAction = new UserAction1();
		userAction.upload();
	}
}

1/7、PersonAction

package com.lgs.ioc.web;

import com.lgs.ioc.biz.UserBiz;

public class PersonAction {
	
	private UserBiz userBiz;
	
	public UserBiz getUserBiz() {
		return userBiz;
	}

	public void setUserBiz(UserBiz userBiz) {
		this.userBiz = userBiz;
	}

	public void upload() {
		userBiz.upload();
	}
	
	public static void main(String[] args) {
		PersonAction personAction = new PersonAction();
		personAction.upload();
	}
}

1/8、spring-context配置文件

<?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"
	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-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

<!-- 本文件中配置整个项目中包含的所有的JavaBean，目的在于spring项目的统一管理 -->

<!-- <bean name="userBiz1" class="com.lgs.ioc.biz.impl.UserBizImpl1"></bean> -->
<bean name="userBiz2" class="com.lgs.ioc.biz.impl.UserBizImpl1"></bean>
<bean name="userBiz1" class="com.lgs.ioc.biz.impl.UserBizImpl2"></bean>

<bean name="personAction" class="com.lgs.ioc.web.PersonAction">
	<property name="userBiz" ref="userBiz2"></property>
</bean>

<bean name="userAction1" class="com.lgs.ioc.web.UserAction1">
	<property name="userBiz" ref="userBiz1"></property>
</bean>
<bean name="userAction2" class="com.lgs.ioc.web.UserAction2">
	<property name="userBiz" ref="userBiz1"></property>
</bean>
<bean name="userAction3" class="com.lgs.ioc.web.UserAction3">
	<property name="userBiz" ref="userBiz1"></property>
</bean>

</beans>

1/9、测试IocTest

package com.lgs.ioc.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lgs.ioc.web.PersonAction;
import com.lgs.ioc.web.UserAction1;
import com.lgs.ioc.web.UserAction2;
import com.lgs.ioc.web.UserAction3;

public class IocTest {

	public static void main(String[] args) {
//		建模
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
//		可以得到任意bena
		PersonAction personAction = (PersonAction) applicationContext.getBean("personAction");
		personAction.upload();
		
		UserAction1 userAction1 = (UserAction1) applicationContext.getBean("userAction1");
		userAction1.upload();
		
		UserAction2 userAction2 = (UserAction2) applicationContext.getBean("userAction2");
		userAction2.upload();
		
		UserAction3 userAction3 = (UserAction3) applicationContext.getBean("userAction3");
		userAction3.upload();
	}
	
}

运行结果：

如果需要要求要userBizImpl1的版本：那么只需要在此处改一下就好了

运行结果：

总结：

假如我们要换一个功能，则需要修改很多地方，很繁琐，IOC解决了此问题，userAction和OrderAction是实现不同的功能，都用了UserBiz属性去调用后台代码的方法，只需要在配置的时候进行修改即可。

解决以下两点风险：

1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险

二，spring传参

IOC的传参的三种方式

1、ser传参

2、构造传参

3、自动装配（基本不用）

1、ser传参新建实体类，自定义传参（一定要get/set方法）

输出方法：

spring-context配置文件
<bean name="paramAction" class="com.lgs.ioc.web.ParamAction">
	<property name="name" value="鲁迅"></property>
	<property name="age" value="34"></property>
	<property name="hobby">
		<list>
			<value>学医</value>
			<value>白话文学</value>
			<value>作家</value>
		</list>
	</property>
</bean>
调用：

运行结果：

2、构造传参

建立有参无参构造

spring-context配置文件
<bean name="paramAction" class="com.lgs.ioc.web.ParamAction">
	<constructor-arg name="name" value="武则天"></constructor-arg>
	<constructor-arg name="age" value="22"></constructor-arg>
	<constructor-arg name="hobby">
		<list>
			<value>跳舞</value>
			<value>唱歌</value>
			<value>当皇帝</value>
		</list>
	</constructor-arg>
</bean>
调用：

运行结果：

三、spring与Tomcat整合

为什么要利用Tomcat整合？

每一次在网页上发送一个请求时，都要访问后台，然后建模，我们不可能每次都要建模，建模也是非常消耗性能的，所以我们现在的处理方式就是利用Tomcat整

3/1、建立监听器 SpringLoaderListener

package com.lgs.ioc.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringLoaderListener implements ServletContextListener{

	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("监听器方法执行》》》》");
		ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-context.xml");
		
		sce.getServletContext().setAttribute("SpringContext", applicationContext);
	}
	
}

3/2、配置监听器 web.xml

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
  <display-name>Archetype Created Web Application</display-name>
<listener>
	<listener-class>com.lgs.ioc.listener.SpringLoaderListener</listener-class>
</listener>
</web-app>

3/3、servlet进行测试 Userservlet

package com.lgs.ioc.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.ApplicationContext;

import com.lgs.ioc.web.ParamAction;

@WebServlet("/user")
public class Userservlet extends HttpServlet{

	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		ApplicationContext springContext = (ApplicationContext) req.getServletContext().getAttribute("SpringContext");
		ParamAction paramAction = (ParamAction) springContext.getBean("paramAction");
		paramAction.execute();
	}
	
}

测试结果：

OK！到这就结束了，希望能帮到你！！

亣柒

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
什么是spring && ioc（控制反转/依赖注入）

一、什么是spring，它能够做什么?Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。目的：解决企业应用开发的复杂性功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能范围：任何Java应用简单来说，Spring是一.
复制链接

扫一扫