Spring之ioc

最新推荐文章于 2024-06-21 09:54:19 发布
最新推荐文章于 2024-06-21 09:54:19 发布
阅读量113 收藏
点赞数 1
分类专栏： struts,hibernate,spring，shiro 文章标签： spring java 后端 控制反转（依赖注入） spring传参
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53436351/article/details/120941616
版权

目录

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

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

案例：实现Spring的IoC做一个上传的功能，普通写法和spring写法的区别

(1)普通写法

(2)spring写法

3，Spring传参

 四、spring与tomcat的整合

1、监听器：SpringLoaderListener实现 ServletContextListener接口

2、web.xml中配置监听器

3、测试及结果

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

spring tool suite官方下载地址：http://spring.io/tools/sts/all

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

spring是中间层框架、万能胶，将其他框架包裹进来

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

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

案例：实现Spring的IoC做一个上传的功能，普通写法和spring写法的区别

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

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

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

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

代码演示如下：

使用的相关类：

接口

package com.ltf.ioc.biz;

public interface UserBiz {
	public void upload();
}

(1)普通写法

第一个版本（原始版本）写UserBiz.xml的实现类UserBizImpl1.java实现基础功能

package com.ltf.ioc.biz.impl;

import com.ltf.ioc.biz.UserBiz;

/**
 * 功能：上传功能
 * 提出整改
 * 1，限定上传文件大小  2.限定上传文件类别
 * 总结：
 * 1，更新版本需要改动原有代码
 * 2，相关调用此方法的模块伴随着巨大的风险
 * 
 *action1   需要加限制
 *action2   不需要加限制

 * @author zjjt
 *
 */
public class UserBizImpl1 implements UserBiz{

	@Override
	public void upload() {
		System.out.println("循规蹈矩的把功能开发出来");
	}

}

 第二个版本（更新后版本）写UserBiz.xml的实现类UserBizImpl2.java实现优化性能功能

package com.ltf.ioc.biz.impl;

import com.ltf.ioc.biz.UserBiz;

public class UserBizImpl2 implements UserBiz{

	@Override
	public void upload() {
		System.out.println("做条件判断加限定，文件太大了不能上传");
		System.out.println("循规蹈矩的把功能开发出来");
	}

}

假设有两个模块要使用（一个本模块，一个关联模块）

UserAction ：

package com.ltf.ioc.web;

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

public class UserAction {
	private UserBiz userBiz = new UserBizImpl1();

	public void upload() {
		userBiz.upload();
	}

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

PersonAction ：

package com.ltf.ioc.web;

import com.ltf.ioc.biz.UserBiz;
import com.ltf.ioc.biz.impl.UserBizImpl2;

public class PersonAction {
	private UserBiz userBiz = new UserBizImpl2();

	public void upload() {
		userBiz.upload();
	}

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

如果有100个需要整改模块，那就需要改100次原有代码（繁琐）；

同时，相关调用此方法的模块伴随巨大的风险；

(2)spring写法

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.ltf</groupId>
	<artifactId>spring01</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring01 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>spring01</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>

2，resourse目录下导入xsd文件（spring-context.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"
    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的统一管理-->

</beans>

3，新建测试类对spring-context.xml进行建模

package com.ltf.ioc.test;

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

import com.ltf.ioc.web.PersonAction;

public class IocTest {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
//		Object bean = applicationContext.getBean("personAction");强转如下
		PersonAction personAction =(PersonAction) applicationContext.getBean("personAction");
		personAction.upload();
	}
}

4，修改action并进行配置

spring-context.xml中提供依赖利用property的name属性为PersonAction中用到的UserBiz赋值

<bean name="personActipon" class="com.ltf.ioc.web.PersonAction.java">
  <property name="userBiz" ref="userBiz2"></property>
 </bean>

同时需要修改 PersonAction，为UserBiz属性提供get set方法

package com.ltf.ioc.web;

import com.ltf.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();
	}
}

 这样private UserBiz userBiz的userBiz 就和spring-context.xml中的相对应

5，IocTest类测试结果如下：

如果版本出现问题，要切回原来的版本，只需要修改ref的参数即可

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

UserAction、UserAction2、UserAction3  三个类是一样的，方便测试

package com.ltf.ioc.web;

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

public class UserAction {
    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) {
        UserAction userAction = new UserAction();
        userAction.upload();
    }
}

 配置spring-context.xml

    <bean name="userAction" class="com.ltf.ioc.web.UserAction">
        <property name="userBiz" ref="userBiz1"></property>
    </bean>
    <bean name="userAction2" class="com.ltf.ioc.web.UserAction2">
        <property name="userBiz" ref="userBiz1"></property>
    </bean>
    <bean name="userAction3" class="com.ltf.ioc.web.UserAction3">
        <property name="userBiz" ref="userBiz1"></property>
    </bean>

 IocTest类测试结果如下：又回到了第一个版本

 开发时一个接口一个实现类，不同模块不同需求时才会一个接口多个实现类

假如需要更新直接修改配置就可以了，不用修改原有代码，实现一次修改多次使用；

3，Spring传参

三种传参方式：

1.set传参

2.构造传参

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

set传参

package com.ltf.ioc.web;

import java.util.List;

public class ParamAction {
	private int age;
	private String name;
	private List<String> hobby;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List<String> getHobby() {
		return hobby;
	}

	public void setHobby(List<String> hobby) {
		this.hobby = hobby;
	}

	public void execute() {
		System.out.println(this.age);
		System.out.println(this.name);
		System.out.println(this.hobby);

	}
}

    <bean name="ParamAction" class="com.ltf.ioc.web.ParamAction">
        <property name="name" value="sb"></property>
        <property name="age" value="20"></property>
        <property name="hobby">
            <list>
                <value>吃吃吃</value>
                <value>睡睡睡</value>
                <value>胖胖胖</value>
            </list>
        </property>
    </bean>

 

 构造传参

package com.ltf.ioc.web;

import java.util.List;

public class ParamAction {
	private int age;
	private String name;
	private List<String> hobby;

	public ParamAction() {
		super();
	}

	public ParamAction(int age, String name, List<String> hobby) {
		super();
		this.age = age;
		this.name = name;
		this.hobby = hobby;
	}

	public void execute() {
		System.out.println(this.age);
		System.out.println(this.name);
		System.out.println(this.hobby);

	}
}

<bean name="ParamAction" class="com.ltf.ioc.web.ParamAction">  
         
        <constructor-arg name="name" value="sb"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>吃吃吃</value>
                <value>睡睡睡</value>
                <value>胖胖胖</value>
            </list>
        </constructor-arg>
    </bean>

 四、spring与tomcat的整合

假如spring-context.xml中配置了几百个类，测试建模的时间过程非常久；

javabean每建一次模，时间就越久，性能就越差；

这行代码会执行很久，所以说这行代码在项目中只能执行一次，将他放到监听器中

建模存在代码性能问题，那么只能存在一次
通过监听器的方式，保障整个过程中只有一次建模

1、监听器：SpringLoaderListener实现 ServletContextListener接口

package com.ltf.ioc.listener;

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

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

public class SpringLoaderListenner implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("监听方法执行。。。。。。");
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
        sce.getServletContext().setAttribute("SpringContext", applicationContext);
    }
}

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.ltf.ioc.listener.SpringLoaderListerer</listener-class>
</listener>


</web-app>
 

3、测试及结果

①、测试UserServlet

package com.ltf.ioc.web;

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 org.springframework.context.support.ClassPathXmlApplicationContext;

@WebServlet("/user")
public class UserServlet extends HttpServlet {
    @Override
    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();
    }
}
 

 ②、结果：监听器只会执行一次，结果可执行多次

小宝的宝呢
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring之IOC详解
08-31
Spring之IOC详解 IOC（Inversion of Control，控制反转）是一种重要的面向对象编程法则，用于削减计算机程序的耦合问题。它是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection...
IOC是什么？
weixin_33966365的博客
06-03 145
2019独角兽企业重金招聘Python工程师标准>>> ...
依赖注入和控制反转
隋旭峰的专栏
08-08 500
链接：https://www.zhihu.com/question/23277575/answer/169698662 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 要了解控制反转( Inversion of Control ), 我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则（Dependency Inversion Principle
spring IOC的好处
ustcyy91的博客
06-06 2317
作者：Sevenvidia 链接：https://www.zhihu.com/question/23277575/answer/169698662 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 要了解控制反转( Inversion of Control ), 我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则（Dependency Inver
Spring中的IOC原理解释-来自知乎
风暴计划
10-22 495
Spring IOC详解 一、Spring IOC详解 1、Spring IOC详解： https://www.zhihu.com/question/23277575/answer/24259844
Spring之IOC示例
04-19
NULL 博文链接：https://huangminwen.iteye.com/blog/1041298
Spring中IoC优点与缺点解析
08-28
Spring 中 IoC 优点与缺点解析 IoC(Inversion of Control)是 Spring 框架中的一种设计模式，它的主要思想是将对象的创建和管理交给容器，从而解耦合对象之间的依赖关系。今天，我们将详细解析 IoC 的优点和缺点。 ...
简单理解Spring之IOC和AOP及代码示例
08-28
Spring之IOC和AOP详解 Spring是一个开源框架，主要实现两件事，IOC（控制反转）和AOP（面向切面编程）。在本文中，我们将详细了解Spring之IOC和AOP，及其代码示例。 一、IOC（控制反转） IOC控制反转，也可以...
spring_ioc
06-04
这是spring_ioc部分的内容。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
02_01_SpringMVC初识
XQ_898878888的博客
06-15 974
SpringMVC是Spring框架的一部分，是基于Java实现MVC设计模式的轻量级Web框架。
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
最新发布
gb4215287的博客
06-21 64
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
Spring IOC 控制反转（注解版）
Dreadnaught的博客
06-17 627
Spring 框架中的核心概念之一就是控制反转（Inversion of Control，IoC）。IOC就是一种思想，而依赖注入(Dependency Injection, DI)是控制反转的一种实现方式。Spring本身是一个容器，存的是对象。对象这个词，在 Spring的范围内，称之为 Bean。控制反转（Inversion of Control，IoC）是一种设计原则，它将对象的创建和依赖关系的管理从程序代码中解耦出来，交由框架或容器进行处理。
springboot与flowable（9）：候选人组
游王子的博客
06-15 294
act_id_xxx相关表存储了所有用户和组的数据。
小白快速入门之SpringBoot面向切面编程（AOP）
weixin_42415173的博客
06-18 144
AOP、切面编程、SpringBoot
【尚庭公寓SpringBoot + Vue 项目实战】移动端项目初始化（十九）
小林的博客
06-20 422
由于**common模块**中配置了**MinioClient**这个Bean，并且**web-app模块**依赖于**common模块**，因此在启动**AppWebApplication**时，SpringBoot会创建一个MinioClient实例，但是由于**web-app模块**的application.yml文件中并未提供MinioClient所需的参数（**web-app模块**暂时不需要使用MinioClient），因此MinioClient实例的创建会失败。
springboot“漫画之家”系统 LW+PPT+源码
u014445459的博客
06-17 846
链接：https://pan.baidu.com/s/1ihILTui-XEFdC15mcOB0vA?pwd=ewry提取码：ewry由于本系统是作为毕业设计系统，且系统本身存在一些技术层面的缺陷，并不能直接用于商业用途，只想要通过该系统的开发提高自身学术水平，不需要特定服务器等额外花费。所有创造及工作过程仅需在个人电脑上就能实现，使用到的软件大多为开源软件，所以经济成本并不高，可以轻易实现。
SpringCloud与Dubbo区别？
余十步的博客
06-14 241
dubbo与springcloud都可以使用分布式、微服务场景下。Dubbo目前已经停止更新,SpringCloud更新速度快。dubbo与springcloud都可以实现RPC远程调用。springcloud使用eureka作为注册中心。Springcloud是一套完整的微服务解决方案。dubbo支持多种协议，默认使用dubbo协议。dubbo有比较强的背景,在国内有一定影响力。dubbo使用zk或redis作为作为注册中心。Springcloud只能支持http协议。
【SpringBoot】SpringBoot：实现文件上传和下载功能
Easonmax的博客
06-15 833
在现代应用中，用户需要上传各种类型的文件，如图片、文档、视频等，或者下载生成的报告和数据文件。SpringBoot通过其强大的生态系统和简化的配置，能够高效地实现文件上传和下载功能。在完成文件上传和下载功能的开发后，应该进行充分的测试，确保所有功能都能正常工作。通过这种方式，可以确保应用的各个部分在开发过程中得到充分的测试，减少上线后的问题。通过本文的介绍，我们了解了如何使用SpringBoot实现文件上传和下载。为了方便管理上传的文件，我们需要在项目中配置文件存储的位置。这将文件上传目录设置为。
1958springboot VUE宿舍管理系统开发mysql数据库web结构java编程计算机网页源码maven项目
qq_251836457的博客
06-20 952
(3)生活习惯信息管理：对系统分配宿舍基本依据，系统把每个生活习惯进行整数编码，爱学习（11），爱音乐（22），这样为了后续算法自定分配宿舍做好基础数据。(5)宿舍分配管理：系统主要包括自动分配，和手动分配两部分功能，系统自动分配宿舍，根据学生的生活习惯，结合顺序表算法进行挨个宿舍进行分配。需要源码 其他的定制服务 下方联系卡片↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 或者私信作者。(1)人员信息：主要包括对管理员，学生用户信息进行维护，主要包括对学生用户信息、可以自主的维护信息操作。
Spring的IOC
08-12
- *1* *3* [Spring之IOC概念](https://blog.csdn.net/Q_J_B/article/details/128067666)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小宝的宝呢

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值