Springboot

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// @SpringBootApplication ：标注这这个类是一个SpringBoot的应用   启动类下的所有资源被导入
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        // 将Springboot启动
        SpringApplication.run(DemoApplication.class, args);
    }

}

1
2
3
4
5
6
7
8

@SpringBootConfiguration 	： springboot的配置
	@Configuration	：spring的配置类
		@Component	：说明这也是一个spring的组件

@EnableAutoConfiguration	：自动配置
	@AutoConfigurationPackage	：自动配置包
		@Import(AutoConfigurationPackages.Registrar.class)	：自动配置包注册
	@Import(AutoConfigurationImportSelector.class)	：自动配置导入选择

1
2

Properties properties = PropertiesLoaderUtils.loadProperties(resource)
//所有资源加载到配置类中！

1

k: v

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@Component			//注册bean到容器中
public class Dog {

    @Value("wangcai")
    private String name;
    @Value("3")
    private int age;
	
	// 有参无参构造、get、set方法、toString()方法
}

1
2
3
4
5
6
7

@Component //注册bean 
public class Dog { 
	@Value("阿黄") 
	private String name;
	@Value("18") 
	private Integer age;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@SpringBootTest
class DemoApplicationTests {
	@Autowired //将狗狗自动注入进来
	private Dog dog;
	
	@Test
	public void contextLoads() {
	System.out.println(dog); //打印看下狗狗对象
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Component 	//注册bean到容器中
public class Person {
		private String name;
		private Integer age;
		private Boolean happy;
		private Date birth;
		private Map<String,Object> maps;
		private List<Object> lists;
		private Dog dog;
		//有参无参构造、get、set方法、toString()方法
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

person:
  name: clover
  age: 3
  happy: false
  birth: 1996/08/24
  maps: {k1: v1,k2: v2}
  lists:
    - code
    - music
  dog:
    name: wangcai
    age: 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@Component

/*
    @ConfigurationProperties作用：
    将配置文件中配置的每一个属性的值，映射到这个组件中；
    告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
    参数 prefix = "person" ：将配置文件中的person下面的所有属性一一对应

    只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
*/

@ConfigurationProperties(prefix = "person")
public class Person {

    private String name;
    private int age;
    private boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
	
}

1
2
3
4
5
6

 <!-- 导入配置文件处理器，配置文件进行绑定就会有提示，需要重启 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@SpringBootTest
class Springboot02ConfigApplicationTests {
    @Autowired
    private Person person;		//将person自动注入进来

    @Test
    void contextLoads() {
        System.out.println(dog);
    }

}

1
2
3
4

在配置文件中能配置的东西，都存在一个固有的规律
比如：xxxxAutoConfiguration：都有一个默认值   xxxProperties  和  配置文件进行绑定，我们就可以使用自定义的配置了

xxxProperties中存在一些默认值，也就是xxxxAutoConfiguration的默认值，如果我们想要修改值，就必须让xxxProperties与配置文件绑定，然后就可以通过其中的属性修改默认值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件；
@Configuration

//启动指定类的ConfigurationProperties功能；
		//进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑定起来；
		//并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties({HttpProperties.class})

//Spring底层@Conditional注解
		//根据不同的条件判断，如果满足指定的条件，整个配置类里面的配置就会生效；
		//这里的意思就是判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)

//判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnClass({CharacterEncodingFilter.class})

//判断配置文件中是否存在某个配置：spring.http.encoding.enabled；
	//如果不存在，判断也是成立的
	//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(
prefix = "spring.http.encoding",
value = {"enabled"},
matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
		//他已经和SpringBoot的配置文件映射了
		private final Encoding properties;
		
		//只有一个有参构造器的情况下，参数的值就会从容器中拿
		public HttpEncodingAutoConfiguration(HttpProperties properties) {
			this.properties = properties.getEncoding();
		}
		//给容器中添加一个组件，这个组件的某些值需要从properties中获取
		@Bean
		@ConditionalOnMissingBean //判断容器没有这个组件？
		public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));   
		filter.setForceResponseEncoding(this.properties.shouldForce(org.springframe work.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE)); 
		return filter;
		} //。。。。。。。 
}
		

1
2
3
4
5

//从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(prefix = "spring.http")
		public class HttpProperties {
		// .....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@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/**")) {
				customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**")
						.addResourceLocations("classpath:/META-INF/resources/webjars/")
						.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
			}
			// 静态资源配置
			String staticPathPattern = this.mvcProperties.getStaticPathPattern();
			if (!registry.hasMappingForPattern(staticPathPattern)) {
				customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern)
						.addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
						.setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
			}
		}

1
2
3
4
5

<dependency>
	<groupId>org.webjars</groupId>
	<artifactId>jquery</artifactId>
	<version>3.4.1</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 进入方法
public String[] getStaticLocations() {
	return this.staticLocations;
}
// 找到对应的值
private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
// 找到路径
private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
		"classpath:/META-INF/resources/",
		"classpath:/resources/",
		"classpath:/static/",
		"classpath:/public/"
};

1
2
3
4

"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/"

1
2
3
4
5

<!--thymeleaf-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@ConfigurationProperties(
		prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
		private static final Charset DEFAULT_ENCODING;
		public static final String DEFAULT_PREFIX = "classpath:/templates/";
		public static final String DEFAULT_SUFFIX = ".html";
		private boolean checkTemplate = true;
		private boolean checkTemplateLocation = true;
		private String prefix = "classpath:/templates/";
		private String suffix = ".html";
		private String mode = "HTML";
		private Charset encoding;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Spring MVC Auto-configuration
// Spring Boot为Spring MVC提供了自动配置，它可以很好地与大多数应用程序一起工作。
Spring Boot provides auto-configuration for Spring MVC that works well with most applications.

// 自动配置在Spring默认设置的基础上添加了以下功能：
The auto-configuration adds the following features on top of Spring's defaults:

// 包含视图解析器
Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

// 支持静态资源文件夹的路径，以及webjars
Support for serving static resources, including support for WebJars

// 自动注册了Converter：
// 转换器，这就是我们网页提交数据到后台自动封装成为对象的东西，比如把"1"字符串自动转换为 int类型
// Formatter：【格式化器，比如页面给我们了一个2019-8-10，它会给我们自动格式化为Date对象】
Automatic registration of Converter, GenericConverter, and Formatter beans.

// HttpMessageConverters
// SpringMVC用来转换Http请求和响应的的，比如我们要把一个User对象转换为JSON字符串，可以去看官网文档解释；
Support for HttpMessageConverters (covered later in this document).

// 定义错误代码生成规则的
Automatic registration of MessageCodesResolver (covered later in this document).

// 首页定制
Static index.html support.

// 图标定制
Custom Favicon support (covered later in this document).

// 初始化数据绑定器：帮我们把请求数据绑定到JavaBean中！
Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).

/*
如果您希望保留Spring Boot MVC功能，并且希望添加其他MVC配置（拦截器、格式化程序、视图控制器和其他功能），
则可以添加自己的@configuration类，类型为webmvcconfiguer，但不添加@EnableWebMvc。如果希望提供
RequestMappingHandlerMapping、RequestMappingHandlerAdapter或
ExceptionHandlerExceptionResolver的自定义实例，则可以声明WebMVCregistrationAdapter实例来提供此类组件。
*/
If you want to keep Spring Boot MVC features and you want to add additional MVC configuration
(interceptors, formatters, view controllers, and other features), you can add your own@Configuration class 
of type WebMvcConfigurer but without @EnableWebMvc.If you wish to provide custom instances of 
RequestMappingHandlerMapping,RequestMappingHandlerAdapter, orExceptionHandlerExceptionResolver, 
you can declare a WebMvcRegistrationsAdapter instance to provide such components.
// 如果您想完全控制Spring MVC，可以添加自己的@Configuration，并用@EnableWebMvc进行注释。
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@Bean
@ConditionalOnBean(ViewResolver.class)
@ConditionalOnMissingBean(name = "viewResolver", value =
ContentNegotiatingViewResolver.class)
public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory)
{
	ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
	
	resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));
	
	// ContentNegotiatingViewResolver使用所有其他视图解析器来定位视图，因此它应该具有较高的优先级
	resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
	return resolver;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

@Nullable // 注解说明：@Nullable 即参数可为null
public View resolveViewName(String viewName, Locale locale) throws Exception
{
		RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
		Assert.state(attrs instanceof ServletRequestAttributes, "No currentServletRequestAttributes");
		List<MediaType> requestedMediaTypes = this.getMediaTypes(((ServletRequestAttributes)attrs).getRequest());
		if (requestedMediaTypes != null) {
			// 获取候选的视图对象
			List<View> candidateViews = this.getCandidateViews(viewName, locale,requestedMediaTypes);
			// 选择一个最适合的视图对象，然后把这个对象返回
			View bestView = this.getBestView(candidateViews, requestedMediaTypes, attrs);
			if (bestView != null) { 		
					return bestView; 
			}
		} 
		// .....
}

1

Iterator var5 = this.viewResolvers.iterator();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

protected void initServletContext(ServletContext servletContext) {
	// 这里它是从beanFactory工具中获取容器中的所有视图解析器
	// ViewRescolver.class 把所有的视图解析器来组合的
	Collection<ViewResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(this.obtainApplicationContext(), ViewResolver.class).values();
	
	ViewResolver viewResolver;
	if (this.viewResolvers == null) {
			this.viewResolvers = new ArrayList(matchingBeans.size());
	}
	// ...............
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package com.clover.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.Locale;

// 扩展SpringMVC
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    // ViewResolver 实现了视图解析器接口的类，我们就可以把它看作视图解析器

    @Bean   // 放入到Bean中
    public ViewResolver getViewResolver(){
        return new MyViewResolver();
    }

    // 自定义了一个自己的视图解析器 MyViewResolver
    public static class MyViewResolver implements ViewResolver{

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class DelegatingWebMvcConfiguration extends
WebMvcConfigurationSupport {
	private final WebMvcConfigurerComposite configurers = newWebMvcConfigurerComposite();
	// 从容器中获取所有的webmvcConfigurer
	@Autowired(required = false)
	public void setConfigurers(List<WebMvcConfigurer> configurers) {
		if (!CollectionUtils.isEmpty(configurers)) {
			this.configurers.addWebMvcConfigurers(configurers);
		}
	}
}

1
2
3

protected void addViewControllers(ViewControllerRegistry registry) { 		
	this.configurers.addViewControllers(registry); 
}

1
2
3
4
5
6
7
8

public void addViewControllers(ViewControllerRegistry registry) {
	Iterator var2 = this.delegates.iterator();
	while(var2.hasNext()) {
		// 将所有的WebMvcConfigurer相关配置来一起调用！包括我们自己配置的和Spring给我们配置的
		WebMvcConfigurer delegate = (WebMvcConfigurer)var2.next();
		delegate.addViewControllers(registry);
	}
}

1
2
3

@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}

1
2
3
4

public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport
{
	// ......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,WebMvcConfigurer.class })

// 这个注解的意思就是：容器中没有这个组件的时候，这个自动配置类才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
TaskExecutionAutoConfiguration.class,ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
}