Pre
为了更好地学习源码，我们有必要对基础知识进行一次简单的复习，只有在知道如何使用的基础上，再去阅读源码才能明白spring这些源码是对哪些功能的支持。
这里简单的梳理一下
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 https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="artisan" class="com.artisan.base.Artisan"/> </beans>
【读取Bean】
ClassPathXmlApplicationContext cx = new ClassPathXmlApplicationContext("classpath:spring.xml"); System.out.println(cx.getBean("artisan").getClass().getSimpleName()); }
【输出】
JavaConfig
【POJO】
public class Bean1 { }
【配置文件 】
@Configuration public class MainConfig { @Bean public Bean1 bean1(){ return new Bean1(); } }
【读取Bean— 传入配置类】
public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfig.class); System.out.println(ac.getBean("bean1")); }
@Bean的形式， bean的默认名称是方法名，若@Bean(value=“bean的名称”) ,那么bean的名称是指定的名称。
【测试结果】
@CompentScan
在配置类上写@CompentScan注解来进行包扫描
【配置类】
package com.artisan.base.componentscan.config; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @Configuration @ComponentScan("com.artisan.base.componentscan") public class CSMainConfig { }
【c - s -d 】
package com.artisan.base.componentscan.controller; import org.springframework.stereotype.Controller; @Controller public class ArtisanInfoController { }
package com.artisan.base.componentscan.service; import org.springframework.stereotype.Service; @Service public class ArtisanService { }
package com.artisan.base.componentscan.dao; import org.springframework.stereotype.Repository; @Repository public class ArtisanDao { }
【测试类】
package com.artisan.base.componentscan; import com.artisan.base.componentscan.config.CSMainConfig; import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class CMTest { public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(CSMainConfig.class); // 输出 单例池中的单例bean的名字 for (String beanDefinitionName : ac.getBeanDefinitionNames()) { System.out.println("bdName:" + beanDefinitionName); } } }
【输出】
excludeFilters
【配置类】
import com.artisan.base.componentscan.service.ArtisanService; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.FilterType; import org.springframework.stereotype.Controller; @Configuration @ComponentScan( basePackages = {"com.artisan.base.componentscan"}, excludeFilters = { @ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}), @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {ArtisanService.class}) }) public class CSMainConfig { }
重点配置
@ComponentScan( basePackages = {"com.artisan.base.componentscan"}, excludeFilters = { @ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}), @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {ArtisanService.class}) })
excludeFilters(排除@Controller注解的,和ArtisanService的)
【测试结果】
includeFilters
@Configuration @ComponentScan( basePackages = {"com.artisan.base.componentscan"}, includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class})}, useDefaultFilters = false)、 public class CSMainConfig { }
若使用包含的用法， 需要把useDefaultFilters属性设置为false（true表示扫描全部的）
【测试结果】
@ComponentScan.Filter type的类型
看下源码
public enum FilterType { /** * Filter candidates marked with a given annotation. * @see org.springframework.core.type.filter.AnnotationTypeFilter */ ANNOTATION, /** * Filter candidates assignable to a given type. * @see org.springframework.core.type.filter.AssignableTypeFilter */ ASSIGNABLE_TYPE, /** * Filter candidates matching a given AspectJ type pattern expression. * @see org.springframework.core.type.filter.AspectJTypeFilter */ ASPECTJ, /** * Filter candidates matching a given regex pattern. * @see org.springframework.core.type.filter.RegexPatternTypeFilter */ REGEX, /** Filter candidates using a given custom * {@link org.springframework.core.type.filter.TypeFilter} implementation. */ CUSTOM }
- ANNOTATION 注解形式 举个例子比如
@Compent @Controller @Service @Repository ....... - ASSIGNABLE_TYPE 指定类型的
FilterType.ASSIGNABLE_TYPE举个例子
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {ArtisanService.class})
- ASPECTJ 类型的 FilterType.ASPECTJ 不常用
- REGEX 正则表达式的 FilterType.REGEX 不常用
- CUSTOM 自定义类型
使用自定义过滤器CUSTOM
package com.artisan.base.componentscan.customFilterType; import org.springframework.core.io.Resource; import org.springframework.core.type.AnnotationMetadata; import org.springframework.core.type.ClassMetadata; import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.core.type.filter.TypeFilter; import java.io.IOException; public class ArtisanFilterType implements TypeFilter { @Overridez public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { //获取当前类的注解源信息 AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); //获取当前类的class的源信息 ClassMetadata classMetadata = metadataReader.getClassMetadata(); //获取当前类的资源信息 Resource resource = metadataReader.getResource(); System.out.println("类的路径:"+classMetadata.getClassName()); // 排除包含Artisan的Bean if(classMetadata.getClassName().contains("Artisan")) { return true; } return false; } }
【配置类】
@Configuration @ComponentScan(basePackages = {"com.artisan.base.componentscan"}, excludeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM, value = {ArtisanFilterType.class})}) public class CSMainConfig { }
【测试结果】
@Scope
public class Bean2 { public Bean2() { System.out.println("Bean2 Created"); } }
public class Bean3 { public Bean3() { System.out.println("Bean3 Created"); } }
【config】
package com.artisan.base.scope; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Scope; @Configuration public class Config { @Bean() public Bean2 bean2(){ return new Bean2(); } @Bean() @Scope(value = "prototype") public Bean3 bean3(){ return new Bean3(); } }
【测试bean的加载】
package com.artisan.base.scope; import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class TestScope { public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class); System.out.println("========================"); // 每次调用都会实例化一个新的Bean3+ System.out.println(ac.getBean("bean3")); System.out.println(ac.getBean("bean3")); } }
【输出】
【结论】
- 在不指定@Scope的情况下，所有的bean都是单实例的bean,而且是饿汉加载 即 容器启动实例就创建好了
- 指定@Scope为 prototype 表示为原型bean，而且还是懒汉模式加载 , 即IOC容器启动的时候，并不会创建对象，而是 在第一次使用的时候才会创建 ，并且每次调用，都会实例化一个新的对象
@Lazy
Bean的懒加载@Lazy 主要针对单实例的bean 容器启动的时候，不创建对象，在第一次使用的时候才会创建该对象 ，后续调用不会新建对象，而是从单例池中获取缓存的bean。
继续使用上面的例子 ，给Bean2 加上Lazy注解
@Bean() @Lazy public Bean2 bean2(){ return new Bean2(); }
【测试】
import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class TestScope { public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class); System.out.println(ac.getBean("bean2")); System.out.println(ac.getBean("bean2")); } }
【结果】
@Conditional 条件判断
需求： 只有容器中有bean5 才装载bean6
value 是一个class数组， 需要实现Condition 接口 ， 那我们也弄个呗
【自定义Condition 】
package com.artisan.base.condition; import org.springframework.context.annotation.Condition; import org.springframework.context.annotation.ConditionContext; import org.springframework.core.type.AnnotatedTypeMetadata; public class ArtisanCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { //判断容器中是否有Bean5 ，有的话 返回true if(context.getBeanFactory().containsBean("bean5")) { return true; } return false; } }
【config 】
package com.artisan.base.condition; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; @Configuration public class CDConfig { @Bean public Bean5 bean5(){ return new Bean5(); } // Conditional的条件返回true，才装载Bean6 @Bean @Conditional(value = ArtisanCondition.class) public Bean6 bean6(){ return new Bean6(); } }
【beans】
public class Bean5 { public Bean5() { System.out.println("Bean5 Created"); } }
public class Bean6 { public Bean6() { System.out.println("Bean6 Created"); } }
【正常情况】
package com.artisan.base.condition; import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class CDTest { public static void main(String[] args) { AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(CDConfig.class); for (String beanDefinitionName : ac.getBeanDefinitionNames()) { System.out.println(beanDefinitionName); } } }
我们看到了 CDConfig中 bean5 上标注了@Bean
现在我们把Bean5的@Bean去掉
