Spring——IOC

已于 2022-08-07 16:41:42 修改
阅读量168 收藏
点赞数 2
文章标签： spring java mybatis
于 2022-08-05 17:22:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65808248/article/details/126163134
版权

目录

一、对Spring的理解

二、Spring中IOC的特点

三、依赖注入的3种方式

四、Spring与web容器的整合

五、总结

一、对Spring的理解

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

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

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

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

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

   如下图（Spring所包含的功能）：

   范围：任何Java应用

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

 1.1 Spring是中间层框架、万能胶


       struts2
       spring
       hibernate

在Spring 出现之前，框架之间都必须相互整合：

 而Spring出现之后，各框架只需要跟Spring整合即可：

   1.2 容器框架


         JavaBean    项目中的一个个类
         IOC和AOP
        

二、Spring中IOC的特点

首先新建一个maven项目，注意要先导入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.zking</groupId>
  <artifactId>T280_spring</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>T280_spring 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>T280_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>

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">

项目创建成功之后呢，我们开始我们伟大的编码工程：

关于Spring中IOC的特点，我们拿一个 用户业务类来作为案例，

比如说有客户，它提出需求：同时在用户模块、订单模块拿到所有的用户数据。

需求总是会有所变更，

需求变更1：
     同时在用户模块、订单模块拿到所有的用户数据，并且要求用户数据是已经通过年龄排序了的。
     对应策略：修改userBiz中的list方法，添加排序功能，按照年龄排序
 
 需求变更2：
     同时在用户模块、订单模块拿到所有的用户数据，并且要求用户数据是已经通过注册的时间点排序了的。
     对应策略：修改userBiz中的list方法，添加排序功能，按照时间点排序

总结：

以上的对应策略是我们最原始的方法，弊端：频繁修改业务层biz层代码。

同时还有一个多实现方法，弊端：凡是涉及到用户业务层调用的地方，都需要修改代码。

因此我们的SpringIOC就来了：

biz层：

 UserBiz：

package com.ycx.biz;
/**
 * 用户业务类
 * @author 杨总
 *
 */
public interface UserBiz {
	void list();
}

 web层：

UserAction ：

package com.ycx.web;

import com.ycx.biz.UserBiz;
import com.ycx.biz.impl.UserBizImpl1;
import com.ycx.biz.impl.UserBizImpl2;

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

	public UserBiz getUserBiz() {
		return userBiz;
	}


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


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

Spring 配置文件：

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.ycx.biz.impl.UserBizImpl2" id="userBiz1"></bean> -->
	<bean class="com.ycx.biz.impl.UserBizImpl2" id="userBiz"></bean>
	<bean class="com.ycx.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
	</bean>
	<bean class="com.ycx.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
	</bean>
</beans>

 OrderAction ：

package com.ycx.web;

import com.ycx.biz.UserBiz;
import com.ycx.biz.impl.UserBizImpl1;
import com.ycx.biz.impl.UserBizImpl2;

public class OrderAction {

//	private UserBiz userBiz=new UserBizImpl1();
	private UserBiz userBiz;
	public UserBiz getUserBiz() {
		return userBiz;
	}


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



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

 实现类：

UserBizImpl1 ：

package com.ycx.biz.impl;

import com.ycx.biz.UserBiz;

public class UserBizImpl1 implements UserBiz{

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

 UserBizImpl2 ：

package com.ycx.biz.impl;

import com.ycx.biz.UserBiz;

public class UserBizImpl2 implements UserBiz{

	@Override
	public void list() {
		System.out.println("查询用户数据...通过注册的时间点排序...");
		
	}
	
}

 测试：

package com.ycx.ioc.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.UserAction;

public class Demo1 {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
		UserAction userAction = (UserAction)context.getBean("userAction");
		userAction.list();
	}
}

 打印结果：

 因此，Spring只需要修改配置就好了（以前手动创建对象，Spring可自动创建对象）：

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.ycx.biz.impl.UserBizImpl1" id="userBiz"></bean>
	<bean class="com.ycx.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
	</bean>
	<bean class="com.ycx.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
	</bean>
</beans>

 再测试：

package com.ycx.ioc.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.OrderAction;
import com.ycx.web.UserAction;
/**
 * 1、对Spring框架的配置进行建模，建模之后，spring-context.xml中所有的javabean信息都会加载进Spring 容器的上下文
 * 2、上下文中包含了spring-context.xml 所有对象
 * @author 杨总
 *
 *IOC的特点（什么叫控制反转）：
 *	指的是将创建对象的权利反转给Spring容器来完成
 *
 */
public class Demo1 {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
		UserAction userAction = (UserAction)context.getBean("userAction");
		userAction.list();
		
		OrderAction orderAction = (OrderAction)context.getBean("orderAction");
		orderAction.list();
	}
}

 

  IOC的特点（什么叫控制反转）：
           指的是将创建对象的权利反转给Spring容器来完成

三、依赖注入的3种方式

如果把OrderAction内的get和set方法注释掉，再测试，会报错：

 所以我们来需要了解依赖注入的三种方式。

依赖注入的三种方式：


    1、set注入——在业务类中获取属性的set和get方法

UserAction:

package com.ycx.web;



import java.util.List;

import com.ycx.biz.UserBiz;
import com.ycx.biz.impl.UserBizImpl1;
import com.ycx.biz.impl.UserBizImpl2;
/**
 * 依赖注入的三种方式：
 * 	1、set注入
 * 	2、构造注入
 * 	3、自动装配
 * 		byName
 * 		byType
 * 
 * @author 杨总
 *
 */
public class UserAction {
//	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 String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

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

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

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

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.ycx.biz.impl.UserBizImpl1" id="userBiz"></bean>
	<bean class="com.ycx.web.UserAction" id="userAction">
		<property name="userBiz" ref="userBiz"></property>
		
		<property name="name" value="杨总"></property>
		<property name="age" value="22"></property>
		<property name="hobby">
			<list>
				<value>唱歌</value>
				<value>跳舞</value>
				<value>乒乓球</value>
			</list>
		</property>
	</bean>
	<bean class="com.ycx.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
	</bean>
</beans>

Demo1:

package com.ycx.ioc.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.OrderAction;
import com.ycx.web.UserAction;
/**
 * 1、对Spring框架的配置进行建模，建模之后，spring-context.xml中所有的javabean信息都会加载进Spring 容器的上下文
 * 2、上下文中包含了spring-context.xml 所有对象
 * @author 杨总
 *
 *IOC的特点（什么叫控制反转）：
 *	指的是将创建对象的权利反转给Spring容器来完成
 *
 */
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();
		
		OrderAction orderAction = (OrderAction)context.getBean("orderAction");
		orderAction.list();
	}
}

在Demo1中运行，

打印结果如下：

 

    2、构造注入——在业务类中回去属性的构造方法

OrderAction ：

package com.ycx.web;

import java.util.List;

import com.ycx.biz.UserBiz;
import com.ycx.biz.impl.UserBizImpl1;
import com.ycx.biz.impl.UserBizImpl2;

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(String name, int age, List<String> hobby) {
		super();
		this.name = name;
		this.age = age;
		this.hobby = hobby;
	}

	public OrderAction() {
		super();
	}

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

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.ycx.web.OrderAction" id="orderAction">
		<property name="userBiz" ref="userBiz"></property>
		<!-- 构造注入 -->
		<constructor-arg name="name" value="杨总"></constructor-arg>
		<constructor-arg name="age" value="18"></constructor-arg>
		<constructor-arg name="hobby" >
				<list>
					<value>唱歌</value>
					<value>跳舞</value>
					<value>乒乓球</value>
				</list>
		</constructor-arg>
	</bean>
</beans>

然后在Demo1运行：

 

    3、自动装配


                ① byName——是Spring管理的bean对象的id进行查找，如果找不到则注入失败，反之成功

        
               运行：

 

          ②byType——是Spring管理的bean对象接口实现类进行查找，如果没有或两个以上，则注入失败，反之成功。

 

 

四、Spring与web容器的整合

 Spring与web容器的整合过程


 Why: 建模的过程是十分耗时的
 解决问题：
         1、建模必不可少
         2、建模要保证只执行一次
         3、建模后期望在在每一个servlet都能够拿到Spring的上下文对象ClassPathXmlApplicationContext


  How:
         1、监听器的初始化方法
         2、Spring的上下文 要存放在tomacat上下文中

DemoServlet ：

package com.ycx.ioc.demo;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.UserAction;



@WebServlet("/springDemo")
public class DemoServlet extends HttpServlet{
	@Override
	public void service(ServletRequest req, ServletResponse res) 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();
		
		
		super.service(req, res);
	}
}

 SpringLoadListener ：

 

 

package com.ycx.ioc.listener;

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

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.UserAction;

public class SpringLoadListener implements ServletContextListener{

	@Override
	public void contextInitialized(ServletContextEvent sce) {
System.out.println("初始化......");
		//	拿到Spring的上下文
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
//		将Spring上文保存到Tomcat上下文中
		ServletContext servletContext=sce.getServletContext();
		servletContext.setAttribute("springContext", context);
	
	
	}
	
}

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.ycx.ioc.listener.SpringLoadListener</listener-class>
</listener>

</web-app>

运行：

 进一步优化：

 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>

<context-param>
	<param-name>springConfigLocation</param-name>
	<param-value>/applicationContext.xml</param-value>
</context-param>

<listener>
	<listener-class>com.ycx.ioc.listener.SpringLoadListener</listener-class>
</listener>

</web-app>

 SpringLoadListener :

package com.ycx.ioc.listener;

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

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ycx.web.UserAction;

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);
	
	
	}
	
}

五、总结

1、Spring的作用

        容器框架        用来整合其他的第三方框架

        有两大核心组件：IOC和aop

2、IOC的作用

        特点：依赖注入、控制反转

        控制反转：将创建对象的权利，由程序员手动new对象的权利交给Spring容器

        优点：便于维护，拥抱变化

3、依赖注入的方式

        set注入

        构造注入

        自动装配

4、自动装配

        byName:根据bean的id在Spring的上下文进行寻找

        byType:根据属性接口在Spring上下文找对应的接口实现类

5、Spring与web集成

        监听器  初始化  

        优化

酒醉猫(^･ｪ･^)
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring——IOC（控制反转）与DI（依赖注入）.docx
07-03
Spring框架中的IOC（控制反转）和DI（依赖注入）是两种关键的设计模式，它们极大地提升了软件的可维护性和可扩展性。控制反转是一种设计思想，它改变了传统的对象创建方式，将对象的创建和管理权从应用程序自身转移...
Spring-IOC-总结理解
泰山与水
07-06 200
总结IOC的知识点前，先思考以下问题： 什么是 IOC ？ 为什么有IOC的出现？ 如何理解IOC的概念的模型？ 如何理解Spring中IOC的模型？ Spring中IOC分类？ IOC中Bean的生命周期有哪些？ Spring中IOC的特点有哪些？ Spring中IOC怎么实现的？ Spring中IOC实现方式给我们什么样的启示？ 让你实现Spring中IOC,你怎么做？ Spring中IOC会被新的框架替代吗？ 一、理解IOC思想 背烂的定义 想到IOC立马会想到关键词：控制反转，依赖注入；一般
Spring特性（IoC详解）
weixin_51335774的博客
01-07 403
Spring是JavaEE编程领域的一个轻量级开源框架，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架。同时，它对于其它框架（如Mybatis、Hibernate、Struts等）也有着很好的支持，在开发的过程中相当于一个中间件的存在。而Spring最重要的两个特性即为IoC（Inversion of Control）“控制反转”和AOP（Aspect Oriented Programming）“面向切面编程”。
IOC的优点是什么
GeekLee的博客
04-25 1万+
ioc的思想最核心的地方在于，资源不由使用资源的双方管理，而由不使用资源的第三方管理，这可以带来很多好处。 IOC的优点: 第一，资源集中管理，实现资源的可配置和易管理。 第二，降低了使用资源双方的依赖程度，也就是我们说的耦合度。 IOC的缺点: 1、创建对象的步骤变复杂了，不直观，当然这是对不习惯这种方式的人来说的。 2、因为使用反射来创建对象，所以在效率上会有些损耗。但相对于程序的灵活性和可维...
Spring IOC 三大高级特性（简述）
weixin_43878909的博客
05-13 370
spring IOC 特性
SpringIOC特性
weixin_47626220的博客
04-08 135
一alias（别名） 1.xml方式配置 public class TestService { public TestService() { System.out.println("TestService初始化成功"); } } <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi
Spring的ioc小案例
09-07
本案例主要探讨的是Spring框架的核心特性之一——依赖注入（Dependency Injection，简称DI），通常也被称为IOC（Inversion of Control，控制反转）。通过这个小案例，我们可以深入理解Spring如何实现IoC以及属性注入...
初识Spring——Spring核心容器
02-24
IOC-InversionofControl，译为控制反转，是一种遵循依赖倒置原则的代码设计思想。所谓依赖倒置，就是把原本的高层建筑依赖底层建筑“倒置”过来，变成底层建筑依赖高层建筑。高层建筑决定需要什么，底层去实现这样的...
Spring-IOC丐版
02-26
在这个名为"Spring-IOC丐版"的项目中，我们将深入探讨Spring框架的核心组件——IOC容器的基础实现。 IOC，即控制反转，是一种设计模式，它的主要思想是将对象的创建和管理权交给一个外部容器，而不是由对象自身负责...
IOC的优缺点
最新发布
m0_62197181的博客
04-27 358
这就是spring IoC的思想所在。由IOC容器通过配置文件来管理对象的生命周期、依赖关系等，这样就不用重新修改并编译具体的代码，从而实现组件之间的解耦。3、缺少IDE重构的支持，如果修改了类名，还需到XML文件中手动修改，这似乎是所有XML方式的缺憾所在。3、缺少IDE重构的支持，如果修改了类名，还需到XML文件中手动修改，这似乎是所有XML方式的缺憾所在。1、创建对象的步骤变复杂了，不直观，当然这是对不习惯这种方式的人来说的。1、创建对象的步骤变复杂了，不直观，当然这是对不习惯这种方式的人来说的。
深入理解Spring的两大特征（IOC和AOP）
热门推荐
Vision
04-05 8万+
众所周知，Spring的核心特性就是IOC和AOP，IOC（Inversion of Control），即“控制反转”；AOP（Aspect-OrientedProgramming），即“面向切面编程”。参考书《Spring In Action》，下面分享一下我对这两大特性的个人理解。IOC：IOC，另外一种说法叫DI（Dependency Injection），即依赖注入。它并不是一种技术实现，而
【IOC框架】分析与理解
weixin_34153893的博客
02-01 3863
1 IoC理论的背景我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。图1：软件系统中耦合的对象如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同...
什么是IOC,IOC的优缺点及IOC的应用
Camel
03-04 3561
更多免费教学文章请关注这里 IOC，即控制反转（Inversion of Control，英文缩写为IoC），是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。 IOC的优点:实现组件之间的解耦，提高程序的灵活性和...
IoC的好处
无知的博客
11-25 6951
IoC（Inversion of Control​，控制反转）也称为依赖注入（Dependency Injection），作为Spring的一个核心思想，是一种设计对象之间依赖关系的原则及其相关技术。 IoC是什么？ 高内聚低耦合可以说是软件技术形态的终极目标。用学术界的话来说，软件的两个本质特性就是构造性和演化性，高内聚低耦合的设计能够让构造和演化都更加高效，比如： 开发更
浅谈IOC--说清楚IOC是什么
weixin_33929309的博客
06-05 3087
博文目录 1.IOC的理论背景 2.什么是IOC 3.IOC也叫依赖注入(DI) 4.IOC的优缺点 5.IOC容器的技术剖析 6.IOC容器的一些产品 7.参考博文 本文旨在用语言(非代码)说清楚IOC到底是什么，没有什么高深的技术，园中的老牛、大虾们看到这里可以绕行了，以免浪费您宝贵的时间。IOC这个东西DebugLZQ早就想写了，但是出于对文章权威性的考虑(不能误人子弟- -...
Spring IOC 特点
美妙_perfect
02-27 347
IOC（Inversion of Control） 是设计思想，不是技术 IOC 容器（container）实现了 IOC 设计思想得一个容器 Spring IOC 容器得基本实现思路: 配置文件，工厂，容器 Spring IOC 最大优势：不需要编译，内存优化，解耦; 劣势：构成复杂，可读性差...
Ioc容器的革命性优点
冰糖糊涂的专栏
07-27 910
　我们知道，在Java基本教程中有一个定律告诉我们：所有的对象都必须创建；或者说：使用对象之前必须创建，但是现在我们可以不必一定遵循这个定律了，我们可以从Ioc容器中直接获得一个对象然后直接使用，无需事先创建它们。　　这种变革，就如同我们无需考虑对象销毁一样；因为Java的垃圾回收机制帮助我们实现了对象销毁；现在又无需考虑对象创建，对象的创建和销毁都无需考虑了，这给编程带来的影响是巨大的。
用IOC注入最大的好处是什么
请叫我雷锋！！
06-08 1988
IoC是什么？Inversion of Control，即反转控制，或许说为依赖注入更为合适。IoC就是IoC，不是什么技术，与GoF一样，是一种设计模式。 Interface Driven Design接口驱动，接口驱动有很多好处，可以提供不同灵活的子类实现，增加代码稳定和健壮性等等，但是接口一定是需要实现的，也就是如下语句迟早要执 行：AInterface a = new AInter
深入解析Spring框架IOC核心机制
本文主要探讨了Spring框架的核心部分——IOC（Inversion of Control，控制反转）容器，以及如何在实际开发中使用它来构建一个简单的J2EE项目。首先，我们来看看学习目标： 1. **理解IOC的工厂体系结构**：在Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

酒醉猫(^･ｪ･^)

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

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

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

打赏作者

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

抵扣说明：

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

余额充值