Spring 注解开发之注册组件

最新推荐文章于 2024-01-20 07:18:07 发布

深蓝海威

最新推荐文章于 2024-01-20 07:18:07 发布

阅读量262

点赞数

分类专栏： java 文章标签： spring注解开发 spring组件 spring

本文链接：https://blog.csdn.net/Mokyskury/article/details/89925121

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Spring 注解开发之注册组件

文章目录

Spring 注解开发之注册组件

1、@Configuration & @Bean

Spring xml配置（在resources目录下配置一个beans.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <bean id="person" class="com.atguigu.bean.Person">
        <property name="age" value="18"></property>
        <property name="name" value="zhangsan"></property>
    </bean>

</beans>

调用方法：

public class MainTest {

    public static void main(String[] args) {
        //类路径下读取xml配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //读取容器中id为person的组件
        Person bean = (Person) applicationContext.getBean("person");
        System.out.println(bean);

    }
}

Spring 注解配置

创建一个配置类(创建MainConfig配置类)


@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
    //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id，但如果@Bean后面加了值，则id为@Bean的value值
    @Bean("person")
    public Person person01(){
        return new Person("lisi", 20);
    }
}

调用方法：


public class MainTest {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        //读取注解配置信息
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
        //通过类型获取bean
        Person bean = applicationContext.getBean(Person.class);
        System.out.println(bean);

        //通过类型获取所有bean的id
        String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
        for (String name : namesForType) {
            System.out.println(name);
        }

    }

}

2、@ComponentScan

Spring xml配置（在resources目录下配置一个beans.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">


    <!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component -->
    <!-- use-default-filters 默认的过滤规则是扫描所有，如果需要只包含，则需要禁用默认过滤规则 -->
    <context:component-scan base-package="com.atguigu" use-default-filters="false"></context:component-scan>

</beans>

spring 注解配置

//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
@ComponentScans(
    value = {
        @ComponentScan(value="com.atguigu",includeFilters = {
            /*                @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                              @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/              
            @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
        },useDefaultFilters = false)   
    }
)
//@ComponentScan  value:指定要扫描的包
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
//FilterType.ASPECTJ：使用ASPECTJ表达式
//FilterType.REGEX：使用正则指定
//FilterType.CUSTOM：使用自定义规则
//use-default-filters 默认的过滤规则是扫描所有，如果需要只包含，则需要禁用默认过滤规则
public class MainConfig {

    //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean("person")
    public Person person01(){
        return new Person("lisi", 20);
    }

}

public class MyTypeFilter implements TypeFilter {

    /**
                * metadataReader：读取到的当前正在扫描的类的信息
                * metadataReaderFactory:可以获取到其他任何类信息的
                * 自定义规则需实现TypeFilter接口，return true表示加入容器，false则禁止
                */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
        throws IOException {
        // TODO Auto-generated method stub
        //获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类资源（类的路径）
        Resource resource = metadataReader.getResource();

        String className = classMetadata.getClassName();
        System.out.println("--->"+className);
        if(className.contains("er")){
            return true;
        }
        return false;
    }

}

3、@Scope & @Lazy

Spring 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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">


    <bean id="person" class="com.atguigu.bean.Person"  scope="prototype" lazy-init="true">
        <property name="age" value="18"></property>
        <property name="name" value="zhangsan"></property>
    </bean>


</beans>

Spring 注解配置：

@Configuration
public class MainConfig2 {

    //默认是单实例的
    /**
            * ConfigurableBeanFactory#SCOPE_PROTOTYPE    
            * @see ConfigurableBeanFactory#SCOPE_SINGLETON  
            * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request
            * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION     sesssion
            * @return\
            * @Scope:调整作用域
            * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
            *                 每次获取的时候才会调用方法创建对象；
            * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
            *           以后每次获取就是直接从容器（map.get()）中拿，
            * request：同一次请求创建一个实例
            * session：同一个session创建一个实例
            * 
            * 懒加载：
            *        单实例bean：默认在容器启动的时候创建对象；
            *        懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
            * 
            */
    // @Scope("prototype")
    @Lazy
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加Person....");
        return new Person("张三", 25);
    }

}

4、@Conditional

Spring 注解配置：

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
@Conditional({WindowsCondition.class})
@Configuration          
public class MainConfig2 {

    /**
                * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
                * 
                * 如果系统是windows，给容器中注册("bill")
                * 如果是linux系统，给容器中注册("linus")
                */

    @Bean("bill")
    @Conditional({WindowsCondition.class})
    public Person person01(){
        return new Person("Bill Gates",62);
    }

    @Conditional(LinuxCondition.class)
    @Bean("linus")
    public Person person02(){
        return new Person("linus", 48);
    }
}

//判断是否windows系统
public class WindowsCondition implements Condition {

    @Override
    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;
    }

}

//判断是否linux系统
public class LinuxCondition implements Condition {

    /**
                * ConditionContext：判断条件能使用的上下文（环境）
                * AnnotatedTypeMetadata：注释信息
                */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // TODO是否linux系统
        //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");

        //可以判断容器中的bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        if(property.contains("linux")){
            return true;
        }

        return false;
    }

}

调用方法：

        @Test
        public void test03(){
           AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
           String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
           ConfigurableEnvironment environment = applicationContext.getEnvironment();
           //动态获取环境变量的值；Windows 10
           String property = environment.getProperty("os.name");
           System.out.println(property);
           for (String name : namesForType) {
              System.out.println(name);
           }

           Map<String, Person> persons = applicationContext.getBeansOfType(Person.class);
           System.out.println(persons);

        }

5、@Import

spring 注解配置：

@Configuration
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
	
	/**
	 * 给容器中注册组件；
	 * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
	 * 2）、@Bean[导入的第三方包里面的组件]
	 * 3）、@Import[快速给容器中导入一个组件]
	 * 		1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
	 * 		2）、ImportSelector:返回需要导入的组件的全类名数组；
	 * 		3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
	 * 4）、使用Spring提供的 FactoryBean（工厂Bean）;
	 * 		1）、默认获取到的是工厂bean调用getObject创建的对象
	 * 		2）、要获取工厂Bean本身，我们需要给id前面加一个&
	 * 			&colorFactoryBean
	 */	
    @Bean
	public ColorFactoryBean colorFactoryBean(){
		return new ColorFactoryBean();
	}

}

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

	//返回值，就是到导入到容器中的组件全类名
	//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		// TODO Auto-generated method stub
		//importingClassMetadata
		//方法不要返回null值，否则会报空指针异常
		return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
	}

}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * AnnotationMetadata：当前类的注解信息
	 * BeanDefinitionRegistry:BeanDefinition注册类；
	 * 		把所有需要添加到容器中的bean；调用
	 * 		BeanDefinitionRegistry.registerBeanDefinition手工注册进来
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		
		boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
		boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
		if(definition && definition2){
			//指定Bean定义信息；（Bean的类型，Bean。。。）
			RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
			//注册一个Bean，指定bean名
			registry.registerBeanDefinition("rainBow", beanDefinition);
		}
	}

}

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

	//返回一个Color对象，这个对象会添加到容器中
	@Override
	public Color getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("ColorFactoryBean...getObject...");
		return new Color();
	}

	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Color.class;
	}

	//是单例？
	//true：这个bean是单实例，在容器中保存一份
	//false：多实例，每次获取都会创建一个新的bean；
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}

}

调用方法：

	@Test
	public void testImport(){
		printBeans(applicationContext);
		Blue bean = applicationContext.getBean(Blue.class);
		System.out.println(bean);

		//工厂Bean获取的是调用getObject创建的对象
		Object bean2 = applicationContext.getBean("colorFactoryBean");
		Object bean3 = applicationContext.getBean("colorFactoryBean");
		System.out.println("bean的类型："+bean2.getClass());
		System.out.println(bean2 == bean3);

		//通过添加‘&’,可以获取FactoryBean本身
		Object bean4 = applicationContext.getBean("&colorFactoryBean");
		System.out.println(bean4.getClass());

深蓝海威

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring 注解开发之注册组件

Spring 注解开发之注册组件文章目录Spring 注解开发之注册组件1、@Configuration & @BeanSpring xml配置（在resources目录下配置一个beans.xml）：**调用方法：**Spring 注解配置创建一个配置类(创建MainConfig配置类)调用方法：2、@ComponentScanSpring xml配置（在resources目录下配置一...
复制链接

扫一扫