Spring IOC

控制反转,通过一种方式(XML/注解),通过第三方去产生或者获取特定对象的方式。

《Java EE 亘联网轻量级框架整合开发-SSM 框架( Spring MVC+Spring+MyBatis )和 Redis 实现
》第九章实例解析-要橙汁,详细代码:https://download.youkuaiyun.com/download/xuwang777/10886388

1.  eclipse搭建spring:https://blog.youkuaiyun.com/peng86788/article/details/81166670

2.  juice.xml

<?--beans定义,根元素,引入xsd-->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	 
        <?--依赖注入(setter方式)-->        
<?--定义bean编号id(自定义,首字母小写),class(类限定全名),property(定义类的属性),name(名称),value(值)-->
	<bean id="beanPostProcessor" class="bean.BeanPostProcessorImpl"/>
	<bean id="disPosableBean" class="bean.DisposableBeanImpl"/>
	
	<bean id="source" class="pojo.Source">
		<property name="fruit" value="橙"/>
		<property name="water" value="汁"/>
		<property name="size" value="小杯"/>
		<property name="sugar" value="少糖"/>
	</bean>	
	
	<bean id="juiceMaker" class="pojo.JuiceMaker"
		destroy-method="destroy" init-method="init">
		<property name="shop" value="爱心"/>
		<property name="source" ref="source"/>
	</bean>
</beans>

eclipse配置xml自动补全功能:https://blog.youkuaiyun.com/HH775313602/article/details/70176531

tips!!!!!!!!!!!!!!!!!!!!!!!!!!!!:   class="文件上方出现的package"

2. package bean;

重写了BeanPostProcessor以及DisposableBean的三个方法,其中BeanPostProcessor针对所有Bean,DisposableBean针对IOC容器本身。

3.  package pojo;'

source.java

        public String size;
	public String fruit;
	public String water;
	public String sugar;

自动补全set/get方法:source->generate steter/getter,快捷键:Ctrl+Shift+S

JuiceMaker.java

package pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class JuiceMaker implements BeanNameAware,BeanFactoryAware,ApplicationContextAware,InitializingBean{
	private String shop=null;
	private Source source=null;
	
	public String getShop() {
		return shop;
	}
	public void setShop(String shop) {
		this.shop = shop;
	}
	public Source getSource() {
		return source;
	}
	public void setSource(Source source) {
		this.source = source;
	}
	
	public String maker() {
		String juice="这是"+shop+"饮料店的"+source.getSize()+source.getSugar()+source.getFruit()+source.getWater();
		return juice;	
	}
	
	private void init() {
		System.out.println("执行自定义初始化方法");
	}
	private void destroy() {
		System.out.println("执行自定义销毁方法");
	}
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println(this.getClass().getSimpleName()+"调用afterPropertiesSet方法");
		
	}
	@Override
	public void setApplicationContext(ApplicationContext arg0) throws BeansException {
		System.out.println(this.getClass().getSimpleName()+"调用setApplicationContext方法");
		
	}
	@Override
	public void setBeanFactory(BeanFactory arg0) throws BeansException {
		System.out.println(this.getClass().getSimpleName()+"调用setBeanFactory方法");
		
	}
	@Override
	public void setBeanName(String arg0) {
		System.out.println(this.getClass().getSimpleName()+"调用setBeanName方法");
		
	}
	
	
	
}


自定义初始化方法和销毁方法,以及一些重写方法,执行顺序后面结合实验结果详述。

4.

package main;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import pojo.JuiceMaker;

public class JuiceApplication {
	public static void main(String[] args) {
		testJuice();
	}
	public static void testJuice() {
		ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("juiceapplication.xml");		
		System.out.println("初始化IOC完成");

		JuiceMaker juiceMaker=(JuiceMaker) ctx.getBean("juiceMaker");
                System.out.println("获取Bean完成");

		System.out.println(juiceMaker.maker());		
		ctx.close();

		System.out.println("结束");
	}
		
}

5.实验结果

执行步骤 :

(1)初始化IOC容器.ClassPathXmlApplicationContex(".xml");

        load x beans

     creat shared instance (every bean id)

     初始化beans实例。

初始化中会执行.java中的方法,执行顺序如下图。

按照|.xml bean的加载顺序disposableBen->source->juiceMaker

开始实例化和实例化完成是执行BeanPostProcessor接口的PostProcessorBeforeInitialization方法和PostAfterInitialization方法,针对所有bean。

JuiceMaker.java中定义的方法的接口针对单个bean,所以只有juiceMaker实例会有那些执行语句,各种接口中的方法执行顺序如下图。

(2)获取Bean

		System.out.println("获取Bean开始");
		JuiceMaker juiceMaker=(JuiceMaker) ctx.getBean("juiceMaker");
		System.out.println("获取Bean完成");
		System.out.println(juiceMaker.maker());
		ctx.close();
		
		System.out.println("结束");

然后销毁,自定义销毁方法和针对IOC容器本身的接口DisposableBean的销毁方法。

6. 配置log4j.properties

log4j.rootLogger=INFO , stdout
log4j.logger.org.mybatis=INFO
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

 

### Spring IOC 原理及实现 #### 1. 控制反转(IOC)的概念 控制反转(Inversion of Control,简称 IOC)是一种设计思想,旨在将对象的创建和管理从应用程序代码中分离出来。通过 IOC,开发者无需手动管理对象的生命周期和依赖关系,而是由框架负责这些任务。这种思想使得开发者可以专注于业务逻辑的实现,而不需要关心对象之间的交互细节[^1]。 #### 2. 依赖注入(DI) 依赖注入(Dependency Injection,简称 DI)是实现 IOC 的一种方式。DI 的核心在于通过外部配置或注解的方式,将对象的依赖关系注入到目标对象中,而不是由对象自己负责依赖的创建和管理。依赖注入有三种主要形式:构造器注入、Setter 方法注入和字段注入[^4]。 #### 3. Spring IOC 容器的核心接口 Spring 框架提供了两种主要的 IOC 容器接口: - **BeanFactory**:这是 Spring 框架的基础接口,面向 Spring 内部使用。它负责配置、创建和管理 Bean 的生命周期。 - **ApplicationContext**:这是一个更高级的容器接口,面向开发者使用。它扩展了 BeanFactory 的功能,提供了更多的企业级特性,如国际化支持、事件传播等。在实际开发中,通常使用 ApplicationContext 而非 BeanFactory[^2]。 #### 4. Spring IOC 的实现方式 Spring IOC 的实现主要包括以下几个方面: ##### (1) 元数据解析 Spring 使用 XML 文件、Java 注解或 Java 配置类来定义 Bean 的元数据。例如,通过 `<bean>` 标签在 XML 文件中定义 Bean,或者使用 `@Component`、`@Service` 等注解在 Java 类上声明 Bean[^5]。 示例代码(XML 配置): ```xml <bean id="userDao" class="com.mayuanfei.springioc.dao.impl.UserDaoImpl" /> ``` 示例代码(注解配置): ```java @Component public class UserDaoImpl implements UserDao { // 实现方法 } ``` ##### (2) 依赖注入 Spring 通过反射机制解析 Bean 的依赖关系,并将其注入到目标对象中。以下是一个简单的依赖注入示例: 示例代码(字段注入): ```java @Service public class UserService { @Autowired private UserDao userDao; // 自动注入 UserDao } ``` ##### (3) 生命周期管理 Spring 容器会管理 Bean 的整个生命周期,包括初始化、运行时和销毁阶段。开发者可以通过实现特定的接口(如 `InitializingBean` 和 `DisposableBean`)或使用注解(如 `@PostConstruct` 和 `@PreDestroy`)来定制 Bean 的生命周期行为。 示例代码(生命周期管理): ```java @Component public class MyBean { @PostConstruct public void init() { System.out.println("Bean 初始化"); } @PreDestroy public void destroy() { System.out.println("Bean 销毁"); } } ``` ##### (4) 扩展机制 Spring 提供了丰富的扩展点,允许开发者自定义容器的行为。例如,通过实现 `BeanFactoryPostProcessor` 或 `BeanPostProcessor` 接口,可以在 Bean 初始化前后插入自定义逻辑[^4]。 #### 5. Spring IOC 的优势 Spring IOC 的核心优势包括: - **解耦**:对象之间不再直接依赖具体实现,而是通过接口或抽象类进行交互。 - **灵活性**:通过配置文件或注解动态管理 Bean,便于修改和扩展。 - **可维护性**:集中处理对象的创建和依赖关系,降低了代码复杂度。 ### 总结 Spring IOC 是一种通过容器管理对象生命周期和依赖关系的设计模式。其核心原理包括元数据解析、依赖注入、生命周期管理和扩展机制。通过这些机制,Spring 实现了对象控制权的反转,从而提高了系统的解耦性、灵活性和可维护性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值