Spring之IoC

Spring的设计理念和整体架构

一句话概括就是：Spring是一个轻量级的、非侵入式的控制反转(IOC)和面向切面(AOP)的框架。

设计理念：

松散耦合： Spring鼓励开发者编写松散耦合的代码，通过依赖注入和接口抽象等方式来减少组件之间的紧耦合性。这有助于提高代码的可维护性和可测试性。
依赖注入（DI）： Spring的核心特性之一是依赖注入，它允许开发者将对象之间的依赖关系通过配置文件或注解来声明，而不是在代码中硬编码依赖。这使得代码更加灵活和可配置。
面向切面编程（AOP）： Spring支持AOP，允许开发者定义切面和通知，以实现横切关注点的重用，如日志记录、事务管理等。
声明式事务管理： Spring提供了声明式事务管理的支持，允许将事务配置为注解或XML配置，从而简化了事务管理的实现。
模块化： Spring框架被分为多个模块，每个模块提供特定的功能，如Spring核心容器、数据访问/集成、Web开发等。这种模块化的设计使得开发者可以根据需要引入特定的功能。
轻量级容器： Spring框架本身是非常轻量级的，不需要依赖大量外部库。它提供了自己的容器，用于管理应用程序中的对象。

主要模块：

Spring分模块存在，除了最核心的Spring Core Container(Beans、Core、Context和SpEl)之外，其他都是可选的。

七大主要模块：

Spring Core：Spring 核⼼，它是框架最基础的部分，提供 IOC 和依赖注⼊ DI 特性。
Spring Context：Spring 上下⽂容器，它是 BeanFactory 功能加强的⼀个⼦接⼝。
Spring Web：它提供 Web 应⽤开发的⽀持。
Spring MVC：它针对 Web 应⽤中 MVC 思想的实现。
Spring DAO：提供对 JDBC 抽象层，简化了 JDBC 编码，同时，编码更具有健壮性。
Spring ORM：它⽀持⽤于流⾏的 ORM 框架的整合，⽐如：Spring + Hibernate、Spring + iBatis、Spring + JDO 的整合等。
Spring AOP：即⾯向切⾯编程，它提供了与 AOP 联盟兼容的编程实现。

整体架构：

Spring框架的整体架构是分层的，各个层次的功能被组织成不同的模块，如下所示：

核心容器（Core Container）： 核心容器包括Beans、Core、Context和Expression Language模块，用于提供基本的IoC和DI功能。
数据访问/集成（Data Access/Integration）： 这些模块包括JDBC、ORM、JMS、Transactions等，用于处理数据访问和集成外部系统。
Web层（Web）： Spring提供了多个Web开发相关的模块，如Web、Web-MVC、Web-Socket等，用于构建Web应用程序。
AOP和Instrumentation（Aspect-Oriented Programming）： 这些模块包括AOP、Aspects、Instrumentation等，用于支持AOP编程和性能监控。
消息（Messaging）： 这些模块包括JMS、AMQP等，用于处理消息传递。
测试（Testing）： Spring提供了Test模块，用于编写和运行单元测试和集成测试。

Spring IoC

IoC的基础概念

IoC（Inversion of Control）： IoC是一种设计原则，它反转了传统的控制流。在传统的编程中，应用程序通常负责控制对象的创建和生命周期。而在IoC中，控制权被反转，应用程序不再负责直接创建和管理对象，而是将这些职责委托给一个容器或框架。这个容器负责实例化、组装和管理对象，使得应用程序的组件更加解耦、可维护和可扩展。举个简单的例子，从前要什么自己创建，现在要什么，spring容器给。

DI（Dependency Injection）： DI是IoC的一种实现方式，它是IoC的一种具体形式。DI指的是通过将对象的依赖关系注入到对象中，而不是由对象自己创建或查找依赖关系。这可以通过构造函数注入、方法注入或属性注入来实现。DI的目的是降低组件之间的耦合性，使它们更容易被替换、测试和维护。关于DI最简单的例子就是Setter了。

IoC的设计与实现

Spring Ioc容器的设计中，可以看到两个主要的容器系列：简单容器BeanFactory和高级容器ApplicationContext。

简单容器BeanFactory

简单模拟下BeadFactory演示IoC的设计：

创建配置文件，包含BeanDefinition的信息。
```
user:com.elaine.myspring.ioc.beanfactory.bean.User
```

创建一个BeanDefinition类，定义bean的属性。

public class BeanDefinition {private String beanName;
private Class beanClass;
public String getBeanName() {return beanName;}
public void setBeanName(String beanName) {this.beanName = beanName;}
public Class getBeanClass() {return beanClass;}
public void setBeanClass(Class beanClass) {this.beanClass = beanClass;}
}

创建资源加载器ResourceLoader，用来加载配置文件中的配置。

/*** 载入配置文件，通过BeanDefinition解析加载*/
public class ResourceLoader {public static Map<String, BeanDefinition> getResource() {Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(16);Properties properties = new Properties();try {InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties");properties.load(inputStream);// 迭代遍历配置文件Iterator<String> iterator = properties.stringPropertyNames().iterator();while (iterator.hasNext()) {String key = iterator.next();String className = properties.getProperty(key);BeanDefinition beanDefinition = new BeanDefinition();beanDefinition.setBeanName(key);Class clazz = Class.forName(className);beanDefinition.setBeanClass(clazz);// 加载资源beanDefinitionMap.put(key, beanDefinition);}inputStream.close();} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}return beanDefinitionMap;}
}

创建对象注册器BeanRegister，注册bean到container中。

public class BeanRegister {// 假设所有对象都是单例的，用一个单例map缓存private Map<String, Object> singletonMap = new HashMap<>();
/*** 获取单例bean* @param beanName* @return*/public Object getSingletonBean(String beanName) {return singletonMap.get(beanName);}
/*** 注册单例bean* @param beanName* @param bean*/public void registerSingletonBean(String beanName, Object bean) {if(singletonMap.containsKey(beanName)) {return;}singletonMap.put(beanName, bean);}
}

创建对象工厂BeanFactory，初始化需要完成资源的加载，对象注册器的创建。

public class BeanFactory {private BeanRegister beanRegister;
private Map<String, BeanDefinition> map = new HashMap<>();
public BeanFactory(){// 创建bean注册器beanRegister = new BeanRegister();// 加载资源this.map = new ResourceLoader().getResource();}
/*** 获取bean* @param beanName* @return*/public Object getBean(String beanName) {Object bean = beanRegister.getSingletonBean(beanName);if (bean != null) {return bean;}return createBean(map.get(beanName));}
/*** 创建bean* @param beanDefinition* @return*/private Object createBean(BeanDefinition beanDefinition) {try {Object bean = beanDefinition.getBeanClass().newInstance();beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);return bean;} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return null;}
}

测试验证。

public class TestUser {@Testpublic void beanFactory() {BeanFactory beanFactory = new BeanFactory();
// 第一次获取，通过反射User user = (User) beanFactory.getBean("user");user.sayHello();
// 第二次获取，通过缓存User user1 = (User) beanFactory.getBean("user");user.sayHello();
// 所有对象都是单例的前提下，是同一个对象System.out.println(user1 == user);}
}

高级容器ApplicationContext

ApplicationContext继承自BeanFactory，拥有更多的功能和特性，包括国际化、事件传播、资源访问等。
和BeanFactory的延迟加载不同，ApplicationContext会在容器启动时就实例化和初始化所有的bean。
支持更丰富的配置方式，包括XML配置、注解、java配置等，并且支持自动扫描并注册bean。

ApplicationContext通过读取xml配置的形式获取bean：

public class MySpringApplication {public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");Product product = (Product) applicationContext.getBean("product");System.out.println(product.getId());}
}