码迷，mamicode.com
首页 > 编程语言 > 详细

Spring入门之五-------SpringIoC之通过注解实现

时间：2018-12-02 20:37:29      阅读：184      评论：0      收藏：0      [点我收藏+]

标签：his   设定   bbb   prot   not   允许   out   imp   加载模式   

一、准备工作

创建一个Class注解@Configuration，如下例子：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

}

我们创建了一个Class（类名可随意）并注解了@Configuration，这样可以将该Class看做一个spring的xml文件。同时我们增加了@ComponentScan注解开启了包扫描，在扫描包及其子包下面的所有被注解了@Component、@Controller、@Service、@Repository的Class会自动被实例化。

测试代码类似之前通过加载xml格式文件：

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
    // 省略其他代码...
}

二、通过构造方法实例化Bean

直接在Class上面注解@Component即可，当然也可以注解@Controller、@Service、@Repository。@Component为通用型注解，@Controller、@Service、@Repository则各具有一定的业务含义，一般的@Controller被标注在Controller层、@Service被标注在Service层、@Repository被标注在Dao层。

@Component // 通过构造方法实例化bean
public class Bean1 {
}
@Component // 通过构造方法实例化bean
public class Bean2 {
    private final Bean1 bean1;
    @Autowired // 自动注入Bean1的实例
    public Bean2(Bean1 bean1) {
        this.bean1 = bean1;
    }
}

在上面的两个例子中，Bean1有默认构造方法，则Spring会通过默认构造方法实例化Bean1；Bean2的构造方法包含参数Bean1，所以Spring在实例化Bean2的时候回在IoC容器中寻找Class为Bean1的实例并注入到该构造方法中以完成对Bean2的实例化。其中：@Autowired表示自动注入。

三、注入Bean

1. 通过方法注入Bean

（1）可通过构造方法注入Bean，如上面Bean2的例子

（2）可通过Set方法注入Bean，例如：

@Component // 通过构造方法实例化bean
public class Bean2 {  
    private Bean1 bean1;
    @Autowired // 自动注入Bean1的实例
    public void setBean1(Bean1 bean1) {
        this.bean1 = bean1;
    }
    // get方法省略......   
}

2. 通过属性注入Bean

@Component // 通过构造方法实例化bean
public class Bean2 {  
    @Autowired // 自动注入Bean1的实例
    private Bean1 bean1;
    // get/set方法省略......   
}

3. 集合类型Bean的注入

（1）直接注入集合实例

@Component // 通过构造方法实例化bean
public class Bean {
    private List<String> stringList;
    private Map<String, String> stringMap;

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

    @Autowired // 通过set方法注入bean
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    public Map<String, String> getStringMap() {
        return stringMap;
    }

    @Autowired // 通过set方法注入bean
    public void setStringMap(Map<String, String> stringMap) {
        this.stringMap = stringMap;
    }
}

当然，同时也需要在IoC容器中存在List的Bean和Map的Bean，那么我们怎么实例化这两个Bean呢？修改最开始我们创建的BeanConfiguration即可：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean() // 实例化一个List
    public List<String> stringList() {
        List<String> list = new ArrayList<String>();
        list.add("aaaaa");
        list.add("bbbbb");
        return list;
    }

    @Bean() // 实例化一个Map
    public Map<String, String> stringMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("aaa", "111");
        map.put("bbb", "222");
        return map;
    }
}

通常情况下，@Bean用来实例化那些我们不能修改源码的Class，或者需要多次实例化的Class。而@Component系列的四个注解用来实例化我们自己创建的且只需要一次实例化的Class。

那么小伙伴会问了，在上面的例子中，如果我们实例化了多个List或多个Map，Spring在为Bean注入的时候会给我注入哪个呢？答案是：Spring会报错给你看！解决办法就是在通过@Bean和@Component系列实例化Bean的时候指定BeanId，通过@Autowired注入Bean的时候同时通过@Qualifier指定要注入的BeanId。那么上面的例子可以改成：

@Component // 通过构造方法实例化bean
public class Bean {
    // ... 省略部分代码
    @Autowired // 通过set方法注入bean
    @Qualifier("stringList") // 指定注入id为stringList的bean
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }
    // ... 省略部分代码
    @Autowired // 通过set方法注入bean
    @Qualifier("stringMap") // 指定注入id为mapString的bean
    public void setStringMap(Map<String, String> stringMap) {
        this.stringMap = stringMap;
    }
}
@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean("stringList") // 实例化一个List，id为stringList
    public List<String> stringList() {
         // ... 省略部分代码
    }

    @Bean("stringMap") // 实例化一个Map，id为stringMap
    public Map<String, String> stringMap() {
        // ... 省略部分代码
    }
}

（2）将多个泛型的实例注入到集合

Spring支持将多个泛型的实例注入到集合，举例如下：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation") // 开启包扫描
public class BeanConfiguration {

    @Bean("integer1") // 实例化一个Integer，id为integer1
    public Integer integer1() {
        return 10001;
    }

    @Bean("integer2") // 实例化一个Integer，id为integer2
    public Integer integer2() {
        return 10002;
    }
}

在上面的代码中，我们实例化了两个Integer类型数据，并为每个实例设定了beanId。然后：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {
    private List<Integer> integerList;
    private Map<String, Integer> integerMap;

    public List<Integer> getIntegerList() {
        return integerList;
    }

    @Autowired // 通过set方法注入bean，将注入所有已经交由IoC容器管理的Integer类型的bean
    public void setIntegerList(List<Integer> integerList) {
        this.integerList = integerList;
    }

    public Map<String, Integer> getIntegerMap() {
        return integerMap;
    }

    @Autowired // 通过set方法注入bean，将注入所有已经交由IoC容器管理的Integer类型的bean，其中beanId即为键值
    public void setIntegerMap(Map<String, Integer> integerMap) {
        this.integerMap = integerMap;
    }
}

上面两个@Autowired会将我们在BeanConfiguration中创建的两个Integer类型的Bean全部注入到集合当中，当注入到Map类型（键为String类型）时，beanId即作为键值注入。

测试代码：

 

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);   
    System.out.println("bean.getIntegerList() = " + bean.getIntegerList());
    System.out.println("bean.getIntegerMap() = " + bean.getIntegerMap());       
}

 

输出：

bean.getIntegerList() = [10001, 10002]
bean.getIntegerMap() = {integer1=10001, integer2=10002}

当然，如果你想控制泛型实例在List中的顺序，可以通过增加@Order注解的方式实现：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation")
public class BeanConfiguration {

    @Bean("integer1") // 实例化一个Integer，id为integer1
    @Order(5) // 该注解可决定这个bean被注入到list时候的顺序，可以不连续
    public Integer integer1() {
        return 10001;
    }

    @Bean("integer2") // 实例化一个Integer，id为integer2
    @Order(2) // 该注解可决定这个bean被注入到list时候的顺序，可以不连续
    public Integer integer2() {
        return 10002;
    }
}

则输出结果即变为：

bean.getIntegerList() = [10002, 10001]
bean.getIntegerMap() = {integer1=10001, integer2=10002}

4. String、Integer等类型直接赋值

String、Integer等类型直接赋值可用@Value实现，例如：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {
    private String string;
    
    public String getString() {
        return string;
    }

    @Value("zzzzz") // 直接将zzzzz这个值注入进去
    public void setString(String string) {
        this.string = string;
    }
}

四、设定Bean的作用域scope

可直接通过@Scope来实现，例如：

@Component // 通过构造方法实例化bean
@Scope("singleton") // 设定bean作用域
public class Bean1 {
}
@Configuration // 该注解可理解为将当前class等同于一个xml文件
@ComponentScan("com.imooc.springClass5.annotation")
public class BeanConfiguration {
    @Bean // 实例化一个Bean1
    @Scope("singleton")  // 设定bean作用域
    public Bean1 bean1() {
        return new Bean1();
    } 
}

五、Bean的懒加载

可直接通过@Lazy实现，例如：

@Component // 通过构造方法实例化bean
@Lazy // 开启懒加载
public class Bean1 {
}
@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Lazy // 开启懒加载
public class BeanConfiguration {
    @Bean // 实例化一个Bean1
    @Scope("singleton")  // 设定bean作用域
    public Bean1 bean1() {
        return new Bean1();
    } 
}
@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Lazy // 开启懒加载
public class BeanConfiguration {
}

注意第三段代码中的@Lazy注解，这意味着在该Configuration中实例化的Bean都将默认为懒加载模式

六、Bean别名

Spring允许一个Bean拥有多个BeanId，但暂时只能在@Bean中实现，@Component系列四个注解暂不支持，@Bean举例如下：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
public class BeanConfiguration {
    @Bean({"bean1_1", "bean1_2"}) // 实例化一个Bean1设定其拥有两个BeanId，分别为bean1_1和bean1_2
    public Bean1 bean1() {
        return new Bean1();
    } 
}

七、引入其他注解了@Configuration的Class 或 其他xml文件格式配置

可直接通过@Import实现，例如：

@Configuration // 该注解可理解为将当前class等同于一个xml文件
@Import(BeanConfiguration1.class)
@ImportResource("classpath:spring.xml")
public class BeanConfiguration { 
}

 并且BeanConfiguration1无需注解@Configuration

public class BeanConfiguration1 {}

八、方法注入

可能存在如下场景：Class A 的某个方法依赖于Class B的实例，Class A使用scope=singleton单例模式，但是Class A每次执行方法的时候都希望获取一个新的Class B的实例，这个时候就用到了方法注入。举例：

@Component // 通过构造方法实例化bean
@Scope("prototype") // 设定bean作用域
public class Bean3 {
   
}
@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public abstract class Bean {
    @Lookup
    protected abstract Bean3 createBean3();
    public void printBean3() {
        System.out.println("createBean3().toString() = " + createBean3().toString());
    }
}

测试代码：

public class BeanTest {
    @Test
    public void testBean() throws Exception {
        final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
        Bean bean = context.getBean(Bean.class);    
        bean.printBean3();
        bean.printBean3();
        bean.printBean3();
      
    }
}

输出：

createBean3().toString() = com.imooc.springClass5.annotation.Bean3@1722011b
createBean3().toString() = com.imooc.springClass5.annotation.Bean3@57ad2aa7
createBean3().toString() = com.imooc.springClass5.annotation.Bean3@5b3f61ff

可以看到Bean.printBean3()方法每次拿到的Bean3都是不同的实例

 九、@PostConstruct和@PreDestroy

如果需要在Bean实例化完成之后或需要在Bean销毁之前执行一些逻辑，

  1. 可通过@PostConstruct和@PreDestroy实现。
  2. 可通过@Bean的initMethod和destroyMethod实现。
@Component // 通过构造方法实例化bean
public class Bean1 {

    public Bean1() {
        System.out.println(this.getClass().getSimpleName() + ":" + this.toString() + " has been created");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println(this.getClass().getSimpleName() + ":postConstruct()");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println(this.getClass().getSimpleName() + ":preDestroy()");
    }
}
public class Bean4 {

    public Bean4() {
        System.out.println(this.getClass().getSimpleName() + ":" + this.toString() + " has been created");
    }

    public void init() {
        System.out.println(this.getClass().getSimpleName() + ":init()");
    }

    public void destroy() {
        System.out.println(this.getClass().getSimpleName() + ":destroy()");
    }

}

测试：

@Test
public void testBean() throws Exception {
    final AbstractApplicationContext context = new AnnotationConfigApplicationContext(BeanConfiguration.class);
    System.out.println("=================context has bean created=====================");
    context.close();
}

输出：

Bean1:com.imooc.springClass5.annotation.Bean1@415b0b49 has been created
Bean1:postConstruct()
Bean4:com.imooc.springClass5.annotation.Bean4@7ef27d7f has been created
=================context has bean created=====================
Bean4:init()
Bean4:destroy()
Bean1:preDestroy()

十、SpringIoC容器本身接口实例注入

Spring支持我们直接注入其相关接口实例，例如：ApplicationContext、BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageSource接口及其实现类，举例其中一个说明：

@Component // 通过构造方法实例化bean，类似的还有@Controller、@Service、@Repository
public class Bean {

    private ApplicationContext context;

    public ApplicationContext getContext() {
        return context;
    }

    @Autowired // 可直接将ApplicationContext注入进来，也可以注入BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageSource及其实现类
    public void setContext(ApplicationContext context) {
        this.context = context;
    }
}

 

Spring入门之五-------SpringIoC之通过注解实现

标签：his   设定   bbb   prot   not   允许   out   imp   加载模式   

原文地址：https://www.cnblogs.com/LOVE0612/p/10055014.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！