Spring框架

目录

Spring AOP

AOP原理

Spring IOC

IOC工作流程

IOC原理

Spring Bean作用域

Spring Bean作用域并发安全

Spring循环依赖

Spring容器获取bean实例

依赖注入 DI

基于field注入

基于Setter注入

基于构造器注入

Spring自带工具类

Spring@Async注解

同步调用和异步调用

Spring实现的线程池

@Async自定义线程池

Spring ORM

Spring Batch

Spring Message

---

Spring是什么，为什么用Spring

Spring是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与Swing等桌面应用程序AP组合。Spring不仅仅能应用于J2EE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是Spring Core、Spring AOP、Spring ORM、 Spring DAO、Spring Context、Spring Web和Spring Web MVC。

Spring | Home

Spring AOP

AOP(Aspect Oriented Programming)面向切面思想。Java是一个面向对象(OOP)的编程语言，当需要为多个不具有继承关系的对象引入一个公共行为时，例如日志记录、权限校验、事务管理、统计等功能，只能在每个对象里都引用公共行为，这样做不便于维护，而且有大量重复代码，AOP的出现弥补了OOP的这点不足。

AOP原理

给对象提供代理以控制对这个对象的访问，分为静态代理和动态代理，静态代理就是在程序运行前就已经存在代理类的字节码文件，代理类和原始类的关系在运行前就已经确定。动态代理类的源码是在程序运行期间通过JVM反射等机制动态生成，代理类和委托类的关系是运行时才确定的。JDK代理和Cglib代理两种动态代理，Spring框架在底层都集成了进去，无需担心实现动态生成代理。

Spring是如何生成代理对象的

创建容器对象的时候，根据切入点表达式拦截的类，生成代理对象。如果目标对象有实现接口，使用jdk代理。如果目标对象没有实现接口，则使用Cglib代理。然后从容器获取代理后的对象，在运行期植入"切面"类的方法。如果目标类没有实现接口，且class为final修饰的，则不能进行Spring AOP编程。

Spring IOC

控制反转(Inversion Of Control)，将对象的创建和依赖关系(对象之间的依赖关系可以通过配置文件或者注解来建立)交给第三方容器处理，用的时候告诉容器需要什么然后直接去拿就行了。

IOC工作流程

Person类作为bean

   public class Person {
       public void work(){
           System.out.println("I am working...");
       }
   }

applicationContext.xml配置bean

 测试类

public class Client {
    public static void main(String[] args) {
           ClassPathResource classPathResource = new ClassPathResource("applicationContext.xml");//资源定位
           DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();//创建一个默认的bean工厂
           XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(defaultListableBeanFactory);//创建Reader用来读取xml文件，将创建的defaultListableBeanFactory作为参数传递给Reader，表示为此工厂创建Reader
           beanDefinitionReader.loadBeanDefinitions(classPathResource);//Reader读取配置信息，并将解析的bean定义注册到defaultListableBeanFactory中。
           System.out.println(defaultListableBeanFactory.getBeanDefinitionCount());
           Person person = (Person)defaultListableBeanFactory.getBean("person");
           person.work();
     }
}

先获取资源定位，然后创建了一个默认的bean工厂，然后创建了一个Reader用来读取xml文件，将创建的defaultListableBeanFactory作为参数传递给Reader，表示为此工厂创建Reader，用Reader读取配置信息，并将解析的bean定义注册到defaultListableBeanFactory 中。这样bean工厂就正确初始化了，可以调用工厂的getBean()方法获取实例了。Spring用ApplicationContext包含了上面所有步骤，如下：

IOC原理

IOC(Inversion of Control)即控制反转，将对象的创建和依赖关系交给第三方容器处理，当需要某个对象时，容器会把这个对象返回给你，而不需要自己去new出一个对象，对象的创建和管理会由容器自动进行，直接从容器中拿来用就可以了。源码如下：     

package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";
    Object getBean(String name) throws BeansException;
     T getBean(String name, @Nullable Class requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
     T getBean(Class requiredType) throws BeansException;
     T getBean(Class requiredType, Object... args) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, @Nullable Class typeToMatch) throws NoSuchBeanDefinitionException;

    @Nullable
    Class getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}   

这个接口便是spring核心的bean工厂定义，它是IOC容器的顶层接口，spring中所有bean工厂都直接或间接的实现了这个接口。ApplicationContext接口也继承了BeanFactory接口，因此它具有BeanFactory接口的所有功能。从BeanFactory获取bean时，实例化BeanFactory容器并不会实例化所配置的bean，只有当使用某个bean(getBean)时，才会实例化该bean。ApplicationContext获取bean时，实例化ApplicationContext容器时会一并实例化容器中的所有的bean。BeanFactory的源码可以看出，它实现的核心功能就是根据名称或类型来返回一个bean实例。一个工厂如果要具备这种功能，结合工厂模式的思想，设想它应该需要具备以下几个条件：

1、持有各种bean的定义，只有拿到了bean的定义信息，才能根据这些信息进行实例化。

2、持有各种bean之间的依赖关系，如果一个类中持有对另一个类的引用，那么在对该类进行实例化时，必须根据类之间的依赖关系对相关类也进行实例化，所以工厂必须获得类之间的依赖关系，否则无法正确实例化。

3、以上两种信息都依赖于配置信息定义，比如xml配置文件，工厂需要一个工具来读取配置文件的信息。

以上是我们设想IOC的实现思路，只要满足以上三个条件，就能构造一个工厂，生产各种bean。首先如何持有bean的定义呢？看下面接口：

package org.springframework.beans.factory.config;

import org.springframework.beans.BeanMetadataElement;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.core.AttributeAccessor;
import org.springframework.lang.Nullable;

/**
 * 一个BeanDefinition描述一个bean实例具有的属性值，构造函数参数值，以及具体实现的进一步信息。
 * 
 * A BeanDefinition describes a bean instance, which has property values,
 * constructor argument values, and further information supplied by
 * concrete implementations.
 *
 */
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
    String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
    int ROLE_APPLICATION = 0;
    int ROLE_SUPPORT = 1;
    int ROLE_INFRASTRUCTURE = 2;
    void setParentName(@Nullable String parentName);

    @Nullable
    String getParentName();
    void setBeanClassName(@Nullable String beanClassName);

    @Nullable
    String getBeanClassName();

    void setScope(@Nullable String scope);

    @Nullable
    String getScope();

    void setLazyInit(boolean lazyInit);
    boolean isLazyInit();

    /**
     * Set the names of the beans that this bean depends on being initialized.
     * The bean factory will guarantee that these beans get initialized first.
     */
    void setDependsOn(String... dependsOn);

    /**
     * Return the bean names that this bean depends on.
     */
    @Nullable
    String[] getDependsOn();
    void setAutowireCandidate(boolean autowireCandidate);
    boolean isAutowireCandidate();
    void setPrimary(boolean primary);
    boolean isPrimary();
    void setFactoryBeanName(@Nullable String factoryBeanName);

    @Nullable
    String getFactoryBeanName();
    void setFactoryMethodName(@Nullable String factoryMethodName);

    @Nullable
    String getFactoryMethodName();
    ConstructorArgumentValues getConstructorArgumentValues();
    MutablePropertyValues getPropertyValues();
    boolean isSingleton();
    boolean isPrototype();
    boolean isAbstract();
    int getRole();

    @Nullable
    String getDescription();

    @Nullable
    String getResourceDescription();

    @Nullable
    BeanDefinition getOriginatingBeanDefinition();
}

BeanDefinition是spring中的bean定义接口，spring工厂里持有的就是此接口定义的内容。这个接口继承了另外两个接口，一个是AttributeAccessor接口，继承这个接口就意味着BeanDefinition接口拥有了处理属性的能力，另外一个接口是BeanMetedataElement，它可以获得bean的配置定义的元素，对于xml文件来说就是会持有bean的标签。BeanDefinition接口定义了两个方法分别是void setDependsOn(String... dependsOn)和String[] getDependsOn()，这两个方法是设置依赖的bean的名称和获取依赖bean的名称，只要有一个BeanDefinition，就能得到得到bean的定义信息和bean之间的依赖关系，从而可以生产一个完整的bean实例。让bean工厂持有一个Map，String型的beanName作为key，BeanDefinition型的bean定义作为value，这样就能生产一个bean实例。这个map对象是在BeanDefinition的某个实现类里所持有的。来找到这个实现类：

package org.springframework.beans.factory.support;

import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.inject.Provider;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.TypeConverter;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanCurrentlyInCreationException;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.BeanNotOfRequiredTypeException;
import org.springframework.beans.factory.CannotLoadBeanClassException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InjectionPoint;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.SmartFactoryBean;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.config.NamedBeanHolder;
import org.springframework.core.OrderComparator;
import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.CompositeIterator;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

/**
 * 基于bean definition对象的完整bean工厂
 * 
 * Default implementation of the
 * {@link org.springframework.beans.factory.ListableBeanFactory} and
 * {@link BeanDefinitionRegistry} interfaces: a full-fledged bean factory
 * based on bean definition objects.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Sam Brannen
 * @author Costin Leau
 * @author Chris Beams
 * @author Phillip Webb
 * @author Stephane Nicoll
 * @since 16 April 2001
 * @see StaticListableBeanFactory
 * @see PropertiesBeanDefinitionReader
 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
 */
@SuppressWarnings("serial")
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    @Nullable
    private static Class javaxInjectProviderClass;

    static {
        try {
            javaxInjectProviderClass =
                    ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
        }
        catch (ClassNotFoundException ex) {
            // JSR-330 API not available - Provider interface simply not supported then.
            javaxInjectProviderClass = null;
        }
    }


    /** Map from serialized id to factory instance */
    private static final Map> serializableFactories =
            new ConcurrentHashMap<>(8);

    /** Optional id for this factory, for serialization purposes */
    @Nullable
    private String serializationId;

    /** Whether to allow re-registration of a different definition with the same name */
    private boolean allowBeanDefinitionOverriding = true;

    /** Whether to allow eager class loading even for lazy-init beans */
    private boolean allowEagerClassLoading = true;

    /** Optional OrderComparator for dependency Lists and arrays */
    @Nullable
    private Comparator