spring框架以及ioc概念和运用

最新推荐文章于 2023-01-03 19:49:08 发布
最新推荐文章于 2023-01-03 19:49:08 发布
阅读量130 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46765422/article/details/108285606
版权

spring框架以及ioc概念和运用

spring框架

spring是一个开源框架，不仅可用于服务器的开发，从简单性和松耦合等角度看，更是让很多java应用从中受益，spring框架是一个轻量级的控制反转（ioc）和面向切面（aop）的容器框架

ioc概念

ioc中文意思为控制反转，又称依赖注入，传统实现中，代码直接操控程序之间的关系，也就是耦合关系非常紧密，而控制反转将控制权由应用代码中转到外部容器，这个控制权的转移就是反转。

举个例图方便理解：
在这里插入图片描述
在没使用spring前，各个类之间的关系可能是如上图一样，关系非常复杂且紧密，而使用spring后，如下图：
在这里插入图片描述
将类与类之间的联系交给第三方（spring）处理，此时spring就犹如一个胶水和中间商一样，将各个类联系起来

ioc运用

package com.luojun.action;

import java.util.List;

import com.luojun.biz.UserBiz;
/**
 * ioc 的注入方式以及各种类型
 * 
 * set注入
 *    基本类型和string
 *    数组
 *    自定义类型（此案例）
 * 构造注入
 * 自动装配
 *  spring4后出现
 *  byType:根据配置的bean中的接口，在spring的上下文中寻找对应的实现类
 *  byName:根据配置的bean中的接口名字，在spring的上下文寻找对应的实现类
 *   
 * @author luojun
 *
 */
public class UserAction {

	private UserBiz userBiz;
	private String uname;
	private int age;
	private List<String> hobby;
	

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

	public UserAction(String uname, int age) {
		this.uname = uname;
		this.age = age;
	}

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

	public void upload() {
		userBiz.upload();
	}
	/**
	 * 注入
	 */
	public void test() {
		System.out.println(this.uname);
		System.out.println(this.age);
		System.out.println(this.hobby);
	}
	public UserBiz getUserBiz() {
		return userBiz;
	}

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

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"
	default-autowire="byType"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean class="com.luojun.biz.impl.UserBizImp1" id="userBiz"></bean>
	<bean class="com.luojun.action.UserAction" id="userAction">
		<!-- <property name="userBiz" ref="userBiz"></property> -->
		<!-- set注入 property标签 -->
		<!-- <property name="uname" value="zs"></property> <property name="age" 
			value="22"></property> -->
		<!-- 构造器注入 constructor-arg -->
		<constructor-arg name="uname" value="ls"></constructor-arg>
		<constructor-arg name="age" value="22"></constructor-arg>
		<property name="hobby">
			<list>
				<value>篮球</value>
				<value>rap</value>
			</list>
		</property>
	</bean>
	</bean>
</beans>

两个业务逻辑的action(测试)：

package com.luojun.biz.impl;

import com.luojun.biz.UserBiz;

public class UserBizImp1 implements UserBiz {

	@Override
	public void upload() {
		System.out.println("实现用户上传功能");
	}

}



package com.luojun.biz.impl;

import com.luojun.biz.UserBiz;

public class UserBizImp2 implements UserBiz {

	@Override
	public void upload() {
		System.out.println("开始优化性能的代码");
	}

}

两个不同的实现类是为了模仿一个业务逻辑：

假如项目上线时有个功能是用户上传，但是需要维护优化性能，那么如果不使用spring，需要修改那么势必就会将之前的功能代码进行修改，而使用spring只需要在注入依赖时，更换成优化版本即可，也就是这行：

<bean class="com.xiaoyang.biz.impl.UserBizImp1" id="userBiz"></bean>

测试类：

package com.luojun.test;

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

import com.luojun.action.OrderAction;
import com.luojun.action.UserAction;

public class IocTest {
	public static void main(String[] args) {
		ApplicationContext springContext = new ClassPathXmlApplicationContext("/spring-context.xml");
		UserAction userAction = (UserAction) springContext.getBean("userAction");
		OrderAction orderAction = (OrderAction) springContext.getBean("orderAction");
		userAction.upload();
     	userAction.test();
	}
}

输出：

实现用户上传功能
ls
22
[篮球, rap]

这个测试代表刚发布时版本，如果优化，只需要进行修改xml中bean为对应优化后的实现类：

<bean class="com.xiaoyang.biz.impl.UserBizImp2" id="userBiz"></bean>

输出：

开始优化性能的代码
ls
22
[篮球, rap]

与tomcat整合
与tomcat整合只需要在web.xml中配置一下上下文，并在action中进行读取配置文件信息即可：
web.xml:

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<display-name>Archetype Created Web Application</display-name>
	<context-param>
		<param-name>springXmlLocation</param-name>
		<param-value>/spring-context.xml</param-value>
	</context-param>
</web-app>

目录
spring框架
ioc概念
ioc运用
与tomcat整合
spring框架以及ioc概念和运用

Dawn.x 2020-08-14 01:01:18 55 收藏
文章标签： spring
版权
目录
spring框架
ioc概念
ioc运用
与tomcat整合
spring框架
spring是一个开源框架，不仅可用于服务器的开发，从简单性和松耦合等角度看，更是让很多java应用从中受益，spring框架是一个轻量级的控制反转（ioc）和面向切面（aop）的容器框架

ioc概念
ioc中文意思为控制反转，又称依赖注入，传统实现中，代码直接操控程序之间的关系，也就是耦合关系非常紧密，而控制反转将控制权由应用代码中转到外部容器，这个控制权的转移就是反转。

举个例图方便理解：
在这里插入图片描述在没使用spring前，各个类之间的关系可能是如上图一样，关系非常复杂且紧密，而使用spring后，如下图：

在这里插入图片描述
将类与类之间的联系交给第三方（spring）处理，此时spring就犹如一个胶水和中间商一样，将各个类联系起来

ioc运用
package com.xiaoyang.action;

import java.util.List;

import com.xiaoyang.biz.UserBiz;
/**

  • ioc 的注入方式以及各种类型
  • set注入
  • 基本类型和string
  • 数组
  • 自定义类型（此案例）
  • 构造注入
  • 自动装配
  • spring4后出现
  • byType:根据配置的bean中的接口，在spring的上下文中寻找对应的实现类
  • byName:根据配置的bean中的接口名字，在spring的上下文寻找对应的实现类
  • @author xiaoyang

*/
public class UserAction {

private UserBiz userBiz;
private String uname;
private int age;
private List<String> hobby;


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

public UserAction(String uname, int age) {
	this.uname = uname;
	this.age = age;
}

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

public void upload() {
	userBiz.upload();
}
/**
 * 注入
 */
public void test() {
	System.out.println(this.uname);
	System.out.println(this.age);
	System.out.println(this.hobby);
}
public UserBiz getUserBiz() {
	return userBiz;
}

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
spring.context.xml:

<?xml version="1.0" encoding="UTF-8"?> 

<bean class="com.xiaoyang.biz.impl.UserBizImp1" id="userBiz"></bean>
<bean class="com.xiaoyang.action.UserAction" id="userAction">
	<!-- <property name="userBiz" ref="userBiz"></property> -->
	<!-- set注入 property标签 -->
	<!-- <property name="uname" value="zs"></property> <property name="age" 
		value="22"></property> -->
	<!-- 构造器注入 constructor-arg -->
	<constructor-arg name="uname" value="ls"></constructor-arg>
	<constructor-arg name="age" value="22"></constructor-arg>
	<property name="hobby">
		<list>
			<value>篮球</value>
			<value>rap</value>
		</list>
	</property>
</bean>
</bean>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
两个业务逻辑的action(测试)：

package com.xiaoyang.biz.impl;

import com.xiaoyang.biz.UserBiz;

public class UserBizImp1 implements UserBiz {

@Override
public void upload() {
	System.out.println("实现用户上传功能");
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.xiaoyang.biz.impl;

import com.xiaoyang.biz.UserBiz;

public class UserBizImp2 implements UserBiz {

@Override
public void upload() {
	System.out.println("开始优化性能的代码");
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
两个不同的实现类是为了模仿一个业务逻辑：

假如项目上线时有个功能是用户上传，但是需要维护优化性能，那么如果不使用spring，需要修改那么势必就会将之前的功能代码进行修改，而使用spring只需要在注入依赖时，更换成优化版本即可，也就是这行：


1
测试类：

package com.xiaoyang.test;

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

import com.xiaoyang.action.OrderAction;
import com.xiaoyang.action.UserAction;

public class IocTest {
public static void main(String[] args) {
ApplicationContext springContext = new ClassPathXmlApplicationContext("/spring-context.xml");
UserAction userAction = (UserAction) springContext.getBean(“userAction”);
OrderAction orderAction = (OrderAction) springContext.getBean(“orderAction”);
userAction.upload();
userAction.test();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
输出：

实现用户上传功能
ls
22
[篮球, rap]

1
2
3
4
5
这个测试代表刚发布时版本，如果优化，只需要进行修改xml中bean为对应优化后的实现类：


1
输出：

开始优化性能的代码
ls
22
[篮球, rap]
1
2
3
4
与tomcat整合
与tomcat整合只需要在web.xml中配置一下上下文，并在action中进行读取配置文件信息即可：
web.xml:


Archetype Created Web Application

springXmlLocation
/spring-context.xml

action：

package com.luojun.action;

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;
@WebServlet("/user")
public class UserServlet extends HttpServlet {
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doPost(req, resp);
	}
	@Override
		protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
			// TODO Auto-generated method stub
			System.out.println("处理用户请求");
			ApplicationContext springContext =(ApplicationContext) req.getServletContext().getAttribute("spring_key");
			UserAction userAction = (UserAction) springContext.getBean("userAction");
			userAction.upload();
		}
	}

运行项目后，控制台输出：

处理用户请求
开始优化性能的代码
qq_46765422
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring中的IoC的基本概念及实现原理
YETA的博客
07-16 863
本篇文章内容基于《Spring 5企业级开发实战》。 1. IoC的概念 1.1依赖倒置原则 1.2依赖注入 2. Spring IoC的实现方式 2.1 XML方式 2.2注解方式 3. Spring IoC实现原理解析 3.1 BeanFactory代码解析 3.2 ApplicationContext代码解析 3.3 BeanDefinition代码解析 3.4 ...
IOC的理解与使用
qq_52559693的博客
02-23 1161
概念 控制反转(Inversion of Control)IOC,是面向对象编程中的一种设计原则，作用是用来减少计算机代码之间的耦合性。其最常见的方式叫做依赖注入（Dependency Injection,简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。 其主要目的就是为了降低耦合度 底层原理（简单的） （1）XML解析、工厂模式、反射 图片来源于
java专业术语 ioc_轻松理解Java面试和开发中的IoC（控制反转）
weixin_29876887的博客
02-26 743
ioc的概念介绍控制反转(ioc)模式(又称di：dependency injection)就是inversion of control，控制反转。在java开发中，ioc意 味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转。控制反转(inversion of control，英文缩写为ioc)是框架的重要特征，做到控制反转需要一个容器来实现，就是我们所说的ioc容器，最常...
java高级培训中心-IOC的应用理解
T_LJAVA的博客
04-18 136
IOC—InversionofControl，即，“控制反转”不是技术，而是设计思想。在Java开发中，Ioc意味着将您设计的对象提供给容器进行控制，而不是在对象内部进行传统的直接控制。如何理解Ioc？理解Ioc的关键是要明确“谁控制谁，什么被控制，为什么要逆转（如果有逆转，就应该向前旋转）以及哪些方面逆转”。 谁控制谁，控制什么？ 在传统的JavaSE编程中，我们通过new在对象内部直接创建对象，这意味着该程序会主动创建相关对象。IoC有一个特殊的容器来创建这些对象，即Ioc容器控制对象的创建；谁控制谁？
Ioc的来由与Ioc基本概念及Ioc使用实现
醉卧雕龙舫，的博客
05-28 328
Ioc的来由与Ioc基本概念传统的对象创建科学的对象创建Ioc的概念 传统的对象创建 public class UserServiceImpl implements UserService { private UserDao userDao = new UserMysqlDaoImpl(); @Override public void getUser() { userDao.getUser(); } } 存在的问题： 当接口调用者想要改变成通过Oracl
springIoc实现原理
04-20
Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由代码自身来完成，而在Spring Ioc中...
spring-IOC代码
06-16
在Java开发领域，Spring框架因其强大的功能和灵活性而备受推崇，其中的核心概念就是IOC（Inversion of Control，控制反转）。本文将深入探讨Spring IOC，以及它如何通过容器来管理和配置应用对象，实现松耦合。 **...
Spring框架入门教程，助你快速掌握核心概念
最新发布
06-23
此外，通过创建实际项目并动手实践，可以更好地理解和掌握Spring框架的运用。 通过本教程，你将逐步理解Spring的基本概念，并能够运用到实际项目中。如果你在学习过程中遇到任何问题，可以与其他开发者交流，或者...
spring IOC实现（墨者革离）
12-12
Spring IOC（Inversion of Control，控制反转）是Spring框架的核心特性，它将对象的创建和管理权交给了Spring容器，从而让开发者从繁琐的依赖管理中解脱出来，更专注于业务逻辑的实现。在这个名为"spring_IOC实现...
Spring-ioc-jar
07-18
同时，掌握如何利用ApplicationContext获取Bean，以及如何利用AOP和生命周期管理功能，将帮助你更好地运用Spring框架解决实际问题。在这个过程中，"Spring-ioc-jar"中的类和接口是实现这些功能的基础，深入研究其...
一篇文章讲透spring ioc (概念、原理、实例、应用场景、面试题)
zhouyunjian的博客
07-12 4286
ioc概念 优势 原理 常见api 实例 应用场景 常见面试题 ioc概念、优势、原理、常见使用、实例、应用场景 ioc概念与定义：ioc翻译成中文为控制反转。意思可以理解为类与类之间的依赖通过容器来控制、配置实现；换一种方式可以这么理解 原来类与类之间在编译时即产生了依赖，即new 对象时，已建立好两者之间的依赖关系；ioc机制将两者之间的依赖关系通过容器进行...
Spring IOC详解
星海IT学习之路
07-14 1770
目录一、IOC的基本概念1.简述 IOC 概念2.Spring的IoC理解3.IOC的优点是什么？二、程序中的耦合1.程序的耦合和解耦2.解决耦合的思路3.工厂模式解耦程序的耦合三、解决程序的耦合1.BeanFactory和ApplicationContext有什么区别？2.ApplicationContext的常用实现类：3.Bean 标签解释Spring的几种bean的作用域4.Spring Bean的生命周期5.实例化bean的三种方式第一种方式：使用默认无参构造函数第二种方式：spring 管理静态
spring IOC 概念理解
qq_43966957的博客
12-04 1497
spring IOC 概念理解
Spring之IOC概念
Q_J_B的博客
11-27 1001
IOC就是控制反转，把对象创建和对象之间的调用过程交给Spring进行管理。
什么是IOC
jlcheerful的博客
01-03 3576
笔记
Spring框架——IOC
weixin_60246887的博客
08-19 1696
spring框架IOC部分的内容，可配合尚硅谷spring5视频实用。基于视频内容根据自己理解整理出的，按照视频顺序的笔记可以看另一位博主的文章，链接如下：https://blog.csdn.net/m0_63324772/article/details/124129130
Spring —— IoC 简介
m0_51976820的博客
04-11 1818
Spring —— IoC 简介
Spring中IOC的理解（通俗易懂版）
热门推荐
qq_48508278的博客
05-11 1万+
文章目录1.IOC提出背景2:IOC的核心概念3:IOC的实现方式4:IOC的入门案例(1):思路分析(2):代码解析5:DI入门案例(1):思路分析(2):代码解析 1.IOC提出背景 代码书写现状:耦合度太高，我们修改一处代码，往往要修改很多出相关联的代码。 举例如下:当我们在数据层中不满足BookDaoImpl2中提供的方法了,我们写了新的实现类BookImpl,那么当业务层想要调用数据层中的实现方法的时候,我们就要修改 new 的对象。那么引发问题 我们该一处代码，就要修改与其相关联的代.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值