spring ioc学习（三）

最新推荐文章于 2023-03-03 08:59:29 发布
最新推荐文章于 2023-03-03 08:59:29 发布
阅读量120 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_whang/article/details/102315561
版权

SpringIoc注解注入Bean
构造方法注入
pom

<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>

实例对象

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                '}';
    }
}


package com.example.springboot02.class14;

import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class AnotherBean {
}


package com.example.springboot02.class14;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

}

测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);
    }

}

结果
在这里插入图片描述
set方法注入
实例对象

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;
    private AnotherBean anotherBean2;

    /**
     * set方法注入
     * @param anotherBean2
     */
    @Autowired
    public void setAnotherBean2(AnotherBean anotherBean2) {
        this.anotherBean2 = anotherBean2;
    }

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                ", anotherBean2=" + anotherBean2 +
                '}';
    }
}

测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);
    }

}

结果
在这里插入图片描述
私有方法注入

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;
    private AnotherBean anotherBean2;

    /**
     * 私有化属性注入 不需要get和set方法
     */
    @Autowired
    private AnotherBean anotherBean3;


    /**
     * set方法注入
     * @param anotherBean2
     */
    @Autowired
    public void setAnotherBean2(AnotherBean anotherBean2) {
        this.anotherBean2 = anotherBean2;
    }

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                ", anotherBean2=" + anotherBean2 +
                ", anotherBean3=" + anotherBean3 +
                '}';
    }
}

结果
在这里插入图片描述
List注入
修改实例对象属性 新增list属性

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;
    private AnotherBean anotherBean2;

    /**
     * 私有化属性注入 不需要get和set方法
     */
    @Autowired
    private AnotherBean anotherBean3;

    private List<String> stringList;

    public List<String> getStringList() {
        return stringList;
    }

    @Autowired
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    /**
     * set方法注入
     * @param anotherBean2
     */
    @Autowired
    public void setAnotherBean2(AnotherBean anotherBean2) {
        this.anotherBean2 = anotherBean2;
    }

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                ", anotherBean2=" + anotherBean2 +
                ", anotherBean3=" + anotherBean3 +
                ", stringList=" + stringList +
                '}';
    }
}

注入类

package com.example.springboot02.class14;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

    /**
     * 交给Spring管理的javabean
     * @return
     */
    @Bean
    public List<String> stringList(){
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("2222");
        return list;
    }

}

测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);

        for (String s:myBean.getStringList()){
            System.out.println("s ="+s);
        }

    }

}

结果

在这里插入图片描述
也可以使用

package com.example.springboot02.class14;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

    /**
     * 交给Spring管理的javabean
     * @return
     */
   /* @Bean
    public List<String> stringList(){
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("2222");
        return list;
    }*/
   @Bean
   public String string1(){
       return "333";
   }
   @Bean
   public String string2(){
       return "444";
   }


}

结果
在这里插入图片描述
就是说，如果定义注入的是list的话，那么spring会找到所有返回属性和list中类型一致的方法，进行注入
如果两种方式都放开执行

package com.example.springboot02.class14;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

    /**
     * 交给Spring管理的javabean
     * @return
     */
  @Bean
    public List<String> stringList(){
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("2222");
        return list;
    }
   @Bean
   public String string1(){
       return "333";
   }
   @Bean
   public String string2(){
       return "444";
   }


}

结果输出
在这里插入图片描述
如果想要指定输出的bean的话 就得设置beanid了
在这里插入图片描述
注入的地方也需要设置id
在这里插入图片描述
再执行的结果就是
在这里插入图片描述
设置list输出顺序
@Order注解 不需要从0开始，也不用设置连续的

package com.example.springboot02.class14;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

    /**
     * 交给Spring管理的javabean
     * @return
     */
 /* @Bean(value = "stringList")
    public List<String> stringList(){
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("2222");
        return list;
    }*/
   @Bean
   @Order(33)
   public String string1(){
       return "333";
   }

   @Bean
   @Order(22)
   public String string2(){
       return "444";
   }


}

结果
在这里插入图片描述

map注入
新增map属性值
set方法加@Autowired注入

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;
    private AnotherBean anotherBean2;

    /**
     * 私有化属性注入 不需要get和set方法
     */
    @Autowired
    private AnotherBean anotherBean3;

    private List<String> stringList;

    private Map<String,String> map;

    public Map<String, String> getMap() {
        return map;
    }

    @Autowired
    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public List<String> getStringList() {
        return stringList;
    }

    @Autowired
    //@Qualifier("stringList")
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    /**
     * set方法注入
     * @param anotherBean2
     */
    @Autowired
    public void setAnotherBean2(AnotherBean anotherBean2) {
        this.anotherBean2 = anotherBean2;
    }

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                ", anotherBean2=" + anotherBean2 +
                ", anotherBean3=" + anotherBean3 +
                ", stringList=" + stringList +
                '}';
    }
}

实例对象

package com.example.springboot02.class14;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:27
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class14")
public class MyConfigruation {

    /**
     * 交给Spring管理的javabean
     * @return
     */
 /* @Bean(value = "stringList")
    public List<String> stringList(){
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("2222");
        return list;
    }*/
	@Bean
    public Map<String,String> map(){
        Map<String,String> map = new HashMap<String,String>();
        map.put("111","111");
        map.put("222","222");
        return map;
    }

   @Bean
   @Order(33)
   public String string1(){
       return "333";
   }

   @Bean
   @Order(22)
   public String string2(){
       return "444";
   }


}

测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);

        for (String s:myBean.getStringList()){
            System.out.println("s ="+s);
        }

        for (Map.Entry<String,String> map:myBean.getMap().entrySet()) {
            System.out.println("map="+map);
        }

    }

}

结果如下：

在这里插入图片描述
简单类型注入
在这里插入图片描述
测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);

        for (String s:myBean.getStringList()){
            System.out.println("s ="+s);
        }

        for (Map.Entry<String,String> map:myBean.getMap().entrySet()) {
            System.out.println("map="+map);
        }
        System.out.println("string="+myBean.getString());
    }

}

结果：
在这里插入图片描述
ApplicationContext注入
新增ApplicationContext属性

package com.example.springboot02.class14;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:25
 * @Modified By:
 */
@Component
public class MyBean {

    private AnotherBean anotherBean1;
    private AnotherBean anotherBean2;

    /**
     * 私有化属性注入 不需要get和set方法
     */
    @Autowired
    private AnotherBean anotherBean3;

    private List<String> stringList;

    private Map<String,String> map;

    private String string;

    private ApplicationContext context;

    public ApplicationContext getContext() {
        return context;
    }
    @Autowired
    public void setContext(ApplicationContext context) {
        this.context = context;
    }

    public String getString() {
        return string;
    }

    @Value("555")
    public void setString(String string) {
        this.string = string;
    }

    public Map<String, String> getMap() {
        return map;
    }

    @Autowired
    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public List<String> getStringList() {
        return stringList;
    }

    @Autowired
    //@Qualifier("stringList")
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    /**
     * set方法注入
     * @param anotherBean2
     */
    @Autowired
    public void setAnotherBean2(AnotherBean anotherBean2) {
        this.anotherBean2 = anotherBean2;
    }

    /**
     * 注入实例
     * @param anotherBean1
     */
    @Autowired
    public MyBean(AnotherBean anotherBean1) {
        this.anotherBean1 = anotherBean1;
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "anotherBean1=" + anotherBean1 +
                ", anotherBean2=" + anotherBean2 +
                ", anotherBean3=" + anotherBean3 +
                ", stringList=" + stringList +
                '}';
    }
}

测试类

package com.example.springboot02.class14;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Map;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 17:28
 * @Modified By:
 */
public class class14 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(MyConfigruation.class);
        MyBean myBean=context.getBean("myBean",MyBean.class);
        System.out.println("myBean="+myBean);

        for (String s:myBean.getStringList()){
            System.out.println("s ="+s);
        }

        for (Map.Entry<String,String> map:myBean.getMap().entrySet()) {
            System.out.println("map="+map);
        }
        System.out.println("string="+myBean.getString());

        AnotherBean anotherBean=myBean.getContext().getBean("anotherBean",AnotherBean.class);

        System.out.println("anotherBean="+anotherBean);
    }

}

结果
在这里插入图片描述
通过注解设置bean作用域 使用@Scope注解
pom

<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>

实例化类

package com.example.springboot02.class15;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:44
 * @Modified By:
 */
@Component("test2")
@Scope("prototype")
public class TestBean {
}

package com.example.springboot02.class15;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:45
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class15")
public class TestConfiguration {

    @Bean(value = "test1")
    @Scope("prototype")
    public TestBean testBean(){
        return new TestBean();
    }

}

测试类

package com.example.springboot02.class15;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:48
 * @Modified By:
 */
public class Class15 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(TestConfiguration.class);
        for (int i=0;i<5;i++){
            TestBean testBean1=context.getBean("test1",TestBean.class);
            System.out.println("testBean1="+testBean1);
        }
        System.out.println("==========================");
        for (int i=0;i<5;i++){
            TestBean testBean2=context.getBean("test2",TestBean.class);
            System.out.println("testBean2="+testBean2);
        }

    }

}

结果
在这里插入图片描述
自定义作用域
新增作用域实现类

package com.example.springboot02.class15;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import org.springframework.lang.Nullable;

import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 15:23
 * @Modified By: 自定义的双利模式作用域 需要实现Scope接口 注意：import org.springframework.beans.factory.config.Scope包中的
 */
public class MyScope implements Scope {

   private Map<String,Object> map1=new ConcurrentHashMap<String,Object>();
   private Map<String,Object> map2=new ConcurrentHashMap<String,Object>();


    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        //如果map1不包含这个实例
        if(!map1.containsKey(name)){
            //我们就获取这个实例并保存
            Object o=objectFactory.getObject();
            map1.put(name,o);
            return o;
        }

        if(!map2.containsKey(name)){
            //我们就获取这个实例并保存
            Object o=objectFactory.getObject();
            map2.put(name,o);
            return o;
        }
        int i=new Random().nextInt(2);
        //随机返回一个实例
        if(i==0){
            return map1.get(name);
        }else{
            return map2.get(name);
        }

    }

    @Nullable
    @Override
    public Object remove(String name) {
        //如果map2包含这个实例 我们就要删除这个实例
        if(map2.containsKey(name)){
            Object o=map2.get(name);
            map2.remove(name);
            return o;
        }
        //如果map1包含这个实例 我们就要删除这个实例
        if(map1.containsKey(name)){
            Object o=map1.get(name);
            map1.remove(name);
            return o;
        }
        //如果都包含，我们就返回null
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable runnable) {

    }

    @Nullable
    @Override
    public Object resolveContextualObject(String name) {
        return null;
    }

    @Nullable
    @Override
    public String getConversationId() {
        return null;
    }
}

实例化对象

package com.example.springboot02.class15;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:44
 * @Modified By:
 */
@Component("test2")
@Scope("myScope")
public class TestBean {
}


package com.example.springboot02.class15;

import org.springframework.beans.factory.config.CustomScopeConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:45
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class15")
public class TestConfiguration {

    @Bean(value = "test1")
    @Scope("myScope")
    public TestBean testBean(){
        return new TestBean();
    }

    @Bean
    public MyScope myScope(){
        return new MyScope();
    }
    @Bean
    public CustomScopeConfigurer customScopeConfigurer(){
        CustomScopeConfigurer configurer=new CustomScopeConfigurer();
        configurer.addScope("myScope",myScope());
        return configurer;
    }

}

测试类

package com.example.springboot02.class15;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 18:48
 * @Modified By:
 */
public class Class15 {

    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(TestConfiguration.class);
        for (int i=0;i<5;i++){
            TestBean testBean1=context.getBean("test1",TestBean.class);
            System.out.println("testBean1="+testBean1);
        }
        System.out.println("==========================");
        for (int i=0;i<5;i++){
            TestBean testBean2=context.getBean("test2",TestBean.class);
            System.out.println("testBean2="+testBean2);
        }

    }

}

结果
在这里插入图片描述
双利模式，之会实例化两次 所以两个实例话对象的结果，也分别是2个对象

springIOC注解懒加载 使用@Lazy注解
pom

<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>

初始化类

package com.example.springboot02.class16;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:08
 * @Modified By:
 */
@Component("testBean1")
@Lazy
public class TestBean {
    public TestBean(){
        System.out.println("testBean加载");
    }
}


package com.example.springboot02.class16;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:08
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class16")
public class TestConfiguration {

    @Bean("testBean2")
    @Lazy
    public TestBean testBean(){
        return new TestBean();
    }

}

测试代码

package com.example.springboot02.class16;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:08
 * @Modified By:
 */
public class class16 {
    @Test
    public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext(TestConfiguration.class);
        System.out.println("context 已经被初始化了");
            TestBean testBean1=context.getBean("testBean1",TestBean.class);
            System.out.println("testBean1="+testBean1);
            System.out.println("==========================");
            TestBean testBean2=context.getBean("testBean2",TestBean.class);
            System.out.println("testBean2="+testBean2);

    }
}

结果
在这里插入图片描述
SpringIoc注解实现 bean的初始化和销毁
第一种方式实现： InitializingBean,DisposableBean接口
pom

<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>RELEASE</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.1.6.RELEASE</version>
		</dependency>

实例对象

package com.example.springboot02.class17;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:18
 * @Modified By:
 */
@Component("testBean")
public class TestBean implements InitializingBean,DisposableBean{

    @Override
    public void destroy() throws Exception {
        System.out.println("test.destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("test.init");

    }
}


package com.example.springboot02.class17;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:19
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class17")
public class TestConfiguration {

//    @Bean
//    public TestBean testBean(){
//        return new TestBean();
//    }

}

测试类

package com.example.springboot02.class17;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:20
 * @Modified By:
 */
public class Class17 {

    @Test
    public void test(){
        AbstractApplicationContext context=new AnnotationConfigApplicationContext(TestConfiguration.class);
        TestBean testBean=context.getBean("testBean",TestBean.class);
        System.out.println("testBean="+testBean);
        context.close();
    }
}

输出结果
在这里插入图片描述
第二种方式
使用注解：PostConstruct、PreDestroy

package com.example.springboot02.class17;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @Author: Administrator
 * @Description: PostConstruct:bean初始化的处理
 * PreDestroy：bean销毁的处理
 * @Date: 2019-10-07 19:18
 * @Modified By:
 */
@Component("testBean")
public class TestBean implements InitializingBean,DisposableBean{

    @Override
    public void destroy() throws Exception {
        System.out.println("test.destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("test.init");

    }
    @PostConstruct
    public void onInit(){
        System.out.println("testBean.onInit");
    }

    @PreDestroy
    public void onDestory(){
        System.out.println("testBean.onDesctory");
    }

}

结果
在这里插入图片描述
第三种方式

package com.example.springboot02.class17;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @Author: Administrator
 * @Description: PostConstruct:bean初始化的处理
 * PreDestroy：bean销毁的处理
 * @Date: 2019-10-07 19:18
 * @Modified By:
 */
@Component("testBean")
public class TestBean implements InitializingBean,DisposableBean{

    @Override
    public void destroy() throws Exception {
        System.out.println("test.destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("test.init");

    }
    @PostConstruct
    public void onInit(){
        System.out.println("testBean.onInit");
    }

    @PreDestroy
    public void onDestory(){
        System.out.println("testBean.onDesctory");
    }
    public void onInit1(){
        System.out.println("testBean.onInit1");
    }

    public void onDestory1(){
        System.out.println("testBean.onDesctory1");
    }

}

实例化对象

package com.example.springboot02.class17;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-10-07 19:19
 * @Modified By:
 */
@Configuration
@ComponentScan("com.example.springboot02.class17")
public class TestConfiguration {

    @Bean(initMethod = "onInit1",destroyMethod = "onDestory1")
    public TestBean testBean(){
       return new TestBean();
    }

}

结果
在这里插入图片描述
三种方式均可以实现销毁和初始化方法

智航云科技
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-Bean作用域scope详解
Lili429的博客
04-02 994
概述 Bean的作用域: 什么是作用域呢？即“scope”，在面向对象程序设计中一般指对象或变量之间的可见范围。而在Spring容器中是指其创建的Bean对象相对于其他Bean对象的请求可见范围。 Spring支持以下作用域: 基本作用域：singleton、prototype web作用域 ：request、session、global session 自定义作用域 详析 ...
spring4.3.6源代码 - beans - 编写自己的scope[CustomScopeConfigurer]
~~简~~
07-23 401
1、编写自己的scope处理器 package cn.java.demo.beantag.customscope; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.a...
Spring中Scope源码分析
jspang582的博客
03-29 2536
Scope翻译过来就是作用域的意思，是描述bean实例的bean定义中重要组成部分之一。我们平时接触最多的就是singleton（单例）和prototype（多例）。Spring给我们提供了几个内置的Scope，当内置Scope无法满足需求时，Spring框架允许我们自定义Scope。最后通过一个简单的实战案例验证效果。
【Spring6】| Bean的作用域
m0_61933976的博客
03-03 1972
【Spring6】| Bean的作用域
如何在 Spring 中自定义 scope
weixin_34363171的博客
02-14 242
大家对于 Spring 的 scope 应该都不会默认。所谓 sc...
spring IOC学习源码
02-26
当我们说"spring IOC学习源码"时，通常会关注以下几个关键部分： - **BeanDefinition**：这是Spring容器中对bean的元数据描述，包含了类名、属性值、依赖关系等信息。 - **BeanFactory**：这是Spring容器的基础接口...
学习spring ioc和aop
05-14
spring 核心功能演示项目 1. applicationContext xml方式和注解方式配置 2. pring bean循环依赖。 3. spring bean 启动顺序。 4. BeanDefinition编程式注入到容器。 5. spring aop 打印 6. spring 事务
SpringIoc三种方案
05-28
本项目学习的框架是Spring框架主要讲解的内容是mvc中的创建对象的IOC和Aop的内容案例简单适合更多的学者去学习。**在业务逻辑逻辑层 创建对象使用spring框架。spring中分为好多模块利用bean管理。在spring框架中你...
Spring核心学习IOC部分
05-11
本学习资料主要聚焦于Spring的IOC容器，特别是从最基本的BeanFactory开始，逐步深入理解如何构建一个类似Spring功能的系统。 首先，BeanFactory是Spring的最基本容器，它负责管理对象（也称为Bean）。BeanFactory...
Java-Spring-SpringIoC容器-SpringIoC的学习
最新发布
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
Spring高级注解
gdjlc的专栏
09-29 286
目录： 1、使用限定注解； 2、自定义限定注解； 3、自定义bean的生命周期； 开发环境：IntelliJ IDEA 2019.2.2 Spring Boot版本：2.1.8 新建一个名称为demo的Spring Boot项目。 一、限定注解 当存在多个同类型的bean时，可以使用Primary注解指定优先注入的bean。如果对bean的注入选择做进一步的控制，则可以使用限定注解。 限定...
Spring 自定义bean的生命周期（@Scope）
MrLee的博客
10-05 706
一，背景 Scope注解主要用于配置bean在容器中的生命周期，除了可以配置为singleton和prototype，在Web环境还可以配置为request、session等 值，表示容器会为一次请求或一个会话分配一个bean的实例。如果对bean的生命周期有特殊需求，可以使用自定义的Scope。比如实现一个bean被使用3次后，就获取新的bean实例。 二，实现 下面以Spring boo...
Spring学习笔记——Spring Scope（作用域）详解
Mr_SeaTurtle_的博客
11-03 3638
本文介绍了如何在Spring中自定义Bean的作用域，且如何在作用域内对Bean进行管理。本文分成三部分，示例（包含一个简单的代码示例），代码解析（包含类图分析）和小结。
spring2.0 自定义Scope
smile6688的专栏
01-24 605
<!--google_ad_client = "pub-6769732252051080";google_ad_width = 468;google_ad_height = 60;google_ad_format = "468x60_as";google_ad_type = "text_image";//2007-01-24: www.csdn.netgoogle_ad
Spring后处理器使用解析 -- BeanFactoryPostProcessor和BeanPostProcessor
成长之路
08-11 1737
前言 有一篇非常不错的文章：《Spring的BeanFactoryPostProcessor和BeanPostProcessor》，详细的讲解了Spring的两种处理器的用法和Spring源码实现，推荐大家阅读 目录 一. 概念 1. BeanPostProcessor 2. BeanFactoryPostProcessor 容器后处理器 3. Spring已有的...
spring自定义bean的作用域
liaomin416100569的专栏
12-14 1154
在Spring 2.0中，Spring的bean作用域机制是可以扩展的。这意味着，你不仅可以使用Spring提供的预定义bean作用域； 还可以定义自己的作用域，甚至重新定义现有的作用域（不提倡这么做，而且你不能覆盖内置的singleton和prototype作用域）。作用域由接口org.springframework.beans.factory.config.Scope定义。要将你自己的自定
Spring 配置使用 - Bean 作用域
一把空心菜
10-08 4785
基本概念Scope，也称作用域，在 Spring IoC 容器是指其创建的 Bean 对象相对于其他 Bean 对象的请求可见范围。在 Spring IoC 容器中具有以下几种作用域：基本作用域（request、prototype），Web 作用域（reqeust、session、globalsession），自定义作用域。Spring 的作用域在装配 Bean 时就必须在配置文件中指明，配置方式如
Spring: 通过注解设定Bean作用域：
Wangjalong的博客
06-05 270
在被管理的Bean上标明@Scope("") 自定义作用域： 在管理类中创建一个自定义作用域的方法并加上@Bean标签 例如： ` @Bean public MyScope myScope() { return new MyScope(); } @Bean public CustomScopeConfigurer customScopeConfigurer() { CustomScopeConfigurer customScopeConfigur
java junit 使用注解引入
huaishuming的专栏
11-17 3309
需求：单独测试一个连接，不想全部测试。那么首先想到 单元测试。 如何做呢？
spring IOC学习最佳路径
02-14
学习 Spring IOC 的最佳路径如下： 1. 了解什么是依赖注入 (Dependency Injection, DI) 以及它的优点。 2. 了解 Spring IOC 容器的工作原理。 3. 阅读 Spring 官方文档中关于 IOC 容器的章节，了解容器的组成以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值