几个直击灵魂的Spring拷问（五）

这一篇主要来讲讲Spring的架构设计理念和优秀的设计模式吧。

一、体系框架

Spring 框架采用分层架构，根据不同的功能被划分成了多个模块，这些模块大体可分为 Data Access/Integration、Web、AOP、Aspects、Messaging、Instrumentation、Core Container 和 Test。

Spring 总共有十几个组件，Spring 框架中的核心组件只有三个：Core、Context 和 Beans。它们构建起了整个 Spring 的骨骼架构。Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context 要解决的问题，所以 Context 就是一个 Bean 关系的集合，这个关系集合又叫 Ioc 容器，一旦建立起这个 Ioc 容器后 Spring 就可以为你工作了。而Core 就是发现、建立和维护每个 Bean 之间的关系所需要的一些列的工具。

Bean组件

Bean 组件在 Spring 的 org.springframework.beans 包下。这个包下的所有类主要解决了三件事：Bean 的定义、Bean 的创建以及对 Bean 的解析。对 Spring 的使用者来说唯一需要关心的就是 Bean 的创建，其他两个由 Spring 在内部完成，对开发透明。

Spring Bean 的创建时典型的工厂模式，它的顶级接口是 BeanFactory，下图是这个工厂的继承层次关系：

Bean 工厂的继承关系

Bean 的定义就是完整的描述了在 Spring 的配置文件或者Spring注解中定义的bean所有的信息，包括各种子节点。当 Spring 成功解析你定义的一个节点后，在 Spring 的内部就被转化成 BeanDefinition 对象。

context组件

Context 在 Spring 的 org.springframework.context 包下，前面已经讲解了 Context 组件在 Spring 中的作用，他实际上就是给 Spring 提供一个运行时的环境，用以保存各个对象的状态。

标识一个应用环境
利用 BeanFactory 创建 Bean 对象
保存对象关系表
能够捕获各种事件

core组件

Core 组件作为 Spring 的核心组件，他其中包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。 Resource 接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。Context 和 Resource 是如何建立关系的？

Context 是把资源的加载、解析和描述工作委托给了 ResourcePatternResolver 类来完成，他相当于一个接头人，他把资源的加载、解析和资源的定义整合在一起便于其他组件使用。Core 组件中还有很多类似的方式。

参考引用：https://developer.ibm.com/zh/articles/j-lo-spring-principle/

Spring中优秀的设计模式

1、静态工厂模式

简单工厂模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 spring中的 BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

自己来实现一个简单工厂还是挺easy的，比如按照这个文章的<工厂模式--简单工厂模式>

1、抽象产品，负责描述所有实例共有的公共接口

public interface Computer {
    /**
     * 产品的抽象方法，由具体的产品类去实现
     */
    public abstract void start();
}

2、具体产品，是简单工厂模式的创建目标。

public class LenovoComputer implements Computer{
    @Override
    public void start() {
        System.out.println("联想电脑启动");
    }

3、简单工厂，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

public class ComputerFactory {
    public static Computer createComputer(String type){
        Computer mComputer=null;
        switch (type) {
            case "lenovo":
                mComputer=new LenovoComputer();
               break;
            case "hp":
                mComputer=new HpComputer();
                break;
            case "asus":
                mComputer=new AsusComputer();
                break;

        }
        return mComputer;
    }
}

好处：使用户根据参数获得对应的类实例，避免了直接实例化类，降低了耦合性。
坏处：简单工厂模式每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度，违背了“开闭原则”。

Spring 中的 BeanFactory 就是简单工厂模式的体现，根据传入一个唯一的标识来获得 Bean 对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。在容器启动过程中，Spring读取 bean 的 xml 配置文件或者注解了Bean的组件，将 bean 元素分别转换成一个 BeanDefinition 对象。然后通过 BeanDefinitionRegistry 将这些 bean 注册到 beanFactory 中，保存在它的一个 ConcurrentHashMap 中。取的时候通过这个方法来取：

Object getBean(String name)
<T> T getBean(Class<T> requiredType) 
<T> T getBean(String name, Class<T> requiredType)

2、工厂方法模式

工厂方法模式是对简单工厂模式进一步的解耦，一个产品要抽象成一个专门的工厂来生产，原来的简单工厂要进一步划分为抽象工厂和具体工厂。新增一种产品类型的时候，无需修改原来的“简单工厂”，只需要按照接口约定，实现抽象工厂，扩展出这个产品对应的具体工厂来即可！

1.抽象工厂，提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。

public interface ComputerFactory {
    public Computer createComputer() ;
}

2.具体工厂，主要是实现抽象工厂中的抽象方法，完成具体产品的创建。

// Lenove类工厂
public class LenovoComputerFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new LenovoComputer();
    }
}

3、产品还是维持原先的抽象产品和具体产品不变，那么需要产品的时候，只需要先拿一个工厂，然后再创建产品即可使用。

public class Client {

    public static void main(String[] args) {
        ComputerFactory cf = new LenovoComputerFactory();
        Computer computer = cf.createComputer();
        computer.start();
    }
}

在Spring中用到的静态工厂模式的是FactoryBean接口，具体包含的接口如下所以：

T getObject() throws Exception;    //返回此工厂管理的对象的实例
Class<?> getObjectType();    //返回此FactoryBean创建的对象的类型
//这个工厂返回的对象是否是单例，默认返回true；若是单例则由getObject返回的//是相同的对象，是可以缓存的引用
default boolean isSingleton() {     
   return true;
}

所以对照着来看的，Factorybean本身就是一个抽象工厂，每个开发自己实现Factorybean接口的实现类就是一个具体工厂，这个工厂通过 getObject() 方法可以拿到一个特定的对象。
在Spring工程中使用Factorybean也很简单，案例如下：

//FactoryBean接口的实现类
@Component
public class FactoryBeanLearn implements FactoryBean {

    @Override
    public Object getObject() throws Exception {
        //这个Bean是我们自己new的，这里我们就可以控制Bean的创建过程了
        return new FactoryBeanServiceImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return FactoryBeanService.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}
//接口
public interface FactoryBeanService {

    /**
     * 测试FactoryBean
     */
    void testFactoryBean();
}
//实现类
public class FactoryBeanServiceImpl implements FactoryBeanService {
    /**
     * 测试FactoryBean
     */
    @Override
    public void testFactoryBean() {
        System.out.println("我是FactoryBean的一个测试类。。。。");
    }
}
//单测
@Test
public void test() {
        ClassPathXmlApplicationContext cac = new ClassPathXmlApplicationContext("classpath:com/applicationContext.xml");
        FactoryBeanService beanService = cac.getBean(FactoryBeanService.class);
        beanService.testFactoryBean();
    }

实现原理：实现了 FactoryBean 接口的 bean 是一类叫做 factory 的 bean。其特点是，spring 会在使用 getBean()调用获得该 bean 时，会自动调用该 bean 的 getObject()方法，所以返回的不是 factory 这个 bean，而是这个 bean.getOjbect()方法的返回值。

3、观察者模式

也叫发布-订阅模式，Spring 的事件驱动模型使用的是观察者模式，Spring 中 Observer 模式常用的地方是 listener 的实现。具体的使用方式在基于JDK与Spring中的观察者模式
已经提供了，其原理简单概括下：

事件机制的实现需要三个部分：事件源，事件，事件监听器

1、事件，所有的事件都需要继承 ApplicationEvent，ApplicationEvent 抽象类[事件] 继承自 JDK 的 EventObject，并且通过构造器参数 source 得到事件源，ApplicationContextEvent 表示 ApplicaitonContext 的容器事件。

public abstract class ApplicationEvent extends EventObject {
    private static final long serialVersionUID = 7099057708183571937L;
    private final long timestamp;
    public ApplicationEvent(Object source) {
    super(source);
    this.timestamp = System.currentTimeMillis();
    }
    public final long getTimestamp() {
        return this.timestamp;
    }
}

2、事件监听器，所有的监听器都要实现 ApplicationListener 接口，这个接口只有一个 onApplicationEvent()方法,该方法接受一个 ApplicationEvent 或其子类对象作为参数，在方法体中，可以通过不同对 Event 类的判断来进行相应的处理。当事件触发时所有的监听器都会收到消息。

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

3、事件源，ApplicationContext 是 spring 中的全局”应用上下文”，它负责实现了 ApplicationEventPublisher 接口。Applicationcontext 通过publishEvent() 方法发布 Event 广播给所有的监听器。

public interface ApplicationEventPublisher {
        void publishEvent(ApplicationEvent event);
}

public void publishEvent(ApplicationEvent event) {
    Assert.notNull(event, "Event must not be null");
    if (logger.isTraceEnabled()) {
         logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    }
    getApplicationEventMulticaster().multicastEvent(event);
    if (this.parent != null) {
       this.parent.publishEvent(event);
    }
}

Spring中的设计模式很多，前面已经讲过了动态代理部分，还有一个单例模式，十分重要单独抽取成章节继续讲解。

1、微信文章.Spring中涉及的设计模式总结
2、软件设计模式概述