IOC
我们学Java的基本上都会使用Spring进行开发，而Spring中最为核心的又是IOC和AOP，接下来的内容是在学习手写Spring渐进式源码实践这本书后的学习总结，看是否我们能开发出一个mini-Spring。因为后期代码会很多，而且基本上都是在前一版的基础上进行扩展。这里我只声明每一章的目标扩展点是啥，具体从Github上获取源码：
第一章：实现一个简单的Spring Bean容器
先不深究Spring源码，我就看自己平时使用Spring时的体会，使用Spring时，通过XML配置文件或者通过注解，声明哪些类是需要注入到容器中的，到自己使用时，可以从容器中获取该类对象。那这不就是我们基础中学的Collection或者Map就能实现的操作嘛，因为我需要频繁的从容器中获取指定类对象，所以查询返回的效率需要非常高，那就我们就用Map来实现，先不要想那么多。
public class BeanFactory { // 用Map来存储Bean private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); // 获取 public Object getBean(String name) { return beanDefinitionMap.get(name).getBean(); } // 注册 public void registerBeanDefinition(String name, BeanDefinition beanDefinition) { beanDefinitionMap.put(name, beanDefinition); } }
这里我们使用BeanDefinition来包裹实际的对象，因为我们知道一个Bean不仅拥有自己属性，还拥有一些通用属性，比如：单例模式还是原型模式，Bean内需要填充的属性，这里我们只做包裹，其余的后面实现。
public class BeanDefinition { // 实际填充的对象 private Object bean; // 省略 构造器 和 get方法。。 }
我们来测试一下：
/@Test public void test_BeanFactory(){ // 1.初始化 BeanFactory BeanFactory beanFactory = new BeanFactory(); // 2.注入bean BeanDefinition beanDefinition = new BeanDefinition(new UserService()); beanFactory.registerBeanDefinition("userService", beanDefinition); // 3.获取bean UserService userService = (UserService) beanFactory.getBean("userService"); userService.queryUserInfo(); }
第二章：实现Bean对象的定义，注册和获取
在上面我们可以看到我是创建好了的UserService放入容器中，这和我们之前学的依赖倒置并不符合，我们应只指定哪些Bean需要加载到容器中，具体的对象实例应又BeanFactory自己管理，所以我们修改BeanDefinition，在内只存放Bean的Class对象。
public class BeanDefinition { private Class beanClass; // 构造器 get，set方法 }
BeanFactory也修改为接口，定义获取Bean的方式，具体Bean存储与获取交给子类来实现，使职责单一。
我们在这里先假设每个Bean都是单例的，创建SingletonBeanRegistry接口，定义注册和获取单例对象的方式，剩下的交给子类具体实现。
现在系统中有两个容器，一个是BeanDefinitionMap负责存储加载到容器的Bean信息，一个是singletonObjects负责存储已经创建好的单例对象。具体可看下面的UML类图，关系还是很清楚的。BeanFactory在实例化对象时，通过BeanDefinitionMap中的类信息，通过反射直接创建对象，并放入容器中。
Spring中有大量的接口与抽象类，我个人感觉是将职责划分清楚，容易未来系统的扩展性，有一点是通过抽象类去实现接口，并定义自己的抽象方法，而且可以实现一部分的接口方法，这样既可以扩容接口，又能保证自己可以只实现自己职责内的方法。
第三章：基于Cglib实现含有构造函数的类实例化策略
在第二章中我们在AbstractAutowireCapableBeanFactory::createBean中通过反射进行Bean的实例化，这一章我们引入了实例化策略：InstantiationStrategy，并通过JDK和Cglib两个种方式去实现。
JDK 和 Cglib实例化对象有什么区别
CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。
第四章：注入属性与依赖对象
比方说我UserService内需要注入UserDao来操作数据库，所以我在实例化Bean后，应将所需的属性和依赖注入到Bean中，而这部分信息通过PropertyValues记录，并封装到BeanDefinition中。在实例化后应通过对应BeanDefinition获取到需要哪些内容，并进行填充处理。
第五章：资源加载器解析文件注册对象
这里我们要加入XML解析，在上面我们都是手动将所有信息通过Java注册到BeanFactory的，这不利于维护，现实Spring中我们都是使用Xml进行配置或者注解开发，所以我们需要定义一个ResourceLoader去加载各种数据（XML文件，URL，Classpath）。
资源加载，读取指定资源，转化为Resource，核心是获取文件的二进制流为后面解析
资源解析：利用XML解析器解析
Spring.xml文件,获取所有Bean信息定义，并将其封装为BeanDefinition并注册
容器初始化：完成实例的实例化与属性填充
这一章类扩展的很多，建议仔细读两遍源码，着重关注资源加载解析部分即可，其余流程大体不变。
第六章：实现应用上下文
重点：
引入应用上下文，进行资源扫描与加载，为Bean对象实例化过程添加扩展机制，允许加载Bean对象和在其实例化前后进行修改和扩展。
核心：
增加BeanPostProcessor 和 BeanFactoryPostProcessor
有啥用：
比如说我们想在Bean的实例化之前，对BeanDefinition做出记录或修改，影响Bean的实例化，或者在Bean的初始化方法前后进行一系列操作，这是后面章节的基础部分，实现容器感知，AOP等技术的实现
AbstractApplicationContext::refresh() 刷新容器
@Override public void refresh() throws BeansException { // 1. 创建 BeanFactory，并加载 BeanDefinition refreshBeanFactory(); // 2. 获取 BeanFactory ConfigurableListableBeanFactory beanFactory = getBeanFactory(); // 3. 在 Bean 实例化之前，执行 BeanFactoryPostProcessor ，这时候Bean还没有实例化，找到所有的BeanFactoryPostProcessor，进行处理，可以修改BeanDefinition ！！！ invokeBeanFactoryPostProcessors(beanFactory); // 4. BeanPostProcessor 需要提前于其他 Bean 对象实例化之前执行注册操作，找到所有的BeanPostProcessor，添加到一个容器中，等对象实例化时进行处理 ！！！ registerBeanPostProcessors(beanFactory); // 5. 提前实例化单例Bean对象 beanFactory.preInstantiateSingletons(); }
加载出所有注册的BeanFactoryPostProcessor，普通Bean实例化前操作
private void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { Map<String, BeanFactoryPostProcessor> beanFactoryPostProcessorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class); for (BeanFactoryPostProcessor beanFactoryPostProcessor : beanFactoryPostProcessorMap.values()) { beanFactoryPostProcessor.postProcessBeanFactory(beanFactory); } }
加载出所有注册的BeanPostProcessor，必须加载并注册，因为这些Bean是转为针对普通Bean实例化后操作的。
private void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { Map<String, BeanPostProcessor> beanPostProcessorMap = beanFactory.getBeansOfType(BeanPostProcessor.class); for (BeanPostProcessor beanPostProcessor : beanPostProcessorMap.values()) { beanFactory.addBeanPostProcessor(beanPostProcessor); } }
public void preInstantiateSingletons() throws BeansException { // 实例化所有未实例化的Bean beanDefinitionMap.keySet().forEach(this::getBean); } protected <T> T doGetBean(final String name, final Object[] args) { // 先从单例工厂找，有则直接返回，这样就不担心之前加载的Processor再被加载处理了 Object bean = getSingleton(name); if (bean != null) { return (T) bean; } // 获取Bean对应的定义信息 BeanDefinition beanDefinition = getBeanDefinition(name); // 实例化Bean return (T) createBean(name, beanDefinition, args); } @Override protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException { Object bean = null; try { // 将 Bean 实例化，执行构造器方法 bean = createBeanInstance(beanDefinition, beanName, args); // 给 Bean 填充属性 applyPropertyValues(beanName, bean, beanDefinition); // 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法 bean = initializeBean(beanName, bean, beanDefinition); } catch (Exception e) { throw new BeansException("Instantiation of bean failed", e); } // 将Bean注入单例容器中 registerSingleton(beanName, bean); return bean; } private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) { // 1. 执行 BeanPostProcessor Before 处理 ！！！ Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName); // 待完成内容：invokeInitMethods(beanName, wrappedBean, beanDefinition); 这里就是未来init方法调用的地方 invokeInitMethods(beanName, wrappedBean, beanDefinition); // 2. 执行 BeanPostProcessor After 处理 ！！！ wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); return wrappedBean; }
第七章：Bean对象的初始化与销毁
<?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao" init-method="initDataMethod" destroy-method="destroyDataMethod"/> </beans>
在Bean定义信息中我们指定了初始化方法（和对象构造器方法无关）和销毁方法。加入了init-method 和 destroy-method。我们可以在Xml解析中，读取出该数据，并把该数据保存到BeanDefinition中。这里的销毁方法，我们利用JVM的Hook进行调用。
public class BeanDefinition { private Class beanClass; private PropertyValues propertyValues; private String initMethodName; private String destroyMethodName; // ...get/set/construct方法 }
除了在Xml中进行设置初始化和销毁方式外，我们也可以设计两个接口，让Bean来实现对应的方法，未来初始化时执行相应方法。
public interface InitializingBean { /** * Bean 处理了属性填充后调用 */ void afterPropertiesSet() throws Exception; } public interface DisposableBean { /** * Bean 销毁时执行 */ void destroy() throws Exception; }
