MeiMing_104

SpringBoot 学习笔记(四) - 原理篇

一、自动配置

1.1 bean加载方式

bean的加载方式1 - xml方式声明bean

导入依赖：

<dependencies>
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.3.9version>
  dependency>
  <dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.17version>
  dependency>
dependencies>

配置applicationContext1.xml


<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="cat" class="com.ming.bean.Cat"/>
  <bean class="com.ming.bean.Dog"/>

  
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"/>
  <bean class="com.alibaba.druid.pool.DruidDataSource"/>
  <bean class="com.alibaba.druid.pool.DruidDataSource"/>
beans>

测试：

public class App1 {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext1.xml");
        //        Object cat = ctx.getBean("cat");
        //        System.out.println(cat); // com.ming.bean.Cat@59494225
        //        Dog dog = ctx.getBean(Dog.class);
        //        System.out.println(dog); // com.ming.bean.Dog@4566e5bd
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
            /**
             * cat
             * com.ming.bean.Dog#0
             * dataSource
             * com.alibaba.druid.pool.DruidDataSource#0
             * com.alibaba.druid.pool.DruidDataSource#1
             */
        }
    }
}

bean的加载方式2 - XML+注解方式声明bean


<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:context="http://www.springframework.org/schema/context"
  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
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd">

  <context:component-scan base-package="com.ming.bean,com.ming.config"/>
beans>

使用@Component及其衍生注解@Controller 、@Service、@Repository定义bean

@Component("tom")
public class Cat {}

@Controller("jerry")
public class Mouse {}

@Service
public class BookServiceImpl01 implements BookService {
    @Override
    public void check() {
        System.out.println("BookServiceImpl01 ..");
    }
}

// ....

使用@Bean定义第三方bean，并将所在类定义为配置类或Bean

@Configuration
public class DbConfig {
    /**
     * 加载第三方bean
     * @return
     */
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

测试：

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext2.xml");
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
            /**
             * tom
             * jerry
             * bookServiceImpl01
             * dbConfig
             * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
             * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
             * org.springframework.context.annotation.internalCommonAnnotationProcessor
             * org.springframework.context.event.internalEventListenerProcessor
             * org.springframework.context.event.internalEventListenerFactory
             * dataSource
             */
        }
    }
}

bean的加载方式3 - 注解方式声明配置类

标注注解的类同上
配置类如下所示：

@ComponentScan({"com.ming.bean","com.ming.config"})
public class SpringConfig3 {
    
}

如果通过扫描的方式加入(new AnnotationConfigApplicationContext(SpringConfig3.class))，
则SpringConfig3类上的 @Configuration可以省略

测试：

public class App3 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig3.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
            /**
             * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
             * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
             * org.springframework.context.annotation.internalCommonAnnotationProcessor
             * org.springframework.context.event.internalEventListenerProcessor
             * org.springframework.context.event.internalEventListenerFactory
             * springConfig3
             * tom
             * jerry
             * bookServiceImpl01
             * dbConfig
             * dataSource
             */
        }
    }
}

扩展1：

初始化实现FactoryBean接口的类，实现对bean加载到容器之前的批处理操作

public class DogFactoryBean implements FactoryBean<Dog> {
    @Override
    public Dog getObject() throws Exception {
        Dog dog = new Dog();
        // 进行dog对象的相关初始化
        return dog;
    }

    @Override
    public Class<?> getObjectType() {
        return Dog.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

使用方式：返回的不是DogFactoryBean对象，而是DogFactoryBean对象创建出来的Dog对象

@ComponentScan({"com.ming.bean","com.ming.config"})
public class SpringConfig3 {
    @Bean
    public DogFactoryBean dog(){
        return new DogFactoryBean();
    }
}

测试：

public class App3 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig3.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println(ctx.getBean("dog"));
    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig3
 * tom
 * jerry
 * bookServiceImpl01
 * dbConfig
 * dataSource
 * dog
 * com.ming.bean.Dog@65d6b83b
 */

扩展2：

如何在同时加载配置文件和配置类？(系统迁移)

@ImportResource({"applicationContext3.xml"})
public class SpringConfig32 {
}

思考：若配置文件1里面加载了cat，配置文件2里面也加载cat会发生什么？

如下所示：配置文件1

<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="cat" class="com.ming.bean.Cat">
    <property name="name" value="tom1"/>
  bean>
beans>

配置文件2


<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="cat" class="com.ming.bean.Cat">
    <property name="name" value="tom2"/>
  bean>
beans>

配置类：

@ImportResource({"applicationContext3.xml","applicationContext32.xml"})
public class SpringConfig32 {
}

结果：与@ImportResource的导入顺序有关，配置文件2覆盖配置文件1的bean，另外在配置类中声明Bean，也会被覆盖，优先级最低

public class App32 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig32.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("--------------");
        Cat cat = (Cat) ctx.getBean("cat");
        System.out.println(cat.getName()); // tom2
    }
}

扩展3：

使用proxyBeanMethods=true可以保障调用此方法得到的对象是从容器中获取的而不是重新创建的

@Configuration(proxyBeanMethods = true) // 默认为true
public class SpringConfig33 {
    @Bean
    public Cat cat(){
        System.out.println("cat init ...");
        return new Cat();
    }
}

测试：

public class App33 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig33.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("--------------------");
        System.out.println(ctx.getBean("springConfig33")); //
        /**
         * 当Configuration注解的proxyBeanMethods属性为true(默认)时：
         * 打印结果为：com.ming.config.SpringConfig33$$EnhancerBySpringCGLIB$$1939a483@21a947fe
         * 从打印结果可以看出，这个对象是由CGLIB动态代理生成的代理对象
         * 改为false后：
         * 打印结果为：com.ming.config.SpringConfig33@2c039ac6
         */

        SpringConfig33 springConfig33 = ctx.getBean("springConfig33", SpringConfig33.class);
        System.out.println(springConfig33.cat());
        System.out.println(springConfig33.cat());
        /**
         * 当proxyBeanMethods属性为true(默认)时：
         *  打印结果都为 com.ming.bean.Cat@1dd92fe2 ，同一个对象
         * 改为false后：
         *  打印结果不同：
         *  com.ming.bean.Cat@ed9d034
         *  com.ming.bean.Cat@6121c9d6
         */
    }
}

bean的加载方式4- 使用@Import()注入bean

使用@Import注解导入要注入的bean对应的字节码

@Import({Dog.class})
public class SpringConfig4 {

}

被导入的bean无需使用注解声明为bean

public class Dog {
}

此形式可以有效的降低源代码与Spring技术的耦合度，在spring技术底层及诸多框架的整合中大量使用

测试：

public class App4 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig4.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("------------------");
        System.out.println(ctx.getBean(Dog.class));
    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig4
 * com.ming.bean.Dog
 * ------------------
 * com.ming.bean.Dog@9a7504c
 */

扩展4：

除了可以使用@Import()注解注入普通的Bean外，还可以加载配置类，并且在配置类中声明的bean也生效

@Import({DbConfig.class})
public class SpringConfig42 {

}

配置类可以不加@Configuration注解

// @Configuration
public class DbConfig {
    @Bean
    public DruidDataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

测试：

public class App42 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig42.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig42
 * com.ming.config.DbConfig
 * dataSource
 */

bean的加载方式5 - 硬编码方式注入（register/registerBean方法）

使用上下文对象在容器初始化完毕后注入bean

public class App5 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig5.class);
        // 上下文容器对象已经初始化完毕后，手工加载bean。 - registerBean/register
        ctx.registerBean("tom", Cat.class);
        ctx.register(Dog.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig5
 * tom
 * dog
 */

bean的加载方式6 - ImportSelector接口

导入实现了ImportSelector接口的类，实现对导入源的编程式处理

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.ming.bean.Cat","com.ming.bean.Dog"};
    }
}

配置类导入MyImportSelector

@Import(MyImportSelector.class)
public class SpringConfig6 {
}

测试：

public class App6 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig6.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig6
 * tom # 因为Cat类上有@Component("tom")
 * com.ming.bean.Dog
 */

扩展：selectImports方法的使用技巧

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        System.out.println("==============");
        // 获取的类名
        System.out.println(""+annotationMetadata.getClassName()); // com.ming.config.SpringConfig6

        // 获取的类名上是否注解：org.springframework.context.annotation.Configuration
        System.out.println(annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration")); // true

        // 获取类上注解的属性，如 @ComponentScan(basePackages = {"com.ming"})
        Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes("org.springframework.context.annotation.ComponentScan");
        System.out.println(attributes); // {basePackageClasses=[], basePackages=[com.ming], excludeFilters=[], includeFilters=[], lazyInit=false, nameGenerator=interface org.springframework.beans.factory.support.BeanNameGenerator, resourcePattern=**/*.class, scopeResolver=class org.springframework.context.annotation.AnnotationScopeMetadataResolver, scopedProxy=DEFAULT, useDefaultFilters=true, value=[com.ming]}
        System.out.println("==============");
        return new String[]{"com.ming.bean.Cat","com.ming.bean.Dog"};
    }
    //    @Override
    //    public String[] selectImports(AnnotationMetadata annotationMetadata) {
    //        // 还可以进行条件的判定，判定完毕后决定装载哪个bean
    //        boolean flag = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration");
    //        if(flag){
    //            return new String[]{"com.ming.bean.Cat"};
    //        }else{
    //            return new String[]{"com.ming.bean.Dog"};
    //        }
    //    }
}

bean的加载方式7 - ImportBeanDefinitionRegistrar接口

导入实现了ImportBeanDefinitionRegistrar接口的类，通过BeanDefinition的注册器注册实名bean，实现对容器中bean的裁定，例如对现有bean的覆盖，进而达成不修改源代码的情况下更换实现的效果

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Dog.class).getBeanDefinition();
        registry.registerBeanDefinition("dog1",beanDefinition);
    }
}

配置类注入：

@Import(MyImportBeanDefinitionRegistrar.class)
public class SpringConfig7 {

}

测试：

public class App7 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig7.class);
        String[] names = ctx.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}
/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig7
 * dog1
 */

bean的加载方式8 - BeanDefinitionRegistryPostProcessor接口

导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefinition的注册器注册实名bean，实现对容器中bean的最终裁定

场景构建：在一个配置类上的@Import()注解可以导入多个bean，如果此时导入的bean名字相同，一般来说配置靠后的会覆盖前面的配置，为了最终统一得到想要的bean，可以使用实现BeanDefinitionRegistryPostProcessor的方式完成
声明BeanDefinitionRegistryPostProcessor接口实现类：

public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        BeanDefinition beanDefinition = BeanDefinitionBuilder
        .rootBeanDefinition(BookServiceImpl04.class)
        .getBeanDefinition();
        beanDefinitionRegistry.registerBeanDefinition("bookService", beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

@Import({BookServiceImpl01.class })

@Service("bookService")
public class BookServiceImpl01 implements BookService {
    @Override
    public void check() {
        System.out.println("BookServiceImpl01 ..");
    }
}

@Import({MyImportBeanDefinitionRegistrar81.class, })

public class MyImportBeanDefinitionRegistrar81 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl02.class).getBeanDefinition();
        registry.registerBeanDefinition("bookService",beanDefinition);
    }
}

@Import({MyImportBeanDefinitionRegistrar82.class, })

public class MyImportBeanDefinitionRegistrar82 implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(BookServiceImpl03.class).getBeanDefinition();
        registry.registerBeanDefinition("bookService",beanDefinition);
    }
}

@Import({MyPostProcessor.class, })

public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        BeanDefinition beanDefinition = BeanDefinitionBuilder
        .rootBeanDefinition(BookServiceImpl04.class)
        .getBeanDefinition();
        beanDefinitionRegistry.registerBeanDefinition("bookService", beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

导入配置类：

//@Import({BookServiceImpl01.class })  // 此时运行App8.java 打印出 BookServiceImpl01 ..
//@Import({BookServiceImpl01.class, MyImportBeanDefinitionRegistrar81.class, }) // 此时运行App8.java 打印出 BookServiceImpl02 .. ..
//@Import({BookServiceImpl01.class, MyImportBeanDefinitionRegistrar81.class, MyImportBeanDefinitionRegistrar82.class}) // 此时运行App8.java 打印出 BookServiceImpl03 .. .. ..
//@Import({BookServiceImpl01.class, MyImportBeanDefinitionRegistrar82.class, MyImportBeanDefinitionRegistrar81.class}) // 此时运行App8.java 打印出 BookServiceImpl02 .. ..
@Import({MyPostProcessor.class, BookServiceImpl01.class, MyImportBeanDefinitionRegistrar82.class, MyImportBeanDefinitionRegistrar81.class, }) // 此时运行App8.java 打印出 BookServiceImpl04 .. .. .. ..
public class SpringConfig8 {

}

测试：

public class App8 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig8.class);
        BookService bookService = ctx.getBean("bookService", BookService.class);
        bookService.check();
    }
}

小结：

1.2 bean加载控制

编程式

bean的加载控制指根据特定情况对bean进行选择性加载以达到适用于项目的目标。
故只有上述8种加载方式的后四种可以实现bean的加载控制

用一种方式举例：实现ImportSelector接口的方式

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        /**
         * 功能描述：如果有Mouse这个类的话，就加载cat,
         * 如果没有Wolf类的话，就不加载cat
         */
        try {
//            Class clazz = Class.forName("com.ming.bean.Mouse");
            Class<?> clazz = Class.forName("com.ming.bean.Wolf");
            if (clazz != null){
                return new String[]{"com.ming.bean.Cat"};
            }
        } catch (ClassNotFoundException e) {
            return new String[0];
        }
        return null;
    }
}

配置类加载MyImportSelector类

@Import(MyImportSelector.class)
public class SpringConfig {
}

测试：前提条件com.ming.bean包下，有Mouse，没有Wolf；

当满足第一种情况下，(有Mouse，加载Cat)

/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig
 * com.ming.bean.Cat  # 因为com.ming.bean包下有Mouse类
 */

当满足第二种情况下，(没有Wolf，不加载Cat)

/**
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 * org.springframework.context.annotation.internalAutowiredAnnotationProcessor
 * org.springframework.context.annotation.internalCommonAnnotationProcessor
 * org.springframework.context.event.internalEventListenerProcessor
 * org.springframework.context.event.internalEventListenerFactory
 * springConfig
 */

注解式

使用@Conditional注解的派生注解设置各种组合条件控制bean的加载

添加SpringBoot相关的jar包

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starterartifactId>
  <version>2.5.3version>
dependency>

spring提供默认规范，springboot提供实现

前提条件com.ming.bean包下，有Mouse，没有Wolf；

匹配指定类

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
public class SpringConfig2 {
    @Bean
    // com.ming.bean包下有Mouse类，则加载 cat
//    @ConditionalOnClass(name = "com.ming.bean.Mouse") 
    // com.ming.bean包下有Wolf类，则加载 cat
    @ConditionalOnClass(name = "com.ming.bean.Wolf") 
    public Cat cat(){
        return new Cat();
    }
}

未匹配指定类

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
public class SpringConfig2 {
    @Bean
    // com.ming.bean包下没有Mouse类，则加载 cat
    @ConditionalOnMissingClass("com.ming.bean.Mouse")
    // com.ming.bean包下没有Wolf类，则加载 cat
//    @ConditionalOnMissingClass("com.ming.bean.Wolf")
    public Cat cat(){
        return new Cat();
    }
}

匹配指定类型的bean

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
@Import(Mouse.class)
public class SpringConfig2 {

    @Bean
    // 容器中有名称为com.ming.bean.Mouse的bean，则加载 cat2
    //    @ConditionalOnBean(name = "com.ming.bean.Mouse")
    // 容器中有名称为jerry的bean，则加载 cat2
    //    @ConditionalOnBean(name = "jerry")
    // 容器中有名称为com.ming.bean.Wolf的bean，则加载 cat2
    @ConditionalOnBean(name = "com.ming.bean.Wolf")
    public Cat cat2(){
        return new Cat();
    }
}

未匹配指定类型的bean

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
@Import(Mouse.class)
public class SpringConfig2 {

    @Bean
    // 容器中没有名称为com.ming.bean.Mouse的bean，则加载 cat2
    //    @ConditionalOnMissingBean(name = "com.ming.bean.Mouse")
    // 容器中没有名称为com.ming.bean.Wolf的bean，则加载 cat2
    @ConditionalOnMissingBean(name = "com.ming.bean.Wolf")  
    public Cat cat2(){
        return new Cat();
    }
}

匹配指定环境

import org.springframework.boot.autoconfigure.condition.ConditionalOnNotWebApplication;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
public class SpringConfig2 {

    @Bean
    // 当是web环境时，才加载
    //    @ConditionalOnWebApplication
    // 当不是web环境时，才加载
    @ConditionalOnNotWebApplication
    public Cat cat3(){
        return new Cat();
    }
}

小结

1.3 bean依赖属性配置

案例描述：
要求在application.yml中传入业务所需要的属性值，并在原始位置声明默认值；
为了实现这一效果，我们先来配置一个基本的环境
业务类：CartoonCatAndMouse

@Component
public class CartoonCatAndMouse {
    private Cat cat;
    private Mouse mouse;
    CartoonCatAndMouse(){
        cat = new Cat();
        cat.setName("tom");
        cat.setAge(3);
        mouse = new Mouse();
        mouse.setName("jerry");
        mouse.setAge(4);
    }
    public void play(){
        System.out.println(cat.getAge()+"岁的"+cat.getName()+"和"+mouse.getAge()+"岁的"+mouse.getName()+"打起来了~~~");
    }
}

实体类：Cat / Mouse

@Data
public class Cat {
    private String name;
    private Integer age;
}

@Data
public class Mouse {
    private String name;
    private Integer age;
}

主类：

@SpringBootApplication
public class App1 {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App1.class);
        CartoonCatAndMouse cartoonCatAndMouse = context.getBean(CartoonCatAndMouse.class);
        cartoonCatAndMouse.play();
    }
}
// 3岁的tom和4岁的jerry打起来了~~~

改进：增加配置文件application.yml 和对应的属性类， (将业务功能bean运行需要的资源抽取成独立的属性类（******Properties），设置读取配置文件信息)
新增：

cartoon:
  cat:
    name: "TOM"
    age: 6
  mouse:
    name: "JERRY"
    age: 8

@Component
@Data
@ConfigurationProperties(prefix = "cartoon")
public class CartoonProperties {
    private Cat cat;
    private Mouse mouse;
}

修改业务类CartoonCatAndMouse读取属性的方式：

@Component
public class CartoonCatAndMouse {
    private Cat cat;
    private Mouse mouse;

    private CartoonProperties cartoonProperties;
    CartoonCatAndMouse(CartoonProperties cartoonProperties){
        this.cartoonProperties = cartoonProperties;
        cat = new Cat();
        cat.setName(cartoonProperties.getCat() != null && StringUtils.hasText(cartoonProperties.getCat().getName()) ? cartoonProperties.getCat().getName() :"tom");
        cat.setAge(cartoonProperties.getCat() != null && cartoonProperties.getCat().getAge() != null ? cartoonProperties.getCat().getAge() : 3);
        mouse = new Mouse();
        mouse.setName(cartoonProperties.getMouse() != null && StringUtils.hasText(cartoonProperties.getMouse().getName()) ? cartoonProperties.getMouse().getName() :"jerry");
        mouse.setAge(cartoonProperties.getMouse() != null && cartoonProperties.getMouse().getAge() != null ? cartoonProperties.getMouse().getAge() : 4);
    }
    public void play(){
        System.out.println(cat.getAge()+"岁的"+cat.getName()+"和"+mouse.getAge()+"岁的"+mouse.getName()+"打起来了~~~");
    }
}

测试效果：6岁的TOM和8岁的JERRY打起来了~~~

完善：

CartoonProperties 不应该强制声明成Bean，因为，没有在配置文件中声明的话，即用默认的即可，无需加载这个Bean
- 解决：去掉CartoonProperties类上的@Component注解，在调用方(CartoonCatAndMouse)类上加@EnableConfigurationProperties(CartoonProperties.class)注解
CartoonCatAndMouse 也不应该强制声明成Bean，因为，只有在调用方(App1)使用到的时候，才应该加载该Bean
- 解决：去掉CartoonCatAndMouse 类上的@Component注解，在调用方(App1)类上加@Import(CartoonCatAndMouse.class)注解

小结：

1.4 自动配置原理

收集Spring开发者的编程习惯，整理开发过程使用的常用技术列表——>(技术集A)
收集常用技术(技术集A)的使用参数，整理开发过程中每个技术的常用设置列表——>(设置集B)
初始化SpringBoot基础环境，加载用户自定义的bean和导入的其他坐标，形成初始化环境
将技术集A包含的所有技术都定义出来，在Spring/SpringBoot启动时默认全部加载
将技术集A中具有使用条件的技术约定出来，设置成按条件加载，由开发者决定是否使用该技术（与初始化环境比对）
将设置集B作为默认配置加载（约定大于配置），减少开发者配置工作量
开放设置集B的配置覆盖接口，由开发者根据自身需要决定是否覆盖默认配置

源码解析：
SpringBoot的自动配置是由@SpringBootApplication实现的，所以我们来先看这个注解内部构造：

/**
 * @SpringBootConfiguration
 *     @Configuration # 里面有一个proxyBeanMethods 属性，控制是否开启代理模式创建bean，详解扩展3
 *         @Component
 *     @Indexed # 在编译时扫描 @Indexed 注解，确定 bean，生成索引文件。先看如下 Spring 官网
 * @EnableAutoConfiguration
 *     @AutoConfigurationPackage
 *         @Import({AutoConfigurationPackages.Registrar.class}) # 重点在此
 *     @Import({AutoConfigurationImportSelector.class}) # 重点在此
 * @ComponentScan( # 组件扫描 排除一些不需要的Bean
 *     excludeFilters = {
 *         @ComponentScan.Filter(type = FilterType.CUSTOM,
 *         classes = {TypeExcludeFilter.class}),
 *         @ComponentScan.Filter(type = FilterType.CUSTOM,
 *         classes = {AutoConfigurationExcludeFilter.class})
 *     })
 */

/**
 * 下面我们来看一下重点的两个：
 *  1. @Import({AutoConfigurationPackages.Registrar.class})
 *  2. @Import({AutoConfigurationImportSelector.class})
 */

@SpringBootApplication
public class App1 {
    public static void main(String[] args) {
        SpringApplication.run(App1.class);
    }
}

@Import({AutoConfigurationPackages.Registrar.class})

public abstract class AutoConfigurationPackages {
    private static final Log logger = LogFactory.getLog(AutoConfigurationPackages.class);
    private static final String BEAN = AutoConfigurationPackages.class.getName();

	// 实现ImportBeanDefinitionRegistrar接口，所以推测出是要注册某个Bean到容器中
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            // 调用register方法，向容器注入一个bean
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }

        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
        }
    }
    // 进入 register
    public static void register(BeanDefinitionRegistry registry, String... packageNames) {
        if (registry.containsBeanDefinition(BEAN)) {
            AutoConfigurationPackages.BasePackagesBeanDefinition beanDefinition = (AutoConfigurationPackages.BasePackagesBeanDefinition)registry.getBeanDefinition(BEAN);
            beanDefinition.addBasePackages(packageNames);
        } else {
            // BEAN： 当前类的全路径名 org.springframework.boot.autoconfigure.AutoConfigurationPackages
            // packageNames : com.ming : 当前App1类所在的包
            registry.registerBeanDefinition(BEAN, new AutoConfigurationPackages.BasePackagesBeanDefinition(packageNames));
        }
    }

    static final class BasePackagesBeanDefinition extends GenericBeanDefinition {
        private final Set<String> basePackages = new LinkedHashSet();

        // 进入BasePackagesBeanDefinition构造器
        BasePackagesBeanDefinition(String... basePackages) {
            this.setBeanClass(AutoConfigurationPackages.BasePackages.class);
            this.setRole(2);
            // 添加 扫描路径 com.ming
            this.addBasePackages(basePackages);
        }

        public Supplier<?> getInstanceSupplier() {
            return () -> {
                return new AutoConfigurationPackages.BasePackages(StringUtils.toStringArray(this.basePackages));
            };
        }

        private void addBasePackages(String[] additionalBasePackages) {
            this.basePackages.addAll(Arrays.asList(additionalBasePackages));
        }
    }
    // .....
}

经过断点模式，发现(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames()是我们当前的App1类所在的包名。

结论：这个@Import 的作用是设置当前配置所在的包作为扫描包，后续要针对当前的包进行扫描

@Import({AutoConfigurationImportSelector.class})

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    // 实现DeferredImportSelector 接口， 发现 DeferredImportSelector 的 getImportGroup 方法,最终返回AutoConfigurationGroup对象，
    // AutoConfigurationGroup 对象又实现了 DeferredImportSelector的Group 方法，在DeferredImportSelector的Group中调用process()方法，
    // 所以入口是process()方法
    private static class AutoConfigurationGroup implements Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
        // 主要看getAutoConfigurationEntry方法
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector, () -> {
                return String.format("Only %s implementations are supported, got %s", AutoConfigurationImportSelector.class.getSimpleName(), deferredImportSelector.getClass().getName());
            });
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector)deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);
            this.autoConfigurationEntries.add(autoConfigurationEntry);
            Iterator var4 = autoConfigurationEntry.getConfigurations().iterator();

            while(var4.hasNext()) {
                String importClassName = (String)var4.next();
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }

        }
    }
    // 跟进，getCandidateConfigurations()
    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            // ....
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        }
    }
    // 跟进，loadFactoryNames()
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }
	// 返回EnableAutoConfiguration的全路径类名，以便在调用loadFactoryNames时，作为参数传入
    protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }
}

调用SpringFactoriesLoader类中的loadFactoryNames()方法：

public final class SpringFactoriesLoader {
    // 跟进，loadSpringFactories()
	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        // 获取类型名，此时的factoryTypeName： org.springframework.boot.autoconfigure.EnableAutoConfiguration
        String factoryTypeName = factoryType.getName();
        // 返回 spring.factories 文件中，所有以factoryTypeName 为key的value，存入list中
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }
	// 发现读取了一个 META-INF/spring.factories 文件
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();
            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }
}

spring.factories 位置:

内容：看EnableAutoConfiguration类下的

结论：这个@Import 的作用：利用AutoConfigurationImportSelector给容器中导入一些组件，具体就是最终就是将类路径下** META-INF/spring.factories **里面配置的所有EnableAutoConfiguration的值加入到了容器中；也就是xxxAutoConfiguration，这些都是用来做自动配置的。

至此，所有的技术集已经全部加载,完成了第四步；
接下来，我们查看spring.factories中的org.springframework.boot.autoconfigure.EnableAutoConfiguration，选取一个redis相关的配置：

RedisAutoConfiguration.java

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})  // 当类库中存在RedisOperations接口时才加载，所以要导入redis的依赖
@EnableConfigurationProperties({RedisProperties.class})  // RedisProperties类中存 所有redis配置
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(name = {"redisTemplate"}) // 如果 没有自定义 redisTemplate ，则使用他封装的
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

@ConfigurationProperties(
    prefix = "spring.redis"
)
public class RedisProperties {
    private int database = 0;
    private String url;
    private String host = "localhost";
    private String username;
    private String password;
    private int port = 6379;
    private boolean ssl;
    private Duration timeout;
    private Duration connectTimeout;
    private String clientName;
    private RedisProperties.ClientType clientType;
    private RedisProperties.Sentinel sentinel;
    private RedisProperties.Cluster cluster;
    private final RedisProperties.Jedis jedis = new RedisProperties.Jedis();
    private final RedisProperties.Lettuce lettuce = new RedisProperties.Lettuce();
}

对比导入redis依赖前后，容器中的bean：

导入redis的依赖：

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-data-redisartifactId>
  <version>3.0.4version>
dependency>

导入前：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
app1
org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
com.ming.bean.CartoonCatAndMouse
org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
org.springframework.boot.context.internalConfigurationPropertiesBinderFactory
org.springframework.boot.context.internalConfigurationPropertiesBinder
org.springframework.boot.context.properties.BoundConfigurationProperties
org.springframework.boot.context.properties.EnableConfigurationPropertiesRegistrar.methodValidationExcludeFilter
cartoon-com.ming.bean.CartoonProperties
org.springframework.boot.autoconfigure.AutoConfigurationPackages
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
propertySourcesPlaceholderConfigurer
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
mbeanExporter
objectNamingStrategy
mbeanServer
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
springApplicationAdminRegistrar
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration
forceAutoProxyCreatorToUseClassProxying
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration
applicationAvailability
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration
lifecycleProcessor
spring.lifecycle-org.springframework.boot.autoconfigure.context.LifecycleProperties
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties
org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties
org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
taskExecutorBuilder
applicationTaskExecutor
spring.task.execution-org.springframework.boot.autoconfigure.task.TaskExecutionProperties
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration
scheduledBeanLazyInitializationExcludeFilter
taskSchedulerBuilder
spring.task.scheduling-org.springframework.boot.autoconfigure.task.TaskSchedulingProperties
org.springframework.aop.config.internalAutoProxyCreator

没有redis相关的信息

导入后：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
app1
org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
com.ming.bean.CartoonCatAndMouse
org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor
org.springframework.boot.context.internalConfigurationPropertiesBinderFactory
org.springframework.boot.context.internalConfigurationPropertiesBinder
org.springframework.boot.context.properties.BoundConfigurationProperties
org.springframework.boot.context.properties.EnableConfigurationPropertiesRegistrar.methodValidationExcludeFilter
cartoon-com.ming.bean.CartoonProperties
org.springframework.boot.autoconfigure.AutoConfigurationPackages
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
propertySourcesPlaceholderConfigurer
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration
mbeanExporter
objectNamingStrategy
mbeanServer
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
springApplicationAdminRegistrar
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration$ClassProxyingConfiguration
forceAutoProxyCreatorToUseClassProxying
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration
applicationAvailability
org.springframework.boot.autoconfigure.data.redis.LettuceConnectionConfiguration
lettuceClientResources
redisConnectionFactory
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
redisTemplate
stringRedisTemplate
spring.redis-org.springframework.boot.autoconfigure.data.redis.RedisProperties
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration
lifecycleProcessor
spring.lifecycle-org.springframework.boot.autoconfigure.context.LifecycleProperties
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration
persistenceExceptionTranslationPostProcessor
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration
reactiveRedisTemplate
reactiveStringRedisTemplate
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration
keyValueMappingContext
redisCustomConversions
redisReferenceResolver
redisConverter
redisKeyValueAdapter
redisKeyValueTemplate
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration
spring.info-org.springframework.boot.autoconfigure.info.ProjectInfoProperties
org.springframework.boot.autoconfigure.netty.NettyAutoConfiguration
spring.netty-org.springframework.boot.autoconfigure.netty.NettyProperties
org.springframework.boot.autoconfigure.sql.init.SqlInitializationAutoConfiguration
spring.sql.init-org.springframework.boot.autoconfigure.sql.init.SqlInitializationProperties
org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer$DependsOnDatabaseInitializationPostProcessor
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
taskExecutorBuilder
applicationTaskExecutor
spring.task.execution-org.springframework.boot.autoconfigure.task.TaskExecutionProperties
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration
scheduledBeanLazyInitializationExcludeFilter
taskSchedulerBuilder
spring.task.scheduling-org.springframework.boot.autoconfigure.task.TaskSchedulingProperties
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration
platformTransactionManagerCustomizers
spring.transaction-org.springframework.boot.autoconfigure.transaction.TransactionProperties
org.springframework.aop.config.internalAutoProxyCreator

有redis相关的信息

扩展：
SpringFactories机制

Java SPI机制的延伸和扩展
Spring框架的基础机制，在Spring以及SpringBoot源码中到处可见
可以基于它来实现SpringBoot的自动配置功能
它的核心逻辑是从classpath中读取到所有jar包中的配置文件META-IF/spring.factories，然后根据指定的key从配置文件中解析出对应的value值

小结：

1.5 变更自动配置

添加自动配置

添加自动配置文件（META-INF/spring.factories）

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.ming.bean.CartoonCatAndMouse

在CartoonCatAndMouse类上添加@ConditionalOnClass

@ConditionalOnClass(name = "org.springframework.data.redis.core.RedisOperations") // 借用redis的jar， 当有这个类时，注册这个bean
@EnableConfigurationProperties(CartoonProperties.class)
public class CartoonCatAndMouse {
    private Cat cat;
    private Mouse mouse;

    private CartoonProperties cartoonProperties;
    CartoonCatAndMouse(CartoonProperties cartoonProperties){
        this.cartoonProperties = cartoonProperties;
        cat = new Cat();
        cat.setName(cartoonProperties.getCat() != null && StringUtils.hasText(cartoonProperties.getCat().getName()) ? cartoonProperties.getCat().getName() :"tom");
        cat.setAge(cartoonProperties.getCat() != null && cartoonProperties.getCat().getAge() != null ? cartoonProperties.getCat().getAge() : 3);
        mouse = new Mouse();
        mouse.setName(cartoonProperties.getMouse() != null && StringUtils.hasText(cartoonProperties.getMouse().getName()) ? cartoonProperties.getMouse().getName() :"jerry");
        mouse.setAge(cartoonProperties.getMouse() != null && cartoonProperties.getMouse().getAge() != null ? cartoonProperties.getMouse().getAge() : 4);
    }
    public void play(){
        System.out.println(cat.getAge()+"岁的"+cat.getName()+"和"+mouse.getAge()+"岁的"+mouse.getName()+"打起来了~~~");
    }
}

测试：删除之前的手动导入Bean - @Import(CartoonCatAndMouse.class)；加上redis依赖；

@SpringBootApplication
//@Import(CartoonCatAndMouse.class)
public class App1 {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App1.class);
        CartoonCatAndMouse cartoonCatAndMouse = context.getBean(CartoonCatAndMouse.class);
        cartoonCatAndMouse.play();
    }
}

删除系统自动配置

在yml 文件中配置

spring:
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration
      - org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

使用注解

@SpringBootApplication(excludeName = "org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration")

小结：

二、自定义starter

2.1 案例：统计独立IP访问次数

功能描述：

每次访问网站行为均进行统计
后台每10s输出1次监控信息(格式：IP + 访问次数)

实现方案：

数据记录位置：Map / Redis
功能触发位置：每次web请求(拦截器)
1. 步骤1：降低难度，主动调用，仅统计单一操作访问次数(例如查询)
2. 步骤2：开发拦截器
业务参数(配置项)
1. 输出频度：默认10s
2. 数据特征：累计数据 / 阶段数据，默认累计数据
3. 输出格式：详细模式 / 极简模式
校验环境：设置加载条件

具体实现：

环境搭建：

参照：TangGuoNiuBi/spring-boot-study
导入数据：tbl_book.sql
访问url：http://localhost:81/pages/books.html

2.2 自定义starter

新建模块及基础功能开发：ip_spring_boot_starter

导入依赖：

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-webartifactId>
dependency>

编写业务功能代码：第一版

public class IpCountService {

    private Map<String,Integer> ipCountMap = new HashMap<String,Integer>();
    @Autowired
    // 当前的request对象的注入工作，由使用当前starter的工程提供自动装配
    private HttpServletRequest httpServletRequest;
    public void count(){
        // 每次调用当前操作，就记录当前访问IP，然后累加访问次数
        // 1. 获取当前操作的IP地址
        String ip = httpServletRequest.getRemoteAddr();
        System.out.println("-----------------------" + ip);
        // 2. 根据IP操作地址从Map取值，并递增
        Integer count = ipCountMap.get(ip);
        if (count == null){
            ipCountMap.put(ip,1);
        }else {
            ipCountMap.put(ip,count + 1);
        }
    }
}

自动配置类：

public class IpAutoConfiguration {
    @Bean
    public IpCountService ipCountService(){
        return new IpCountService();
    }
}

在META-INF/spring.factories文件中配置：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.ming.autoconfig.IpAutoConfiguration

在本地maven仓库中安装自定义starter：

mvn clear
mvn install

切记使用之前先clean后install安装到maven仓库，确保资源更新

简单测试

在需要添加的计数功能的工程中导入自定义starter

<dependency>
  <groupId>cn.minggroupId>
  <artifactId>ip_spring_boot_starterartifactId>
  <version>0.0.1-SNAPSHOTversion>
dependency>

模拟调用：

@Autowired
private IpCountService ipCountService;

@GetMapping("{currentPage}/{pageSize}")
public R getPage(@PathVariable int currentPage, @PathVariable int pageSize, Book book) {

    ipCountService.count();

    IPage<Book> page = bookService.getPage(currentPage, pageSize, book);
    // 如果当前页面值大于总页码值，那么重新执行查询操作，使用最大页码值作为当前页码值
    if (currentPage > page.getPages()) {
        page = bookService.getPage((int) page.getPages(), pageSize, book);
    }
    return new R(true, page);
}

预想结果：每次刷新，点击，出现下面内容；

-----------------------0:0:0:0:0:0:0:1

至此已经完成基础功能，下面开发定时任务功能

功能开发之定时任务功能

添加@EnableScheduling注解，开启定时任务

@EnableScheduling
public class IpAutoConfiguration {
    @Bean
    public IpCountService ipCountService(){
        return new IpCountService();
    }
}

添加业务方法，打印map中存的信息

public class IpCountService {

    private Map<String,Integer> ipCountMap = new HashMap<String,Integer>();

    @Scheduled(cron = "0/5 * * * * ?")
    public void print(){
        System.out.println("       IP访问监控");
        System.out.println("+-----ip-address-----+--num--+");
        for (Map.Entry<String, Integer> entry : ipCountMap.entrySet()) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(String.format("|%18s  |%5d  |",key,value));
        }
    	//System.out.println(String.format("|%18s  |%5d  |","abc",20));
        System.out.println("+--------------------+-------+");
    }

    public static void main(String[] args) {
        new IpCountService().print();
    }
}

注意：String.format()的使用

功能开发之属性动态配置

定义属性类：

@ConfigurationProperties(prefix = "tools.ip")
public class IpProperties {

    /**
     * 日志显示周期
     */
    private Long cycle = 5L;

    /**
     * 是否重置周期内数据
     */
    private Boolean cycleReset = false;

    /**
     * 日志输出格式：detail: 详细模式；simple: 极简模式；
     */
    private String model = LogModel.DETAIL.value;

    public enum LogModel {
        DETAIL("detail"),
        SIMPLE("simple");

        private String value;

        LogModel(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }

    // getter / setter 
}

对应配置文件：

tools:
  ip:
    cycle: 10
    cycle-reset: false
    model: "simple"

测试时使用，实际引入时，要清空yaml文件

在配置类上设置加载Properties类为bean

@EnableScheduling
@EnableConfigurationProperties(IpProperties.class)
public class IpAutoConfiguration {
    @Bean
    public IpCountService ipCountService(){
        return new IpCountService();
    }
}

在业务类中追加逻辑代码

public class IpCountService {

    private Map<String,Integer> ipCountMap = new HashMap<String,Integer>();

    @Autowired
    private IpProperties ipProperties;

    @Scheduled(cron = "0/5 * * * * ?")
    public void print(){
        // 判断启动模式
        if(ipProperties.getModel().equals(IpProperties.LogModel.DETAIL.getValue())){
            // 详细模式
            System.out.println("       IP访问监控(详细)");
            System.out.println("+-----ip-address-----+--num--+");
            for (Map.Entry<String, Integer> entry : ipCountMap.entrySet()) {
                System.out.println(String.format("|%18s  |%5d  |",entry.getKey(),entry.getValue()));
            }
            System.out.println("+--------------------+-------+");
        }else if (ipProperties.getModel().equals(IpProperties.LogModel.SIMPLE.getValue())){
            // 极简模式
            System.out.println("     IP访问监控(极简)");
            System.out.println("+-----ip-address-----+");
            for (Map.Entry<String, Integer> entry : ipCountMap.entrySet()) {
                System.out.println(String.format("|%18s  |",entry.getKey()));
            }
            System.out.println("+--------------------+");
        }
        // 判断是否清空数据
        if(ipProperties.getCycleReset()){
            ipCountMap.clear();
        }
    }
}

测试 tools.ip.cycle-reset 和 tools.ip.model ，输出符合预期；

对 tools.ip.cycle的处理：
处理目标：使用属性类的方式读取cycle属性加载到@Scheduled(cron = "0/5 * * * * ?")位置上去
使用#{beanName.属性名}的方式，可以将IpProperties的cycle注入到注解中。

Tips:
但是，此时的IpProperties类的beanName是tools.ip-cn.ming.properties.IpProperties，所以直接使用的话会报错。
因为当前的beanName是由配置类上的@EnableConfigurationProperties(IpProperties.class注解自动生成的，所以，我们将这个注解删除，在IpProperties类上加上@Component("ipProperties")注解，最后在到配置类上引入即可；

属性类：自定义bean名称

@Component("ipProperties")
@ConfigurationProperties(prefix = "tools.ip")
public class IpProperties {

    /**
     * 日志显示周期
     */
    private Long cycle = 5L;

    /**
     * 是否重置周期内数据
     */
    private Boolean cycleReset = false;

    /**
     * 日志输出格式：detail: 详细模式；simple: 极简模式；
     */
    private String model = LogModel.DETAIL.value;

    public enum LogModel {
        DETAIL("detail"),
        SIMPLE("simple");

        private String value;

        LogModel(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }
    // setter / getter
}

配置类：放弃配置属性创建bean方式，改为手工控制

@EnableScheduling
//@EnableConfigurationProperties(IpProperties.class)
@Import(IpProperties.class)
public class IpAutoConfiguration {
    @Bean
    public IpCountService ipCountService(){
        return new IpCountService();
    }
}

业务类使用：使用#{beanName.attrName}读取bean的属性。

public class IpCountService {

    private Map<String,Integer> ipCountMap = new HashMap<String,Integer>();
    @Autowired
    // 当前的request对象的注入工作，由使用当前starter的工程提供自动装配
    private HttpServletRequest httpServletRequest;
    public void count(){
        // 每次调用当前操作，就记录当前访问IP，然后累加访问次数
        // 1. 获取当前操作的IP地址
        String ip = httpServletRequest.getRemoteAddr();
        System.out.println("-----------------------"+ip);
        // 2. 根据IP操作地址从Map取值，并递增
        Integer count = ipCountMap.get(ip);
        if (count == null){
            ipCountMap.put(ip,1);
        }else {
            ipCountMap.put(ip,count + 1);
        }
    }
    @Autowired
    private IpProperties ipProperties;

    @Scheduled(cron = "0/#{ipProperties.cycle} * * * * ?")
    public void print(){
        // 判断启动模式
        if(ipProperties.getModel().equals(IpProperties.LogModel.DETAIL.getValue())){
            // 详细模式
            System.out.println("       IP访问监控(详细)");
            System.out.println("+-----ip-address-----+--num--+");
            for (Map.Entry<String, Integer> entry : ipCountMap.entrySet()) {
                System.out.println(String.format("|%18s  |%5d  |",entry.getKey(),entry.getValue()));
            }
            System.out.println("+--------------------+-------+");
        }else if (ipProperties.getModel().equals(IpProperties.LogModel.SIMPLE.getValue())){
            // 极简模式
            System.out.println("     IP访问监控(极简)");
            System.out.println("+-----ip-address-----+");
            for (Map.Entry<String, Integer> entry : ipCountMap.entrySet()) {
                System.out.println(String.format("|%18s  |",entry.getKey()));
            }
            System.out.println("+--------------------+");
        }
        // 判断是否清空数据
        if(ipProperties.getCycleReset()){
            ipCountMap.clear();
        }
    }
}

功能开发之添加拦截器

在ip_spring_boot_starter模块中添加拦截器：

package cn.ming.interceptor;
public class IpInterceptor implements HandlerInterceptor {

    @Autowired
    private IpCountService ipCountService;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ipCountService.count();
        return true;
    }
}

设置核心配置类，加载拦截器

@Configuration(proxyBeanMethods = true)
public class SpringMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(ipInterceptor()).addPathPatterns("/**");
    }

    @Bean
    public IpInterceptor ipInterceptor(){
        return new IpInterceptor();
    }
}

记得删除之前测试用的ipCountService.count();

至此，自定义starter已经全部开发完，实现，导入依赖，添加统计功能，移出依赖，不影响自身运行；

2.3 辅助功能开发

yml提示功能开发

导入依赖：


<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-configuration-processorartifactId>
dependency>

执行 mvn clear和 mvn install
复制target/classes/META-INF目录下的spring-configuration-metadata.json文件到src/main/resources/META-INF/spring-configuration-metadata.json
删除多余的spring-configuration-metadata.json和依赖
在json文件中进行自定义提示功能开发

"hints": [
  {
    "name": "tools.ip.model",
    "values": [
      {
        "value": "detail",
        "description": "详细模式."
      },
      {
        "value": "simple",
        "description": "极简模式."
      }
    ]
  }
]

测试：

三、核心原理

SpringBoot启动流程

初始化各种属性，加载成对象
1. 读取环境属性(Environment)
2. 系统配置(spring.factories)
3. 参数(Arguments、application.properties)
创建Spring容器对象ApplicationContext，加载各种配置
在容器创建前，通过监听器机制，应对不同阶段加载数据，更新数据的需求
容器初始化过程中追加各种功能，例如统计时间、输出日志等

小结:

加载数据

创建容器

ClassName[行号] -> 执行代码 // 解释

SpringbootDemo05Application[10] -> SpringApplication.run(SpringbootDemo05Application.class, args);
    SpringApplication[825] -> return run(new Class[]{primarySource}, args);
        SpringApplication[829] -> return (new SpringApplication(primarySources)).run(args);
            SpringApplication[829] -> SpringApplication(primarySources)
            // 加载各种配置信息，初始化各种配置对象
                SpringApplication[101] -> this((ResourceLoader)null, primarySources);
                    SpringApplication[104] -> public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
                        SpringApplication[105] -> this.sources = new LinkedHashSet();  
                        // 创建LinkedHashSet
                        SpringApplication[106] -> this.bannerMode = Mode.CONSOLE;  
                        // 该属性是用来打印springboot启动时的图标。
                        // Mode是org.springframework.boot.Banner接口的静态enum类型
                        //     OFF: 关闭
                        //     CONSOLE: 打印到控制台
                        //     LOG: 打印到日志
                        SpringApplication[107] -> this.logStartupInfo = true;  
                        // true: 打印jvm的启动和运行信息。包括启动类，java版本，pid等
                        SpringApplication[108] -> this.addCommandLineProperties = true;  
                        // true: 通过命令行参数，向application.properties文件中添加属性；例如 java -jar test.jar -server.port=80,(设置端口号)
                        SpringApplication[109] -> this.addConversionService = true;
                        // true: 加载默认的类型转换和格式化类(ApplicationConversionService); 详情参考 ApplicationConversionService[152] -> public static void addApplicationConverters(ConverterRegistry registry)
                        SpringApplication[110] -> this.headless = true;
                        // 开启java的headless模式。此模式允许java在没有显示器、鼠标等设备缺失的情况下启动服务，对于部署在服务器的程序来说是很有必要的。
                        SpringApplication[111] -> this.registerShutdownHook = true;
                        // 创建线程，该线程用来在Java程序关闭后释放资源
                        SpringApplication[112] -> this.additionalProfiles = Collections.emptySet();
                        // 默认为空，即使用springboot默认配置文件。可以调用SpringApplication的setAdditionalProfiles()方法，实现springboot中的profile属性的指定，用于切换环境
                        SpringApplication[113] -> this.isCustomEnvironment = false;
                        // 加载环境配置
                        SpringApplication[114] -> this.lazyInitialization = false;
                        // 懒加载
                        SpringApplication[115] -> this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
                        // TODO
                        SpringApplication[116] -> this.applicationStartup = ApplicationStartup.DEFAULT;
                        // TODO
                        SpringApplication[117] -> this.resourceLoader = resourceLoader;
                        // 初始化资源加载器
                        SpringApplication[118] -> Assert.notNull(primarySources, "PrimarySources must not be null");
                        SpringApplication[119] -> this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
                        // 形参的primarySources: Class类型的SpringbootDemo05Application
                        // 初始化配置类的类名信息(格式转换)(将可变类型转换为集合类型存入成员变量中)
                        SpringApplication[120] -> this.webApplicationType = WebApplicationType.deduceFromClasspath();
                        // 确认当前容器加载的类型
                            WebApplicationType[25] -> static WebApplicationType deduceFromClasspath(){}
                            // WebApplicationType enum类中有三种类型["NONE","SERVLET","REACTIVE"]
                            //      NONE: 需导入spring-boot-starter依赖
                            //      SERVLET: 需导入的spring-boot-starter-web依赖
                            //      REACTIVE: 需导入spring-boot-starter-webflux依赖
                        SpringApplication[121] -> this.bootstrapRegistryInitializers = this.getBootstrapRegistryInitializersFromSpringFactories();
                        // 获取系统配置引导信息
                            SpringApplication[127] -> private List getBootstrapRegistryInitializersFromSpringFactories() {}
                            // 在 META-INF/spring.factories 中查找 以 Bootstrapper.class / BootstrapRegistryInitializer.class 为key的value值
                        SpringApplication[122] -> this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
                        // 在 META-INF/spring.factories 中查找 以 ApplicationContextInitializer.class 为key的value值
                        // 获取ApplicationContextInitializer.class对应的实例
                        SpringApplication[123] -> this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
                        // 在 META-INF/spring.factories 中查找 以 ApplicationListener.class 为key的value值
                        // 初始化监听器，对初始化过程及运行过程进行干预
                        SpringApplication[124] -> this.mainApplicationClass = this.deduceMainApplicationClass();
                        // 初始化了引导类（SpringbootDemo05Application）的类名信息，备用

            SpringApplication[829] -> (new SpringApplication(primarySources)).run(args);
            // 初始化容器，得到一个ApplicationContext对象
            SpringApplication[155] -> StopWatch stopWatch = new StopWatch();
            // 声明一个计时器，用于统计
            SpringApplication[156] -> stopWatch.start();
            // 计时器开始
            SpringApplication[157] -> DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
            // 系统引导信息对应的上下文对象
                SpringApplication[194] -> private DefaultBootstrapContext createBootstrapContext() {
                SpringApplication[195] ->     DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
                SpringApplication[196] ->     this.bootstrapRegistryInitializers.forEach((initializer) -> {
                // List bootstrapRegistryInitializers;
                // 遍历在之前`加载各种配置信息，初始化各种配置对象`阶段加载好的 bootstrapRegistryInitializers 集合
                SpringApplication[197] ->         initializer.initialize(bootstrapContext);
                SpringApplication[198] ->     });
                SpringApplication[199] ->     return bootstrapContext;
                SpringApplication[200] -> }
            SpringApplication[158] -> ConfigurableApplicationContext context = null;
            // 创建容器对象
            SpringApplication[159] -> this.configureHeadlessProperty();
            // 模拟输入输出信号，避免出现因缺少外设导致的信号传递失败，进而引发错误(模拟显示器，键盘，鼠标等)
                SpringApplication[268] -> private void configureHeadlessProperty() {
                SpringApplication[269] ->     System.setProperty("java.awt.headless", System.getProperty("java.awt.headless", Boolean.toString(this.headless)));
                // 为系统变量添加 java.awt.headless = true
                SpringApplication[270] -> }
            SpringApplication[160] -> SpringApplicationRunListeners listeners = this.getRunListeners(args);
            // 获取当前注册的所有监听器
            SpringApplication[161] -> listeners.starting(bootstrapContext, this.mainApplicationClass);
            // 监听器执行了对应的操作步骤
            SpringApplication[163] -> try {
            SpringApplication[164] ->     ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // 获取参数 args
            SpringApplication[165] ->     ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            // 将前期读取的数据加载成了一个环境对象，用来描述信息
            SpringApplication[166] ->     this.configureIgnoreBeanInfo(environment);
            // 做了一个配置，备用
            SpringApplication[167] ->     Banner printedBanner = this.printBanner(environment);
            // 初始化启动图标 使用到之前配置的`SpringApplication[106] -> this.bannerMode = Mode.CONSOLE;` 
            SpringApplication[168] ->     context = this.createApplicationContext();
            // 根据之前的容器类型，创建一个容器上下文
            // 如果是NONE: 则context容器为 org.springframework.context.annotation.AnnotationConfigApplicationContext@386f0da3
            // 如果是SERVLET: 则context容器为 org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@8dbfffb
            SpringApplication[169] ->     context.setApplicationStartup(this.applicationStartup);
            // 设置启动模式
            SpringApplication[170] ->     this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            // 对容器进行设置，参数来源于前期的设定
            SpringApplication[171] ->     this.refreshContext(context);
            // 刷新容器环境，(Spring IOC容器初始化经典原理)【spring默认的onRefresh()方法是空的，springboot将onRefresh()方法重写，加入了tomcat的启动】
            SpringApplication[172] ->     this.afterRefresh(context, applicationArguments);
            // 刷新完毕后做后处理 空方法
            SpringApplication[173] ->     stopWatch.stop();
            // 计时器结束
            SpringApplication[174] ->     if (this.logStartupInfo) {
            // 判定是否记录启动时间的日志，默认为true
            SpringApplication[175] ->         (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            // 创建日志对应的对象，输出日志信息，包含启动时间
            // 控制台打印 ： 2023-08-16 20:10:25.288  INFO 1932 --- [           main] com.ming.SpringbootDemo05Application     : Started SpringbootDemo05Application in 18.095 seconds (JVM running for 20.728)
            SpringApplication[176] ->     }
            SpringApplication[178] ->     listeners.started(context);
            // 监听器执行了对应的操作步骤
            SpringApplication[179] ->     this.callRunners(context, applicationArguments);
            SpringApplication[180] -> } catch (Throwable var10) {
            SpringApplication[181] ->     this.handleRunFailure(context, var10, listeners);
            // 异常处理
            SpringApplication[182] ->     throw new IllegalStateException(var10);
            SpringApplication[183] -> }
            SpringApplication[185] -> try {
            SpringApplication[186] ->     listeners.running(context);
            // 监听器执行了对应的操作步骤
            SpringApplication[187] ->     return context;
            SpringApplication[188] -> } catch (Throwable var9) {
            SpringApplication[189] ->     this.handleRunFailure(context, var9, (SpringApplicationRunListeners)null);
            SpringApplication[190] ->     throw new IllegalStateException(var9);
            SpringApplication[191] -> }

参考博客：

https://blog.csdn.net/weixin_45525272/article/details/126502991
https://blog.csdn.net/A_art_xiang/article/details/122437676

容器类型选择

监听器

监听器类型：

在应用运行但未进行任何处理时，将发送 ApplicationStartingEvent。
当Environment被使用，且上下文创建之前，将发送 ApplicationEnvironmentPreparedEvent。
在开始刷新之前，bean定义被加载之后发送 ApplicationPreparedEvent。
在上下文刷新之后且所有的应用和命令行运行器被调用之前发送 ApplicationStartedEvent。
在应用程序和命令行运行器被调用之后，将发出 ApplicationReadyEvent，用于通知应用已经准备处理请求。
启动时发生异常，将发送 ApplicationFailedEvent

SpringBoot中tomcat启动流程

你可能感兴趣的:(SpringBoot,spring,boot,学习,笔记)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
展现思维导图魅力，不断挖掘人生宝藏思维导图讲师Mandy
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor yangshangchuan 信息抽取 HtmlExtractor 精准抽取信息采集
HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。 HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。如
java编程思想 -- 多态百合不是茶 java 多态详解
一: 向上转型和向下转型面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
[自动数据处理]稳扎稳打,逐步形成自有ADP系统体系 comsci dp
对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长.... 首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
storm 自定义日志文件商人shang storm cluster logback
Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 1. 想要进行一些调试信息的输出 2. 调试信息或者业务日志信息想要输出到一些固定的文件中不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
Extjs3 SpringMVC使用 @RequestBody 标签问题记录 21jhf
springMVC使用 @RequestBody(required = false) UserVO userInfo 传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下：（由于使用了父类aaa
一些排错方法文强chu 方法
1、java.lang.IllegalStateException: Class invariant violation at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) at o
Swing中文件恢复我觉得很难小桔子 swing
我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
php 文件操作 aichenglong PHP 读取文件写入文件
1 写入文件 @$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); if(!$fp){ echo "open file error" ; exit; } $outputstring="date:"." \t tire:".$tire."
MySQL的btree索引和hash索引的区别 AILIKES 数据结构 mysql 算法
Hash 索引结构的特殊性，其检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
JAVA的抽象--- 接口 --实现百合不是茶
抽象接口实现接口 //抽象类 ,方法 //定义一个公共抽象的类 ,并在类中定义一个抽象的方法体抽象的定义使用abstract abstract class A 定义一个抽象类例如： //定义一个基类 public abstract class A{ //抽象类不能用来实例化，只能用来继承 //
JS变量作用域实例 bijian1013 作用域
<script> var scope='hello'; function a(){ console.log(scope); //undefined var scope='world'; console.log(scope); //world console.log(b);
TDD实践（二） bijian1013 java TDD
实践题目：分解质因数 Step1：单元测试： package com.bijian.study.factor.test; import java.util.Arrays; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import com.bijian.
[MongoDB学习笔记一]MongoDB主从复制 bit1129 mongodb
MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。本文介绍MongoDB的主从复制模式，需要指明
【HBase五】Java API操作HBase bit1129 hbase
import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.ha
python调用zabbix api接口实时展示数据 ronin47
zabbix api接口来进行展示。经过思考之后，计划获取如下内容： 1、获得认证密钥 2、获取zabbix所有的主机组 3、获取单个组下的所有主机 4、获取某个主机下的所有监控项
jsp取得绝对路径 byalias 绝对路径
在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下：一、使用${pageContext.request.contextPath} 　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。
Java定时任务调度：用ExecutorService取代Timer bylijinnan java
《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是：如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
SQL 优化原则 chicony sql
一、问题的提出　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
java 线程弹球小游戏 CrazyMizzz java 游戏
最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善这里是提纲 1.线程弹球游戏实现 1.实现界面需要使用哪些API类 JFrame JPanel JButton FlowLayout Graphics2D Thread Color ActionListener ActionEvent MouseListener Mouse
hadoop jps出现process information unavailable提示解决办法 daizj hadoop jps
hadoop jps出现process information unavailable提示解决办法 jps时出现如下信息： 3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 --
PHP图片水印缩放类实现 dcj3sjt126com PHP
<?php class Image{ private $path; function __construct($path='./'){ $this->path=rtrim($path,'/').'/'; } //水印函数，参数：背景图，水印图，位置，前缀,TMD透明度 public function water($b,$l,$pos
IOS控件学习：UILabel常用属性与用法 dcj3sjt126com ios UILabel
参考网站： http://shijue.me/show_text/521c396a8ddf876566000007 http://www.tuicool.com/articles/zquENb http://blog.csdn.net/a451493485/article/details/9454695 http://wiki.eoe.cn/page/iOS_pptl_artile_281
完全手动建立maven骨架 eksliang java eclipse Web
建一个 JAVA 项目： mvn archetype:create -DgroupId=com.demo -DartifactId=App [-Dversion=0.0.1-SNAPSHOT] [-Dpackaging=jar] 建一个 web 项目： mvn archetype:create -DgroupId=com.demo -DartifactId=web-a
配置清单 gengzg 配置
1、修改grub启动的内核版本 vi /boot/grub/grub.conf 将default 0改为1 拷贝mt7601Usta.ko到/lib文件夹拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan 拷贝wifiget.sh到bin文件夹，chm
Windows端口被占用处理方法 huqiji windows
以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等. 这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
开源ckplayer 网页播放器，跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！天梯梦 mobile
CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
简单工厂设计模式 hm4123660 java 工厂设计模式简单工厂模式
简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
maven笔记 zhb8015 maven
跳过测试阶段： mvn package -DskipTests 临时性跳过测试代码的编译： mvn package -Dmaven.test.skip=true maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。指定测试类 mvn test
非mapreduce生成Hfile，然后导入hbase当中 Stark_Summer map hbase reduce Hfile path实例
最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
jsp web tomcat 编码问题王新春 tomcat jsp pageEncode
今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： <Connector port="8080" protocol="HTTP/1.1" connectionTi