各种框架的工作原理（Spring+Struts2+Hibernate+SpringMvc+Mybatist）

Spring工作原理:Spring Framework 的核心组件有三个： Spring Core，Spring Context 和 Spring Beans，它们奠定了 Spring 的基础并撑起了 Spring 的框架结构。Spring 的其它功能特性例如 Web、AOP、JDBC 等都是在其基础上发展实现的。
I. Bean 组件
Spring 使用工厂模式来管理程序中使用的对象（Bean），Bean 工厂最上层的接口为 BeanFactory，简单来看，工厂就是根据需要返回相应的 Bean 实例。

public interface BeanFactory {
    //...        
    Object getBean(String name);
}

在工厂模式中，在工厂的实现类中生成 Bean 返回给调用客户端，这就要求客户端提供生成自己所需类实例的工厂类，增加客户负担。Spring 结合控制反转和依赖注入为客户端提供所需的实例，简化了客户端的操作。具体的实现方式大致如下。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    /** Map of bean definition objects, keyed by bean name */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>;
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition){     
        //...
    }
}

beanDefinitionMap 作为具体的 Bean 容器，Spring 创建的对象实例保存其中。客户端需要时，使用工厂的 getBean 方法去试图得到相应的实例，如果实例已存在，则返回该实例；如果实例不存在，则首先产生相应实例并通过 registerBeanDefinition 方法将其保存在 beanDefinitionMap 中（Lazy Initialization)，然后返回该实例给客户端。

                                                                          SpringBean工厂的继承关系

Spring 中的相关代码包是 org.springframework.beans

beanDefinitionMap 并不直接保存实例本身，而是将实例封装在 BeanDefinition 对象后进行保存。BeanDefinition 包含了实例的所有信息，其简化版的定义如下。

public class BeanDefinition {
    private Object bean;

    private Class<?> beanClass;
    private String beanClassName;

    // Bean 属性字段的初始化值
    private BeanPropertyValues beanPropertyValues;

    //...
}

Spring Bean 工厂生产 Bean 时
1) 先将实例的类型参数保存到 beanClass 和 beanClassName，将需要初始化的字段名和值保存到 beanPropertyValues 中，这个过程 Spring 通过控制反转来实现，本文第二小节将予以简要说明
2) 生成 bean 实例，并利用反射机制将需要初始化的字段值写入 bean 实例，将实例保存在 bean 中，完成 BeanDefinition 的构建。
假设我们已经完成了步骤 1) 的操作，之后的过程用代码表述如下所示。

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition){
    //生成 bean 实例，并完成初始化
    Object bean = createBean(beanDefinition);
    //将 bean 实例保存在 beanDefinition 中
    beanDefinition.setBean(bean);
    //将 beanDefinition 实例保存在 Spring 容器中
    beanDefinitionMap.put(beanName, beanDefinition);
}

protected Object createBean(BeanDefinition beanDefinition) {
    try{
        Object bean = beanDefinition.getBeanClass().newInstance();
        try {
            setBeanPropertyValues(bean, beanDefinition);
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException e) {
            e.printStackTrace();
        }
        return bean;
    }catch(InstantiationException e){
        e.printStackTrace();
    }catch(IllegalAccessException e){
        e.printStackTrace();
    }

    return null;
}

protected void setBeanPropertyValues(Object bean, BeanDefinition beanDefinition) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
    for(PropertyValue pv : beanDefinition.getBeanPropertyValues().getBeanPropertyValues()){
        Field beanFiled = bean.getClass().getDeclaredField(pv.getName());
        beanFiled.setAccessible(true);
        beanFiled.set(bean, pv.getValue());
    }
}

II. Context 组件
一般地，传统的程序设计中，无论是使用工厂创建实例，或是直接创建实例，实例调用者都要先主动创建实例，而后才能使用。控制反转（Inverse of Control) 将实例的创建过程交由容器实现，调用者将控制权交出，是所谓控制反转。
依赖注入（Dependence Injection) 在控制反转的基础上更进一步。如果没有依赖注入，容器创建实例并保存后，调用者需要使用 getBean(String beanName) 才能获取到实例。使用依赖注入时，容器会将 Bean 实例自动注入到完成相应配置的调用者，供其进一步使用。

Context 组件借助上述的控制反转和依赖注入，协助实现了 Spring 的 Ioc 容器。下面我们以一个 Service 类作为所需的 Bean 实例进行说明。实际应用中，我们会需要 Spring 管理很多 Bean 实例。

public class SampleService {
    private String service;
        public String getService() {
        return service;
    }
    public void setService(String service) {
        this.service= service;
    }
}

在程序运行过程中，需要一个 SampleService ，我们不让调用者 new 一个实例，而是在配置文件中表明该 SampleService 的实例交由 Spring 容器进行管理，并指定其初始化参数。配置文件即资源，其内容如下。

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean name="sampleService " class="com.service.SampleService ">
        <property name="service" value="This is a service"></property>
    </bean>
</beans>

Spring Core 组件提供 ResourceLoader 接口，便于读入 xml 文件或其他资源文件。其核心功能代码应该提供如下方法。

public class ResourceLoader {
    public Resource getResource(String location){
        URL resource = this.getClass().getClassLoader().getResource(location);
        return new UrlResource(resource);
    }
}

// UrlResource 的功能代码
public class UrlResource implements Resource {
    private final URL url;

    public UrlResource(URL url){
        this.url = url;
    }

    @Override
    public InputStream getInputStream() throws IOException {
        URLConnection urlConnection = url.openConnection();
        urlConnection.connect();
        return urlConnection.getInputStream();
    }

}

即加载资源文件，并以数据流的形式返回。Context 根据资源中的定义，生成相应的 bean 并保存在容器中，bean 的名字是 sampleService ，供程序进一步使用。这样就完成了控制反转的工作。接下来就需要把 sampleService 注入到需要使用它的地方，亦即完成依赖注入操作。
现在假设 SampleController 中使用 SampleService 的对象，Spring 提供三种依赖注入的方式，构造器注入、setter 注入和注解注入。

public class SampleController {
    /**
     * 3. 注解注入
    **/
    /* @Autowired */
    private SampleService sampleService;

    /**
     * 1. 构造器注入
    **/
    public SampleController(SampleService sampleService){
        this.sampleService = sampleService;
    }
    //无参构造函数
    public SampleController(){}

    // 类的核心功能
    public void process(){
        System.out.println(sampleService.getService());
    }
    /**
     * 2. setter 注入
    **/
    /*public void setService(SampleService service) {
        this.service= service;
    }*/
}

三种注入方式在配置文件中对应不同的配置方式，在前面 xml 文件的基础上，我们可以分别实现这三种注入方式。需要注意的是，这里 SampleController 也是使用 Spring 的 Ioc 容器生成管理的。

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean name="sampleService " class="com.service.SampleService ">
        <property name="service" value="This is a service"></property>
    </bean>

<!-- 1. 构造器注入方式为SampleContorller 的 bean 注入 SampleService -->
    <bean name="sampleContorller" class="com.controller.SampleContorller">
        <!-- index 是构造方法中相应参数的顺序 -->
        <constructor-arg index="0" ref="sampleService"></constructor-arg>
    </bean>

<!-- 2. setter 注入方式为SampleContorller 的 bean 注入 SampleService -->
<!--    
    <bean name="sampleContorller" class="com.controller.SampleContorller">
        <property name="sampleService " ref="sampleService"></property>
    </bean>
-->

<!-- 3. 注解注入方式为SampleContorller 的 bean 注入 SampleService -->
<!--    
    <bean name="sampleContorller" class="com.controller.SampleContorller">

    <!-- 不需要配置，Spring 自动按照类型注入相应的 bean -->
    </bean>
--> 
</beans>

SpringAop：面向切面编程（Aspect Oriented Programming）提供了另一种角度来思考程序的结构，通过这种方式弥补面向对象编程(Object Oriented Programming)的不足。除了类以外，AOP提供了切面，切面对关注点进行模块化，例如横切多个类型和对象的事务管理（这些关注点术语通常称作横切(crosscutting)关注点）。Spring AOP是Spring的一个重要组件，但是Spring IOC并不依赖于Spring AOP，这意味着你可以自由选择是否使用AOP，AOP提供了强大的中间件解决方案，这使得Spring IOC更加完善。我们可以通过AOP来实现日志监听，事务管理，权限控制等等。

AOP概念：

• 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是Java应用程序中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用通过类（基于模式（XML）的风格）或者在普通类中以@Aspect注解（AspectJ风格）来实现。
• 连接点（Join point）：程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中一个连接点总是代表一个方法的执行。说人话就是AOP拦截到的方法就是一个连接点。通过声明一个org.aspectj.lang.JoinPoint类型参数我们可以在通知(Advice)中获得连接点的信息。这个在稍后会给出案例。
• 通知(Advice)：在切面（Aspect）的某个特定连接点上（Join point）执行的动作。通知的类型包括"around"，"before"，"adter"等等。通知的类型将在后面进行讨论。许多AOP框架，包括Spring 都是以拦截器作为通知的模型，并维护一个以连接点为中心的拦截器链。总之就是AOP对连接点的处理通过通知来执行。说人话就是，Advice指当一个方法被AOP拦截到的时候要执行的代码。
• 切入点（Pointcut）：匹配连接点（Join point）的断言。通知（Advice）跟切入点表达式关联，并在与切入点匹配的任何连接点上面运行。切入点表达式如何跟连接点匹配是AOP的核心，Spring默认使用AspectJ作为切入点语法。说人话就是通过切入点的表达式来确定哪些方法要被AOP拦截，之后这些被拦截的方法会执行相对应的Advice代码。
• 引入（Introduction）：声明额外的方法或字段。Spring AOP允许你向任何被通知(Advice)对象引入一个新的接口（及其实现类）。说人话就是AOP允许在运行时动态的向代理对象实现新的接口来完成一些额外的功能并且不影响现有对象的功能。
• 目标对象（Target object）：被一个或多个切面（Aspect）所通知（Advice）的对象，也称作被通知对象。由于Spring AOP是通过运行时代理实现的，所以这个对象永远是被代理对象。说人话就是，所有的对象在AOP中都会生成一个代理类，AOP整个过程都是针对代理类在进行处理。
• AOP代理（AOP proxy）：AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能），在Spring中AOP可以是JDK动态代理或者是CGLIB代理。
• 织入（Weaving）：把切面（aspect）连接到其他的应用程序类型或者对象上，并创建一个被通知对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯AOP框架一样，在运行时完成织入。说人话就是把切面跟对象关联并创建该对象的代理对象的过程。

通知(Advice)的类型：

• 前置通知（Before advice）：在某个连接点（Join point）之前执行的通知，但这个通知不能阻止连接点的执行（除非它抛出一个异常）。
• 返回后通知（After returning advice）：在某个连接点（Join point）正常完成后执行的通知。例如，一个方法没有抛出任何异常正常返回。
• 抛出异常后通知（After throwing advice）：在方法抛出异常后执行的通知。
• 后置通知（After（finally）advice）：当某个连接点（Join point）退出的时候执行的通知（不论是正常返回还是发生异常退出）。
• 环绕通知（Around advice）：包围一个连接点（Join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

 

我个人对AOP流程的一个理解。我把面向对象的过程从一个HttpRquest到访问数据库DB的整个流程看做是一条直线。AOP定义了一个切面（Aspect），一个切面包含了切入点，通知，引入，这个切面上定义了许多的切入点(Pointcut)，一旦访问过程中有对象的方法跟切入点匹配那么就会被AOP拦截。此时该对象就是目标对象（Target Object）而匹配的方法就是连接点（Join Point）。紧接着AOP会用过JDK动态代理或者CGLIB生成一个目标对象的代理对象(AOP proxy)，这个过程就是织入（Weaving）。这个时候我们就可以按照我们的需求对连接点进行一些拦截处理。可以看到，我们可以引入（Introduction）一个新的接口，让代理对象来实现这个接口来，以实现额外的方法和字段。也可以在连接点上进行通知（Advice），通知的类型包括了前置通知，返回后通知，抛出异常后通知，后置通知，环绕通知。最后也是最骚的是整个过程不会改变代码原有的逻辑。下面我将通过简单的案例对Spring AOP进行演示，过程会包括XML以及Annotation。