小潭渔
小潭渔

spring源码深度解析---容器的功能扩展（上）

spring源码深度解析—容器的功能扩展（上）

在之前的博文中我们一直以BeanFactory接口以及它的默认实现类XmlBeanFactory为例进行分析，但是Spring中还提供了另一个接口ApplicationContext，用于扩展BeanFactory中现有的功能。
ApplicationContext和BeanFactory两者都是用于加载Bean的，但是相比之下，ApplicationContext提供了更多的扩展功能，简而言之：ApplicationContext包含BeanFactory的所有功能。通常建议比优先使用ApplicationContext，除非在一些限制的场合，比如字节长度对内存有很大的影响时（Applet），绝大多数“典型的”企业应用系统，ApplicationContext就是需要使用的。
那么究竟ApplicationContext比BeanFactory多了哪些功能？首先我们来看看使用两个不同的类去加载配置文件在写法上的不同如下代码：

使用BeanFactory方式加载XML.
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));

使用ApplicationContext方式加载XML.
ApplicationContext bf = new ClassPathXmlApplicationContext("beanFactoryTest.xml");

接下来我们就以ClassPathXmlApplicationContext作为切入点，开始对整体功能进行分析。首先看下其构造函数：

public ClassPathXmlApplicationContext() {
}

public ClassPathXmlApplicationContext(ApplicationContext parent) {
    super(parent);
}

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
    this(configLocations, true, null);
}

public ClassPathXmlApplicationContext(String[] configLocations, @Nullable ApplicationContext parent)
        throws BeansException {

    this(configLocations, true, parent);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
    this(configLocations, refresh, null);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
        throws BeansException {
    super(parent);
    setConfigLocations(configLocations);
    if (refresh) {
        refresh();
    }
}

设置路径是必不可少的步骤，ClassPathXmlApplicationContext中可以将配置文件路径以数组的方式传入，ClassPathXmlApplicationContext可以对数组进行解析并进行加载。而对于解析及功能实现都在refresh()中实现。下图是ClassPathXmlApplicationContext类层次图：
spring源码深度解析---容器的功能扩展（上）_第1张图片

1. 设置配置路径

在ClassPathXmlApplicationContext中支持多个配置文件以数组方式同时传入，以下是设置配置路径方法代码：

public void setConfigLocations(@Nullable String... locations) {
    if (locations != null) {
        Assert.noNullElements(locations, "Config locations must not be null");
        this.configLocations = new String[locations.length];
        for (int i = 0; i < locations.length; i++) {
            this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

其中如果给定的路径中包含特殊符号，如${var}，那么会在方法resolvePath中解析系统变量并替换

2. 扩展功能

设置了路径之后，便可以根据路径做配置文件的解析以及各种功能的实现了。可以说refresh函数中包含了几乎ApplicationContext中提供的全部功能，而且此函数中逻辑非常清晰明了，使我们很容易分析对应的层次及逻辑，我们看下方法代码：

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        //准备刷新的上下文 环境  
        /* 
         * 初始化前的准备工作，例如对系统属性或者环境变量进行准备及验证。 
         * 在某种情况下项目的使用需要读取某些系统变量，而这个变量的设置很可能会影响着系统 
         * 的正确性，那么ClassPathXmlApplicationContext为我们提供的这个准备函数就显得非常必要， 
         * 它可以在Spring启动的时候提前对必须的变量进行存在性验证。 
         */ 
        prepareRefresh();
        // Tell the subclass to refresh the internal bean factory.
        //初始化BeanFactory，并进行XML文件读取  
        /* 
         * ClassPathXMLApplicationContext包含着BeanFactory所提供的一切特征，在这一步骤中将会复用 
         * BeanFactory中的配置文件读取解析及其他功能，这一步之后，ClassPathXmlApplicationContext 
         * 实际上就已经包含了BeanFactory所提供的功能，也就是可以进行Bean的提取等基础操作了。 
         */  
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // Prepare the bean factory for use in this context.
        //对beanFactory进行各种功能填充  
        /* 
         * @Qualifier与@Autowired等注解正是在这一步骤中增加的支持 
         */  
        prepareBeanFactory(beanFactory);
        try {
            // Allows post-processing of the bean factory in context subclasses.
            //子类覆盖方法做额外处理  
            /* 
             * Spring之所以强大，为世人所推崇，除了它功能上为大家提供了便利外，还有一方面是它的 
             * 完美架构，开放式的架构让使用它的程序员很容易根据业务需要扩展已经存在的功能。这种开放式 
             * 的设计在Spring中随处可见，例如在本例中就提供了一个空的函数实现postProcessBeanFactory来 
             * 方便程序猿在业务上做进一步扩展 
             */ 
            postProcessBeanFactory(beanFactory);
            // Invoke factory processors registered as beans in the context.
            //激活各种beanFactory处理器  
            invokeBeanFactoryPostProcessors(beanFactory);
            // Register bean processors that intercept bean creation.
            //注册拦截Bean创建的Bean处理器，这里只是注册，真正的调用实在getBean时候 
            registerBeanPostProcessors(beanFactory);
            // Initialize message source for this context.
            //为上下文初始化Message源，即不同语言的消息体，国际化处理  
            initMessageSource();
            // Initialize event multicaster for this context.
            //初始化应用消息广播器，并放入“applicationEventMulticaster”bean中  
            initApplicationEventMulticaster();
            // Initialize other special beans in specific context subclasses.
            //留给子类来初始化其它的Bean  
            onRefresh();
            // Check for listener beans and register them.
            //在所有注册的bean中查找Listener bean，注册到消息广播器中  
            registerListeners();
            // Instantiate all remaining (non-lazy-init) singletons.
            //初始化剩下的单实例（非惰性的）  
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            //完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人  
            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();
        }
    }
}

我们简单的分析下代码的步骤：
（1）初始化前的准备工作，例如对系统属性或者环境变量进行准备及验证。
在某种情况下项目的使用需要读取某些系统变量，而这个变量的设置很可能会影响着系统的正确性，那么ClassPathXmlApplicationContext为我们提供的这个准备函数就显得非常必要，他可以在spring启动的时候提前对必须的环境变量进行存在性验证。
（2）初始化BeanFactory，并进行XML文件读取。
之前提到ClassPathXmlApplicationContext包含着对BeanFactory所提供的一切特征，那么这一步中将会复用BeanFactory中的配置文件读取解析其他功能，这一步之后ClassPathXmlApplicationContext实际上就已经包含了BeanFactory所提供的功能，也就是可以进行Bean的提取等基本操作了。
（3）对BeanFactory进行各种功能填充
@Qualifier和@Autowired应该是大家非常熟悉的注解了，那么这两个注解正是在这一步骤中增加支持的。
（4）子类覆盖方法做额外处理。
spring之所以强大，为世人所推崇，除了它功能上为大家提供了遍历外，还有一方面是它完美的架构，开放式的架构让使用它的程序员很容易根据业务需要扩展已经存在的功能。这种开放式的设计在spring中随处可见，例如本利中就提供了一个空的函数实现postProcessBeanFactory来方便程序员在业务上做进一步的扩展。
（5）激活各种BeanFactory处理器
（6）注册拦截bean创建的bean处理器，这里只是注册，真正的调用是在getBean时候
（7）为上下文初始化Message源，及对不同语言的小西天进行国际化处理
（8）初始化应用消息广播器，并放入“applicationEventMulticaster”bean中
（9）留给子类来初始化其他的bean
（10）在所有注册的bean中查找listener bean，注册到消息广播器中
（11）初始化剩下的单实例（非惰性的）
（12）完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人。
接下来我们就详细的讲解每一个过程

3. 环境准备

prepareRefresh函数主要是做些准备工作，例如对系统属性及环境变量的初始化及验证，其方法体如下；

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }
    // Initialize any placeholder property sources in the context environment
    initPropertySources();
    // Validate that all properties marked as required are resolvable
    // see ConfigurablePropertyResolver#setRequiredProperties
    getEnvironment().validateRequiredProperties();
    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

初看这个函数貌似没有什么用，因为最后两句代码才是关键，但是却没有什么逻辑处理，initPropertySources是空的，没有什么逻辑，而getEnvironment().validaterequiredProperties也因为没有需要验证的属性而没有做任何处理。其实这个函数用好了作用还是挺大的，那么该怎么用呢，我们先探索下各个函数的作用。
（1）initPropertySources，这正符合Spring的开放式结构设计，给用户最大扩展Spring的能力。用户可以根据自身的需要重写initPropertySourece方法，并在方法中进行个性化的属性处理及设置。
（2）validateRequiredProperties则是对属性进行验证，那么如何验证呢？举个融合两句代码的小例子来理解。
例如现在有这样一个需求，工程在运行过程中用到的某个设置（例如VAR）是从系统环境变量中取得的，而如果用户没有在系统环境变量中配置这个参数，那工程不会工作。这一要求也许有各种各样的解决办法，在Spring中可以这么做，可以直接修改Spring的源码，例如修改ClassPathXmlApplicationContext。当然，最好的办法是对源码进行扩展，可以自定义类如下代码：

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext{  
      public MyClassPathXmlApplicationContext(String.. configLocations){  
            super(configLocations);  
       }  
       protected void initPropertySources(){  
             //添加验证要求  
             getEnvironment().setRequiredProterties("VAR")；  
       }  
}

自定义了继承自ClassPathXmlApplicationContext的MyClassPathXmlApplicationContext，并重写了initPropertySources方法，在方法中添加了个性化需求，那么在验证的时候也就是程序走到getEnvironment().validateRequiredProperties()代码的时候，如果系统并没有检测到对应VAR的环境变量，将抛出异常。当然我们还需要在使用的时候替换掉原有的ClassPathXmlApplicationContext，如下代码：

public static void main(Stirng[] args){  
      ApplicationContext bf = new MyClassPathXmlApplicationContext("myTest.xml")；  
      User user = (User)bf.getBean("testBean");  
}

4. 加载BeanFactory

obtainFreshBeanFactory方法从字面理解是获取beanFactory.ApplicationContext是对BeanFactory的扩展，在其基础上添加了大量的基础应用，obtainFreshBeanFactory正式实现beanFactory的地方，经过这个函数后ApplicationContext就有了BeanFactory的全部功能。我们看下此方法的代码：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    //初始化BeanFactory,并进行XML文件读取，并将得到的BeanFactory记录在当前实体的属性中  
    refreshBeanFactory();
    //返回当前实体的beanFactory属性 
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

继续深入到refreshBeanFactory方法中，方法的实现是在AbstractRefreshableApplicationContext中：

@Override
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        //创建DefaultListableBeanFactory  
        /* 
         * 以前我们分析BeanFactory的时候，不知道是否还有印象，声明方式为：BeanFactory bf =  
         * new XmlBeanFactory("beanFactoryTest.xml")，其中的XmlBeanFactory继承自DefaulltListableBeanFactory; 
         * 并提供了XmlBeanDefinitionReader类型的reader属性，也就是说DefaultListableBeanFactory是容器的基础。必须 
         * 首先要实例化。 
         */  
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        //为了序列化指定id,如果需要的话，让这个BeanFactory从id反序列化到BeanFactory对象  
        beanFactory.setSerializationId(getId());
        //定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖以及设置  
        //@Autowired和Qualifier注解解析器QualifierAnnotationAutowireCandidateResolver  
        customizeBeanFactory(beanFactory);
        //加载BeanDefiniton  
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            //使用全局变量记录BeanFactory实例。  
            //因为DefaultListableBeanFactory类型的变量beanFactory是函数内部的局部变量，  
            //所以要使用全局变量记录解析结果  
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

我们详细分析下上面代码的步骤：
（1）创建DefaultListableBeanFactory
以前我们分析BeanFactory的时候，不知道是否还有印象，声明方式为：BeanFactory bf = new XmlBeanFactory(“beanFactoryTest.xml”)，其中的XmlBeanFactory继承自DefaulltListableBeanFactory;，并提供了XmlBeanDefinitionReader类型的reader属性，也就是说DefaultListableBeanFactory是容器的基础。必须首先要实例化，这里就是创建DefaultListableBeanFactory的步骤。
（2）指定序列号ID
（3）定制BeanFactory
（4）加载BeanDefinition
（5）使用全局变量保存BeanFactory
因为DefaultListableBeanFactory类型的变量beanFactory是函数内部的局部变量， 所以要使用全局变量记录解析结果

4.1 定制BeanFactory

customizeBeanFactory方法在基本容器的基础上，增加了是否允许覆盖是否允许扩展的设置并提供了主机@Qualifierh额@Autowired支持。我们看到源码：

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    //如果属性sllowBeanDefinitionOverring不为空，设置给beanFactory对象相应属性，  
    //此属性的含义：是否允许覆盖同名称的不同定义的对象  
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    //如果属性allowCircularReferences不为空，设置给beanFactory对象相应属性，  
    //此属性的含义：是否允许循环依赖 
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}

对于允许覆盖和允许依赖的设置这里只判断了是否为空，如果不为空姚进行设置，但是并没有看到在哪里设置，究竟在哪里设置？这就是spring中使用的子类覆盖方式，如下代码我们自己实现一个子类：

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext{  
      ... ...  
      protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory){  
            super.setAllowBeanDefinitionOverriding(fa;se);  
            super.setAllowCircularReferences(false);  
            super.customizeBeanFactory(beanFactory);  
      }  
}

4.2 加载BeanDefinition

在第一步中提到了将ClassPathXmlApplicationContext与XMLBeanFactory创建的对比，除了初始化DefaultListableBeanFactory外，还需要XmlBeanDefinitionReader来读取XML，那么在loadBeanDefinitions方法中首先要做的就是初始化XmlBeanDefinitonReader，我们跟着到loadBeanDefinitions(beanFactory)方法体中，我们看到的是在AbstractXmlApplicationContext中实现的，具体代码如下：

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    // Allow a subclass to provide custom initialization of the reader,
    // then proceed with actually loading the bean definitions.
    initBeanDefinitionReader(beanDefinitionReader);
    loadBeanDefinitions(beanDefinitionReader);
}

在初始化了DefaultListableBeanFactory和XmlBeanDefinitionReader后，就可以进行配置文件的读取了。继续进入到loadBeanDefinitions(beanDefinitionReader)方法体中，代码如下：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

因为在XmlBeanDefinitionReader中已经将之前初始化的DefaultListableBeanFactory注册进去了，所以XmlBeanDefinitionReader所读取的BeanDefinitionHolder都会注册到DefinitionListableBeanFactory中，也就是经过这个步骤，DefaultListableBeanFactory的变量beanFactory已经包含了所有解析好的配置。

5. 功能扩展

spring源码深度解析---容器的功能扩展（上）_第2张图片
如上图所示prepareBeanFactory(beanFactory)就是在功能上扩展的方法，而在进入这个方法前spring已经完成了对配置的解析，接下来我们详细分析下次函数，进入方法体：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    //设置beanFactory的classLoader为当前context的classloader  
    beanFactory.setBeanClassLoader(getClassLoader());
    //设置beanFactory的表达式语言处理器，Spring3增加了表达式语言的支持，  
    //默认可以使用#{bean.xxx}的形式来调用相关属性值  
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    //为beanFactory增加了一个的propertyEditor，这个主要是对bean的属性等设置管理的一个工具
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    //设置了几个忽略自动装配的接口
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    //设置了几个自动装配的特殊规则
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    //增加对AspectJ的支持 
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    //添加默认的系统环境bean  
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

详细分析下代码发现上面函数主要是在以下方法进行了扩展：
（1）对SPEL语言的支持
（2）增加对属性编辑器的支持
（3）增加对一些内置类的支持，如EnvironmentAware、MessageSourceAware的注入
（4）设置了依赖功能可忽略的接口
（5）注册一些固定依赖的属性
（6）增加了AspectJ的支持
（7）将相关环境变量及属性以单例模式注册
接下来我们想法分析下以上步骤。

5.1 增加对SPEL语言的支持

Spring表达式语言全称为“Spring Expression Language”，缩写为“SpEL”，类似于Struts 2x中使用的OGNL语言，SpEL是单独模块，只依赖于core模块，不依赖于其他模块，可以单独使用。
SpEL使用#{…}作为定界符，所有在大框号中的字符都将被认为是SpEL，使用格式如下：

id="database" location="classpath:db.properties">  
  
id="dbcp" class="org.apache.commons.dbcp.BasicDataSource">  
  <property name="username" value="#{database.user}">property>  
  <property name="password" value="#{database.pwd}">property>  
  <property name="driverClassName" value="#{database.driver}">property>  
  <property name="url" value="#{database.url}">property>

上面只是列举了其中最简单的使用方式，SpEL功能非常强大，使用好可以大大提高开发效率。在源码中通过代码beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver())，注册语言解析器，就可以对SpEL进行解析了，那么之后是在什么地方调用这个解析器的呢？
之前说beanFactory中说过Spring在bean进行初始化的时候会有属性填充的一步，而在这一步中Spring会调用AbstractAutowireCapabelBeanFactory类的applyPropertyValues来进行属性值得解析。同时这个步骤中一般通过AbstractBeanFactory中的evaluateBeanDefinitionString方法进行SpEL解析，方法代码如下：

protected Object evaluateBeanDefinitionString(String value, BeanDefinition beanDefinition) {  
    if (this.beanExpressionResolver == null) {  
        return value;  
    }  
    Scope scope = (beanDefinition != null ? getRegisteredScope(beanDefinition.getScope()) : null);  
    return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));  
}

当调用这个方法时会判断是否有语言解析器，如果存在则调用语言解析器，解析的过程在Spring的expression包里。

5.2 增加属性注册编辑器

在spring的DI注入的时候可以把普通属性注入进来，但是像Date类型是无法被识别的，如下我们先定义一个简单的bean；

public class User {
    private String name;
    private Date birthday;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

在配置文件中需要对User的birthday进行注入，如下：


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.yhl.myspring.demo.applicationcontext.User">
        <property name="name" value="user"/>
        <property name="birthday" value="2018-04-18"/>
    bean>
beans>

如果直接按照上面的使用方式使用的话就会报错，类型转换异常，因为在User中的birthday是Date类型，而在XML配置文件中配置的是string类型，在spring中有两种方式解决：
5.2.1 自定义属性编辑器
使用自定义属性编辑器，继承PropertyEditorSupport，重写setAsText方法，具体步骤如下：
（1）编写自定义编辑器

public class MyPropertyEditor extends PropertyEditorSupport {
    private String format = "yyyy-MM-dd";

    public void setFormat(String format) {
        this.format = format;
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date date = sdf.parse(text);
            this.setValue(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //super.setAsText(text);
    }
}

（2）将自定义属性编辑器注册到spring中

   <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
       <property name="customEditors">
           <map>
               <entry key="java.util.Date">
                   <bean class="com.yhl.myspring.demo.applicationcontext.MyPropertyEditor">
                       <property name="format" value="yyyy-MM-dd">property>
                   bean>
               entry>
           map>
       property>
   bean>

如上述所示在配置文件中引入CustomEditorConfigurer的bean，并加入自定义的属性编辑器，其中key为属性编辑器对应的类，经过这样的配置后当spring在注入属性时如果遇到Date类型属性时会自动调用自定义的属性编辑器进行解析，并用解析结果代替配置属性进行注入。
5.2.2 注册spring自带的属性编辑器CustomDateEditor
也可以通过注册spring自带的CustomDateEditor编辑器来实现。实现步骤如下：
（1）定义属性编辑器

public class DataPropertyEditorRegistrar implements PropertyEditorRegistrar {
    public void registerCustomEditors(PropertyEditorRegistry registry) {
        registry.registerCustomEditor(Date.class,new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));
    }
}

（2）然后注册到spring中

    <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="propertyEditorRegistrars">
            <list>
                <bean class="com.yhl.myspring.demo.applicationcontext.DataPropertyEditorRegistrar">bean>
            list>
        property>
    bean>

通过在配置文件中将自定义的DataPropertyEditorRegistrar注册到CustomEditorConfigurer的propertyEditorRegistrars属性中，可以与方式1有相同的效果。
我们了解了自定义属性编辑器的使用，但是这跟我们要分析的核心代码beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()))好像并无关联，因为在自定义属性编辑器注册时用的是PropertyEditorRegistrar的registerCustomEditor方法，而这里用到的是ConfigurableListableBeanFactory的addPropertyEditorRegistrar方法，为了弄清楚具体逻辑，我们就深入的来看下ResourceEditorRegistrar的内部实现，在其实现中我们最关心的是registerCustomEditors方法了，具体看下代码：

public void registerCustomEditors(PropertyEditorRegistry registry) {
    ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader, this.propertyResolver);
    doRegisterEditor(registry, Resource.class, baseEditor);
    doRegisterEditor(registry, ContextResource.class, baseEditor);
    doRegisterEditor(registry, InputStream.class, new InputStreamEditor(baseEditor));
    doRegisterEditor(registry, InputSource.class, new InputSourceEditor(baseEditor));
    doRegisterEditor(registry, File.class, new FileEditor(baseEditor));
    doRegisterEditor(registry, Path.class, new PathEditor(baseEditor));
    doRegisterEditor(registry, Reader.class, new ReaderEditor(baseEditor));
    doRegisterEditor(registry, URL.class, new URLEditor(baseEditor));

    ClassLoader classLoader = this.resourceLoader.getClassLoader();
    doRegisterEditor(registry, URI.class, new URIEditor(classLoader));
    doRegisterEditor(registry, Class.class, new ClassEditor(classLoader));
    doRegisterEditor(registry, Class[].class, new ClassArrayEditor(classLoader));

    if (this.resourceLoader instanceof ResourcePatternResolver) {
        doRegisterEditor(registry, Resource[].class,
                new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader, this.propertyResolver));
    }
}

上述代码中都使用了doRegisterEditor这个方法，在其方法内部使用了我们之前提到的自定义属性的关键代码：registry.registerCustomEditor(requiredType, editor);我们继续看下registerCustomEditors方法的功能，发现其无非就是注册一系列常用类型的属性编辑器，编辑器注册后，一旦一个bean中存在一些类型的属性转换，spring就会调用对应的属性类型编辑器对属性进行转换后使用。
分析到这里我们看到ResourceEditorRegistrar的registerCustomEditors方法实现了一些批量注册的功能，但是beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()))仅仅是注册了ResourceEditorRegistrar的实例，而并没有调用ResourceEditorRegistrar的registerCustomEditors方法进行注册，那具体是在什么时候进行注册呢？我们进一步的查看ResourceEditorRegistrar的registerCustomEditors方法的调用层次结构，如下图说是：
这里写图片描述
发现在AbstractBeanFactory中的registerCustomEditors方法调用过，我们继续跟踪这个方法的调用层次，如下图：
这里写图片描述
在上图的方法调用层次中我们看到了一个非常熟悉的方法initBeanWrapper，这个是在bean初始化时使用的方法，此方法主要是在将BeanDefinition转换为BeanWrapper后用于属性的填充，看到这里后逻辑就非常的清晰了。在bean初始化后会调用ResourceEditorRegistrar的registerCustomEditors进行属性编辑器的批量注册，注册后在属性填充环节就可以让spring使用这些编辑器对属性进行编辑了。
上面我们提到了BeanWrapper，在spring中用于封装bean的就是BeanWrapper类型，而BeanWrapper类型继承了PropertyEditorRegistry类型，也就是我们之前反复看到的方法参数PropertyEditorRegistry registry，其实大部分情况下都是BeanWrapper，而BeanWrapper在spring中的默认实现是BeanWrapperImpl，而BeanWrapperImpl除了实现了BeanWrapper外还继承了PropertyEditorRegistrySupport，在PropertyEditorRegistrySupport中有这样一个方法：

private void createDefaultEditors() {
    this.defaultEditors = new HashMap<>(64);

    // Simple editors, without parameterization capabilities.
    // The JDK does not contain a default editor for any of these target types.
    this.defaultEditors.put(Charset.class, new CharsetEditor());
    this.defaultEditors.put(Class.class, new ClassEditor());
    this.defaultEditors.put(Class[].class, new ClassArrayEditor());
    this.defaultEditors.put(Currency.class, new CurrencyEditor());
    this.defaultEditors.put(File.class, new FileEditor());
    this.defaultEditors.put(InputStream.class, new InputStreamEditor());
    this.defaultEditors.put(InputSource.class, new InputSourceEditor());
    this.defaultEditors.put(Locale.class, new LocaleEditor());
    this.defaultEditors.put(Path.class, new PathEditor());
    this.defaultEditors.put(Pattern.class, new PatternEditor());
    this.defaultEditors.put(Properties.class, new PropertiesEditor());
    this.defaultEditors.put(Reader.class, new ReaderEditor());
    this.defaultEditors.put(Resource[].class, new ResourceArrayPropertyEditor());
    this.defaultEditors.put(TimeZone.class, new TimeZoneEditor());
    this.defaultEditors.put(URI.class, new URIEditor());
    this.defaultEditors.put(URL.class, new URLEditor());
    this.defaultEditors.put(UUID.class, new UUIDEditor());
    this.defaultEditors.put(ZoneId.class, new ZoneIdEditor());

    // Default instances of collection editors.
    // Can be overridden by registering custom instances of those as custom editors.
    this.defaultEditors.put(Collection.class, new CustomCollectionEditor(Collection.class));
    this.defaultEditors.put(Set.class, new CustomCollectionEditor(Set.class));
    this.defaultEditors.put(SortedSet.class, new CustomCollectionEditor(SortedSet.class));
    this.defaultEditors.put(List.class, new CustomCollectionEditor(List.class));
    this.defaultEditors.put(SortedMap.class, new CustomMapEditor(SortedMap.class));

    // Default editors for primitive arrays.
    this.defaultEditors.put(byte[].class, new ByteArrayPropertyEditor());
    this.defaultEditors.put(char[].class, new CharArrayPropertyEditor());

    // The JDK does not contain a default editor for char!
    this.defaultEditors.put(char.class, new CharacterEditor(false));
    this.defaultEditors.put(Character.class, new CharacterEditor(true));

    // Spring's CustomBooleanEditor accepts more flag values than the JDK's default editor.
    this.defaultEditors.put(boolean.class, new CustomBooleanEditor(false));
    this.defaultEditors.put(Boolean.class, new CustomBooleanEditor(true));

    // The JDK does not contain default editors for number wrapper types!
    // Override JDK primitive number editors with our own CustomNumberEditor.
    this.defaultEditors.put(byte.class, new CustomNumberEditor(Byte.class, false));
    this.defaultEditors.put(Byte.class, new CustomNumberEditor(Byte.class, true));
    this.defaultEditors.put(short.class, new CustomNumberEditor(Short.class, false));
    this.defaultEditors.put(Short.class, new CustomNumberEditor(Short.class, true));
    this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));
    this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));
    this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));
    this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));
    this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));
    this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));
    this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));
    this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));
    this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));
    this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));

    // Only register config value editors if explicitly requested.
    if (this.configValueEditorsActive) {
        StringArrayPropertyEditor sae = new StringArrayPropertyEditor();
        this.defaultEditors.put(String[].class, sae);
        this.defaultEditors.put(short[].class, sae);
        this.defaultEditors.put(int[].class, sae);
        this.defaultEditors.put(long[].class, sae);
    }
}

5.3 添加ApplicationContextAwareProcessor处理器

在上面对属性编辑器进行了分析后接下来我们继续分析方法beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this))，此方法的目的是用来注册BeanPostProcessor的，主要的逻辑还是在ApplicationContextAwareProcessor中实现的，ApplicationContextAwareProcessor实现了BeanPostProcessor接口，我们看下之前说过，在bean实例化的时候，也就是Spring激活bean的init-method的前后，会调用BeanProcessor的postProcessBeforeInitialization方法和postProcessAfterInitialization方法。同样，对于ApplicationContextAwareProcessor也有这两个方法。我们看下这两个方法在ApplicationContextAwareProcessor中具体代码：

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;
    if (System.getSecurityManager() != null &&
            (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                    bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                    bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    }

    if (acc != null) {
        AccessController.doPrivileged((PrivilegedAction) () -> {
            invokeAwareInterfaces(bean);
            return null;
        }, acc);
    }
    else {
        invokeAwareInterfaces(bean);
    }

    return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    return bean;
} 
  
我们可以看到postProcessAfterInitialization在其中没有做过多的处理，那我们就重点看下postProcessBeforeInitialization方法，其方法内部使用了invokeAwareInterfaces方法，继续进入到方法体内：
 
  
private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}
 
  
从invokeAwareInterfaces方法中，我们可以看出来，实现这些Aware接口的bean在被初始化之后，可以取得一些对应的资源。
 
  
5.4 设置忽略依赖
 
  
Spring将ApplicationContextAwareProcessor注册后，在invokeAwareInterfaces方法中间调用的Aware类已经不是普通的bean了，如ResourceLoaderAware，ApplicationEventPublisherAware等，那么当然需要在Spring做bean的依赖注入的时候忽略它们。而ignoreDependencyInterface的作用正是如此。 
 以下是设置忽略的方法：
 
  
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
 
  
5.5 注册依赖
 
  
Spring中有忽略依赖的功能，也有注册依赖的功能。以下是注册依赖的代码：
 
  
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
 
  
当注册了依赖解析后，例如当注册了对BeanFactory.class的解析后，当bean的属性注入的时候，一旦检测到属性为BeanFactory类型便会将beanFactory的实例注入进去。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring源码深度解析)

        

            

                
    
                    
  • 公众号流量主如何赚钱？深度解析流量变现之道
                        日常购物技巧呀

                        
    微信公众号作为自媒体平台的重要一环，吸引了越来越多的内容创作者和商家。而公众号流量主作为平台上的重要角色，如何有效地将流量变现，成为许多运营者关注的焦点。那么，公众号流量主究竟如何赚钱呢？本文将深度解析流量变现的奥秘，为您揭示公众号流量主的赚钱之道。废掉一个孩子最快的方式，就让他待在家里，一天到晚待在家里公众号流量主就找善士导师（shanshi2024）公众号：「善士笔记」主理人，《我的亲身经历，
    
                    
    • 
                    
  • STM32的寄存器深度解析
                        千千道
STM32stm32单片机物联网
                        
    目录一、STM32寄存器概述二、寄存器的定义与作用三、寄存器分类1.内核寄存器2.外设寄存器四、重要寄存器详解1.GPIO相关寄存器2.定时器相关寄存器3.中断相关寄存器4.RCC相关寄存器五、寄存器操作方法1.直接操作寄存器2.使用库函数操作寄存器六、总结在嵌入式系统开发中，STM32微控制器以其强大的性能和丰富的功能而备受青睐。而理解和掌握STM32的寄存器是深入学习和开发STM32的关键。本
    
                    
    • 
                    
  • 深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式
                        m0_57781768
语言模型json人工智能
                        
    深度解析：如何使用输出解析器将大型语言模型（LLM）的响应解析为结构化JSON格式在现代自然语言处理（NLP）的应用中，大型语言模型（LLM）已经成为了重要的工具。这些模型能够生成丰富的自然语言文本，适用于各种应用场景。然而，在某些应用中，开发者不仅仅需要生成文本，还需要将这些生成的文本转换为结构化的数据格式，例如JSON。这种结构化的数据格式在数据传输、存储以及进一步处理时具有显著优势。本文将深
    
                    
    • 
                    
  • 深度解析：云原生环境下Docker部署Doris数据库
                        N201871643
云原生docker数据库
                        
    深度解析：云原生环境下Docker部署Doris数据库目录深度解析：云原生环境下Docker部署Doris数据库引言一、云原生与Docker基础1.云原生概念2.Docker简介二、Doris数据库概述1.Doris数据库特性2.Doris在云原生环境中的应用三、Docker部署Doris数据库1.准备环境2.编写Dockerfile3.使用DockerCompose部署Doris集群4.配置Do
    
                    
    • 
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • 单例模式详解（DLC和spring源码中的应用）
                        CCCCVVVVCCCC
单例模式springjava
                        
    单例模式详解（DLC和spring源码中的应用）单例模式通过确保一个类只有一个实例并提供一个全局访问点来访问该实例来实现。通常，实现单例模式有两种方法：饿汉式和懒汉式。饿汉式单例在类加载时就创建了实例，所以不存在线程安全问题。懒汉式单例在第一次调用时才创建实例，并且必须通过同步机制来保证线程安全。下面是一个简单的饿汉式单例类的示例：publicclassSingleton{//创建Singleto
    
                    
    • 
                    
  • 腾讯云技术深度解析：AI代码助手与微服务架构的实践应用
                        我的运维人生
架构腾讯云人工智能运维开发技术共享
                        
    腾讯云技术深度解析：AI代码助手与微服务架构的实践应用在数字化转型的浪潮中，云计算作为关键基础设施，正深刻改变着企业的IT架构和业务模式。腾讯云，作为国内领先的云服务提供商，不仅在基础设施层面提供了强大的支持，还在AI、大数据、微服务等领域不断创新，为开发者提供了丰富的技术工具和解决方案。本文将深入探讨腾讯云AI代码助手在编程实践中的应用，并结合微服务架构的实例，展示腾讯云在提升开发效率和系统稳定
    
                    
    • 
                    
  • 淘宝返利app哪个最好 淘宝返利的软件有哪些app
                        高省APP

                        
    淘宝返利app哪个最好淘宝返利的软件有哪些app在淘宝购物时，你是否曾想过通过返利软件来获得额外的优惠呢？现在市面上有很多淘宝返利app，其中高省和氧惠是备受推荐的两种。本文将为你深度解析高省和氧惠返利app，让你购物更划算！大家好，我是高省的波西导师。在开始本文的交流之前，我想向大家介绍一款网购省钱利器——高省APP，同时也是一项难得的零投入零成本的创业项目。官方邀请码088886，应用商店搜索
    
                    
    • 
                    
  • Redis 缓存深度解析：穿透、击穿、雪崩与预热的全面解读
                        加勒比海涛
Redis入门实践缓存redis数据库
                        
    Redis缓存深度解析：穿透、击穿、雪崩与预热的全面解读一.什么是缓存?二.使用Redis作为缓存三.缓存的更新策略3.1定期生成3.2实时生成四.缓存预热、缓存穿透、缓存雪崩、缓存击穿4.1缓存预热4.2缓存穿透4.3缓存雪崩4.4缓存击穿Hello,大家好,这个专栏给大家带来的是Redis系列!本篇文章给大家讲解的是Redis的缓存.在Redis缓存系统中,缓存穿透、缓存击穿、缓存雪崩和缓存预
    
                    
    • 
                    
  • Spring源码浅析の循环依赖
                        西岭千秋雪_
源码分析springjava后端springboot
                        
    AbstractBeanFactory#doGetBean:尝试获取bean如果bean是单例的：if(mbd.isSingleton()){//尝试获取beansharedInstance=getSingleton(beanName,()->{try{//获取不到就创建returncreateBean(beanName,mbd,args);}catch(BeansExceptionex){//E
    
                    
    • 
                    
  • 计算机组成原理：总线技术深度解析
                        努力编程的阿伟
网络计算机组成
                        
    目录1.总线技术概述1.1什么是总线？1.2总线的基本功能2.总线的类型2.1内部总线2.2外部总线3.总线的标准与协议3.1常见的总线标准3.2总线协议4.总线的性能考量4.1带宽4.2延迟4.3可扩展性5.总线的未来趋势6.结语在计算机科学的浩瀚宇宙中，总线技术扮演着至关重要的角色。它是连接计算机硬件组件的神经网络，负责协调数据、指令和电源的流动。今天，我们将深入探讨总线的概念、类型、标准以及
    
                    
    • 
                    
  • 《隐秘的角落》分集深度解析第五回（连载）
                        Ricky的成长疗愈空间

                        
    第五集妈妈第一幕：晶晶的葬礼结束后，王瑶在公安局质问办案人员为什么不去抓凶手朱朝阳，朱永平说朝阳出现在少年宫不能说明什么。王瑶找到朝阳试探他是否知道事情的细节，朝阳慌张露出马脚。王瑶追打朝阳时，周春红赶来导致了更激烈的纠缠。王瑶一口咬定朝阳妈妈是幕后主谋，两人都是杀人凶手。王瑶质问周春红当天在哪里，周春红无法回答，加深了她的怀疑。在邻居的阻拦下，王瑶只好离开，并说“我一定让你们两个偿命！”启发：当
    
                    
    • 
                    
  • java 接口创建对象
                        专注API从业者
经验分享电商平台API接口java开发语言大数据数据库数据挖掘
                        
    Java接口创建对象：深度解析与示例在Java编程中，接口是一种非常重要的概念。它不仅为不同类之间的交互提供了规范，也促进了代码的重用和解耦。本文将深入探讨如何在Java中使用接口创建对象，带您理解这一关键特性。什么是接口？接口（Interface）是一种特殊的抽象类，定义了一组方法的声明，但不提供具体的实现。接口允许我们定义类的方法，而不需要指定它们是什么。这使得接口在Java中成为实现多态性、
    
                    
    • 
                    
  • 深度解析《完美陌生人》的另类结构
                        星期五文艺

                        
    要探讨这部《完美陌生人》背后所暴露出的种种社会问题，首先我们得先把这部电影看懂。而看懂这部电影的关键之处有二：一是缕清它讲故事的总体结构。二是缕清它的人物（人设）结构。当你缕清这两个结构问题的时候，便会发现这部电影的厉害之处——无论是其完美的对称性，还是导演对电影娴熟的节奏把控，再或是电影“假戏真演”的技法所诱发的你的深度思考……都足以让我们学习借鉴了。接下来我们就从电影的结构来细看下这部电影——
    
                    
    • 
                    
  • WebKit 简介及工作流程深度解析
                        不知名靓仔
webkitchromesafariedge
                        
    WebKit是一个开源的浏览器引擎，最初由苹果公司为Safari浏览器开发，后来被多个浏览器和应用采纳，如早期的Chrome和众多移动平台上的浏览器。WebKit不仅仅是一个渲染引擎，它集成了HTML、CSS、JavaScript的解析与渲染能力，以及网络资源加载、图形处理、排版布局等功能，为用户提供丰富的网页浏览体验。本文将深入探讨WebKit的核心组件以及其复杂的工作流程。WebKit核心架构
    
                    
    • 
                    
  • Python搭建自己的VPN
                        用数据说话用数据决策
pythonphp网络
                        
    在这个信息爆炸的数字化时代，我们的网络隐私和安全正面临着前所未有的挑战。虚拟专用网络（VPN）作为一种有效的解决方案，通过加密通信和隧道技术，为用户在公共网络上提供安全的连接。本文将带您深入了解VPN的工作机制，并展示如何使用Python和strongSwan库构建一个高级VPN连接，以实现更高级别的安全性和灵活性。VPN工作机制深度解析加密通信协议：数据的保护神VPN的首要任务是确保数据的机密性
    
                    
    • 
                    
  • 【WebKit深度解析】HTML5支持全景与实践指南
                        2401_85812026
webkithtml5前端
                        
    标题：【WebKit深度解析】HTML5支持全景与实践指南WebKit作为许多现代浏览器的核心技术，对HTML5的支持程度直接关系到Web应用的性能和体验。HTML5是构建现代Web应用的基石，提供了丰富的特性和API。本文将深入探讨WebKit对HTML5的支持程度，并通过实际代码示例，展示如何在WebKit浏览器上充分利用HTML5的强大功能。1.WebKit与HTML5概述WebKit是一个
    
                    
    • 
                    
  • 深度解析：从概念到变革——Transformer大模型的前世今生以及大模型预备知识讲解[知存科技]
                        汀、人工智能
LLM技术汇总transformer深度学习人工智能自然语言处理LLMattention机制编码器解码器
                        
    深度解析：从概念到变革——Transformer大模型的前世今生点击：知存科技相关课程推荐知存科技是全球领先的存内计算芯片企业。针对AI应用场景，在全球率先商业化量产基于存内计算技术的神经网络芯片。凭借颠覆性的技术创新，知存科技突破传统计算架构局限，利用存储与计算的物理融合大幅减少数据搬运，在相同工艺条件下将AI计算效率提升2个数量级，充分满足快速发展的神经网络模型指数级增长的算力需求。相关链接推
    
                    
    • 
                    
  • Nginx部署前端Vue项目的深度解析
                        小周不想卷
#前端vue入门前端前端框架nginxvue.js
                        
    目录一、准备工作1.1开发环境1.2服务器环境1.3Nginx安装二、构建Vue项目三、上传静态文件到服务器四、配置Nginx五、测试并重新加载Nginx六、访问Vue应用七、高级配置7.1启用HTTPS7.2启用Gzip压缩7.3缓存控制八、常见问题与解决方案8.1404错误8.2权限问题8.3跨域问题九、总结在现代Web开发中，Vue.js因其组件化、响应式数据绑定和易于上手的特点，成为了前端
    
                    
    • 
                    
  • 3.创建型设计模式详解：生成器模式与原型模式的深度解析
                        胡耀超
设计模式原型模式设计模式生成器模式创建型设计模式java后端
                        
    设计模式（DesignPatterns）是软件开发中常用的解决方案，帮助开发者处理常见的设计问题。创建型设计模式专注于对象的实例化，旨在提高系统的灵活性和可维护性。在这篇文章中，我们将深入探讨创建型设计模式中的生成器模式（BuilderPattern）和原型模式（PrototypePattern），详细分析它们的应用场景、优缺点，并通过类图和综合案例加以对比。1.创建型设计模式概述创建型设计模式包
    
                    
    • 
                    
  • MySQL数据库运维：深度解析与实践指南
                        野老杂谈
数据库mysql运维
                        
    欢迎来到我的博客，很高兴能够在这里和您见面！欢迎订阅相关专栏：+V:LAF20151116进行更多交流学习⭐️全网最全IT互联网公司面试宝典：收集整理全网各大IT互联网公司技术、项目、HR面试真题.⭐️AIGC时代的创新与未来：详细讲解AIGC的概念、核心技术、应用领域等内容。⭐️全流程数据技术实战指南：全面讲解从数据采集到数据可视化的整个过程，掌握构建现代化数据平台和数据仓库的核心技术和方法。⭐
    
                    
    • 
                    
  • 揭开数据可视化的神秘面纱：《Python数据可视化：科技图表绘制》深度解析
                        屿小夏
书籍推荐信息可视化python科技
                        
    文章目录一、内容简介二、值得一读2.1全面覆盖Python基础与高级可视化技术2.2丰富的实践案例与操作示例2.3视频教学与配套资源文件2.4作者的专业背景与权威性三、适读人群3.1科研人员与工程师3.2数据分析师与从业者3.3大学生与研究生3.4零基础的编程爱好者四、配套资源与学习支持4.1公共数据集与示例代码4.2微信公众号支持与资源下载4.3常见问题与读者互动五、总结一、内容简介在大数据和人
    
                    
    • 
                    
  • 数仓还是湖仓？专家圆桌深度解析
                        StarRocks_labs
数据仓库数据库大数据数据分析湖仓一体
                        
    近期，Databricks以超过10亿美元的价格收购了Tabular——ApacheIceberg的商业支持公司，这一动作加剧了Snowflake和Databricks在开放湖仓标准发展上的竞争。这起收购也突显了数据湖表格式在现代数据分析架构中的关键地位。在上月的StarRocksMeetup活动中，四位湖仓技术专家代表ApacheIceberg、ApacheHudi、ApachePaimon和S
    
                    
    • 
                    
  • 微软云技术深度解析与实战案例
                        我的运维人生
microsoftflaskpython运维开发技术共享
                        
    微软云技术深度解析与实战案例在云计算的浪潮中，微软Azure凭借其强大的技术实力和丰富的服务种类，成为了众多企业和开发者首选的云服务平台。本文将从微软云服务的核心优势、关键技术、以及一个具体的代码使用案例出发，深入探讨如何在Azure平台上构建高效、可靠的应用程序。微软云服务的核心优势微软Azure作为全球领先的云服务平台，其优势主要体现在以下几个方面：广泛的服务种类：Azure提供了包括计算、存
    
                    
    • 
                    
  • 深入剖析 RabbitMQ：架构深度解析、原理细节与关键特性全面掌握
                        马丁的代码日记
开发语言后端
                        
    摘要：本文深入探讨了RabbitMQ这一开源消息代理的各个方面，包括其架构设计、工作原理、关键特性如延迟消息、死信队列、高可用性、消费限流、去重策略、消息持久化和事务性操作等。旨在为开发者和架构师提供全面的RabbitMQ知识，以助其在分布式系统中有效利用该技术。关键词：RabbitMQ,消息队列,分布式系统,延迟消息,死信队列,高可用性,消费限流,消息持久化,事务性操作一、引言在当今复杂的分布式
    
                    
    • 
                    
  • 『深度解析』本金5千回血30万-精选文案
                        胡力

                        
    我想帮助更多的人是认真的蹈失425.68.05，所以总结出来了一些经验，也是希望让更多的大家不要在误入歧途了。平台的重要性；如今平台众多，黑的、圈的、跑的多不胜数，更有甚者直接把你的收获以各种理由去掉！从此处可以看出平台的重要性显得尤其重要！心态的重要性；一旦心态奔溃，眼红失去理智，盲目无措，意味着必定错，能控制好自己、不急躁、不乱来、不凭感觉，才是你成的开始。娱乐心态，过分看重，劝你别玩了！技巧
    
                    
    • 
                    
  • Node.js 入门：中间件与安全性深度解析
                        Switch616
前端node.js中间件chrome服务器架构前端前端框架
                        
    Node.js入门：中间件与安全性深度解析目录认证与授权使用jsonwebtoken实现JWT身份验证用户注册与登录：认证流程与实践️权限管理：安全访问控制详解️安全性防止SQL注入：参数化查询与ORM的最佳实践防止XSS攻击：用户输入处理与安全防护使用HTTPS和SSL/TLS：加密传输与数据安全⚠️错误处理️全局错误处理：确保应用稳定性的关键异常捕获与日志记录：有效排查问题的核心认证与授权使用
    
                    
    • 
                    
  • 探索Node.js内存的奥秘：node-mtrace深度解析与应用推荐
                        焦珑雯

                        
    探索Node.js内存的奥秘：node-mtrace深度解析与应用推荐node-mtraceNativememoryallocationtracingandmtracelogparsingfornode.项目地址:https://gitcode.com/gh_mirrors/no/node-mtrace在Node.js的世界里，内存管理一直是一个关键而微妙的话题。开发者往往需要精准地掌握应用程序的
    
                    
    • 
                    
  • 深度解析react中hooks的底层原理是啥？React架构fiber原理深度解析
                        为了WLB努力
react.js
                        
    1.ReactHooks底层原理ReactHooks的底层原理是基于ReactFiber架构的实现。下面是对ReactHooks底层原理的深度解析：Fiber架构：ReactFiber是React的新的协调引擎，它的设计目标是支持增量式更新、优先级调度、暂停和继续执行等特性。Fiber架构重新实现了React的调度算法，使得React可以更灵活地控制组件的渲染过程。我们都知道react框架的核心算
    
                    
    • 
                    
  • 深度解析构建 API 时常见的 10 种错误状态代码及应对策略
                        sjsdblog
服务器网络数据库API开发
                        
    在首次构建API时，可能会遇到各种错误状态代码。这些错误代码可以帮助我们快速识别问题所在，并采取相应的解决措施。本文将介绍10个常见的错误状态代码，包括4XX客户端错误和5XX服务器端错误，并提供相应的解决方法。一、客户端错误1.404未找到当客户端请求的资源不存在时，会返回404错误。这可能是因为输入的URL错误、资源已被删除或移动等原因导致的。解决方法是检查输入的URL是否正确，确保资源存在且
    
                    
    • 
                                
  • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
    
                                
    • 
                                
  • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
    (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
    
                                
    • 
                                
  • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
    Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
    
                                
    • 
                                
  • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
    
                                
    • 
                                
  • 重绘之画图板
                                    朱辉辉33
画图板
                                    
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
    
                                
    • 
                                
  • Java的IO流
                                    西蜀石兰
java
                                    
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
    
                                
    • 
                                
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
    
                                
    • 
                                
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
    
                                
    • 
                                
  • JS 格式化时间
                                    alxw4616
JavaScript
                                    
    /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
    
                                
    • 
                                
  • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
      
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
    
                                
    • 
                                
  • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
    Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
    
                                
    • 
                                
  • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
    扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
    
                                
    • 
                                
  • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
    浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
    
                                
    • 
                                
  • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
     1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
    
                                
    • 
                                
  • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
    
                                
    • 
                                
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
    
                                
    • 
                                
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
    
                                
    • 
                                
  • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
     
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
    
                                
    • 
                                
  • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
    方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
    
                                
    • 
                                
  • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
    
                                
    • 
                                
  • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
    
                                
    • 
                                
  • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
    
                                
    • 
                                
  • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
    MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
    
                                
    • 
                                
  • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
    重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
    
                                
    • 
                                
  • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
      
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
    
                                
    • 
                                
  • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
    前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
    
                                
    • 
                                
  • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
    
                                
    • 
                                
  • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
    // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


    
                                
    • 
                                
  • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
      
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
    
                                
    • 
                                
  • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
    
                                
    •