Spring-6-BeanFactoryPostProcessor

BeanFactoryPostProcessor是一个扩展点接口，用来在BeanFactory创建完成，BeanDefinition加载完后修改Bean Definition中的属性。Application Context会自动探测到Bean Definitions中的BeanFactoryPostProcessor，并将它们在其他Bean创建前应用。这个接口对于使用自定义配置文件中的值覆盖应用上下文中配置的属性值，比如PropertyResourceConfigurer和它的子类就是用来实现这个目的的。BeanFactoryPostProcessor只可能会修改BeanDefinition，不会修Bean。如果修改Bean，会导致Bean过早实例化，侵犯容器，产生副作用。

BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor

more >>

Spring-3-BeanDefinition

BeanDefinition是什么？

　　作为一个IOC容器框架，Spring管理Bean的生命周期，自然需要知道这些Bean用哪些类创建？在什么时候需要被创建？这些Bean在创建的时候需要哪些参数？创建后需要为其设置哪些属性？需要调用什么初始化方法？Bean的是什么类型的？Bean销毁时调用什么方法？

more >>

Spring-2-ApplicationContext

ApplicationContext

作为IOC的的核心组件之一，相比于BeanFactory，ApplicationContext还提供了ResourceLoader功能，ApplicationEventPublisher功能以及MessageSource功能。

ResourceLoader

ResourceLoader接口用于加载各种路径下的资源，比如类路径下资源，文件系统中的资源等。ResourceLoader的默认实现DefaultResourceLoader，它的Resource getResource(String location) 方法会通过先注册的ProtocolResolver去尝试解析location，如果某个ProtocolResolver解析成功，直接返回一个Resource。如果解析失败，会依次判断是否以/开头，或者前缀为”classpath:”，如果都不满足则会创建以个URL，根据URL的协议读取本地文件或远程资源，具体代码如下：

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
public Resource getResource(String location) {
	Assert.notNull(location, "Location must not be null");

	for (ProtocolResolver protocolResolver : this.protocolResolvers) {
		Resource resource = protocolResolver.resolve(location, this);
		if (resource != null) {
			return resource;
		}
	}

	if (location.startsWith("/")) {
		return getResourceByPath(location);
	}
	else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
		return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
	}
	else {
		try {
			// Try to parse the location as a URL...
			URL url = new URL(location);
			return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
		}
		catch (MalformedURLException ex) {
			// No URL -> resolve as resource path.
			return getResourceByPath(location);
		}
	}
}

ApplicationEventPublisher

ApplicationEventPublisher接口用于发布ApplicationEvent事件。最终事件会通知到各个ApplicationListener。

MessageSource

MessageSource主要用于解析消息，支持参数化和国际化。

ApplicationContext 继承关系

ApplicationContext接口有两个子接口分支：ConfigurableApplicationContext和WebApplicationContext。ConfigurableApplicationContext添加了配置功能，继承了Lifecycle和Closeable，提供了生命周期管理：addApplicationListener为ApplicationEventPublisher接口提供了ApplicationListener,addProtocolResolver方法提供了添加Resource解析器的功能，setEnvironment为EnvironmentCapable接口提供了修改Environment的功能，setId提供了修改ApplicationContext Id的功能，setParent为HierarchicalBeanFactory提供了设置父ApplicationContext和父BeanFactory的功能， 此外 ConfigurableApplicationContext还提供了refresh用于刷新，isActive判断状态，close方法用于关闭和释放资源，并且addBeanFactoryPostProcessor提供了添加BeanFactoryPostProcessor的功能，这些BeanFactoryPostProcessor将会在ApplicationContext内部的BeanFactory refresh时，评估任何BeanDefinition之前被调用。而WebApplicationContext提供了获取ServletContext方法，以及SCOPE_REQUEST、SCOPE_SESSION和SCOPE_APPLICATION Bean。

ConfigurableApplicationContext有一个继承接口ConfigurableWebApplicationContext和抽象子类AbstractApplicationContext。

AbstractApplicationContext类通过模板方法设计模式为子类提供了框架，具体的实现在子类中。其中最重要的是refresh方法。

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// 1. 为刷新context做准备，加载属性文件，设置环境信息和context状态信息
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 2. 获取内部BeanFactory,其中调用了refreshBeanFactory和getBeanFactory，由子类实现
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// 3. 配置beanFactory的标准上下特征，比如ClassLoader和post-processors.
		prepareBeanFactory(beanFactory);

		try {
			// 4. application context的内部bean Factory初始化完成后修改它，所有的bean definition都已经加载了，但还没有实例化，这个方法可以用来注册特殊的BeanPostProcessors
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 5. 实例化所有的BeanFactoryPostProcessor bean，并按照指定的顺序调用，在singleton 实例化之前调用
			invokeBeanFactoryPostProcessors(beanFactory);

			// 6. 注册拦截Bean创建的BeanPostProcessor
			registerBeanPostProcessors(beanFactory);

			// 7. 初始化Message资源
			initMessageSource();

			// 8. 初始化事件广播器
			initApplicationEventMulticaster();

			// 9. 留给子类初始化其他特殊的Bean
			onRefresh();

			// 10. 在所有注册Bean中查找ApplicationListener Bean,并注册到消息广播器中
			registerListeners();

			// 11. 初始化剩下的单例Bean(非延迟加载的)
			finishBeanFactoryInitialization(beanFactory);

			// 12. 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

obtainFreshBeanFactory方法中调用了refreshBeanFactory和getBeanFactory方法，refreshBeanFactory和getBeanFactory方法都是模板方法，由子类去实现。AbstractApplicationContext的两个子类：GenericApplicationContext和AbstractRefreshableApplicationContext都提供了refreshBeanFactory的实现，GenericApplicationContext的实现只是设置refreshed和serializationId，AbstractRefreshableApplicationContext则会去创建DefaultListableBeanFactory，并调用loadBeanDefinitions加载BeanDefinition,loadBeanDefinitions方法也是一个抽象方法，具体实现由AbstractRefreshableApplicationContext子类实现。

ConfigurableWebApplicationContext是所有webContext的父接口，提供了提供了设置web信息的方法：

1
2
3
4
void setServletContext(@Nullable ServletContext servletContext);
void setNamespace(@Nullable String namespace);
void setConfigLocation(String configLocation);
void setConfigLocations(String... configLocations);

Spring-1-BeanPostProcessor

BeanPostProcessor是Spring容器的一个扩展点，可以进行自定义的实例化、初始化、依赖装配、依赖检查等流程，即可以覆盖默认的实例化，也可以增强初始化、依赖注入、依赖检查等流程。BeanPostProcessor一共有两个回调方法postProcessBeforeInitialization和postProcessAfterInitialization，那这两个方法会在什么Spring执行流程中的哪个步骤执行呢？

more >>

Spring-Boot-0-@Configuration

SpringBoot 启动注册主程序类

org.springframework.context.support.GenericApplicationContext#registerBeanDefinition

org.springframework.boot.SpringApplication#run(java.lang.String…)
org.springframework.boot.SpringApplication#prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner)
org.springframework.boot.SpringApplication#load(ApplicationContext context, Object[] sources)
org.springframework.boot.BeanDefinitionLoader#load()
org.springframework.boot.BeanDefinitionLoader#load(java.lang.Object)
org.springframework.boot.BeanDefinitionLoader#load(java.lang.Class<?>)
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#register(Class<?>… annotatedClasses)
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#registerBean(java.lang.Class<?>)
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#register

将@SpringBootApplication注解类注册到BeanDefinition中，其他的类将由ConfigurationClassPostProcessor自动扫描。ConfigurationClassPostProcessor在processConfigBeanDefinitions中创建了ConfigurationClassParser，并调用ConfigurationClassParser.parse(candidates)方法解析@Configuration注解的类。整个调用流程如下：

1
2
3
4
5
6
7
8
9
10
11
12
// BeanDefinitionRegistryPostProcessor扩展点
org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
// 从BeanDefinitionRegistry找到所有的Full和Lite Configuration BeanDefinition
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions(BeanDefinitionRegistry registry)
org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)
org.springframework.context.annotation.ConfigurationClassParser#parse(org.springframework.core.type.AnnotationMetadata, java.lang.String)
org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass(ConfigurationClass configClass)
org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException
// 调用ComponentScanAnnotationParser解析@ComponentScan
org.springframework.context.annotation.ComponentScanAnnotationParser#parseparse(AnnotationAttributes componentScan, final String declaringClass)
// 扫描包
org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

full VS lite Configuration

  1. 如果类上使用了@Configuration，则为full Configuration
    2.如果不满足1，检查类上是否使用了@Component、@ComponentScan、@Import或@ImportResource,如果都没有使用，则检查方法上是否使用了@Bean

@Configuration解析过程

ConfigurationClassPostProcessor同时实现了BeanDefinitionRegistryPostProcessor和

从已有的 BeanDefinition 中，找到配置类，然后解析出更多 BeanDefinition

postProcessBeanFactory
这里就是增强配置类，添加一个 ImportAwareBeanPostProcessor，这个类用来处理 ImportAware 接口实现

Full Configuration

Full Configuration 和

ConfigurationClassEnhancer

BeanMethodInterceptor

scope proxy

Spring Boot-1. 架构

ImportSelector

Import

autoconfigure模块

@ConfigurationProperties和spring-configuration-metadata.json

spring-boot-autoconfigure-processor

ConditionalOnMissingBean
Conditional

starter模块

##Spring boot启动过程

org/springframework/boot/BeanDefinitionLoader.java:148

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#register

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#registerBean(java.lang.Class<?>)

org/springframework/context/annotation/ComponentScanAnnotationParser.java:123

SOFA

CQRS

扩展，扩展点， 业务身份识别

贫血模式

Repository Tunnel盒马概念

元数据引擎

Spring-Security-Authentication

org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#configure(org.springframework.security.config.annotation.web.builders.HttpSecurity)

通过FormLoginConfigurer将UsernamePasswordAuthenticationFilter添加到HttpSecurity的filter中
通过ExpressionUrlAuthorizationConfigurer将FilterSecurityInterceptor添加到HttpSecurity的filter中

org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter#getHttp

将WebAsyncManagerIntegrationFilter，SecurityContextPersistenceFilter,HeaderWriterFilter,LogoutFilter,RequestCacheAwareFilter,SecurityContextHolderAwareRequestFilter,AnonymousAuthenticationFilter,SessionManagementFilter,ExceptionTranslationFilter天骄到HttpSecurity的filter列表中。

WebSecurityConfigurerAdapter的以下两个方法：

1
2
3
4
5
6
7
8
9
10
protected void configure(HttpSecurity http) throws Exception {
		logger.debug("Using default configure(HttpSecurity). If subclassed this will potentially override subclass configure(HttpSecurity).");

		http
			.authorizeRequests() // 应用ExpressionUrlAuthorizationConfigurer
				.anyRequest().authenticated()
				.and()
			.formLogin().and() // 应用FormLoginConfigurer
			.httpBasic();
	}
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
protected final HttpSecurity getHttp() throws Exception {
		if (http != null) {
			return http;
		}

		DefaultAuthenticationEventPublisher eventPublisher = objectPostProcessor
				.postProcess(new DefaultAuthenticationEventPublisher());
		localConfigureAuthenticationBldr.authenticationEventPublisher(eventPublisher);

		AuthenticationManager authenticationManager = authenticationManager();
		authenticationBuilder.parentAuthenticationManager(authenticationManager);
		authenticationBuilder.authenticationEventPublisher(eventPublisher);
		Map<Class<? extends Object>, Object> sharedObjects = createSharedObjects();

		http = new HttpSecurity(objectPostProcessor, authenticationBuilder,
				sharedObjects);
		if (!disableDefaults) {
			// @formatter:off
			http
				.csrf().and()
				.addFilter(new WebAsyncManagerIntegrationFilter()) //WebAsyncManagerIntegrationFilter
				.exceptionHandling().and()	// ExceptionTranslationFilter
				.headers().and()	// HeaderWriterFilter
				.sessionManagement().and()	// SessionManagementFilter
				.securityContext().and()	// SecurityContextPersistenceFilter
				.requestCache().and()	//RequestCacheAwareFilter
				.anonymous().and()	//AnonymousAuthenticationFilter
				.servletApi().and()	//SecurityContextHolderAwareRequestFilter
				.apply(new DefaultLoginPageConfigurer<>()).and()//DefaultLoginPageGeneratingFilter和DefaultLogoutPageGeneratingFilter
				.logout();// LogoutFilter
			// @formatter:on
			ClassLoader classLoader = this.context.getClassLoader();
			List<AbstractHttpConfigurer> defaultHttpConfigurers =
					SpringFactoriesLoader.loadFactories(AbstractHttpConfigurer.class, classLoader);

			for (AbstractHttpConfigurer configurer : defaultHttpConfigurers) {
				http.apply(configurer);
			}
		}
		configure(http);
		return http;
	}

HttpSecurity最终会用上面的那些filter构建一个DefaultSecurityFilterChain，在构建DefaultSecurityFilterChain前，会使用FilterComparator对filter进行排序。
HttpSecurity会添加到WebSecurity的securityFilterChainBuilders中，被用来构建成一个FilterChainProxy，这个FilterChainiProxy在WebSecurityConfiguration中被注册到ApplicationContext中，名称为springSecurityFilterChain。

AbstractSecurityWebApplicationInitializer在onStartup时，调用insertSpringSecurityFilterChain，根据bean名称springSecurityFilterChain获取到，然后用其创建DelegatingFilterProxy，最终添加到ServletContext的

title: Thymeleaf
date: 2018-11-27 14:58:54

tags: [“Java”]

Thymeleaf标准表达式语法

Thymeleaf有五种语法：

  • ${} :变量表达式
  • *{} :选择表达式
  • #{} :消息（i8n）表达式
  • @{} :链接表达式
  • ~{} :片段表达式

变量表达式

变量表达式是OGNL表达式，或者Spring EL，在上下文变量中执行，也称作模型属性。写法如下：

1
${session.user.name}

变量表达式可以作为标签属性：

1
<span th:text="${book.author.name}">

上面的写法等同于：

1
((Book)context.getVariable("book")).getAuthor().getName()

|