一个努力的码农
一个努力的码农

spring boot 源码解析8-SpringApplication#run第8步

前言

这篇文章我们分析SpringApplication#run第8步.执行prepareContext方法.该方法的内容比较多.我们慢慢来.

分析

  1. SpringApplication#run 第8步执行如下代码:

    private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 1. 上下文设置环境
    context.setEnvironment(environment);
    // 2. 调用postProcessApplicationContext方法设置上下文的beanNameGenerator和resourceLoader(如果SpringApplication有的话)
    postProcessApplicationContext(context);
    // 3. 拿到之前实例化SpringApplication对象的时候设置的ApplicationContextInitializer，调用它们的initialize方法，对上下文做初始化
    applyInitializers(context);
    // 4. contextPrepareds 是一个空实现 
    listeners.contextPrepared(context);
    // 5. 打印启动日志
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // Add boot specific singleton beans
    // 6. 日志往上下文的beanFactory中注册一个singleton的bean，bean的名字是springApplicationArguments，bean的实例是之前实例化的ApplicationArguments对象
    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);
    // 如果之前获取的printedBanner不为空，那么往上下文的beanFactory中注册一个singleton的bean，bean的名字是springBootBanner，bean的实例就是这个printedBanner
    if (printedBanner != null) {
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // Load the sources
    Set sources = getSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    // 7. 调用load方法注册启动类的bean定义，也就是调用SpringApplication.run(Application.class, args);的类，SpringApplication的load方法内会创建BeanDefinitionLoader的对象，并调用它的load()方法
    load(context, sources.toArray(new Object[sources.size()]));
    // 8. 调用listeners的contextLoaded方法，说明上下文已经加载，该方法先找到所有的ApplicationListener，遍历这些listener，如果该listener继承了ApplicationContextAware类，那么在这一步会调用它的setApplicationContext方法，设置context
    listeners.contextLoaded(context);
} 
    做了8件事:
     
    
       
     
    1. 为上下文设置Environment. 注意 这里传入的是 StandardServletEnvironment
      2.  
     
    2. 调用postProcessApplicationContext方法设置上下文的beanNameGenerator和resourceLoader(如果SpringApplication有的话)
      3.  
     
    3. 拿到之前实例化SpringApplication对象的时候设置的ApplicationContextInitializer，调用它们的initialize方法，对上下文做初始化
      4.  
     
    4. 调用listeners#contextPrepared,该方法是一个空实现
      5.  
     
    5. 打印启动日志
      6.  
     
    6. 往上下文的beanFactory中注册一个singleton的bean，bean的名字是springApplicationArguments，bean的实例是之前实例化的ApplicationArguments对象, 
       如果之前获取的printedBanner不为空，那么往上下文的beanFactory中注册一个singleton的bean，bean的名字是springBootBanner，bean的实例就是这个printedBanner.这里默认是SpringBootBanner.
      7.  
     
    7. 调用load方法注册启动类的bean定义，也就是调用SpringApplication.run(Application.class, args);的类，SpringApplication的load方法内会创建BeanDefinitionLoader的对象，并调用它的load()方法
      8.  
     
    8. 调用listeners的contextLoaded方法，说明上下文已经加载，该方法先找到所有的ApplicationListener，遍历这些listener，如果该listener继承了ApplicationContextAware类，那么在这一步会调用它的setApplicationContext方法，设置context
      9.  
    
     
   
  2. 为上下文设置Environment 执行的是AnnotationConfigEmbeddedWebApplicationContext#setEnvironment,代码如下:
     
    public void setEnvironment(ConfigurableEnvironment environment) {
    super.setEnvironment(environment);
    this.reader.setEnvironment(environment);
    this.scanner.setEnvironment(environment);
}
     
    3件事:
     
    
       
     
    1. 调用父类的setEnvironment方法.代码如下:
       
      public void setEnvironment(ConfigurableEnvironment environment) {
    this.environment = environment;
}
      2.  
     
    2. 为AnnotatedBeanDefinitionReader设置Environment.执行如下代码.
       
      public void setEnvironment(Environment environment) {
this.conditionEvaluator = new ConditionEvaluator(this.registry,         environment, null);
}
       
      实例化了ConditionEvaluator.其构造器如下:
       
      public ConditionEvaluator(BeanDefinitionRegistry registry, Environment environment, ResourceLoader resourceLoader) {
this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}
       
      在实例化ConditionEvaluator时实例化了ConditionContextImpl.该类是ConditionContext的一个实现.是Condition使用时的上下文.其构造器如下:
       
      public ConditionContextImpl(BeanDefinitionRegistry registry, Environment environment, ResourceLoader resourceLoader) {
    this.registry = registry;
    this.beanFactory = deduceBeanFactory(registry);
    this.environment = (environment != null ? environment : deduceEnvironment(registry));
    this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
}
       
      
         
       
      1. 设置BeanDefinitionRegistry.这里实际上持有的是AnnotationConfigEmbeddedWebApplicationContext.
        2.  
       
      2. 设置beanFactory.执行如下代码:
         
        private ConfigurableListableBeanFactory deduceBeanFactory(BeanDefinitionRegistry source) {
if (source instanceof ConfigurableListableBeanFactory) {
    return (ConfigurableListableBeanFactory) source;
}
if (source instanceof ConfigurableApplicationContext) {
    return (((ConfigurableApplicationContext) source).getBeanFactory());
}
return null;
}
         
        由于AnnotationConfigEmbeddedWebApplicationContext是ConfigurableApplicationContext的子类,因此会调用getBeanFactory获得ConfigurableListableBeanFactory.代码如下:
         
        public final ConfigurableListableBeanFactory getBeanFactory() {
return this.beanFactory;
}
         
        返回的是DefaultListableBeanFactory.
        3.  
       
      3. 设置environment.由于environment不为null,因此不会执行deduceEnvironment.因此直接设置为StandardServletEnvironment.
        4.  
       
      4. 设置resourceLoader.由于传入的resourceLoader 为null,因此会执行deduceResourceLoader.代码如下；
         
        private ResourceLoader deduceResourceLoader(BeanDefinitionRegistry source) {
if (source instanceof ResourceLoader) {
    return (ResourceLoader) source;
}
return null;
}
         
        同样的,由于AnnotationConfigEmbeddedWebApplicationContext是ResourceLoader的子类,因此向上转型为ResourceLoader进行赋值.
        5.  
      
      3.  
     
    3. 为ClassPathBeanDefinitionScanner设置Environment.执行如下代码.
       
      public void setEnvironment(Environment environment) {
    Assert.notNull(environment, "Environment must not be null");
    this.environment = environment;
    this.conditionEvaluator = null;
}
      4.  
    
    3.  
   
  3. SpringApplication#prepareContext 接下来执行的是 postProcessApplicationContext 方法.设置上下文的beanNameGenerator和resourceLoader(如果SpringApplication有的话).代码如下:
     
        protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton(
                AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
    }
    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext) context)
                    .setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader) context)
                    .setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
}
     
    2件事:
     
    
       
     
    1. 如果beanNameGenerator不为null的话,就向BeanFactory进行注册,bean id 为 org.springframework.context.annotation.internalConfigurationBeanNameGenerator.
      2.  
     
    2. 如果resourceLoader不为null的话
       
      
         
       
      1. 如果context 是 GenericApplicationContext 子类的话,就为其设置ResourceLoader
        2.  
       
      2. 如果context 是DefaultResourceLoader 子类的话,就为其设置ClassLoader
        3.  
      
      3.  
    
    4.  
   
  4. 接下来执行第3步.代码如下:
     
        protected void applyInitializers(ConfigurableApplicationContext context) {
    // 1. 从SpringApplication类中的initializers集合获取所有的ApplicationContextInitializer
    for (ApplicationContextInitializer initializer : getInitializers()) {
        // 2. 循环调用ApplicationContextInitializer中的initialize方法
        Class requiredType = GenericTypeResolver.resolveTypeArgument(
                initializer.getClass(), ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
    }
}
     
    2件事:
     
    
       
     
    1. 从SpringApplication类中的initializers集合获取所有的ApplicationContextInitializer.将其封装为LinkedHashSet.
      2.  
     
    2. 遍历之,调用其initialize 进行初始化.当前的initialize有如下:
       
      org.springframework.boot.context.config.DelegatingApplicationContextInitializer, 
org.springframework.boot.context.ContextIdApplicationContextInitializer, 
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer, 
org.springframework.boot.context.embedded.ServerPortInfoApplicationContextInitializer, 
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer, 
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer
       
      我们分别看下其initialize 的实现.
       
      DelegatingApplicationContextInitializer#initialize
       
      代码如下:
       
      public void initialize(ConfigurableApplicationContext context) {
    ConfigurableEnvironment environment = context.getEnvironment();
    // 1. 通过env获取到context.initializer.classes配置的值，如果有则直接获取到具体的值并进行实例化
    List> initializerClasses = getInitializerClasses(environment);
    if (!initializerClasses.isEmpty()) {
        applyInitializerClasses(context, initializerClasses);
    }
}
       
      还是3步
       
      
         
       
      1. 从context中获得ConfigurableEnvironment
        2.  
       
      2. 调用getInitializerClasses获得通过context.initializer.classes 设置的class.
         
        代码如下:
         
        
private static final String PROPERTY_NAME = "context.initializer.classes";

private List> getInitializerClasses(ConfigurableEnvironment env) {
String classNames = env.getProperty(PROPERTY_NAME);
List> classes = new ArrayList>();
if (StringUtils.hasLength(classNames)) {
for (String className : StringUtils.tokenizeToStringArray(classNames, ",")) {
    classes.add(getInitializerClass(className));
}
}
return classes;
}
         
        3步:
         
        
           
         
        1. 从env获得context.initializer.classes 配置的值
          2.  
         
        2. 如果有配置的话,就依次遍历之,如果有多个的话,用,分隔即可. 一般是没有配置的,这里是一个扩展点.
          3.  
         
        3. 调用getInitializerClass 进行加载.代码如下:
           
              private Class getInitializerClass(String className) throws LinkageError {
try {
// 1. 进行加载
Class initializerClass = ClassUtils.forName(className,
    ClassUtils.getDefaultClassLoader());
// 2. 要加载的类必须是ApplicationContextInitializer 实现才行
Assert.isAssignable(ApplicationContextInitializer.class, initializerClass);
return initializerClass;
}
catch (ClassNotFoundException ex) {
throw new ApplicationContextException(
    "Failed to load context initializer class [" + className + "]", ex);
}
}
          4.  
        
        3.  
       
      3. 如果有配置的话,就掉用applyInitializerClasses方法进行初始化. 代码如下:
         
        private void applyInitializerClasses(ConfigurableApplicationContext context,
List> initializerClasses) {
Class contextClass = context.getClass();
List> initializers = new ArrayList>();
for (Class initializerClass : initializerClasses) {
initializers.add(instantiateInitializer(contextClass, initializerClass));
}
applyInitializers(context, initializers);
}
         
        2件事.
         
        
           
         
        1. 依次遍历initializerClasses 进行初始化.
          2.  
         
        2. 实例化完毕后调用applyInitializers,依次调用其initialize方法.代码如下:
           
          private void applyInitializers(ConfigurableApplicationContext context,
List> initializers) {
// 排序后调用具体ApplicationContextInitializer类中的initialize方法
Collections.sort(initializers, new AnnotationAwareOrderComparator());
for (ApplicationContextInitializer initializer : initializers) {
initializer.initialize(context);
}
}
          3.  
        
        4.  
      
       
      ContextIdApplicationContextInitializer#initialize
       
      代码如下:
       
      public void initialize(ConfigurableApplicationContext applicationContext) {
applicationContext.setId(getApplicationId(applicationContext.getEnvironment()));
}
       
      3件事:
       
      
         
       
      1. 通过applicationContext 获得ConfigurableEnvironment
        2.  
       
      2. 调用getApplicationId 生成id.代码如下
         
            private String getApplicationId(ConfigurableEnvironment environment) {
String name = environment.resolvePlaceholders(this.name);
String index = environment.resolvePlaceholders(INDEX_PATTERN);
String profiles = StringUtils
    .arrayToCommaDelimitedString(environment.getActiveProfiles());
if (StringUtils.hasText(profiles)) {
name = name + ":" + profiles;
}
if (!"null".equals(index)) {
name = name + ":" + index;
}
return name;
}
         
        5件事.
         
        
           
         
        1. 获取名称。名称的取值依赖如下几个属性获取名称 spring.application.name,vcap.application.name, spring.config.name:application默认是application
          2.  
         
        2. 获取索引.从以下几个属性中获得.
           
          
             
           
          • vcap.application.instance_index
            •  
           
          • spring.application.index
            •  
           
          • server.port
            •  
           
          • PORT
            •  
           
          • null
            •  
          
           
          默认是null
          3.  
         
        3. 获取ActiveProfiles
          4.  
         
        4. 如果profiles 不会null,就与name进行拼接
          5.  
         
        5. 如果index 不为null的话,就与name进行拼接
          6.  
        
         
        
         
         
        举例说明. 假如我配置 spring.profiles.active=test.端口号为8881,则最后生成的id为application:test:8881
         
        
        3.  
       
      3. 对applicationContext 设置id.代码如下:
         
        public void setId(String id) {
    this.id = id;
}
        4.  
      
       
      ConfigurationWarningsApplicationContextInitializer#initialize
       
      代码如下:
       
      public void initialize(ConfigurableApplicationContext context) {
context.addBeanFactoryPostProcessor(
        new ConfigurationWarningsPostProcessor(getChecks()));
}
       
      向context中添加一个ConfigurationWarningsPostProcessor.
       
      在实例化ConfigurationWarningsPostProcessor时首先会调用getChecks获得Check[],传入到ConfigurationWarningsPostProcessor的构造器中.代码如下:
       
      protected Check[] getChecks() {
    return new Check[] { new ComponentScanPackageCheck() };
}
       
      其返回了一个ComponentScanPackageCheck. 其初始化的代码如下:
       
      private static final Set<String> PROBLEM_PACKAGES;

static {
    Set<String> packages = new HashSet<String>();
    packages.add("org.springframework");
    packages.add("org");
    PROBLEM_PACKAGES = Collections.unmodifiableSet(packages);
}
       
      将org.springframework,org 加入到了PROBLEM_PACKAGES 中.
       
      ConfigurationWarningsPostProcessor 构造器如下:
       
      public ConfigurationWarningsPostProcessor(Check[] checks) {
    this.checks = checks;
}
       
      这样 ConfigurationWarningsPostProcessor 就持有了ComponentScanPackageCheck.
      3.  
    
     
    ServerPortInfoApplicationContextInitializer#initialize
     
    代码如下:
     
    public void initialize(ConfigurableApplicationContext applicationContext) {
    applicationContext.addApplicationListener(
            new ApplicationListener() {

                @Override
                public void onApplicationEvent(
                        EmbeddedServletContainerInitializedEvent event) {
                    ServerPortInfoApplicationContextInitializer.this
                            .onApplicationEvent(event);
                }

            });
}
     
    向applicationContext 添加一个监听.当发生EmbeddedServletContainerInitializedEvent时间时.会执行ServerPortInfoApplicationContextInitializer#onApplicationEvent方法.将server.ports添加到名为server.ports 的MapPropertySource
     
    SharedMetadataReaderFactoryContextInitializer#initialize
     
    代码如下:
     
    public void initialize(ConfigurableApplicationContext applicationContext) {
    applicationContext.addBeanFactoryPostProcessor(
            new CachingMetadataReaderFactoryPostProcessor());
}
     
    向applicationContext 添加了一个CachingMetadataReaderFactoryPostProcessor 的BeanFactoryPostProcessor
     
    SharedMetadataReaderFactoryContextInitializer#initialize
     
    代码如下:
     
    public void initialize(ConfigurableApplicationContext applicationContext) {
    this.applicationContext = applicationContext;
    applicationContext.addApplicationListener(new AutoConfigurationReportListener());
    if (applicationContext instanceof GenericApplicationContext) {
        // Get the report early in case the context fails to load
        this.report = ConditionEvaluationReport
                .get(this.applicationContext.getBeanFactory());
    }
}
     
    2件事
     
    
       
     
    1. 向applicationContext添加了一个AutoConfigurationReportListener
      2.  
     
    2. 如果applicationContext是GenericApplicationContext子类的话,就调用ConditionEvaluationReport#get生成ConditionEvaluationReport.代码如下:
       
          public static ConditionEvaluationReport get(
    ConfigurableListableBeanFactory beanFactory) {
synchronized (beanFactory) {
    ConditionEvaluationReport report;
    if (beanFactory.containsSingleton(BEAN_NAME)) {
        report = beanFactory.getBean(BEAN_NAME, ConditionEvaluationReport.class);
    }
    else {
        report = new ConditionEvaluationReport();
        beanFactory.registerSingleton(BEAN_NAME, report);
    }
    locateParent(beanFactory.getParentBeanFactory(), report);
    return report;
}
}
       
      
         
       
      1. 首先判断是否包含autoConfigurationReport,如果有的话,直接获取即可.否则就实例化一个,然后进行注册.
        2.  
       
      2. 调用locateParent.代码如下:
         
        private static void locateParent(BeanFactory beanFactory,
ConditionEvaluationReport report) {
if (beanFactory != null && report.parent == null
    && beanFactory.containsBean(BEAN_NAME)) {
report.parent = beanFactory.getBean(BEAN_NAME,
        ConditionEvaluationReport.class);
}
}
         
        这里很明显,由于当前环境下 AnnotationConfigEmbeddedWebApplicationContext 中的BeanFactory 是顶层容器,因此 其 ParentBeanFactory 是不存在的,因此该方法是不会执行的.
        3.  
      
      3.  
    
     
    AutoConfigurationReportLoggingInitializer#initialize
     
    代码如下：
     
    public void initialize(ConfigurableApplicationContext applicationContext) {
    this.applicationContext = applicationContext;
    applicationContext.addApplicationListener(new AutoConfigurationReportListener());
    if (applicationContext instanceof GenericApplicationContext) {
        // Get the report early in case the context fails to load
        this.report = ConditionEvaluationReport
                .get(this.applicationContext.getBeanFactory());
    }
}
     
    3件事:
     
    
       
     
    1. 给applicationContext进行赋值
      2.  
     
    2. 添加ApplicationListener
      3.  
     
    3. 如果当前的applicationContext 是GenericApplicationContext 实例的话,就给report进行赋值.很明显,会执行赋值的.执行如下代码:
       
      public static ConditionEvaluationReport get(
    ConfigurableListableBeanFactory beanFactory) {
synchronized (beanFactory) {
    ConditionEvaluationReport report;
    if (beanFactory.containsSingleton(BEAN_NAME)) {
        report = beanFactory.getBean(BEAN_NAME, ConditionEvaluationReport.class);
    }
    else {
        report = new ConditionEvaluationReport();
        beanFactory.registerSingleton(BEAN_NAME, report);
    }
    locateParent(beanFactory.getParentBeanFactory(), report);
    return report;
}
}
      4.  
    
     
    2件事:
     
    
       
     
    1. 如果当前beanFactory包含autoConfigurationReport定义的话,就从beanFactory中获取,否则就实例化一个,然后进行注册
      2.  
     
    2. 如果存在父容器的话,就从父容器中获取。
      3.  
    
     
    很明显,这里是不存在父容器的,并且beanFactory是不包含autoConfigurationReport的定义,因此会实例化后再进行注册. 
    5.  
   
  5. 视线回到SpringApplication#prepareContext中的第5步,打印日志.代码如下:
     
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
     
    3件事
     
    
       
     
    1. 判断是否允许打印启动信息,默认是true.如果为false,则不进行打印.
      2.  
     
    2. 调用logStartupInfo进行打印.代码如下:
       
      protected void logStartupInfo(boolean isRoot) {
if (isRoot) {
    new StartupInfoLogger(this.mainApplicationClass)
            .logStarting(getApplicationLog());
}
}
       
      由于此时的context为顶级容器,因此为实例化StartupInfoLogger,实例化时将启动类传入构造器,然后调用其logStarting方法.调用时,首先getApplicationLog获得启动类的log.代码如下:
       
      protected Log getApplicationLog() {
if (this.mainApplicationClass == null) {
    return logger;
}
return LogFactory.getLog(this.mainApplicationClass);
}
       
      由于此时的mainApplicationClass不为null,因此会实例化启动类的Log.
       
      public void logStarting(Log log) {
Assert.notNull(log, "Log must not be null");
    if (log.isInfoEnabled()) {
        log.info(getStartupMessage());
    }
    if (log.isDebugEnabled()) {
        log.debug(getRunningMessage());
    }
}
       
      2件事:
       
      
         
       
      1. 如果日志级别是info的话,调用getStartupMessage进行打印.代码如下:
         
        private String getStartupMessage() {
StringBuilder message = new StringBuilder();
message.append("Starting ");
message.append(getApplicationName());
message.append(getVersion(this.sourceClass));
message.append(getOn());
message.append(getPid());
message.append(getContext());
return message.toString();
}
         
        会打印启动类名,启动类所在的版本号,主机名,进程id,上下文.打印的日志如下；
         
        2017-12-25 10:25:22.276  INFO 50826 --- [           main] com.example.demo.DemoApplication         : Starting DemoApplication on localhost with PID 50826 (/Users/hejiarui/Documents/spring-boot-source/demo/target/classes started by hejiarui in /Users/hejiarui/Documents/spring-boot-source/demo)
        2.  
       
      2. 如果日志级别是debug的话,调用getRunningMessage进行打印.代码如下:
         
        private StringBuilder getRunningMessage() {
StringBuilder message = new StringBuilder();
message.append("Running with Spring Boot");
message.append(getVersion(getClass()));
message.append(", Spring");
message.append(getVersion(ApplicationContext.class));
return message;
}
         
        打印spring boot 的版本号,ApplicationContext的版本号,打印如下:
         
        2017-12-25 10:29:02.626 DEBUG 50852 --- [           main] com.example.demo.DemoApplication         : Running with Spring Boot, Spring v4.3.13.RELEASE   
        3.  
      
      3.  
    
    6.  
   
  6. 第7步代码如下:
     
    protected void load(ApplicationContext context, Object[] sources) {
    if (logger.isDebugEnabled()) {
        logger.debug(
                "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
    }
    // 1. 实例化BeanDefinitionLoader
    BeanDefinitionLoader loader = createBeanDefinitionLoader(
            getBeanDefinitionRegistry(context), sources);
    // 2. 如果当前的beanNameGenerator 不会null的话,就将SpringApplication中的beanNameGenerator赋值给BeanDefinitionLoader
    if (this.beanNameGenerator != null) {
        loader.setBeanNameGenerator(this.beanNameGenerator);
    }
    // 3. 如果当前的resourceLoader 不会null的话,就将SpringApplication中的resourceLoader赋值给BeanDefinitionLoader
    if (this.resourceLoader != null) {
        loader.setResourceLoader(this.resourceLoader);
    }
    // 4. 如果当前的environment 不会null的话,就将SpringApplication中的environment赋值给BeanDefinitionLoader
    if (this.environment != null) {
        loader.setEnvironment(this.environment);
    }
    // 5. 调用load方法进行加载
    loader.load();
}
     
    5件事:
     
    
       
     
    1. 实例化BeanDefinitionLoader.代码如下:
       
      protected BeanDefinitionLoader createBeanDefinitionLoader(
    BeanDefinitionRegistry registry, Object[] sources) {
return new BeanDefinitionLoader(registry, sources);
}
       
      构造器如下:
       
      BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
Assert.notNull(registry, "Registry must not be null");
Assert.notEmpty(sources, "Sources must not be empty");
this.sources = sources;
this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
this.xmlReader = new XmlBeanDefinitionReader(registry);
if (isGroovyPresent()) {
    this.groovyReader = new GroovyBeanDefinitionReader(registry);
}
this.scanner = new ClassPathBeanDefinitionScanner(registry);
this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
}
       
      5件事.
       
      
         
       
      1. 将sources赋值给BeanDefinitionLoader中的sources
        2.  
       
      2. 实例化AnnotatedBeanDefinitionReader.该实例化的过程我们之前有分析过
        3.  
       
      3. 实例化了XmlBeanDefinitionReader
        4.  
       
      4. 判断是否是在groovy的环境中,如果是的话,就实例化GroovyBeanDefinitionReader.一般情况下,是不会实例化的.判断代码如下:
         
        private boolean isGroovyPresent() {
return ClassUtils.isPresent("groovy.lang.MetaClass", null);
}
        5.  
       
      5. 实例化ClassPathBeanDefinitionScanner.该实例化的过程我们之前有分析过.并将启动类,添加到ClassPathBeanDefinitionScanner的ExcludeFilter中。
        6.  
      
      2.  
     
    2. 如果当前的beanNameGenerator 不会null的话,就将SpringApplication中的beanNameGenerator赋值给BeanDefinitionLoader.对于当前是不会进行赋值的.
      3.  
     
    3. 如果当前的resourceLoader 不会null的话,就将SpringApplication中的resourceLoader赋值给BeanDefinitionLoader.对于当前是不会进行赋值的.
      4.  
     
    4. 如果当前的environment 不会null的话,就将SpringApplication中的environment赋值给BeanDefinitionLoader.对于当前是不会进行赋值的.
      5.  
     
    5. 调用load方法进行加载.代码如下:
       
      public int load() {
    int count = 0;
    for (Object source : this.sources) {
        count += load(source);
    }
    return count;
}
       
      2件事:
       
      
         
       
      1. 声明一个计数器,该计数器统计的是sources中加载bean的数量.
        2.  
       
      2. 遍历sources,进行加载.
         
        代码如下:
         
        private int load(Object source) {
Assert.notNull(source, "Source must not be null");
if (source instanceof Class) {
    return load((Class) source);
}
if (source instanceof Resource) {
    return load((Resource) source);
}
if (source instanceof Package) {
    return load((Package) source);
}
if (source instanceof CharSequence) {
    return load((CharSequence) source);
}
throw new IllegalArgumentException("Invalid source type " + source.getClass());
}
         
        判断source 的类型,然后调用相应的load方法进行加载,由于我们此时传入的是启动类,因此会调用如下方法,代码如下:
         
        private int load(Class source) {
if (isGroovyPresent()) {
// Any GroovyLoaders added in beans{} DSL can contribute beans here
if (GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
    GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
            GroovyBeanDefinitionSource.class);
    load(loader);
}
}
if (isComponent(source)) {
// 进行注册
this.annotatedReader.register(source);
return 1;
}
return 0;
}
         
        2件事:
         
        
           
         
        1. 如果是Groovy环境下,并且该类是GroovyBeanDefinitionSource的子类的话,就调用BeanDefinitionLoader#load(GroovyBeanDefinitionSource) 进行加载,很明显,是不会执行的.
          2.  
         
        2. 如果当前类是Component注解的话,就调用AnnotatedBeanDefinitionReader#register进行加载.判断的方法如下:
           
          private boolean isComponent(Class type) {
// This has to be a bit of a guess. The only way to be sure that this type is
// eligible is to make a bean definition out of it and try to instantiate it.
if (AnnotationUtils.findAnnotation(type, Component.class) != null) {
return true;
}
// Nested anonymous classes are not eligible for registration, nor are groovy
// closures
if (type.getName().matches(".*\\$_.*closure.*") || type.isAnonymousClass()
    || type.getConstructors() == null || type.getConstructors().length == 0) {
return false;
}
return true;
}
           
          3件事
           
          
             
           
          1. 如果当前类上有@Component 注解的话,则返回true.
            2.  
           
          2. 如果当前类的类名匹配.*$_.*closure.* ,或者是一个匿名类,或者构造器不存在的话,返回false.
            3.  
           
          3. 如果以上都不匹配的话,返回true.
            4.  
          
           
          由于我们在启动类上加了@SpringBootApplication的注解,又由于@SpringBootApplication中存在@SpringBootConfiguration,而@SpringBootConfiguration中又存在@Configuration,最终在@Configuration中存在@Component,因此匹配1,因此返回true.
          3.  
         
        3. 如果以上都没匹配到的话,就返回0.
          4.  
        
        3.  
      
      6.  
    
    7.  
   
  7. AnnotatedBeanDefinitionReader#register ,通过遍历annotatedClasses,依次调用registerBean进行加载,代码如下:
     
    public void register(Class... annotatedClasses) {
    for (Class annotatedClass : annotatedClasses) {
        registerBean(annotatedClass);
    }
}
     
    registerBean代码如下:
     
    public void registerBean(Class annotatedClass) {
    registerBean(annotatedClass, null, (Classextends Annotation>[]) null);
}
     
    调用:
     
    public void registerBean(Class annotatedClass, String name, Classextends Annotation>... qualifiers) {
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }

    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    abd.setScope(scopeMetadata.getScopeName());
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    if (qualifiers != null) {
        for (Classextends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            }
            else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            }
            else {
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }

    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
     
    9件事:
     
    
       
     
    1. 实例化AnnotatedGenericBeanDefinition.该类的继承结构如下:
       
      spring boot 源码解析8-SpringApplication#run第8步_第1张图片 
       由继承结构可知.会首先实例化AbstractBeanDefinition,执行如下构造器.代码如下:
       
      protected AbstractBeanDefinition() {
    this(null, null);
}
       
      调用
       
      protected AbstractBeanDefinition(ConstructorArgumentValues cargs, MutablePropertyValues pvs) {
    setConstructorArgumentValues(cargs);
    setPropertyValues(pvs);
}
       
      2件事:
       
      
         
       
      1. 调用 setConstructorArgumentValues 实例化constructorArgumentValues.代码如下:
         
        public void setConstructorArgumentValues(ConstructorArgumentValues constructorArgumentValues) {
this.constructorArgumentValues =
    (constructorArgumentValues != null ? constructorArgumentValues : new ConstructorArgumentValues());
}
         
        由于传入的constructorArgumentValues 为null,因此会实例化ConstructorArgumentValues.
        2.  
       
      2. 调用setPropertyValues 对propertyValues 进行赋值,代码如下:
         
        public void setPropertyValues(MutablePropertyValues propertyValues) {
this.propertyValues = (propertyValues != null ? propertyValues : new MutablePropertyValues());
}
         
        由于传入的propertyValues为null，因此会实例化MutablePropertyValues.
        3.  
      
       
      接下来实例化AnnotatedGenericBeanDefinition,构造器如下:
       
      public AnnotatedGenericBeanDefinition(Class beanClass) {
setBeanClass(beanClass);
this.metadata = new StandardAnnotationMetadata(beanClass, true);
}
       
      2件事:
       
      
         
       
      1. 对beanClass属性赋值为传入的beanClass.
        2.  
       
      2. 实例化StandardAnnotationMetadata.
        3.  
      
      2.  
     
    2. 如果应该跳过加载的话,就直接return. 判断逻辑如下:
       
      public boolean shouldSkip(AnnotatedTypeMetadata metadata, ConfigurationPhase phase) {
// 如果这个类没有被@Conditional注解所修饰，不会skip
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
    return false;
}

// 如果参数中沒有设置条件注解的生效阶段
if (phase == null) {
    // 是配置类的话直接使用PARSE_CONFIGURATION阶段
    if (metadata instanceof AnnotationMetadata &&
            ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
        return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
    }
    // 否则使用REGISTER_BEAN阶段
    return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}

List conditions = new ArrayList(); // 要解析的配置类的条件集合
// 获取配置类的条件注解得到条件数据，并添加到集合中
for (String[] conditionClasses : getConditionClasses(metadata)) {
    for (String conditionClass : conditionClasses) {
        Condition condition = getCondition(conditionClass, this.context.getClassLoader());
        conditions.add(condition);
    }
}

AnnotationAwareOrderComparator.sort(conditions);

for (Condition condition : conditions) {
    ConfigurationPhase requiredPhase = null;
    if (condition instanceof ConfigurationCondition) {
        requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
    }
    if (requiredPhase == null || requiredPhase == phase) {
        // 阶段不满足条件的话，返回true并跳过这个bean的解析
        if (!condition.matches(this.context, metadata)) {
            return true;
        }
    }
}

return false;
}
       
      4件事:
       
      
         
       
      1. 如果这个类没有被@Conditional注解所修饰，不会skip
        2.  
       
      2. 如果参数中沒有设置条件注解的生效阶段
         
        
           
         
        1. 是配置类的话直接使用PARSE_CONFIGURATION阶段
          2.  
         
        2. 否则使用REGISTER_BEAN阶段
          3.  
        
         
        递归调用shouldSkip进行判断.对于当前阶段 ConfigurationPhase为ConfigurationPhase.PARSE_CONFIGURATION.
        3.  
       
      3. 获取配置类的条件注解得到条件数据，并添加到集合中.排序
        4.  
       
      4. 遍历conditions,进行判断,阶段不满足条件的话,返回true并跳过这个bean的解析 
        5.  
      
      3.  
     
    3. 调用AnnotationScopeMetadataResolver#resolveScopeMetadata解析ScopeMetadata. 代码如下:
       
      public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
ScopeMetadata metadata = new ScopeMetadata();
if (definition instanceof AnnotatedBeanDefinition) {
    AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
    AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
            annDef.getMetadata(), this.scopeAnnotationType);
    if (attributes != null) {
        metadata.setScopeName(attributes.getString("value"));
        ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
        if (proxyMode == null || proxyMode == ScopedProxyMode.DEFAULT) {
            proxyMode = this.defaultProxyMode;
        }
        metadata.setScopedProxyMode(proxyMode);
    }
}
return metadata;
}
       
      2件事:
       
      
         
       
      1. 实例化ScopeMetadata.其默认scopeName为singleton,scopedProxyMode为NO.
        2.  
       
      2. 如果BeanDefinition是AnnotatedBeanDefinition实例的话,调用AnnotationConfigUtils#attributesFor获得AnnotationAttributes.如果AnnotationAttributes不会null的话,就为metadata设置ScopeName,设置ScopedProxyMode.此处返回的null.
        3.  
       
      3. 如果不是的话,就返回ScopeMetadata.
        4.  
      
       
      因此设置AnnotatedGenericBeanDefinition的scope为singleton
      4.  
     
    4. 调用AnnotationBeanNameGenerator#generateBeanName生成beanName,代码如下:
       
      public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
// 1. 如果当前类是AnnotatedBeanDefinition,就调用determineBeanNameFromAnnotation生成beanName
// 如果生成的beanName不为空的话,直接return。否则进入第2步.
if (definition instanceof AnnotatedBeanDefinition) {
    String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
    if (StringUtils.hasText(beanName)) {
        // Explicit bean name found.
        return beanName;
    }
}
// 2. Fallback: generate a unique default bean name.
return buildDefaultBeanName(definition, registry);
}
       
      2件事:
       
      
         
       
      1. 如果当前类是AnnotatedBeanDefinition,就调用determineBeanNameFromAnnotation生成beanName,如果生成的beanName不为空的话,直接return。否则进入第2步.在当前场景,是会进入第2步的.
        2.  
       
      2. 经过层层调用最终会调用AnnotationBeanNameGenerator#buildDefaultBeanName获得name,代码如下:
         
         
         protected String buildDefaultBeanName(BeanDefinition definition) { 
         String shortClassName = ClassUtils.getShortName(definition.getBeanClassName()); 
         return Introspector.decapitalize(shortClassName); 
         }
        3.  
      
      5.  
     
    5. 调用AnnotationConfigUtils#processCommonDefinitionAnnotations进行处理.代码如下:
       
      static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
if (metadata.isAnnotated(Lazy.class.getName())) {
abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
}
else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
}
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
if (metadata.isAnnotated(DependsOn.class.getName())) {
abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
}
if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
if (metadata.isAnnotated(Role.class.getName())) {
    absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
}
if (metadata.isAnnotated(Description.class.getName())) {
    absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
}
}
}
       
      4件事:
       
      
         
       
      1. 如果有Lazy的注解的话,则设置LazyInit的值
        2.  
       
      2. 如果有Primary的注解的话,则设置Primary为true
        3.  
       
      3. 如果有DependsOn的注解的话,则设置DependsOn的值
        4.  
       
      4. 如果abd 是AbstractBeanDefinition 子类的话
         
        
           
         
        1. 如果有Role的注解的话,则设置Role的值
          2.  
         
        2. 如果有Description的注解的话,则设置Description的值
          3.  
        
        5.  
      
      6.  
     
    6. 设置qualifier，依次遍历传入的qualifiers进行如下判断.
       
      
         
       
      1. 如果 qualifier 为Primary 的话,设置AnnotatedGenericBeanDefinition#Primary为true.
        2.  
       
      2. 如果 qualifier 为 Lazy 的话,就设置AnnotatedGenericBeanDefinition #LazyInit 为true。
        3.  
       
      3. 否则 就添加一个AutowireCandidateQualifier的实例到AnnotatedGenericBeanDefinition#qualifiers中.
        4.  
      
       
      由于此时传入qualifier 为null,因此是不会进行遍历的.
      7.  
     
    7. 调用applyScopedProxyMode,这是有关代理方面的.代码如下:
       
      static BeanDefinitionHolder applyScopedProxyMode(
    ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
    return definition;
}
boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}
       
      2件事
       
      
         
       
      1. 如果scopedProxyMode为NO,就直接return。
        2.  
       
      2. 否则调用ScopedProxyCreator#createScopedProxy生成BeanDefinitionHolder.
        3.  
      
       
      由于这里的scopedProxyMode为NO,因此是直接进行return的.
      8.  
    
    8.  
   
  8. 视线回到SpringApplication#prepareContext.接下来该执行最后一步了, 调用listeners的contextLoaded方法.代码如下；
     
    public void contextLoaded(ConfigurableApplicationContext context) {
    for (SpringApplicationRunListener listener : this.listeners) {
        listener.contextLoaded(context);
    }
}
     
    调用EventPublishingRunListener#contextLoaded,代码如下:
     
    public void contextLoaded(ConfigurableApplicationContext context) {
    for (ApplicationListener listener : this.application.getListeners()) {
        if (listener instanceof ApplicationContextAware) {
            ((ApplicationContextAware) listener).setApplicationContext(context);
        }
        context.addApplicationListener(listener);
    }
    this.initialMulticaster.multicastEvent(
            new ApplicationPreparedEvent(this.application, this.args, context));
}

     
    2件事
     
    
       
     
    1. 遍历application 中的ApplicationListener,如果listener 实现了ApplicationContextAware的话,就调用其setApplicationContext进行赋值.当前的如下:
       
      org.springframework.boot.context.config.ConfigFileApplicationListener,
org.springframework.boot.context.config.AnsiOutputApplicationListener, 
org.springframework.boot.logging.LoggingApplicationListener, 
org.springframework.boot.logging.ClasspathLoggingApplicationListener, 
org.springframework.boot.autoconfigure.BackgroundPreinitializer, 
org.springframework.boot.context.config.DelegatingApplicationListener, 
org.springframework.boot.builder.ParentContextCloserApplicationListener,  
org.springframework.boot.ClearCachesApplicationListener, 
org.springframework.boot.context.FileEncodingApplicationListener,
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener
       
      只有ParentContextCloserApplicationListener实现了ApplicationContextAware接口.
      2.  
     
    2. 发送ApplicationPreparedEvent 事件.由前可知,会依次调用listener的onApplicationEvent事件,接下来我们就来看看其各自的实现.
      3.  
    
     
    ConfigFileApplicationListener#onApplicationEvent
     
    代码如下:
     
    public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ApplicationEnvironmentPreparedEvent) {
        onApplicationEnvironmentPreparedEvent(
                (ApplicationEnvironmentPreparedEvent) event);
    }
    if (event instanceof ApplicationPreparedEvent) {
        onApplicationPreparedEvent(event);
    }
}
     
    调用onApplicationPreparedEvent,代码如下:
     
        private void onApplicationPreparedEvent(ApplicationEvent event) {
    this.logger.replayTo(ConfigFileApplicationListener.class);
    addPostProcessors(((ApplicationPreparedEvent) event).getApplicationContext());
}
     
    调用
     
        protected void addPostProcessors(ConfigurableApplicationContext context) {
    context.addBeanFactoryPostProcessor(
            new PropertySourceOrderingPostProcessor(context));
}
     
    最终添加了一个PropertySourceOrderingPostProcessor.
     
    LoggingApplicationListener#onApplicationEvent
     
    最终会执行LoggingApplicationListener#onApplicationPreparedEvent,向beanFactory注册了一个id为springBootLoggingSystem,class 为 LoggingSystem 的bean.
     
    BackgroundPreinitializer#onApplicationEvent
     
    没有做任何事
     
    DelegatingApplicationListener#onApplicationEvent
     
    没有做任何事
    9.  
   
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(spring,boot,spring,boot,源码解析,spring,源码)
    
        
    
            
    
                
      
                    
    • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
      摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
      
                    
      • 
                    
    • 四章-32-点要素的聚合
                        彩云飘过

                        
      本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
      文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
      
                    
      • 
                    
    • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
      SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
      
                    
      • 
                    
    • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
      目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
      
                    
      • 
                    
    • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
      ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
      
                    
      • 
                    
    • Python神器！WEB自动化测试集成工具 DrissionPage
                        亚丁号
python开发语言
                        
      一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
      
                    
      • 
                    
    • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
      前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
      
                    
      • 
                    
    • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
      这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
      
                    
      • 
                    
    • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
      笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
      
                    
      • 
                    
    • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
      引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
      
                    
      • 
                    
    • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
      文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
      
                    
      • 
                    
    • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
      在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
      
                    
      • 
                    
    • 博客网站制作教程
                        2401_85194651
javamaven
                        
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
      
                    
      • 
                    
    • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
                        疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
                        
      系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
      
                    
      • 
                    
    • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开
                        摸鱼小号
php
                        
      可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
      
                    
      • 
                    
    • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署）
                        java毕设程序源码王哥
php课程设计vue.js
                        
      该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
      
                    
      • 
                    
    • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
      重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
      
                    
      • 
                    
    • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
      文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
      
                    
      • 
                    
    • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
      概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
      
                    
      • 
                    
    • html+css网页设计 旅游网站首页1个页面
                        html+css+js网页设计
htmlcss旅游
                        
      html+css网页设计旅游网站首页1个页面网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode、Sublime、Webstorm、Text、Notepad++等任意html编辑软件进行运行及修改编辑等操作）。获取源码1，访问该网站https://download.csdn.net/download/qq_42431718/897527112，点击
      
                    
      • 
                    
    • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
      SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
      
                    
      • 
                    
    • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
      通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
      
                    
      • 
                    
    • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
      Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
      
                    
      • 
                    
    • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
      撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
      
                    
      • 
                    
    • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
      springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
      
                    
      • 
                    
    • python中文版软件下载-Python中文版
                        编程大乐趣

                        
      python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
      
                    
      • 
                    
    • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
      探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
      
                    
      • 
                                
    • 安装数据库首次应用
                                    Array_06
javaoraclesql
                                    
      可是为什么再一次失败之后就变成直接跳过那个要求 
enter full pathname of java.exe的界面 
 
 
这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 
注意第一次，使用SQL D
      
                                
      • 
                                
    • Weblogic Server Console密码修改和遗忘解决方法
                                    bijian1013
Welogic
                                    
              在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 
一.修改Console密码 
        打开weblogic控制台，安全领域 --> myrealm -->&n
      
                                
      • 
                                
    • IllegalStateException: Cannot forward a response that is already committed
                                    Cwind
javaServlets
                                    
      对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。   示例代码：   
protected void doPost() {
    if (someCondition) {
        sendRedirect();
    }
    forward(); // Thi
      
                                
      • 
                                
    • 基于流的装饰设计模式
                                    木zi_鸣
设计模式
                                    
      当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 
自定义的类成为装饰类 
 
模仿BufferedReader，对Reader进行包装，体现装饰设计模式 
 
装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 
装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 
 
装饰类因为增强已有对象，具备的功能该
      
                                
      • 
                                
    • Linux中的uniq命令
                                    被触发
linux
                                    
      Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 
AD： 
uniq [选项] 文件 
说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
      
                                
      • 
                                
    • 正则表达式Pattern
                                    肆无忌惮_
Pattern
                                    
      正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。 
  
例如，我们需要对QQ号码格式进行检验 
规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} 
&nbs
      
                                
      • 
                                
    • Oracle高级查询之OVER (PARTITION BY ..)
                                    知了ing
oraclesql
                                    
      一、rank()/dense_rank() over(partition by ...order by ...) 
 
现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： 
 
 select e.ename, e.job, e.sal, e.deptno  
  from scott.emp e,  
       (se
      
                                
      • 
                                
    • Python调试
                                    矮蛋蛋
pythonpdb
                                    
      原文地址： 
http://blog.csdn.net/xuyuefei1988/article/details/19399137 
1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： 
 
IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： 
 
http://www.ibm.com/d
      
                                
      • 
                                
    • webservice传递自定义对象时函数为空，以及boolean不对应的问题
                                    alleni123
webservice
                                    
      今天在客户端调用方法 
NodeStatus status=iservice.getNodeStatus(). 
 
结果NodeStatus的属性都是null。 
 
进行debug之后，发现服务器端返回的确实是有值的对象。 
 
后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 
本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
      
                                
      • 
                                
    • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针
                                    百合不是茶

                                    
      C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作： 
  
定义一个指针p来指向a的地址（&是地址符号）： 
        
      
                                
      • 
                                
    • Eclipse打不开，提示“An error has occurred.See the log file ***/.log”
                                    bijian1013
eclipse
                                    
      打开eclipse工作目录的\.metadata\.log文件，发现如下错误： 
 
!ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 
!MESSAGE Application error 
!STACK 1 
java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
      
                                
      • 
                                
    • spring aop实例annotation方法实现
                                    bijian1013
javaspringAOPannotation
                                    
              在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut 
AdviceMethods.jav
      
                                
      • 
                                
    • [Velocity一]Velocity语法基础入门
                                    bit1129
velocity
                                    
      用户和开发人员参考文档 
http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html 
  注释 
1.行级注释## 
2.多行注释#*  *# 
  变量定义 
使用$开头的字符串是变量定义，例如$var1, $var2, 
  赋值 
使用#set为变量赋值，例
      
                                
      • 
                                
    • 【Kafka十一】关于Kafka的副本管理
                                    bit1129
kafka
                                    
      1. 关于request.required.acks 
  
request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 
0表示即不进行确认即返回。 
1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 
-1表示根据指定的最少Partition确认后才返回，这个在 
  
Th
      
                                
      • 
                                
    • lua统计nginx内部变量数据
                                    ronin47
lua nginx　 统计
                                    
      server {
    listen 80;
    server_name photo.domain.com;
    location /{set $str $uri;
        content_by_lua '
            local url = ngx.var.uri
            local res = ngx.location.capture(
      
                                
      • 
                                
    • java-11.二叉树中节点的最大距离
                                    bylijinnan
java
                                    
      
import java.util.ArrayList;
import java.util.List;


public class MaxLenInBinTree {

	/*
	 a.			1
	 		   /  \
	 		  2    3
	 		 / \  / \
	 		4   5 6  7
	 	max=4	pass "root"
	 
      
                                
      • 
                                
    • Netty源码学习-ReadTimeoutHandler
                                    bylijinnan
javanetty
                                    
       
ReadTimeoutHandler的实现思路： 
开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 
这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 
 
 

private final ChannelHandler timeoutHandler =
	new ReadTim
      
                                
      • 
                                
    • jquery验证上传文件样式及大小(好用)
                                    cngolon
文件上传jquery验证
                                    
      <!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <script src="jquery1.8/jquery-1.8.0.
      
                                
      • 
                                
    • 浏览器兼容【转】
                                    cuishikuan
css浏览器IE
                                    
      浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 
 
问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 
 
碰到频率:100% 
 
解决方案：CSS里    *{margin:0;padding:0;} 
 
备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
      
                                
      • 
                                
    • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数
                                    daizj
shell$#$?特殊变量
                                    
      前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码：   
 
  $echo $$  
   
运行结果 
29949 
   特殊变量列表   变量 含义   $0 当前脚本的文件名   $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
      
                                
      • 
                                
    • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID!
                                    dcj3sjt126com
unix
                                    
      翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 
 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
      
                                
      • 
                                
    • android Activity间List传值
                                    dcj3sjt126com
Activity
                                    
      第一个Activity： 
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
      
                                
      • 
                                
    • tomcat 设置java虚拟机内存
                                    eksliang
tomcat 内存设置
                                    
      转载请出自出处：http://eksliang.iteye.com/blog/2117772 
http://eksliang.iteye.com/ 
常见的内存溢出有以下两种: 
java.lang.OutOfMemoryError: PermGen space  
java.lang.OutOfMemoryError: Java heap space 
  
------------
      
                                
      • 
                                
    • Android 数据库事务处理
                                    gqdy365
android
                                    
      使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
      
                                
      • 
                                
    • Java 打开浏览器
                                    hw1287789687
打开网址open浏览器open browser打开url打开浏览器
                                    
      使用java 语言如何打开浏览器呢? 
我们先研究下在cmd窗口中,如何打开网址 
使用IE 打开 
D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 
使用火狐打开 
D:\software\bin>cmd /c start firefox http://hw1287789
      
                                
      • 
                                
    • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件
                                    justjavac
chromeGooglegoogle apichrome插件
                                    
      Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 
 
 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
      
                                
      • 
                                
    • 进程VS.线程
                                    m635674608
线程
                                    
      资料来源： 
http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 
多进程模式最大
      
                                
      • 
                                
    • Linux下安装MemCached
                                    字符串
memcached
                                    
      前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
      
                                
      • 
                                
    • java设计模式之--jdk动态代理（实现aop编程）
                                    Supanccy2013
javaDAO设计模式AOP
                                    
          与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 
&
      
                                
      • 
                                
    • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持
                                    wiselyman
spring 4
                                    
      2.1 默认方法(default method) 
 
 java8引入了一个default medthod; 
 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 
 使用default关键字 
 Spring 4.2支持加载在默认方法里声明的bean 
  
2.2 
 
 将要被声明成bean的类 
  
public class DemoService {
    
      
                                
      •