其他分享
首页 > 其他分享> > spring之组件注解探索(ComponentScan)

spring之组件注解探索(ComponentScan)

作者:互联网

spring的组件注册相关注解探索

本文参考博客(基本摘自以下博客内容)

https://www.jianshu.com/p/81880251a700
https://www.jianshu.com/p/a00d2b43e160

本节主要内容介绍spring注解的组件注册,具体包括下面的几个注解:

1、@ComponentScan自动扫面组件

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
//可以重复使用
    @Repeatable(ComponentScans.class)
    public @interface ComponentScan {
//使用包名
        @AliasFor("basePackages")
        String[] value() default {};
        @AliasFor("value")
        String[] basePackages() default {};
//使用具体类型名称
        Class<?>[] basePackageClasses() default {};
        ....其他属性
//指定扫描的时候只需要包含哪些组件
        Filter[] includeFilters() default {};
//指定扫描的时候按照什么规则排除那些组件
        Filter[] excludeFilters() default {};
        boolean lazyInit() default false;
//过滤规则类
        @Retention(RetentionPolicy.RUNTIME)
        @Target({})
        @interface Filter {
//FilterType定义按什么过滤类型来进行过滤,
/**
FilterType.ANNOTATION:按照注解
FilterType.ASSIGNABLE_TYPE:按照给定的类型;
FilterType.ASPECTJ:使用ASPECTJ表达式
FilterType.REGEX:使用正则指定
FilterType.CUSTOM:使用自定义规则
*/
            FilterType type() default FilterType.ANNOTATION;
            @AliasFor("classes")
            Class<?>[] value() default {};
            @AliasFor("value")
            Class<?>[] classes() default {};
            String[] pattern() default {};

        }

    }
1、只包含有Controller注解bean
@ComponentScan(value="com.qiu",includeFilters = {
                @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),}
,useDefaultFilters = false)
2、排除含有controller注解的bean
@ComponentScan(value="com.qiu",excludeFilters = {
    @Filter(type=FilterType.ANNOTATION,classes={Controller.class})
})  

2、@Scope设置组件的作用域

//作用与类或者方法上
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Scope {
        @AliasFor("scopeName")
        String value() default "";
        @AliasFor("value")
        String scopeName() default "";
        ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
    }
*默认是单实例的,ConfigurableBeanFactory接口含有者两个属性
*单实例和原型实例说明:prototype:多实例的:ioc容器启动并不会去调用方法创建对象放在容器中。 
每次获取的时候才会调用方法创建对象;singleton:单实例的(默认值):ioc容器启动会调用方法创建
对象放到ioc容器中。 以后每次获取就是直接从容器(map.get())中拿
1、原型案例
@Scope("prototype")
    @Bean()
    public User user() {
        System.out.println("给容器中添加user....");
        return new User();
    }
2、测试
ConfigurableApplicationContext context2=new 
AnnotationConfigApplicationContext(ScopeConfig.class);
        //测试scope:获取容器中的bean,singleton单例时候相等,prototype时候不相等
        User user2=(User) context2.getBean("user");
        User user1=(User) context2.getBean("user");
        System.out.println(user1==user2);

3、@Lazy bean组件懒加载

1、没加注解之前主要容器启动就会实例化bean
        ConfigurableApplicationContext context2=new 
AnnotationConfigApplicationContext(ScopeConfig.class);
2、加入@Lazy后必须第一次调用的时候才会加载
User user3=(User) context2.getBean("user1");

4、@Conditional按照条件注册Bean

//作用于方法和类
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
//参数是:继承于Condition的类数组
    Class<? extends Condition>[] value();
}
//condition接口,自定义的condition类需要实现该接口
public interface Condition {
/**
     * ConditionContext:判断条件能使用的上下文(环境)
     * AnnotatedTypeMetadata:注释信息
     */
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}
1、判断是否是linux系统
public class LinuxCondition implements Condition{
    /**
     * ConditionContext:判断条件能使用的上下文(环境)
     * AnnotatedTypeMetadata:注释信息
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) 
{
        //1.能获取到ioc使用的Beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2、获取到类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3.获取到当前环境信息
        Environment environment = context.getEnvironment();
        //4.获取到bean定义的注册类信息
        BeanDefinitionRegistry registry = context.getRegistry();
        //=============这里主要是为了获取当前系统的环境变脸
        String property=environment.getProperty("os.name");
        if (property.contains("linux")) {
            return true;//放行
        }
        return false;
    }

}

2、判断是否是windows系统
public class WindowsCondition implements Condition{
    /**
     * ConditionContext:判断条件能使用的上下文(环境)
     * AnnotatedTypeMetadata:注释信息
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata)
 {
        Environment environment = context.getEnvironment();
        String property=environment.getProperty("os.name");
        if (property.contains("Windows")) {
            return true;//放行
        }
        return false;
    }
}
3、@Conditional:按照一定的逻辑进行判断,满足条件给容器注入bean
public class ConditionalConfig {
//注入windows
    @Conditional(value= {WindowsCondition.class})
    @Bean
    public User user1() {
        User user=new User();
        user.setUserName("bill");
        return user;
    }
//注入linux
    @Conditional(value= {LinuxCondition.class})
    @Bean
    public User user2() {
        User user=new User();
        user.setUserName("linus");
        return user;
    }
4、idea中更换操作系统方法:-Dos.name=linux

介绍完了条件注解在spring中的使用,在Springboot中条件注解的分类:

Class conditions:@ConditionalOnClass和@ConditionalOnMissingClass,表示类是否在类路径下的条件注解
Bean conditions:@ConditionalOnBean和@ConditionalOnMissingBean,表示Bean是否被定义的条件注解
Property conditions:@ConditionalOnProperty,使用prefix和name属性用来表示是否有值,默认的话,只要该属性存在值,且不为false,即可匹配
Resource conditions:@ConditionalOnResource表示是否存在指定的resouce的条件注解
Web application conditions:@ConditionalOnWebApplication和@ConditionalOnNotWebApplication,当项目是web项目,或者不是web项目的条件注解
SpEL expression conditions:@ConditionalOnExpression,根据SPEL表达式执行结果作为条件

5、@Import给容器中导入一个组件

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
//只有一个属性,类型数组
    Class<?>[] value();
}
1、包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)[自己写的类]
2、@Bean[导入的第三方包里面的组件或者自己写的]
3、@Import[快速给容器中导入一个组件,常用于框架中]
(1)、@Import(要导入到容器中的组件);容器中就会自动注册这个组件,id默认是全类名
(2)、ImportSelector:返回需要导入的组件的全类名数组;
(3)、ImportBeanDefinitionRegistrar:手动注册bean到容器中
4、使用Spring提供的 FactoryBean(工厂Bean);
(1)默认获取到的是工厂bean调用getObject创建的对象
1、@Import(要导入到容器中的组件)
@Import(value= {Person.class})
2、ImportSelector:返回需要导入的组件的全类名数组;
//先自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    //返回值,就是到导入到容器中的组件全类名
    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //importingClassMetadata
        //方法不要返回null值
        return new String[]{"com.huya.qiu.model.BlackPerson",
"com.huya.qiu.model.WhitePerson"};
    }
}
//然后注入
@Import(value= {MyImportSelector.class})
3、ImportBeanDefinitionRegistrar:手动注册bean到容器中
//先实现ImportBeanDefinitionRegistrar接口
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * AnnotationMetadata:当前类的注解信息
     * BeanDefinitionRegistry:BeanDefinition注册类;
     *      把所有需要添加到容器中的bean;调用
     *      BeanDefinitionRegistry.registerBeanDefinition手工注册进来
     */
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //当同时拥有下面两个注册bean时候也注册yellowPerson
        boolean definition = registry.containsBeanDefinition("com.huya.qiu.model.BlackPerson");
        boolean definition2 = registry.containsBeanDefinition("com.huya.qiu.model.WhitePerson");
        if(definition && definition2){
            //指定Bean定义信息;(Bean的类型,Bean。。。)
            RootBeanDefinition beanDefinition = new RootBeanDefinition(YellowPerson.class);
            //注册一个Bean,指定bean名
            registry.registerBeanDefinition("yellowPerson", beanDefinition);
        }
    }
}
//然后注入
@Import(value= {MyImportBeanDefinitionRegistrar.class})
1、创建一个Spring定义的FactoryBean
public class PersonFactoryBean implements FactoryBean<Person> {

    //返回一个Person对象,这个对象会添加到容器中
    public Person getObject() throws Exception {
        System.out.println("PersonFactoryBean...getObject...");
        return new Person();
    }

    public Class<?> getObjectType() {
        return Person.class;
    }

    //是单例?
    public boolean isSingleton() {
        return false;
    }

}
2、注入相应的bean
@Bean
    public PersonFactoryBean personFactoryBean(){
        return new PersonFactoryBean();
    }

标签:容器,spring,public,bean,组件,注解,ComponentScan,class
来源: https://www.cnblogs.com/clover-forever/p/15812386.html