Spring IoC

IoC 表示的意思是控制反转，那么什么是控制反转呢？简单的理解就是从主动变成了被动，额，这个似乎是有点抽象和云里雾里的描述，那我们换一种描述方式：

假设我要和果汁，于是我买来了水果和糖并且还在自己家里找来了榨汁机，于是我开开心心的自己给自己做了一杯果汁，那么这个方式就是主动。

那么什么是被动呢？还是我要喝果汁，但是很可惜我没有榨汁机而且也不会制作果汁，可是我还是要喝啊，咋办？那就只有去奶茶店了呗！我和老板说麻烦一杯果汁，谢谢，很快老板帮我制作了一杯果汁出来，同样是得到了果汁但是我这次是通过别人的手得到的，不是自己得到的，这就是被动。

PS：自己的理解，可能有偏差，欢迎指正(^_)！

Spring Ioc容器提供对Bean的管理，那么Bean的初始化到销毁的生命周期是如何的呢？

Bean实现了接口BeanNameAware的setBeanName方法，那么它就会调用这个方法
Bean实现了接口BeanFactoryAware的setBeanFactory方法，那么它就会调用这个方法
Bean实现了接口ApplicationContextAware的setApplicationContext方法，且Spring IoC容器也必须是一个ApplicationContext接口的实现类，那么才会调用这个方法
Bean实现了接口BeanPostProcessor的postProcessBeforeInitialization方法，那么它就会调用这个方法
Bean实现了接口BeanFactoryPostProcessor的afterPropertiesSet方法，那么它就会调用这个方法
Bean自定义了初始化方法，它就会调用已定义的初始化方法
Bean实现了接口BeanPostProcessor的postProcessAfterInitialization方法，完成了这些调用，Bean就完成了初始化，Bean就生存在Spring IoC 的容器中，使用者就可以获取Bean
服务器正常关闭或Spring IoC关闭则Bean开始销毁
Bean实现了接口DisposableBean的destroy方法，那么就会调用它
如果自定义了销毁方法，那么就会调用它

特别注意：BeanPostProcessor接口是针对所有Bean而言的，DisposableBean则是针对Spring IoC容器本身而言，其他的是针对于单个的Bean而言的！！

一个简单的案例来测试一下吧！

运行环境 Eclipse (Spring框架我已经搭建好了，因为没有使用maven创建项目，所以是使用引入第三方jar包的方式！)
我的项目结构如下:

首先对BeanPostProcessor接口创建一个实现类

package com.ww.ssm.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * BeanPostProcessor接口的实现类，针对所有的Bean
 * @author WW
 *
 */
public class BeanPostProcessorImpl implements BeanPostProcessor{
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("[" + bean.getClass().getSimpleName() +
				"]对象" + beanName + "开始实例化");
		return bean;
	}
	
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.err.println("[" + bean.getClass().getSimpleName() +
				"]对象" + beanName + "实例化完成");
		return bean;
	}
}

对DisposableBean接口提供一个实现类

package com.ww.ssm.bean;

import org.springframework.beans.factory.DisposableBean;

/**
 * DisposableBean接口实现  针对Spring IoC容器
 * @author WW
 *
 */
public class DisposableBeanImpl implements DisposableBean{
	@Override
	public void destroy() throws Exception {
		System.out.println("调用接口DisposableBean的destory方法");
	}
}

对一个实际对象的Bean类的创建，实现针对于单独的Bean的接口的实现类

在这里插入代码片package com.ww.ssm.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;

/**
 * 	果汁制作定义类
 * @author WW
 *
 */
public class JuiceMaker implements BeanNameAware,
BeanFactoryAware,ApplicationContextAware,InitializingBean{
	private String beverageShop = null;
	public String getBeverageShop() {
		return beverageShop;
	}
	public void setBeverageShop(String beverageShop) {
		this.beverageShop = beverageShop;
	}
	
	public void init() {
		System.out.println("[" + this.getClass().getSimpleName() +"]执行自定义初始化方法");
	}
	
	public void destroy() {
		System.out.println("[" + this.getClass().getSimpleName() +"]执行自定义销毁方法");
	}
	
	public String makeJuice() {
		String juice = "这是一杯由" + beverageShop + "饮品店，提供的果汁";
		return juice;
	}
	
	@Override
	public void setBeanName(String arg0) {
		System.out.println("[" + this.getClass().getSimpleName() +"]调用BeanNameAware接口的setBeanName方法");
	}
	
	@Override
	public void setBeanFactory(BeanFactory arg0) throws BeansException {
		System.out.println("[" + this.getClass().getSimpleName() +"]调用BeanFactoryAware接口的SetBeanFactory方法");
	}
	
	@Override
	public void setApplicationContext(ApplicationContext arg0) throws BeansException {
		System.out.println("[" + this.getClass().getSimpleName() +"]调用ApplicationContextAware接口的setApplicationContext方法");
	}
	
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("[" + this.getClass().getSimpleName() +"]调用afterPropertiesSet方法");
	}
}

再去配置一下XML文件也就是src目录下的spring-cfg.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<!-- BeanPostProcessor定义 -->
	<bean id="beanPostProcessor"
		class="com.ww.ssm.bean.BeanPostProcessorImpl"/>
	
	<!-- DisposableBean定义 -->
	<bean id="disposableBean"
		class="com.ww.ssm.bean.DisposableBeanImpl"/>
	
	<bean id="juiceMaker" class="com.ww.ssm.pojo.JuiceMaker"
		init-method="init" destroy-method="destroy">
		<property name="beverageShop" value="烧仙草"/>	
	</bean>

</beans>

这样就是已经可以测试生命周期了，我们可以编写一个测试类

package com.ww.ssm.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ww.ssm.pojo.JuiceMaker;

/**
 *	 测试类
 * @author WW
 *
 */
public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext ctx = 
				new ClassPathXmlApplicationContext("spring-cfg.xml");
		JuiceMaker juiceMaker = (JuiceMaker) ctx.getBean("juiceMaker");
		System.out.println(juiceMaker.makeJuice());
		ctx.close();
	}
}

运行结果就截个图吧！！
运行的结果

整理出来一套基本的Java后端的学习路线
Java基础
----基础语法
----面向对象
----集合
----泛型
----多线程
----IO流
前端基础
----HTML （似乎现在都是HTML5啦）
----CSS (或者是CSS/CSS3 ?)
----Javascript
----JQuery （都说JS已经强大到不得行啦，JQuery似乎还是可以接触一下的吧！）
----浮动和定位
----网页布局管理
JavaWeb基础
----JSP/Servlet
----JSTL和EL表达式
----过滤器
----监听器
----JSON
----Ajax
----FreeMarker
数据库开发
----Redis
----MySql
----JDBC
----C3P0
常用框架(还有比较火的Spring Cloud框架还有 SSH 学习的东西很多很多啊！)
----Spring Boot
----SSM整合
----Spring
----Spring MVC
----MyBatis
设计模式(23种模式还是都了解一下下的好！)
----MVC模式
----单例模式
----工厂模式(还有有点差别的使用多的简单工厂模式)
----建造者模式
----模型模式
----适配器模式

原文链接：https://blog.csdn.net/qq_37932989/article/details/88652197