Spring开发2 spring基础及组件使用2(conditional,import,factorybean)

JDO  java data object  99-03年 

注解：

• 声明配置类 bean 早期从xml解析 配置类
• @configuration  相当于 配置文件

扫描的注解： @controller  @Service @Respostry @Component

if(useDefaultFilters){

registerDefaultFilters();

}

this.includeFilters.add(new AnnotationTypeFilter(Componet.class))

以@Component--->

com.enjoy.cpa2

@Controller

@Component

@Service

IOC就是对我们Bean进行管理：bean 注册 实例化 管理

@Conditional条件注册bean

根据指定条件选择性地注册bean实例

package com.enjoy.cap5.config;


import com.enjoy.cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class Cap5MainConfig {

    @Bean("person")  // Bean的id 不设置id的时候，默认取的是方法名
    public Person person(){
        System.out.println("给容器中添加person....");
        return new Person("person", 20);
    }

    @Bean("lison")
    public Person lison(){
        System.out.println("给容器中添加lison....");
        return new Person("Lison", 20);
    }

    @Bean("james")  // bean在容器中的ID为james，IOC容器MAP  map.put("id", value);
    public Person james(){
        System.out.println("给容器中添加james....");
        return new Person("james", 20);
    }

    // 创建的时候就会把bean map.put到容器当中

}

import com.enjoy.cap5.config.Cap5MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap5Test {

    @Test
    public void test01(){
        // 创建容器将bean加载进来
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap5MainConfig.class);

        System.out.println("IOC容器创建完成........");

    }
}

需求：测试运行时候，如果操作系统是windows，就让Lison这个对象实例化到容器中，如果是LINUX，就是让james实例化到容器中。

实现条件

beanFactory

FactoryBean  和 BeanFactory 的区别：

• FactoryBean：可以把java实例bean通过FactoryBean注入到容器中
• BeanFactory：从容器中获取实例化后的bean

package com.enjoy.cap5.config;


import com.enjoy.cap1.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;


@Configuration
public class Cap5MainConfig {

    @Bean("person")  // Bean的id 不设置id的时候，默认取的是方法名
    public Person person(){
        System.out.println("给容器中添加person....");
        return new Person("person", 20);
    }

    @Conditional(WinCondition.class)
    @Bean("lison")
    public Person lison(){
        System.out.println("给容器中添加lison....");
        return new Person("Lison", 20);
    }

    @Conditional(LinCondition.class)
    @Bean("james")  // bean在容器中的ID为james，IOC容器MAP  map.put("id", value);
    public Person james(){
        System.out.println("给容器中添加james....");
        return new Person("james", 20);
    }

    // 创建的时候就会把bean map.put到容器当中

}

package com.enjoy.cap5.config;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class LinCondition implements Condition {
    /**
     * ConditionContext：判断条件可以使用的上下文（环境）
     * AnnotatedTypeMetadata：注解的信息
     * */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // TODO >> 是否为Windows
        // 能够获取到IOC容器正在使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        // 获取当前环境变量（包括当前操作系统是win还是linux）
        Environment environment = conditionContext.getEnvironment();
        String os_name = environment.getProperty("os.name");
        System.out.println(os_name);

        if(os_name.contains("linux")){
            return true;
        }
        return false;  // 返回false不起任何作用
    }
}

package com.enjoy.cap5.config;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class WinCondition implements Condition {
    /**
     * ConditionContext：判断条件可以使用的上下文（环境）
     * AnnotatedTypeMetadata：注解的信息
     * */
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // TODO >> 是否为Windows
        // 能够获取到IOC容器正在使用的beanFactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        // 获取当前环境变量（包括当前操作系统是win还是linux）
        Environment environment = conditionContext.getEnvironment();
        String os_name = environment.getProperty("os.name");
        System.out.println(os_name);

        if(os_name.contains("Windows")){
            return true;
        }
        return false;  // 返回false不起任何作用
    }
}

Mac OS X
Mac OS X
给容器中添加person....
IOC容器创建完成........

@Import注册bean

1，手动添加组件到IOC容器;

2，使用ImportSelector自定义返回组件

3, 使用ImportBeanDefinitionRegistrar返回自定义组件

package com.enjoy.cap6.config;


import com.enjoy.cap1.Person;
import com.enjoy.cap6.bean.Cat;
import com.enjoy.cap6.bean.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;


@Configuration
@Import(value={Dog.class, Cat.class, JamesImportSelector.class})  // 相当与new一个对象放到容器中

public class Cap6MainConfig {

   /**
    * 给我们容器中注册组件：
    * 1.@Bean：[导入第三方的类或包的组件]，比如person为第三方的类，需要再IOC容器中使用
    * 2.包扫描+组件的标注注解（@ComponentScan：@controller @Service @Component）,一般是针对自己写的类。使用这个
    * 3.@import:[快速给容器导入一个组件]  注意：@Bean有点简单
    *      a. @Import(要导入到容器中的组件)：容器会自动注册这个组件，bean的id为全类名（路径+id）
    *      b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
    */
    // 容器启动时初始化person的bean实例
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加person....");
        return new Person("person", 20);
    }

}

package com.enjoy.cap6.config;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class JamesImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 返回全类名的bean
        return new String[]{"com.enjoy.cap6.bean.Fish", "com.enjoy.cap6.bean.Tiger"};
    }
}

import com.enjoy.cap6.config.Cap6MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap6Test {

    @Test
    public void test01(){
        // 创建容器将bean加载进来
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap6MainConfig.class);

        System.out.println("IOC容器创建完成........");
        String[] beanDefinitionNames = app.getBeanDefinitionNames();

        for(String name: beanDefinitionNames){
            System.out.println(name);
        }

    }
}

给容器中添加person....
IOC容器创建完成........
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
cap6MainConfig
com.enjoy.cap6.bean.Dog
com.enjoy.cap6.bean.Cat
com.enjoy.cap6.bean.Fish
com.enjoy.cap6.bean.Tiger
person

/**
 * 给我们容器中注册组件：
 * 1.@Bean：[导入第三方的类或包的组件]，比如person为第三方的类，需要再IOC容器中使用
 * 2.包扫描+组件的标注注解（@ComponentScan：@controller @Service @Component）,一般是针对自己写的类。使用这个
 * 3.@import:[快速给容器导入一个组件]  注意：@Bean有点简单
 *      a. @Import(要导入到容器中的组件)：容器会自动注册这个组件，bean的id为全类名（路径+id）
 *      b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
 *      c. ImportBeanDefinitionRegistrar：可以手动天剑组件到IOC容器，所有Bean的注册可以使用BeanDefinitionRegistry
 * 4.使用Spring提供的FactoryBean（工厂bean）进行注册:把bean注入到容器中
 */

package com.enjoy.cap6.config;


import com.enjoy.cap1.Person;
import com.enjoy.cap6.bean.Cat;
import com.enjoy.cap6.bean.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;


@Configuration
@Import(value={Dog.class, Cat.class, JamesImportSelector.class})  // 相当与new一个对象放到容器中

public class Cap6MainConfig {

   /**
    * 给我们容器中注册组件：
    * 1.@Bean：[导入第三方的类或包的组件]，比如person为第三方的类，需要再IOC容器中使用
    * 2.包扫描+组件的标注注解（@ComponentScan：@controller @Service @Component）,一般是针对自己写的类。使用这个
    * 3.@import:[快速给容器导入一个组件]  注意：@Bean有点简单
    *      a. @Import(要导入到容器中的组件)：容器会自动注册这个组件，bean的id为全类名（路径+id）
    *      b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
    *      c. ImportBeanDefinitionRegistrar：可以手动天剑组件到IOC容器，所有Bean的注册可以使用BeanDefinitionRegistry
    */
    // 容器启动时初始化person的bean实例
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加person....");
        return new Person("person", 20);
    }

}

package com.enjoy.cap6.config;

import com.enjoy.cap6.bean.Pig;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class JamesImportBeanfinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * AnnotationMetadata:当前类的注解信息
     * BeanDefinitionRegistry：BeanDefinition注册类
     *    把所有需要添加到容器中的bean加入；
     *
     **/
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {

        // 面试官：当容器中存在cat dog 才往容器中添加pig

        // 判断bean是否存在
        boolean beanDog = beanDefinitionRegistry.containsBeanDefinition("com.enjoy.cap6.bean.Dog");
        boolean beanCat = beanDefinitionRegistry.containsBeanDefinition("com.enjoy.cap6.bean.Cat");

        //对于我们要注册的bean，给bean进行封装     RootBeanDefinition

        // 如果dog和cat同时存在ioc容器中，那么创建pig类加入到容器当中。
        if(beanCat && beanDog){
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Pig.class);  // 特有的容器封装
            beanDefinitionRegistry.registerBeanDefinition("Pig", beanDefinition);
        }
    }
}

Error:(30, 49) java: 无法访问java.util.function.Supplier
找不到java.util.function.Supplier的类文件

java编译环境出错 打开File--->Projrct Struct 设置JDK版本解决

Factorybean接口实现

1，getObject()返回对象方法;

2，getObjectType返回对象类型

3, isSingleton()是否单例控制

package com.enjoy.cap6.config;

import com.enjoy.cap6.bean.Monkey;
import org.springframework.beans.factory.FactoryBean;

public class JamesFactoryBean implements FactoryBean<Monkey> {
    @Override
    public Monkey getObject() throws Exception {
        return new Monkey();
    }

    @Override
    public Class<?> getObjectType() {
        return Monkey.class;
    }

    // 是否单例模式  true 单实例    false 多实例
    @Override
    public boolean isSingleton() {
        return false;
    }
}

package com.enjoy.cap6.config;

import com.enjoy.cap1.Person;
import com.enjoy.cap6.bean.Cat;
import com.enjoy.cap6.bean.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(value={Dog.class, Cat.class, JamesImportSelector.class, JamesImportBeanDefinitionRegistrar.class})  // 相当与new一个对象放到容器中

public class Cap6MainConfig {

   /**
    * 给我们容器中注册组件：
    * 1.@Bean：[导入第三方的类或包的组件]，比如person为第三方的类，需要再IOC容器中使用
    * 2.包扫描+组件的标注注解（@ComponentScan：@controller @Service @Component）,一般是针对自己写的类。使用这个
    * 3.@import:[快速给容器导入一个组件]  注意：@Bean有点简单
    *      a. @Import(要导入到容器中的组件)：容器会自动注册这个组件，bean的id为全类名（路径+id）
    *      b. ImportSelector:是一个接口，返回需要导入到容器的组件的全类名数组
    *      c. ImportBeanDefinitionRegistrar：可以手动天剑组件到IOC容器，所有Bean的注册可以使用BeanDefinitionRegistry
    * 4.使用Spring提供的FactoryBean（工厂bean）进行注册:把bean注入到容器中
    */
    // 容器启动时初始化person的bean实例
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加person....");
        return new Person("person", 20);
    }

    @Bean
    public JamesFactoryBean jamesFactoryBean(){
        return new JamesFactoryBean();
    }

}

import com.enjoy.cap6.config.Cap6MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Cap6Test {

    @Test
    public void test01(){
        // 创建容器将bean加载进来
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap6MainConfig.class);

        System.out.println("IOC容器创建完成........");
        String[] beanDefinitionNames = app.getBeanDefinitionNames();

        for(String name: beanDefinitionNames){
            System.out.println(name);
        }

        Object bean1 = app.getBean("jamesFactoryBean");
        System.out.println("bean的类型="+bean1.getClass());
    }
}

生命周期-初始化与销毁

如何定义和销毁3种方式;

• 1, 指定初始化和销毁方法
• 2，让Bean实现 InitializingBean(定义初始化逻辑)
• 3, 使用JSR250规则定义的两个注解来实现