《Spring-IOC-03》

《Spring-IOC-03》

注解的使用

注解	作用
@PostConstuct（方法上）	指定为初始化方法 ，容器初始化完成时候的回调方法
@PreDestroy（方法上）	指定销毁方法，容器初始化销毁之前的回调方法
@DependsOn（方法/类上）	用于指定初始化和销毁顺序
@Import（java配置类上）	引入资源
@Lazy(类上，方法上)	延迟加载
@Conditional(类上，方法上)	判断是否注册此类对象
@Scope（类上，方法上）	作用域
@Profie（类上，方法上）	实际上也是Conditional的一种实现

周期控制注解

//java配置类
@Configuration
public class JavaConfig {

	//指定为初始化方法
    @PostConstruct
    public void func1(){
        System.out.println("post");
    }

	//指定销毁方法
    @PreDestroy
    public void func2(){
        System.out.println("pre");
    }


    @Bean
    @DependsOn("U1") //U1的实例化顺序比a1要优先
    public Animal a1(){
        return  new Animal();
    }
    @Bean("U1")
    public User user(){
        return  new User();
    }

	 public static void main(String[] args) {
        ApplicationContext app = new AnnotationConfigApplicationContext(javaConfig.class);
        //运行  我们控制台的结果为
        /*
        post
		user...
		animal...
        */
    }
}
pojo类
@Component
public class User{
	public User(){
        System.out.println("user...");
    }
}
@Component
public class Animal{
	public Animal(){
        System.out.println("animal...");
    }
}

@Lazy 延迟加载

@Component
@Lazy
public class Animal {
    public Animal() {
        System.out.println("animal...");
    }
}
public class Test(){
public  void func1(){
        ApplicationContext app = new AnnotationConfigApplicationContext(Beanconfig.class);
        System.out.println("初始化啦");
        Animal bean = app.getBean(Animal.class); //验证@Lazy 
        //控制器首先打印的是“初始化啦” 走到Animal bean = app.getBean(Animal.class);这一步 
        //才打印animal...  使用到时候才加载

    }
}

@Import 引入资源

//1.直接在java配置类上引用资源
@Configuration
@Import(Animal.class)
public class JavaConfig {

}
//2.动态使用ImportSelector
//通过实现ImportSelector类 重写selectImports方法
public class ImportSelectorDemo implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {

        //在此处实现不同的业务逻辑控制然后返回我们需要的string[]
        return new String[]{Animal.class.getName()};
    }
}
//然后在java配置类中引用
@Configuration
@Import(ImportSelectorDemo .class)
public class JavaConfig {
	//这样我们就能可以使用Animal
}


//3.ImportBeanDefinitionRegistrar 
public class ImportBeanDefinitionRegistrarDemo implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        //需要把将要添加的对象包装成一个RootBeanDefinition对象
        RootBeanDefinition animal= new RootBeanDefinition(Animal.class);
        beanDefinitionRegistry.registerBeanDefinition("animal",animal);

    }
}
//然后在java配置类中引用
@Configuration
@Import(ImportBeanDefinitionRegistrarDemo .class)
public class JavaConfig {
	//这样我们就能可以使用Animal
}

@Scope

@Component
@Scope(value = "prototype")//作用域是prototype 原型 相当于new 出来 始于创建  亡于垃圾回收
//@Scope(value = "singleton") //作用域可以是单例  始于容器初始化   亡于容器销毁
//作用域还有request 和 session								
public class Animal {
    
}

@Conditional 判断是否注册bean

public class ConditionalDemo implements Condition {
	//实现Condition接口
    /**
     * true为表示IOC容器加载该类型
     *false表示不加载该类型
     * @param conditionContext
     * @param annotatedTypeMetadata
     * @return
     */
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return true;
    }
}

@Configuration
public class BeanconfigCondition {

    @Bean
    @Conditional(ConditionalDemo .class)
    public Animal bbbbanimal(){ //容器注册本个bean 名字为bbbbanimal
        return new Animal();

    }
}
//我们return的true测试bbbbanimal是否存在
 @Test
 public void function(){
        ApplicationContext app = new AnnotationConfigApplicationContext(Beanconfig2.class);
        String[] beanDefinitionNames = app.getBeanDefinitionNames();
        for (String s : beanDefinitionNames){
            System.out.println(s);
 }
        //System.out.println(app.getBean("animal"));
  
//控制台
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
beanconfigCondition
bbbbanimal

@Profile

//pojo类
public class Animal(){
	private String name ;
	public Animal(String name){
  		this.name = name;
 	}
}
@Configuration
public class javaConfig {

    @Bean
    @Profile("animal")//本质上就是conditional的一种实现
    public Animal animal(){
        Animal animal= new Animal ("马");
        return animal;

    }

    public static void main(String[] args) {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext();
        app.getEnvironment().setActiveProfiles("animal");
        app.register(javaConfig.class);
        app.refresh();
        System.out.println(app.getBean(Animal.class));
    }
    //这样可以得到我们animal实例的信息

}