Spring-IOC

最新推荐文章于 2023-08-29 20:20:07 发布
最新推荐文章于 2023-08-29 20:20:07 发布
阅读量91 收藏
点赞数 1
分类专栏： Spring 文章标签： servlet java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65211978/article/details/126114554
版权

目录

一、Spring简介

String是什么

Spring的作用

 二、Spring中ioc的特点

建一个maven项目

控制反转

 将spring的配置文件加入

注入依赖

三、spring与web容器的整合

一、Spring简介

String是什么

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

目的：解决企业应用开发的复杂性

功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

范围：任何Java应用

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

Spring的作用

容器框架    用来整合其他的第三方框架 （中间层框架、万能胶）

Spring出来以前，是框架与框架之间相互要整合
Spring出来之后，是所有框架跟Spring整合就可以了

 二、Spring中ioc的特点

建一个maven项目

步骤小编在(http://t.csdn.cn/XUaUN)中有讲解

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.oyang</groupId>
	<artifactId>oyang_Spring_ioc</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>oyang_Spring_ioc Maven Webapp</name>
	<url>http://maven.apache.org</url>
	
	<!-- 将当前项目所用的jar包依赖版本定义在外部，目的在于所有jar包版本进行统一管理 -->
		<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>oyang_Spring_ioc</finalName>
		<plugins>
			<!--第一步就是配置maven-compiler-plugin插件 -->
			<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>

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>
</web-app>

控制反转

UserBiz

package com.oyang.biz;

/**
 * 用户业务类
 */
public interface UserBiz {

	void list();
}

UserBizImpl1

package com.oyang.biz.impl;

import com.oyang.biz.UserBiz;

public class UserBizImpl1 implements UserBiz {

	@Override
	public void list() {
		System.out.println("查询用户数据,按照年龄排序。。");
	}

}

UserBizImpl2

package com.oyang.biz.impl;

import com.oyang.biz.UserBiz;

public class UserBizImpl2 implements UserBiz {

	@Override
	public void list() {
		System.out.println("查询用户数据,按照入职时间排序。。");
	}

}

OrderAction

package com.oyang.web;

import java.util.List;

import com.oyang.biz.UserBiz;
import com.oyang.biz.impl.UserBizImpl1;

public class OrderAction {

//	private UserBiz userBiz=new UserBizImpl1();
	private UserBiz userBiz;
	


	public UserBiz getUserBiz() {
		return userBiz;
	}


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

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

	public void list() {
		System.out.println(name);
		System.out.println(age);
		System.out.println(hobby);
		userBiz.list();
		
	}
}

常规做法即运用spring之前的处理方法 

* 用户业务类
 * 需求：
 *     同时在用户模块、订单模块拿到所有的用户数据
 * 需求变更：
 *     同时在用户模块、订单模块拿到所有的用户数据，并且要求用户数据已经是通过年龄排序了的
 *     对应策略：修改userBiz中list方法，添加排序功能
 * 需求变更2：
 *     同时在用户模块、订单模块拿到所有的用户数据，并且要求用户数据已经是通过注册的时间点排序
 *     对应策略：修改userBiz中list方法，添加排序功能，按照时间点排序
 * ...
 * 总结：
 *     最原始的方法：频繁修改业务层biz的代码
 *     多实现：凡是涉及到 用户业务层 调用的地方，都需要更改代码

 将spring的配置文件加入

<?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">
 
 
</beans>

注意：一定要在有网络的情况下进行，否则约束不生效

IOC的主要作用管理整个项目的Javabean：依靠依赖注入、控制反转的特点进行管理

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">
 
	<!-- IOC的主要作用管理整个项目的Javabean：依靠依赖注入、控制反转的特点进行管理 -->
	<!-- <bean class="com.oyang.biz.impl.UserBizImpl1" id="userBiz1"></bean> -->
	<bean class="com.oyang.biz.impl.UserBizImpl2" id="userBiz2"></bean>
	<bean class="com.oyang.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz2"></property>
	</bean>
	<bean class="com.oyang.web.OrderAction" id="orderAction"></bean>
</beans>

UserAction

package com.oyang.web;
 
import com.oyang.biz.UserBiz;
import com.oyang.biz.impl.UserBizImpl1;
 
public class UserAction {
	
	//private UserBiz userBiz = new UserBizImpl1();
	private UserBiz userBiz;
	
	public void list() {
		userBiz.list();
	}
	public UserBiz getUserBiz() {
		return userBiz;
	}
	public void setUserBiz(UserBiz userBiz) {
		this.userBiz = userBiz;
	}
	
	
}

在里面建一个Demo1的类

建模，打印com.cdl.biz.impl.UserBizImpl2中的语句

package com.oyang.ioc;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.oyang.web.UserAction;
 
public class Demo1 {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		//建模
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
		UserAction userAction = (UserAction) context.getBean("userAction");
		userAction.list();
	}
	
	
}

总结

1.对spring框架的配置文件进行建模，建模之后spring-context.xml中所有的Javabean信息
 都会加载进spring容器的上下文中
 2.上下文中就包含了spring-context.xml 所有对象

 结论：IOC特点（控制反转）：将创建对象的权利反转给spring容器来完成

注入依赖

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byType" 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">
	
	<!-- ioc的主要作用管理整个项目的Javabean,依赖注入,控制反转的特点进行管理 -->
<bean class="com.oyang.biz.impl.UserBizImpl1" id="userBiz"></bean>
<!-- <bean class="com.oyang.biz.impl.UserBizImpl2" id="userBi1"></bean> -->
	<!-- set注入 -->
	<bean class="com.oyang.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		<property name="age" value="18"></property>
		<property name="name" value="oyang"></property>
		<property name="hobby">
			<list>
				<value>运动</value>
				<value>nv</value>
				<value>音乐</value>
			</list>
		</property>
	</bean>
	<!-- 构造注入 -->
	<bean class="com.oyang.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<constructor-arg name="name" value="oyang"></constructor-arg>
		<constructor-arg name="age" value="20"></constructor-arg>
		<constructor-arg name="hobby">
			<list>
				<value>运动</value>
				<value>nv</value>
				<value>音乐</value>
			</list>
		</constructor-arg>
	</bean>
</beans>

自动装配
 default-autowire="byName" 
byName:是通过spring管理的bean对象的ID进行查找，如果找不到，则注入失败，反之成功
 byType：是通过spring管理的bean对象的接口实现类进行查找，如果没有或者2个以上，则注入失败，反之成功

三、spring与web容器的整合

分析：

spring与web容器的整合原理
    why:建模的过程是十分耗时的
  解决问题：
 1.建模必不可少
 2.建模只保障只执行一次
 3.建模后期望在每一个servlet都能够拿到spring的上下文对象ClassPathXmlApplicationContext
  how:
  1.监听器的初始化方法 只执行一次
  2.spring的上下文要存放在Tomcat上下文中

listener

package com.oyang.ioc.listener;
 
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class SpringLoadListener implements ServletContextListener{
	
	@Override
	public void contextInitialized(ServletContextEvent sce) {
		System.out.println("初始化执行");
		ServletContext servletContext = sce.getServletContext();
		String springConfigLocation = servletContext.getInitParameter("springConfigLocation");
		System.out.println(springConfigLocation+"...");
		//拿到spring上下文
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
		//将spring的上下文保存在Tomcat上下文中
		servletContext.setAttribute("springContext", context);
	}
	
}

DemoServlet

package com.oyang.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.support.ClassPathXmlApplicationContext;
//建模耗时间
/**
 * Spring与web容器的整合原理
 * why：建模的过程是十分耗时的
 * 	解决问题：
 * 		1.建模必不可少
 * 		2.建模要保障只执行一次
 * 		3.建模后期望在每一个servelt都能够拿到spring的上下文对象ClassPathXmlApplicationContext
 * how：
 *	1.监听器的初始化方法
 *	2. Spring的上下文，要存放在tomcat上下文中
 * 
 * 
 * @author Administrator
 *
 */
@WebServlet("/springDemo") 
public class DemoServlet extends HttpServlet{

	@Override
	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		
//		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
		ClassPathXmlApplicationContext context =(ClassPathXmlApplicationContext) req.getServletContext().getAttribute("SpringContext");
		UserAction userAction = (UserAction) context.getBean("userAction");
		userAction.list();
	}
}

spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans default-autowire="byType" 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">
	
	<!-- ioc的主要作用管理整个项目的Javabean,依赖注入,控制反转的特点进行管理 -->
<bean class="com.oyang.biz.impl.UserBizImpl1" id="userBiz"></bean>
<!-- <bean class="com.oyang.biz.impl.UserBizImpl2" id="userBi1"></bean> -->
	<!-- set注入 -->
	<bean class="com.oyang.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		<property name="age" value="18"></property>
		<property name="name" value="oyang"></property>
		<property name="hobby">
			<list>
				<value>运动</value>
				<value>nv</value>
				<value>音乐</value>
			</list>
		</property>
	</bean>
	<!-- 构造注入 -->
	<bean class="com.oyang.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<constructor-arg name="name" value="oyang"></constructor-arg>
		<constructor-arg name="age" value="20"></constructor-arg>
		<constructor-arg name="hobby">
			<list>
				<value>运动</value>
				<value>nv</value>
				<value>音乐</value>
			</list>
		</constructor-arg>
	</bean>
</beans>

web.xml

<!-- 修改web.xml由2.3至3.1 -->
<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>

	<context-param>
		<param-name>springConfigLocation</param-name>
		<param-value>/applocationContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>com.oyang.ioc.listener.SpringLoadListener</listener-class>
	</listener>

</web-app>

 OK，今日的学习就到此结束啦，如果对个位看官有帮助的话可以留下免费的赞哦(收藏或关注也行),如果文章中有什么问题或不足以及需要改正的地方可以私信博主，博主会做出改正的。个位看官，小陽在此跟大家说拜拜啦  

歐陽。
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringIOC
weixin_59196705的博客
03-30 573
spring是什么? pring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 Spring项目出发点： 目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂） 鼓励最佳实践： 例如spr
spring01
weixin_62735525的博客
08-05 89
spring之IOC
Spring讲解和ioc用途及Web容器的整合
SAME_LOVE的博客
08-16 335
Spring框架的背景和诞生可以追溯到Java企业级应用开发（Java EE）的发展过程中。在传统的Java EE开发中，应用程序的开发和部署往往需要涉及大量的配置文件和繁琐的代码。开发人员需要手动管理对象的生命周期、依赖关系和事务处理等。这种开发模式存在许多痛点，包括开发效率低下、代码冗余、维护困难等。为了解决这些问题，Rod Johnson于2002年创建了Spring框架。他的目标是简化Java企业级应用程序的开发，使开发人员能够更加专注于解决业务逻辑，而不是被底层的技术细节所束缚。
spring的几大核心思想(aop、ioc、DI、mvc)
路辉的博客
02-01 1764
IOCioc是什么ioc的意义ioc在流程中的体现ioc的具体加载流程spring ioc与springmvcioc的关系涉及到的设计模式DI什么是DI什DIgetBean()createBeanInstance() populateBean()AOPAOP中的几个概念 AOP的几种配置方式注解配置配置文件配置AOP源码阅读心得spring mvcspring mvc的处理流程spring mvc九大组件HanderMappingsHandlerAdapte
Spring 的 IOC 和 AOP 是什么，有哪些优点？
最新发布
大大怪的博客
08-29 288
IOC，即控制反转，是一种设计原则，它将对象的创建和依赖关系的管理从应用代码中解耦出来，交由容器来负责。在传统的程序中，对象之间的依赖关系需要由程序员手动创建和维护，而在IOC容器中，这些依赖关系会被自动管理和注入。AOP，即面向切面编程，是一种编程范式，它允许开发者将横切关注点（如日志、事务管理、安全等）从业务逻辑中分离出来，以模块化的方式进行管理。
springIOC的作用及介绍
开始的博客
10-25 1578
springIOC 及对应四种模式
maven-spring-ioc
08-07
spring IoC， 使用配置文件方式配置Bean的实例化和依赖注入
spring-IOC教程
08-21
来自极客学院平台的springIoc文档
Spring-IOC笔记
08-04
spring-IOC的一些笔记心得
spring-IOC代码
06-16
spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合
Spring-ioc容器
02-26
ioc容器的理解与使用
Spring-ioc-jar
07-18
Spring IOC 技术的必备开发包，有了这些包就可以放心研究Spring IOC 技术了
Spring-IoC
07-19
Spring-IoC
Spring-IOC丐版
02-26
Spring丐版IOC的源代码
spring核心思想之IOC深入浅出介绍
学而时习
05-30 1229
spring核心思想之IOC深入浅出介绍 一.依赖倒置原则 要了解控制反转( Inversion of Control ), 我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则（Dependency Inversion Principle ）。 什么是依赖倒置原则？假设我们设计一辆汽车：先设计轮子，然后根据轮子大小设计底盘，接着根据底盘设计车身，最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系：汽车依赖车身，车身依赖底盘，底盘依赖轮子。这样的设计看起来没问题，但是可维护性却很低。假设设计完工之
Srping的IOC
weixin_30466953的博客
06-11 92
XML方式： IOC:控制反转的底层原理就是：工厂模式+反射+配置文件DI：依赖注入就是通过配置文件设置属性值 BeanFactory 是老版本的工厂类：调用getBean的时候，才会生成类的实例ApplicationContext 是新版本的工厂类：加载配置文件的时候，就会将Spring管理的类都实例化 ApplicationContext有两个实现类：ClassPathXmlApplic...
深入理解Spring两大特性：IoC和AOP
热门推荐
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
Spring的IOC特性
谢知否的博客
08-26 1043
IOC的本质 控制反转是一种设计思想，没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所有的控制反转就是：获得依赖对象的方式反转了。 通过接口去调用，解耦对象与对象之间的强联系 public class UserserviceImpl implements UserService{ private UserDao userDao; public void setUserDao(UserDa

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

歐陽。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值