@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

//  charset
	private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
// 默认加载模版的路径
	public static final String DEFAULT_PREFIX = "classpath:/templates/";
// 默认加载的文件类型 是html
	public static final String DEFAULT_SUFFIX = ".html";
// 可自己修改配置文件中的 前缀和后缀，如果 spring.thymeleaf.suffix=.htmlx
	private String prefix = DEFAULT_PREFIX;

	private String suffix = DEFAULT_SUFFIX;

@Controller
public class HelloController {
    @RequestMapping("/home")
    public String home(Map<String,String> map){
        map.put("hello","Hello World~~~");
        return "home";
    }
}

@Bean
@ConditionalOnBean(ViewResolver.class)
// 如果类路径中不存在ContentNegotiatingViewResolver这个类的时候
@ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
//  返回这个Resolver
    ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
    resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));
    // ContentNegotiatingViewResolver uses all the other view resolvers to locate
    // a view so it should have a high precedence
    resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
    return resolver;
}

// ContentNegotiatingViewResolver 类中的初始化servlet容器方法
protected void initServletContext(ServletContext servletContext) {
// 找出所有的容器中的ViewResolver
    Collection<ViewResolver> matchingBeans =
            BeanFactoryUtils.beansOfTypeIncludingAncestors(obtainApplicationContext(), ViewResolver.class).values();
    if (this.viewResolvers == null) {
        this.viewResolvers = new ArrayList<>(matchingBeans.size());
        // 循环添加到viewResolver中
        for (ViewResolver viewResolver : matchingBeans) {
            if (this != viewResolver) {
                this.viewResolvers.add(viewResolver);
            }
        }
    }

@Override
@Nullable
//实现ViewResolver的实现方法
public View resolveViewName(String viewName, Locale locale) throws Exception {
    RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
    Assert.state(attrs instanceof ServletRequestAttributes, "No current ServletRequestAttributes");
    List<MediaType> requestedMediaTypes = getMediaTypes(((ServletRequestAttributes) attrs).getRequest());
    if (requestedMediaTypes != null) {
        //  获取候选的view
        // 在getCandidateViews这个方法里就是把全局的viewResolver循环一遍
        List<View> candidateViews = getCandidateViews(viewName, locale, requestedMediaTypes);
        // 寻找最好的/最合适的view
        View bestView = getBestView(candidateViews, requestedMediaTypes, attrs);
        if (bestView != null) {
            return bestView;
        }

@Configuration
//@EnableWebMvc // 使用这个注解表示完全不实用SpringBoot对SpringMVC的自动配置功能。
public class MvcConfig implements WebMvcConfigurer {

    @Bean
    public MyViewResolver myViewResolver(){
        return new MyViewResolver();
    }

    class InnerViewResolver implements ViewResolver {

        @Override
        public View resolveViewName(String viewName, Locale locale) throws Exception {
            return null;
        }
    }

@Configuration
//@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry)
    {
        registry.viewResolver(new InnerViewResolver());
    }

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addRedirectViewController("/index","/home");
    }

// ViewResolverRegistry 类中的viewResolver方法，直接添加到全局变量 viewResolvers中，代替前面的遍历
public void viewResolver(ViewResolver viewResolver) {
    if (viewResolver instanceof ContentNegotiatingViewResolver) {
        throw new BeanInitializationException(
                "addViewResolver cannot be used to configure a ContentNegotiatingViewResolver. " +
                "Please use the method enableContentNegotiation instead.");
    }
    this.viewResolvers.add(viewResolver);
}

public class MessageSourceAutoConfiguration {

	private static final Resource[] NO_RESOURCES = {};
// 在配置文件中可以进行配置的内容 以spring.message开头
	@Bean
	@ConfigurationProperties(prefix = "spring.messages")
	public MessageSourceProperties messageSourceProperties() {
		return new MessageSourceProperties();
	}
/***********************MessageSourceProperties**********************/
public class MessageSourceProperties {

	/**
	 * 以逗号分隔的基本名称列表 每一个都是在完整的路径下加载，比如 i18n.home,i18n.hello这样
   * 如果在类路径上，就去掉i18n.
	 */
	private String basename = "messages";

public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
    // 获得propertiesf中的spring.messages.basename属性，如果没有默认是messages
	String basename = context.getEnvironment().getProperty("spring.messages.basename", "messages");
	ConditionOutcome outcome = cache.get(basename);
	if (outcome == null) {
      // 调用方法解析basename
		outcome = getMatchOutcomeForBasename(context, basename);
		cache.put(basename, outcome);
	}
	return outcome;
}

private ConditionOutcome getMatchOutcomeForBasename(ConditionContext context, String basename) {
	ConditionMessage.Builder message = ConditionMessage.forCondition("ResourceBundle");
	for (String name : StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(basename))) {
      // 将basename以逗号分隔，循环这个数组
		for (Resource resource : getResources(context.getClassLoader(), name)) {
        // 这里的getResource方法 是加载classpath + name + .properties中的内容
        // 所以国际化文件只支持 properties文件，其他文件不支持
        // return new PathMatchingResourcePatternResolver(classLoader)
			// 	.getResources("classpath*:" + target + ".properties");
			if (resource.exists()) {
          // 对每一个获取Resource 新建一个match实例对象
				return ConditionOutcome.match(message.found("bundle").items(resource));
			}
		}
	}
	return ConditionOutcome.noMatch(message.didNotFind("bundle with basename " + basename).atAll());
}

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
	// 可以通过请求的locale来定义返回的locale
	Locale locale =
			(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
	response.setLocale(locale);

@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
public LocaleResolver localeResolver() {
  if (this.mvcProperties.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
    return new FixedLocaleResolver(this.mvcProperties.getLocale());
  }
  // 设置了 容器中的localeResolver 为 AcceptHeaderLocaleResolver
  AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
  localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
  return localeResolver;
}

@Override
	public Locale resolveLocale(HttpServletRequest request) {
		Locale defaultLocale = getDefaultLocale();
		if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
			return defaultLocale;
		}
    // 从request中拿Accept-Language这个值。
		Locale requestLocale = request.getLocale();
		List<Locale> supportedLocales = getSupportedLocales();
		if (supportedLocales.isEmpty() || supportedLocales.contains(requestLocale)) {
			return requestLocale;
		}

public class MyLocalResolver implements LocaleResolver {

    private Locale defaultLocale;

    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        Locale defaultLocale = getDefaultLocale();
        String language = request.getParameter("language");
      // 获取请求中的 ?language=「xxx」 
        String[] s = new String[2];
        if(language != null && !"".equals(language)){
            s = getS(language);
        }else{
            //如果是空则找浏览器中的属性
            String header = getFirstLangInRequest(request);
            if(header!=null && !"".equals(header)){
                s = getS(header);
            }else{
                //否则给个默认的local
                s = getS("zh-CN");
            }
        }
        defaultLocale = new Locale(s[0],s[1]);
        return defaultLocale;
    }

    private String getFirstLangInRequest(HttpServletRequest request) {
        return request.getHeader("Accept-Language").split(",")[0];
    }

    private String[] getS(String language) {
        return language.split("-");
    }

    public Locale getDefaultLocale() {
        return this.defaultLocale;
    }
}
//添加到bean中 方法名称必须是localeResolver 或者指定bean的名称为localeResolver
@Bean
public LocaleResolver localeResolver(){
  return new MyLocalResolver();
}

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    // 是否启用默认资源处理
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
        return;
    }
    // 获取资源处理程序所服务资源的缓存周期
    Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
    CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
    // 如果映射器还未映射到/webjars/** 则进行如下操作
    if (!registry.hasMappingForPattern("/webjars/**")) {
    //  添加对/webjars/** 的资源映射
        customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/")
                // 加载包下的 /META-INF/resources/webjars/ 下的内容
                .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
    }
    // 静态路径pattern 为 "/**"
    String staticPathPattern = this.mvcProperties.getStaticPathPattern();
    if (!registry.hasMappingForPattern(staticPathPattern)) {
        //如果映射器还没有映射 /** 路径的资源时
        customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
        // 加载所有的默认定义的位置里的资源。
                .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                .setCachePeriod(getSeconds(cache
                Period)).setCacheControl(cacheControl));
    }
}

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {
	private static final String[] CLASSPATH_RESOURCE_LOCATIONS = { "classpath:/META-INF/resources/",
    "classpath:/resources/", "classpath:/static/", "classpath:/public/" };
	private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
	private boolean addMappings = true;
	private final Chain chain = new Chain();
	private final Cache cache = new Cache();
    // 获取静态资源目录
	public String[] getStaticLocations() {
		return this.staticLocations;
	}

private Optional<Resource> getWelcomePage() {
    String[] locations = getResourceLocations(this.resourceProperties.getStaticLocations());
    //遍历每个locations寻找index.html页面作为首页
    return Arrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();
}

private Resource getIndexHtml(String location) {
    return this.resourceLoader.getResource(location + "index.html");
}

@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext) {
    return new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext),
            applicationContext, getWelcomePage(), this.mvcProperties.getStaticPathPattern());
}

WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
			ApplicationContext applicationContext, Optional<Resource> welcomePage, String staticPathPattern) {
    // 如果存在，设置首页为index.html 映射路径为： /**
    if (welcomePage.isPresent() && "/**".equals(staticPathPattern)) {
        logger.info("Adding welcome page: " + welcomePage.get());
        setRootViewName("forward:index.html");
    }

// 起到了@Controller和@Responsebody两种作用，实际上就是
// 两种注解的整合
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "hello world";
    }
}

@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {

// 使用DataSourceProperties类作为属性类,以下为基本属性

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

	private ClassLoader classLoader;

	private String name;
	private boolean generateUniqueName;
	private Class<? extends DataSource> type;

	private String driverClassName;
	private String url;
	private String username;
	private String password;

// 导入slf4j的jar包
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

Logger logger = LoggerFactory.getLogger(this.getClass());
   @Test
   public void testLogger(){
       // 由低到高 日志的级别，日志框架可以根据配置文件调整输出的日志级别，
       // 只会输出相应日志级别及后面的高级别日志信息
       logger.trace("这是trace日志");
       logger.debug("这是debug日志");
       // SpringBoot默认使用的是info级别，
       // 可以使用日志的配置文件调整级别
       logger.info("这是info日志");
       logger.warn("这是warn日志");
       logger.error("这是error日志");
   }

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
        public @interface SpringBootApplication {

@AutoConfigurationPackage
// 引用了AutoConfigurationImportSelector这个类
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
            () -> String.format("Only %s implementations are supported, got %s",
                    AutoConfigurationImportSelector.class.getSimpleName(),
                    deferredImportSelector.getClass().getName()));
                    // 获得自动配置的entry，点进这个方法看如何获取自动配置的配置信息的
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
            .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
    this.autoConfigurationEntries.add(autoConfigurationEntry);
// 循环所有configuration然后放到entries中添加到容器中。
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
        AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 返回自动配置类的全类名
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // 去掉重复的
    configurations = removeDuplicates(configurations);

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 第一个参数返回的是 EnableAutoConfiguration.class
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
            getBeanClassLoader());

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {

    // 这里的factoryClassName是EnableAutoConfiguration
    String factoryClassName = factoryClass.getName();
    // 下面这句话的意思是需要在loadSpringFactories这个map中获取key为EnableAutoConfiguration的value
    return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

// 在FACTORIES_RESOURCE_LOCATION中获取资源
Enumeration<URL> urls = (classLoader != null ?
				classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
				ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
//定义一个MAP，将结果都存到这个map中
result = new LinkedMultiValueMap<>();
//对每个资源循环
while (urls.hasMoreElements()) {
	URL url = urls.nextElement();
	UrlResource resource = new UrlResource(url);
//  转化为properties
	Properties properties = PropertiesLoaderUtils.loadProperties(resource);
	for (Map.Entry<?, ?> entry : properties.entrySet()) {
		String factoryClassName = ((String) entry.getKey()).trim();
		for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
			// 最后添加到result中
			result.add(factoryClassName, factoryName.trim());
		}
	}
}
cache.put(classLoader, result);
return result;

//表示一个配置文件
@Configuration
// 仅当classpath中存在特定的CacheManager类时匹配
@ConditionalOnClass(CacheManager.class)
// 如果Spring 容器中存在CacheAspectSupport
@ConditionalOnBean(CacheAspectSupport.class)
//如果Spring容器不满足bean的name为cacheResolver，value为CacheMaager
@ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
// 开启自动配置属性，指向 CacheProperties类
@EnableConfigurationProperties(CacheProperties.class)
@AutoConfigureAfter({ CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class,
		HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
// 缓存配置的选择器
@Import(CacheConfigurationImportSelector.class)
public class CacheAutoConfiguration {

// spring.cache就是在配置文件中使用的前缀
@ConfigurationProperties(prefix = "spring.cache")
public class CacheProperties {
// 以下就是各属性值 
	private CacheType type;
	private List<String> cacheNames = new ArrayList<>();
	private final Caffeine caffeine = new Caffeine();
	private final Couchbase couchbase = new Couchbase();
	private final EhCache ehcache = new EhCache();
    private final Redis redis = new Redis();

public static class Redis {
	private Duration timeToLive;
	private boolean cacheNullValues = true;
	private String keyPrefix;
	private boolean useKeyPrefix = true;

@SpringBootApplication
public class DeepSpringBootApplication {
    public static void main(String[] args) {
        // 使用SpringApplication.run方法来启动spring boot应用 其中参数有类和args
        SpringApplication.run(DeepSpringBootApplication.class,args);
    }
}

//点开@SpringBootApplication源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    /** AliasFor注解的作用是为了声明别名
      * AliasFor在下面代码中的作用就是通过别名引用在annotatin指定的类的特定方法
      * 如果有兴趣可以参考AliasFor的官方文档 
      * https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/annotation/AliasFor.html
      * 比如这里就会指定 EnableAutoConfiguration的exclude方法
      **/
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};
    // 。。。其他的省略
}

/**
  * 标示是一个spring boot应用的配置类，用作 @Configuratio的替代品
  * 以便自动找到配置
  */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
	@AliasFor(annotation = Component.class)
	String value() default "";
}

@Configuration
 public class AppConfig {
     @Bean
     public MyBean myBean() {
         // instantiate, configure and return bean ...
     }
}

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
// 注册Bean
ctx.register(AppConfig.class);
ctx.refresh();
MyBean myBean = ctx.getBean(MyBean.class);

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
	Class<?>[] exclude() default {};
	String[] excludeName() default {};
}

// 标注@AutoConfigurationPackage的注解可以使用Registrar进行注册
// @Import的作用就是引用配置类，将多个配置类放到一个主配置中
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

// 注册方法
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
// 注册bean定义信息
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    // 这里的packageName是标注这个注解的类的包的路径名称，如下图
        register(registry, new PackageImport(metadata).getPackageName());
    }
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImport(metadata));
    }
}

// 以编程方式注册自动配置包名称.将给定的包【这里的是com.nanyin 】注册添加到已经注册的包名称中
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
// 	private static final String BEAN = AutoConfigurationPackages.class.getName();
    if (registry.containsBeanDefinition(BEAN)) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
        ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
        constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
    }
    else {
       //  使用标准的类定义 GenericBeanDefinition 注册bean
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(BasePackages.class);
        beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        // 注册bean
        registry.registerBeanDefinition(BEAN, beanDefinition);
    }
}

@Override
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) { Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
            () -> String.format("Only %s implementations are supported, got %s",
                    AutoConfigurationImportSelector.class.getSimpleName(),
                    deferredImportSelector.getClass().getName()));
                    //获取自动导入的内容的全类名，在这一步进行debug见下图
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
            .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				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;
}
// 调用loadFactoryNames获得一组包名称
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

@ComponentScan(excludeFilters = { 
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/***
 * 如果需要使用ConfigurationProperties 这个注解需要添加
 *
 * <dependency>
 * 	<groupId>org.springframework.boot</groupId>
 * 	<artifactId>spring-boot-configuration-processor</artifactId>
 * 	<optional>true</optional>
 * </dependency>
 *
 * @Author nanyin
 * @Date 16:29 2019-07-07
 * 
 * 使用Lombok的data注解可以自动的配置 setter，getter，toString属性，
 * 但是需要IDE的Lombok插件
 **/
@Data
@ConfigurationProperties(value = "person")
@Component
public class Person {
    private String name;
    private int age;
    private User user;
}

@Data
public class User {
    private int id;
}

/***
 * 使用spring的测试，可以使用spring的注入功能
 * 这里的runWith注解说明的是让junit使用Spring的运行测试方式
 * 也就是说可以使用spring的注入等特性
 * @Author nanyin
 * @Date 16:27 2019-07-07
 **/
@RunWith(SpringRunner.class)
@SpringBootTest
public class DeepSpringBootApplicationTest {
    @Autowired
    Person person;

    @Test
    public void testPerson(){
        System.out.println(person.toString());
    }
}

// 标注@Configuration注解，表示这个是Spring的配置类，用来代替配置文件如 xxx.xml
@Configuration
public class MyConfig {

    @Autowired
    Person person;

    /**
      * 使用@bean注解向容器中添加bean，用来替代原来xml配置文件中的
      *<beans>
      * <context:annotation-config/>
      * <bean class="com.acme.AppConfig"/>
      *</beans>
      * 其中方法的返回值是添加到容器中的内容
      */
    @Bean
    public HelloService helloService(){
    // 可以使用person的配置值
        System.out.println("加载MyConfig配置文件！！！ 其中配置文件中的 name 属性：" + person.getName());
        return new HelloService() ;
    }
}

// SpringBoot测试
public class DeepSpringBootApplicationTest {
    @Autowired
    ApplicationContext ctx;
    @Test
    public void testContainsBean(){
        System.out.println(ctx.containsBean("helloService"));
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * EnableAutoConfiguration 表示告诉spring boot如何去配置spring，
 * 其可以帮助 SpringBoot 应用将所有符合条件的 @Configuration 配置都加载到当前 IoC 容器之中
 * 自从添加spring-boot-starter-web这个starter添加了tomcat和spring MVC后，使用该注解，就说明使用spring启动一个web项目
 * SpringBootApplication 等同于使用@Configuration @EnableAutoConfiguration @ComponentScan这三个注解
 * @Author nanyin
 * @Date 21:46 2019-07-04
 **/
@SpringBootApplication
public class DeepSpringBootApplication {
    public static void main(String[] args) {
        // 使用SpringApplication.run方法来启动spring boot应用 其中参数有类和args
        SpringApplication.run(DeepSpringBootApplication.class,args);
    }
}

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public @ResponseBody
    String home() {
        return "Hello World!";
    }
}

public interface Command {
    void excute();
}

// 请求者用来请求命令
public class King {
    private Command command;

    public Command invoke(Command command){
        this.command = command;
        return this.command;
    }

    public void action(){
        command.excute();
    }
}

public class Soldier {

    // 行动方法
    public void prepareWeapon(){
        System.out.println("Soldier prepare Weapon !!!");
    }

    public void attack(){
        System.out.println("Soldier Attack!!!");
    }

    public void retreat(){
        System.out.println("Soldier Retreat!!");
    }
}

public class AttackCommand implements Command{

    Soldier soldier ;

    public AttackCommand(Soldier soldier) {
        this.soldier = soldier;
    }

    @Override
    public void excute() {
    // 收到请求，执行操作
        soldier.prepareWeapon();
        soldier.attack();
    }
}

public class App {
    public static void main(String[] args) {
        //  接受者和请求者
        King king = new King();
        Soldier soldier = new Soldier();
        // 请求者请求命令
        king.invoke(new AttackCommand(soldier));
        // 请求者发起命令
        king.action();
        king.invoke(new RetreatCommand(soldier));
        king.action();
    }
}

public class example {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        Iterator iterator = (Iterator) list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

public interface Iterator<E> {
    boolean hasNext();
    E next();
}

public interface Task {
    void add(int mark);
    void removeLast();
    Iterator<Object> iterator();
}

public class MyTask implements Task {

    private int size = 0 ;

    private Object[] taskTag = new Object[16];

    @Override
    public void add(int mark) {
        taskTag[size] = mark;
        size ++;
    }

    @Override
    public void removeLast() {
        taskTag[--size] = null;
    }

    @Override
    public Iterator<Object> iterator() {
    // 调用内部类实现迭代器
        return new MyTaskItr();
    }
    // 使用内部类实现迭代器
    private class MyTaskItr implements Iterator<Object>{

        private int curr;

        @Override
        public boolean hasNext() {
            return size != curr;
        }

        @Override
        public Object next() {
            int i = curr;
            if(i >= size){
                throw new NoSuchElementException("no element");
            }
            return taskTag[curr++];
        }
    }
}

public class App {
    public static void main(String[] args) {
        Task task = new MyTask();
        task.add(1);
        task.add(3);
        task.add(4);
        task.add(2);
        task.removeLast();
        task.removeLast();
        task.add(5);
        Iterator taskIterator = task.iterator();
        while(taskIterator.hasNext()){
            System.out.println(taskIterator.next());
        }
        // 结果依次打印出 1，3，5
    }
}