1.配置类
使用配置文件的形式代替配置类
2.包扫描注解
- xml配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!--包扫描，只要标注了@Controller，@Service,@Repository,@Component --> <!--<context:component-scan base-package="com.tarot"></context:component-scan>--> <bean id="person" class="com.tarot.bean.Person"> <property name="age" value="18"></property> <property name="name" value="tarot"></property> </bean> </beans> - 配置类
- @Configuration：告诉spring这是一个配置类
- @ComponentScan(value = "url")：指定扫描包的路径,ComponentScan在java1.8后为可重复拒接，即可以多次使用定义扫描策略
- 配置属性excludeFilters
excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})}- 该属性指排除那些注解下的bean被扫描到。
其中：FilterType指使用哪种策略
- 该属性指排除那些注解下的bean被扫描到。
- 配置属性includeFilters
includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})}- 该属性指包括那些注解下的bean被扫描到。
- 该属性与配置属性useDefaultFilters配合使用
- 配置属性useDefaultFilters
- useDefaultFilters是值是否使用默认配置，默认值为true,当指定扫描固定注解的bean扫描时，要关闭默认全部bean扫描。
3.指定扫描规则：Filter的扫描规则
- FilterType.ANNOTATION：默认扫描规则，按照注解的方式
@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class}) - FilterType.ASSIGNABLE_TYPE：按照给定的类型
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,classes = {BookService.class}) - FilterType.ASPECTJ:使用ASPECTJ表达式
- FilterType.REGEX：使用正则表达式
- FilterType.CUSTOM：自定义规则
@ComponentScan.Filter(type = FilterType.CUSTOM,classes = {CustomTypeFilter.class})- 使用自定义规则，需要编写自定义配置类，该类实现接口FilterType
/** * 自定义扫描规则 * 由于： * @ComponentScan(value = "com.tarot", * includeFilters = { * @ComponentScan.Filter(type = FilterType.CUSTOM,classes = {CustomTypeFilter.class}) * }, * useDefaultFilters = false * ) * value配置的路径是：com.tarot，所以所有的该路径下的类都会去匹配该自定义包扫描规则 * @ClassPath: com.tarot.config.CustomTypeFilter * @Author: ZhaoHeJia * @Date: 2018/12/24 11:22 */ public class CustomTypeFilter implements TypeFilter { /** * * @param metadataReader 读取到当前正在扫描的类的信息 * @param metadataReaderFactory 读取其他类信息 * @return 比对结果boolean * @throws IOException io异常 */ @Override public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { //获取当前类注解的信息 AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); //获取当前正在扫描的类的信息 ClassMetadata classMetadata = metadataReader.getClassMetadata(); //获取当前类资源(类路径) Resource resource = metadataReader.getResource(); String className = classMetadata.getClassName(); //自定义扫描规则 if (className.contains("service")){ return true; } return false; } }
4.配置Bean组件
- @Bean注解：往容器中注册bean
@Bean public Person person(){ return new Person("22","zhj"); }- 给容器注册一个Bean,类型为返回值类型,id为方法名。即返回值Person相当于xml文件的class属性,方法名相当于xml文件的id属性
5.@Scope注解(Bean的作用域)
- @Scope注解：bean的作用域,默认为singleton
- 取值：
- SINGLETON：单实例，当ioc容器启动时会创建该方法的实例，加入到ioc容器中，之后直接调用
当一个bean的 作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把 一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都 将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中 只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时 候，spring的IOC容器中只会存在一个该bean。
- PROTOTYPE：多实例，ioc实例启动并不创建实例，每次获取该实例对象时才会ioc才会创建该实例
prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例，相当与一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用
- REQUEST：同一次请求创建一个实例，web环境
request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
- SESSION：同一个session创建一个实例，web环境
session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
- ps:spring中scope作用域
6.@Lazy注解(懒加载)
- 在单实例的情况下
- 在容器启动的时候并不创建对象，而是在第一次使用(获取)Bean对象时创建。
7.@Conditional注解(在一定条件下创建bean)
- 可以注解在配置类和bean上
- 只在一定条件下该bean生效
- @Conditional的配置属性value可以是一个类，该类逻辑判断由实现Condition接口完成。
- 当不同操作系统注入不同的bean
@Configuration public class MainConfig2 { /** * 在windows操作系统下该bean注册生效 * @return bean类型 */ @Conditional(value = WindowCondition.class) @Bean("window") public Person person01(){ return new Person("1111","win"); } /*** * 在linux操作系统下该bean生效 * @return bean类型 */ @Conditional(value = LinuxCondition.class) @Bean("linux") public Person person02(){ return new Person("0000","lnx"); } }- 编写Condition注解的条件
public class WindowCondition implements Condition { /** * * @param context 判断条件的上下文对象 * @param metadata 当前标注了condition的注释信息 * @return */ @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { //获取ioc使用的beanFactory ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); //获取类加载器 ClassLoader classLoader = context.getClassLoader(); //获取当前环境信息 Environment environment = context.getEnvironment(); //获取bean注册的注册类 BeanDefinitionRegistry registry = context.getRegistry(); //获取当前操作系统类型信息 String property = environment.getProperty("os.name"); //忽略大小写 if(property.toLowerCase().contains("window")){ return true; } return false; } }public class LinuxCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { Environment environment = context.getEnvironment(); String property = environment.getProperty("os.name"); if (property.toLowerCase().contains("linux")){ return true; } return false; } }- 测试
public class IOCTest { @Test @SuppressWarnings("resource") public void test03(){ //获取使用注解配置的bean AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class); //获取当前的运行环境 ConfigurableEnvironment environment = applicationContext.getEnvironment(); String property = environment.getProperty("os.name"); System.out.println("当前操作系统："+property); //根据类型获取ioc注册的bean，由于注册的name="linux"的bean生效为linux系统，故此时并没有注册 String[] names = applicationContext.getBeanNamesForType(Person.class); for (String name:names){ System.out.println("注册bean："+name); } //以map形式获取bean信息 Map<String, Person> beansOfType = applicationContext.getBeansOfType(Person.class); System.out.println(beansOfType); } }-
测试结果
测试window操作系统结果 -
修改运行配置
修改当前操作系统名为linux -
测试结果
测试inux下结果
8.@import注解
- 给容器中注入bean的方式
- 包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)
- 使用Bean(导入第三方包里面的组件)
- 使用@Import方式(快速导入)
- 使用Spring提供的FactoryBean(工厂Bean)
- 导入组件，id默认为全类名
@Import(value = {bean1.class,bean2.class}) - 实现ImportSelector接口方法导入多个：返回需要导入的租金按的全类名数组
- 导入组件
@Import(value = {Black.class,CustomImportSelector.class}) public class MainConfig2 {}- 实现ImportSelector接口方法
public class CustomImportSelector implements ImportSelector { /** * * @param importingClassMetadata：当前标注@import注解的类的所有注解信息 * @return 导入到容器的组件全类名 */ @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { //返回值不能为null,可返回空数组new String[]{} return new String[]{"com.tarot.bean.Red","com.tarot.bean.Yellow"}; } } - 实现ImportBeanDefinitionRegistrar接口,使用手工注册的方式注册
- 导入组件
@Import(value = {Black.class,CustomImportSelector.class,CustomImportBeanDefinitionRegistrar.class}) public class MainConfig2 {} - 实现ImportBeanDefinitionRegistrar接口方法
public class CustomImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { /** * * @param importingClassMetadata:当前标注@import注解的类的所有注解信息 * @param registry bean注册类 * 把所有需要添加到容器中的bean,通过BeanDefinitionRegistry.registerBeanDefinition方法手工注册 */ @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //判断容器中是否有该bean boolean black = registry.containsBeanDefinition("com.tarot.bean.Black"); if(black){ //指定Bean定义信息：(Bean的类型...) RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Blue.class); //指定bean名 registry.registerBeanDefinition("Blue",rootBeanDefinition); } } }
- 导入组件
9.使用Spring提供的FactoryBean(工厂Bean)
- 实现FactoryBean<T>接口，其中T为Bean,默认实现的类的类型为Bean(T)的类型，由工厂
整合其他框架，spring内部广泛使用 - FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&
- 一般情况下，Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。
- 编写一个FactoryBean的实现类，实现T为普通Bean(Black).注入到容器中。
- 编写Black的实现类
public class CustomColorFactoryBean implements FactoryBean<Black> { /** * * @return 返回Black对象 * @throws Exception */ @Override public Black getObject() throws Exception { System.out.println("into factory bean..."); return new Black(); } /** * * @return 对象的类型 */ @Override public Class<?> getObjectType() { return Black.class; } /** * 判断是否是单例 * @return true:单实例，容器保存一份；false:每次获取都创建一个新的Bean */ @Override public boolean isSingleton() { return true; } }- 注入CustomColorFactoryBean,获取该Bean类型默认为Black
@Bean public CustomColorFactoryBean customColorFactoryBean(){ return new CustomColorFactoryBean(); }
ps：BeanFactory 简介以及它 和FactoryBean的区别
10.Bean的生命周期
- Bean的生命周期：Bean创建---初始化---销毁 过程
- ioc容器管理bean的生命周期，我们可以自定义初始化和销毁方法：即容器在bean进行到当前生命周期时调用我们自定义的初始化和销毁方法。
- 构造(创建对象)
- 单实例：在容器启动的时候创建对象
- 多实例：在每次获取的时候创建对象，并初始化
- 初始化：单实例，对象创建完，赋值后，调用初始化方法
- 销毁：
- 单实例：当ioc容器关闭时，bean销毁
- 多实例：容器不会管理bean，容器不会调用销毁方法。
- 调用自定义初始化和销毁方法
- 使用注解属性的方式指定哪个方法为该初始化和销毁方法。
@Bean(initMethod = "init",destroyMethod = "destroy")- 通过Bean实现接口InitializingBean(定义初始化)
- 通过Bean实现接口DisposableBean(销毁)
public class BeanLiftCycle2 implements InitializingBean, DisposableBean { public BeanLiftCycle2(){ System.out.println("bean2 constructor..."); } @Override public void afterPropertiesSet() throws Exception { System.out.println("bean2 init..."); } @Override public void destroy() throws Exception { System.out.println("bean2 destroy..."); } }- 使用JSR250规范注解,作用到bean的方法上
@PostConstruct:在bean创建完成后并属性赋值，执行初始化。
@PreDestroy:在容器销毁bean前通知清理工作。 - 使用bean的后置处理器：实现BeanPostProcessor接口
其中方法：- postProcessBeforeInitialization：在初始化工作前调用
- postProcessAfterInitialization：在初始化工作后调用
@Component public class CustomBeanPostProcessor implements BeanPostProcessor{ @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("bean后置处理器--初始化前调用方法"+beanName+"--->"+bean); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("bean后置处理器--初始化后调用方法"+beanName+"--->"+bean); return bean; } }
