Spring Framework Miscellaneous

 

---------------------------------------------------------------------------------------

After ApplicationContext standard initialization.
All regular bean definitions will have been loaded, but no beans will have been instantiated yet.

BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry for BeanDefinitionRegistry

BeanDefinitionRegistryPostProcessor.postProcessBeanFactory for Bean instance Registry

 BeanDefinitionRegistryPostProcessor bean's @PostConstruct maybe ignored.

 ---------------------------------------------------------------------------------------
BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg);
reader.loadBeanDefinitions(new ClassPathResource("bean1.xml"));
reader.loadBeanDefinitions(new ClassPathResource("bean2.xml"));
BeanFactory bf=(BeanFactory)reg; 
-----------------------------------------------------------------------------------------
BeanDefinitionBuilder beanDefBuilder = BeanDefinitionBuilder.genericBeanDefinition(your class);
add/set......
ApplicationContext getAutowireCapableBeanFactory -->(DefaultListableBeanFactory) --> beanFactory
ClassPathXmlApplicationContext is not instanceof DefaultListableBeanFactory
beanFactory.registerBeanDefinition ......
ApplicationContext.getAutowireCapableBeanFactory().applyBeanPostProcessorsAfterInitialization
beanFactory.registerSingleton(obj......);
-----------------------------------------------------------------------------------------
Resource resource = new ClassPathResource("appcontext.xml");
BeanFactory factory = new XmlBeanFactory(resource);

new ClassPathXmlApplicationContext("classpath*:conf/**/*application-context.xml");
new ClassPathXmlApplicationContext("conf/**/*application-context.xml");

new FileSystemXmlApplicationContext("classpath:appcontext.xml");
new FileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");

 

http://repo.spring.io

 

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
<property name="locations"> 
   <list> 
      <!--classpath，file --> 
      <value>classpath:/.../*.properties</value>               
      <value>file:/.../*.properties</value>
    </list> 
</property> 
</bean> 
加载多个配置文件：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:config/applicationContext*.xml,classpath:config/applicationContext-web*.xml</param-value>
</context-param>

<import resource="resources/messageSource.xml"l>
<import resource="resources/applicationContext_*.xml" />
<import resource="lib/validator-rest-1.0.jar*/cms-validator-hibernate.xml"/>
<import resource="classpath*:config/applicationContext-*.xml" />  #ok,in jar

 

<mvc:annotation-driven />  2 beans
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">

context:annotation-config  4 beans
context:component-scan

 

applicationContext.xml in Tomcat load order: ServletContextListener.contextInitialized  filter.init servlet.init

e.g:

main applicationContext.xml
<context:component-scan base-package="com.*">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" /> 
</context:component-scan>
servlet-context.xml  for MVC Servlet.
<mvc:annotation-driven />
<context:component-scan base-package="com.*" use-default-filters="false">#for include-filter
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" /> 
</context:component-scan>

#ref-->#http://angelbill3.iteye.com/blog/1896502

 

Spring Annotation Resource Scanning:

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;

 

<context:component-scan name-generator scope-resolver
当一个 Bean 被自动检测到时，会根据那个扫描器的 BeanNameGenerator 策略生成它的 bean 名称。
默认情况下，对于包含 name 属性的 @Component、@Repository、 @Service 和 @Controller，会把 name 取值作为 Bean 的名字。
如果这个注解不包含 name 值或是其他被自定义过滤器发现的组件，默认 Bean 名称会是小写开头的非限定类名。
如果你不想使用默认 bean 命名策略，可以提供一个自定义的命名策略。首先实现 BeanNameGenerator 接口，确认包含了一个默认的无参数构造方法。然后在配置扫描器时提供一个全限定类名，
如下所示:
 <context:component-scan base-package="a.b" name-generator="a.SimpleNameGenerator"/>
 
与通过 XML 配置的 Spring Bean 一样，通过上述注解标识的 Bean，其默认作用域是"singleton"，为了配合这四个注解，
在标注 Bean 的同时能够指定 Bean 的作用域，Spring 2.5 引入了 @Scope 注解。使用该注解时只需提供作用域的名称就行了，如下所示:
@Scope("prototype")
如果你想提供一个自定义的作用域解析策略而不使用基于注解的方法，只需实现 ScopeMetadataResolver 接口，
确认包含一个默认的没有参数的构造方法。然后在配置扫描器时提供全限定类名:
<context:component-scan base-package="a.b" scope-resolver="footmark.SimpleScopeResolver" />

import org.springframework.core.type.filter.TypeFilter;
<context:component-scan base-package="com.XX">
    <context:exclude-filter type="custom" expression="com.XX.core.spring.BeanComponentScanExcludeFilter"/>
</context:component-scan>
在一个context里可以有多个context:component-scan，针对不同的base-package进行扫描控制，
在一个context:component-scan里也可以存在多个exclude/include filters，当使用include-filter时，需use-default-filters="false"，否则可能只有部分进行match，比如只匹配不带注解的类。

http://sishuok.com/forum/blogPost/list/2458.html
使用路径通配符加载Resource
Ant路径通配符支持“？”、“*”、“**”，注意通配符匹配不包括目录分隔符“/”：
“?”：匹配一个字符，如“config?.xml”将匹配“config1.xml”；
“*”：匹配零个或多个字符串，如“cn/*/config.xml”将匹配“cn/javass/config.xml”，但不匹配匹配“cn/config.xml”；而“cn/config-*.xml”将匹配“cn/config-dao.xml”；
“**”：匹配路径中的零个或多个目录，如“cn/**/config.xml”将匹配“cn /config.xml”，也匹配“cn/javass/spring/config.xml”；而“cn/javass/config-**.xml”将匹配“cn/javass/config-dao.xml”，即把“**”当做两个“*”处理。
Spring提供AntPathMatcher来进行Ant风格的路径匹配。具体测试请参考cn.javass.spring.chapter4. AntPathMatcherTest。
Spring在加载类路径资源时除了提供前缀“classpath:”的来支持加载一个Resource，还提供一个前缀“classpath*:”来支持加载所有匹配的类路径Resource。

Spring配置中classpath:和classpath*:的区别: 
ClassLoader Class Path目录：
一般分为jar中的!/和非jar的first-class目录，典型的WEB-INF/classes or lib/jars目录，当然first-class目录可能有多个，优先加载顺序由加入classLoader时的url顺序决定，jars默认顺序为文件名顺序。
特例：
locationPattern->rootDirPath+subPattern
e.g: classpath:com/sub1/**/*/applicationContext*.xml
rootDirPath->classpath:com/sub1/     又如classpath*:com/sub1/
subPattern->**/*/applicationContext*.xml
Enumeration<URL> resourceUrls = classLoader.getResources([rootDirPath-[classpath: / *:]]->"");[rootDirPath-[classpath: / *:]]长度为零, 如果subPattern.isPattern(*/?)只会在first-class目录查找，(classpath:或者classpath*:)都不会搜索jar中的!/目录， 这源于JDK的ClassLoader.getResources()方法中的一个限制，该方法只返回传入空字符串的文件系统位置(指示要搜索的潜在根)。
如果非模式匹配[由classLoader直接getResource(classpath:)/getResources(classpath*:)]，如果在first-class目录找不到则会搜索jar中的!/目录。
[rootDirPath-[classpath: / *:]]长度为零：
1.subPattern不带模式匹配，classpath:或不加-->首先搜索first-class目录，除非找不到才会进入jar!/中搜索。classpath*:-->会搜索所有cp目录。
2.subPattern带有模式匹配，classpath:或不加-->搜索first-class目录的[rootDirPath-[classpath: / *:]]目录，匹配成功则返回，如果失败，不会进入jar!/中搜索。classpath*:-->同classpath:或不加，不会进入jar!/中搜索。因为classLoader.getResources("")的限制。
[rootDirPath-[classpath: / *:]]长度不为零：
1.subPattern不带模式匹配，classpath:或不加-->首先搜索first-class目录，除非找不到才会进入jar!/中搜索。classpath*:-->会搜索所有cp目录。
2.subPattern带有模式匹配，classpath:或不加-->搜索first-class目录的[rootDirPath-[classpath: / *:]]目录，匹配成功则返回。如果失败，只有当所有first-class目录中不存在[rootDirPath-[classpath: / *:]]才会进入jar!/中搜索。classpath*:-->会搜索所有cp目录。
classpath:是有可能搜索jar中!/目录的！
classpath:优先的单个(不管是否带有通配符)， classpath*:多个(即便是不带有通配符)
PathMatchingResourcePatternResolver.getResource 优先的单个
PathMatchingResourcePatternResolver.getResources 多个

spring-framework-reference:
Please note that " classpath*:" when combined with Ant-style patterns will only work reliably with at
least one root directory before the pattern starts, unless the actual target files reside in the file system.
This means that a pattern like " classpath*:*.xml" will not retrieve files from the root of jar files
but rather only from the root of expanded directories. This originates from a limitation in the JDK’s
ClassLoader.getResources() method which only returns file system locations for a passed-in
empty string (indicating potential roots to search).
<context:property-placeholder location="classpath*:conf/conf*.properties"/> 
<import resource="a.xml"/> 
<import resource="b.xml"/> 

mybatis-config.xml
<properties resource="db.properties"/>

<bean id="bizSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath*:com/XX/**/*.${bizDBTypeName}.mapper.xml" /> #如果在jar中则找不到！
<!--property name="mapperLocations" value="classpath*:com/XX/**/dao/impl/mapper/*.${bizDBTypeName}.mapper.xml" /-->
        <property name="dataSource" ref="bizDataSource" />
    </bean>

 
多事务管理，声明式事务：
<tx:annotation-driven/>
<bean id="bizTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="bizDataSource" />       
        <qualifier value="bizTxManager"/>
    </bean>
    <bean id="sysTxManager" class="your TM implements PlatformTransactionManager">       
        <qualifier value="sysTxManager"/>
    </bean>
@Transactional(value="sysTxManager"[--->qualifier not beanId],rollbackFor={Throwable.class/*else just for RuntimeException/Error*/})

 
Bean Validator:
在mvc的servlet-context.xml中
<mvc:annotation-driven validator="yourValidator" />
 <context:component-scan base-package="com.**.web" />#<-------会影响bean validator的扫描。
<bean id="yourValidator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
<property name="providerClass" value="org.hibernate.validator.HibernateValidator" />
<property name="validationMessageSource" ref="yourResourceBundleMessageSource"/>
</bean>
bean validation constraints的message在国际化环境中填写相应的code/id. "{messageCode}"

 e.g:
List<FieldError> errors = binding.getFieldErrors();
String defaultMsg=ResourceMessageManager.getMessage(error.getDefaultMessage());
手动编程校验：
Set<ConstraintViolation<Object>> cs = yourValidator/LocalValidatorFactoryBean.getValidator().validate(targetObject, groups);
for cs todo ......
Spring mvc 3.2.x ----org.hibernate::hibernate-validator 4.3.x
@ControllerAdvice @ExceptionHandler(Exception.class) except @ResponseStatus Exceptions.
注意：一个@Valid后紧跟一个BindingResult(需要特殊处理时才跟BindingResult)，在action中显式try-catch是捕获不到验证异常的，@Validated能进行分组验证而@Valid不能。
如果需要对参数对象的多个字段进行特殊逻辑验证，需要自定义Constraint，
@Constraint(validatedBy = DTOMultiFieldsValidator.class)
public @interface DTOMultiFieldsValid {
    String message() default "{constraints.DTOMultiFieldsValid}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}
public class DTOMultiFieldsValidator implements ConstraintValidator<DTOMultiFieldsValid, YourDTO> {
    @Override
    public boolean isValid(YourDTO dto, ConstraintValidatorContext context) {

 

 对bean class @Lazy(value=true)
Set the default-lazy-init attribute at the <beans> root element level.
<beans ... default-lazy-init="true" >