spring bean的重新加载

架构体系　　

　　在谈spring bean的重新加载前，首先我们来看看spring ioc容器。

　　spring ioc容器主要功能是完成对bean的创建、依赖注入和管理等功能，而这些功能的实现是有下面几个组件完成的：

　　Resource：对资源的抽象，不同的资源有不同的实现，例如：ClasspathResource、FileSystemResource。。。

　　BeanDefinition：描述一个具体的bean,里面包含了bean的一些基本信息，不同类型的bean也有不同的实现类：ScannedGenericBeanDefinition、RootBeanDefinition

　　BeanDefinitionReader：将资源转化BeanDefinition的一个接口，针对不同类型的资源有不同的实现：XmlBeanDefinitionReader、PropertiesBeanDefinitionReader

　　BeanFactory：bean工厂，实现了对bean的创建、注入于与管理

　　ApplicationContext：应用上下文，持有BeanFactory对象

　　

　　BeanFactory

　　　　 SpringBean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在Spring中有许多的IOC容器的实现供用户选择和使用

　　　　

　　　　BeanFactory定义了工厂类基本的操作，BeanFactory有三个直属子类：AutowireCapableBeanFactory，HierarchicalBeanFactory，ListableBeanFactory；这个三个子类定义了spring对不同bean的处理。

spring对不同的场景提供了不同实现，下面的类

　　　　AutowireCapableBeanFactory：定义了对bean的创建与注入

　　　　HierarchicalBeanFactory：定义了对结构化的bean进行处理

　　　　ListableBeanFactory：定义了对bean的匹配查找

　　　　DefaultListableBeanFactory：以上三个接口的默认实现。提供了bean定义的注册与缓存和对単例bean的初始化

　　BeanDefinition

　　　　BeanDefinition是对一个具体的bean的描述，包括了initMethodName、destroyMethodName、资源文件等 。　　

　　

bean 创建注入

　　ioc容器的初始化过程包括对资源的定位、资源的解析、beanDefinition的注册、bean的创建与注入。

　　  refresh是整个ioc容器创建的入口

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // 实现了对资源的定位，解析，beanDefinition的注册
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
　　　　　　
            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // 初始scope为singleton和不是延迟加载的bean
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

　　resource的解析和beanDefinition的注册

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

    //beanDefintion的注册
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // 将beanDefintion注册到beanFactory
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

　　单例bean的创建入口。

public void preInstantiateSingletons() throws BeansException {

        List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

        // 创建bean
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                            @Override
                            public Boolean run() {
                                return ((SmartFactoryBean<?>) factory).isEagerInit();
                            }
                        }, getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }
    }

　　spring在内部维护了一个缓存用来保存已创建的单例bean，所以spring在创建bean的时候会首先在缓存里看有没有，如果没有则创建，这同时也为循环依赖提供了支持，spring不对是原型的bean提供循环依赖支持

    protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

        final String beanName = transformedBeanName(name);
        Object bean;

        // 首先从缓存里取
        Object sharedInstance = getSingleton(beanName);

        //省略其它代码
        。。。
        。。。
        。。。
    }

　　创建bean

　　　　 BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }

　　bean注入过程，根据注入类型注入

if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            // Add property values based on autowire by name if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            // Add property values based on autowire by type if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
        }

　　一般我们在项目中使用@Autowired注解是由AutowiredAnnotationBeanPostProcessor这个类实现注入的

    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        //获取注入元数据
        //AutowiredAnnotationBeanPostProcessor里面维护了一个变量用户缓存注入元数据
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        try {
            metadata.inject(bean, beanName, pvs);//依赖注入
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }

    public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
        Collection<InjectedElement> elementsToIterate =
                (this.checkedElements != null ? this.checkedElements : this.injectedElements);
        if (!elementsToIterate.isEmpty()) {
            boolean debug = logger.isDebugEnabled();
            for (InjectedElement element : elementsToIterate) {
                if (debug) {
                    logger.debug("Processing injected element of bean '" + beanName + "': " + element);
                }
                element.inject(target, beanName, pvs);
            }
        }
    }

    protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            Field field = (Field) this.member;
            try {
                Object value;
                if (this.cached) {
                    value = resolvedCachedArgument(beanName, this.cachedFieldValue);
                }
                else {
                    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                    desc.setContainingClass(bean.getClass());
                    Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                    TypeConverter typeConverter = beanFactory.getTypeConverter();
                    //获取依赖的bean，会递归调用getBean()方法，直到获取到的bean没有任何依赖
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                    synchronized (this) {
                        if (!this.cached) {
                            if (value != null || this.required) {
                                this.cachedFieldValue = desc;
                                registerDependentBeans(beanName, autowiredBeanNames);
                                if (autowiredBeanNames.size() == 1) {
                                    String autowiredBeanName = autowiredBeanNames.iterator().next();
                                    if (beanFactory.containsBean(autowiredBeanName)) {
                                        if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                            this.cachedFieldValue = new RuntimeBeanReference(autowiredBeanName);
                                        }
                                    }
                                }
                            }
                            else {
                                this.cachedFieldValue = null;
                            }
                            this.cached = true;
                        }
                    }
                }
                if (value != null) {
                    ReflectionUtils.makeAccessible(field);
                    field.set(bean, value);//通过反射设置值
                }
            }
            catch (Throwable ex) {
                throw new BeanCreationException("Could not autowire field: " + field, ex);
            }
        }
    }

 spring bean的重新加载

　　大家都知道我们在eclipse debug模式运行应用程序时，当我们修改了方法体内的代码时，是不需要马上重启就能生效的（其中的原理暂时没找到）。现在我们要实现的spring bean的重新加载，不仅可实现对方法体外做了代码修改能生效，也不需要在dubug模式运行。要实现这样的功能，首先我们要收集到spring为我们创建了哪些bean，然后监听bean对应的字节码文件有没有发生改变，当发生改变时，重新加载。

　　spring bean的收集

　　spring在创建bean时，使用了beanDefinition来描述一个bean，并把beanDefinition维护在DefaultListableBeanFactory.beanDefinitionMap。收集bean 可以在spring容器启动完成时获取beanFactory并持有，创建一个ApplicationListener的实现类

　　

public class Startup implements ApplicationListener<ContextRefreshedEvent> {

    public void onApplicationEvent(ContextRefreshedEvent event) {
        BeanWatch beanWatch = new BeanWatch(event.getApplicationContext());
        beanWatch.start();
    }
}

　　获取需要监听的bean

private Map<String, ClassBeanDefinition> findWatchBean() {
        Map<String, ClassBeanDefinition> watchBeans = new HashMap<String, ClassBeanDefinition>();
        for (String name : applicationContext.getBeanDefinitionNames()) {// 获取spring管理的所有bean名称
            Object bean = applicationContext.getBean(name);// 获取bean
            BeanDefinition beanDefinition = beanFactory.getMergedBeanDefinition(name);
            Class<?> clazz = bean.getClass();
            URL resource = clazz.getResource("");
            File file = new File(resource.getPath() + clazz.getSimpleName() + ".class");
            ClassBeanDefinition classBeanDefinition = new ClassBeanDefinition();
            classBeanDefinition.setBeanDefinition(beanDefinition);
            classBeanDefinition.setFile(file);
            classBeanDefinition.setBeanName(name);
            watchBeans.put(name, classBeanDefinition);
        }
        return watchBeans;
    }

　　字节码重新加载

　　收集完字节码文件之后要做的就是，对文件的监听，当一个文件发生改变时，我们需要做的是重新将改变的class文件加载进来，但spring为我们创建bean时已经将class文件加载进来了，由于java的类加载机制，一个类只会加载一次，所以我们需要自定义一个classLoader去动态的加载我们需要的类

public class DynamicClassLoader extends ClassLoader {

    public DynamicClassLoader(ClassLoader parent) {
        super(parent);
    }

    public Class<?> loadClass(File file,String className) throws ClassNotFoundException {
        try {
            InputStream input = new FileInputStream(file);
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int data = input.read();
            while (data != -1) {
                buffer.write(data);
                data = input.read();
            }
            input.close();
            byte[] classData = buffer.toByteArray();
            return defineClass(className, classData, 0, classData.length);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

}

重新加载bean

　　当我们拥有了最新的字节码时，我们需要把bean工厂维护的beanDefinition修改为最新的字节码并把spring工厂对应的bean缓存删除，然后再调用beanFactory的getBean()方法

public void reloadBean(ClassBeanDefinition classBeanDefinition, Class<?> clazz, DynamicClassLoader classLoader) {
        try {
            //只针对ScannedGenericBeanDefinition做实现
            ScannedGenericBeanDefinition beanDefinition = (ScannedGenericBeanDefinition) beanDefinitionMap.get(classBeanDefinition.getBeanName());
            beanDefinition.setBeanClass(clazz);
            // 删除beanFactory缓存的bean
            factoryBeanObjectCache.remove(classBeanDefinition.getBeanName());
            // 删除合并的BeanDefinitions
            mergedBeanDefinitions.remove(classBeanDefinition.getBeanName());
            Object bean = beanFactory.getBean(classBeanDefinition.getBeanName());
            reloadReferenceClass(classBeanDefinition, bean, classLoader);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

　　到此我们已经把改变的bean重新加载进来，但是，如果该bean是别的bean的一个依赖，那么我们需要为有依赖了改变的bean重新进行注入。由于我们前面将bean加载进来时，bean的字节码是被不同的ClassLoader重新加载进来的，如果此时直接将有依赖的bean从缓存删掉，然后再调用getBean()会导致spring在为bean注入时抛ClassCastException，所以我们需要维护一个ClassLoader对象用来作为每次加载新字节码的ClassLoader的父ClassLoader。

public void reloadReferenceClass(ClassBeanDefinition classBeanDefinition, Object bean, DynamicClassLoader parent) {
        Class<?> typeClass = bean.getClass();
        Set<String> injectCacheKeys = findReferenceClass(typeClass.getName());
        DynamicClassLoader classLoader = new DynamicClassLoader(parent);
        Thread.currentThread().setContextClassLoader(classLoader);
        for (String cacheKey : injectCacheKeys) {// 将引用了该bean的类重新创建
            Map<String, InjectionMetadata> map = (Map<String, InjectionMetadata>) Reflections.getFieldValue(autowiredAnnotationBeanPostProcessor, "injectionMetadataCache");
            InjectionMetadata metadata = map.get(cacheKey);
            ClassBeanDefinition definition = beanDefinitions.get(cacheKey);
            try {
                Class<?> clazz = classLoader.loadClass(definition.getFile(), definition.getBeanDefinition().getBeanClassName());
                Field[] fields = clazz.getDeclaredFields();
                Collection<InjectedElement> injectedElements = (Collection<InjectedElement>) Reflections.getFieldValue(metadata, "injectedElements");
                Set<InjectedElement> checkedElements = (Set<InjectedElement>) Reflections.getFieldValue(metadata, "checkedElements");
                Collection<InjectedElement> elementsToIterate = (checkedElements != null ? checkedElements : injectedElements);
                for (Field f : fields) {
                    Class<?> type = f.getType();

                    if (type.isInstance(bean)) {
                        for (InjectedElement element : elementsToIterate) {
                            Field field = (Field) element.getMember();
                            if (field.getType().getName().equals(f.getType().getName())) {
                                Reflections.setFieldValue(element, "member", f);//修改spring维护的InjectedElement属性
                                break;
                            }
                        }
                    }
                }
                parentClassLoader = parent;
                reloadBean(definition, clazz, classLoader);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }