2. 程式人生 > >Spring入門之五-------SpringIoC之通過註解實現

Spring入門之五-------SpringIoC之通過註解實現

阿新 • • 發佈：2018-12-02
string類型 protected abstract 準備工作 @service urn 解決辦法 sin val

一、準備工作

創建一個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之通過註解實現

相關推薦

Spring入門之五-------SpringIoC之通過註解實現

string類型 protected abstract 準備工作 @service urn 解決辦法 sin val 一、準備工作 創建一個Class註解@Configuration，如下例子： @Configuration // 該註解可理解為將當前class等同於一個

Spring入門（基於Java的容器註解之@Scope和基於泛型的自動裝配）

@Scope 在使用@Bean的時候，預設@Bean定義出來的註解是單例的，那麼有什麼方式可以指定它的範圍呢，我們使用@Scope。Bean的作用域包括singleton、prototype、request、session、global session。 @

Spring入門（基於Java的容器註解之@ImportResource和@Value）

如何使用@ImportResource和@Value進行資原始檔讀取。 首先看個例子，使用beans來定義一個配置 <beans> <context:annotation-config/> <context:

Spring框架第五篇之Spring與AOP

lease nco 列表 odi 動態 www implement .get org 一、AOP概述 AOP(Aspect Orient Programming)，面向切面編程，是面向對象編程OOP的一種補充。面向對象編程是從靜態角度考慮程序的結構，而面向切面編程是從動態角

Spring入門（三）之IoC

使用 bsp martin 需要 容器 nbsp 依賴註入 tin 這就是 一、IoC定義 　　IoC，即控制反轉。開發者在使用類的實例之前，需要先創建對象的實例。但是IoC將創建實例的任務交給IoC容器，這樣開發應用代碼時只需要直接使用類的實例，這就是IoC。在討論控制反

mybatis入門（五）之Java API

Java API 既然你已經知道如何配置 MyBatis 和建立對映檔案，你就已經準備好來提升技能了。MyBatis 的 Java API 就是你收穫你所做的努力的地方。正如你即將看到的，和 JDBC 相比，MyBatis 很大程度簡化了你的程式碼並保持程式碼簡潔，容易

JavaFX入門（五）之在JavaFX中建立表單

在開發應用程式時，建立表單是一項常見活動。本教程將向您介紹屏幕布局的基礎知識，如何將控制元件新增到佈局窗格以及如何建立輸入事件。 在本教程中，您將使用JavaFX構建如圖4-1所示的登入表單。 圖4-1登入表單   本入門教程中使用的工具是NetBeans

Java網路程式設計入門（五）之TCP程式設計——複用Socket連線

如何複用Socket連線？ 在前面的示例中，客戶端中建立了一次連線，只發送一次資料就關閉了，這就相當於撥打電話時，電話打通了只對話一次就關閉了，其實更加常用的應該是撥通一次電話以後多次對話，這就是複用客戶端連線。 那 麼如何實現建立一次連線，進行多次資料交換呢？其實很簡單

Spring入門Blog[五、Spring容器組建註解@Component和Resouces實現完全註解配置]

@Resource和@Component實現零XML配置 1、@Resource的註解： @Resource是J2EE的註解。意思是說在容器裡面找相應的資源。也可以通過name屬性指定它name的資源。可以註解到field或者setter上面 public class

spring 通過註解實現工具類註入Service方法

註解在開發過程中，我們經常有碰到工具類裏面，要執行CRUD操作，需要調用到Service實現類，這時可以通過下述方法來得到。 1註入@Component 在持久層、業務層和控制層中，分別采用@Repository、@Service和@Controller對分層中的類進行凝視；而用@Component對那些

（12）Spring學習記錄---Spring_bean（Spring_通過註解配置 Bean）

用註解標識特定的元件，用元件掃描讓系統自動找到特點的元件       例項： 1.建立4個包  （1）annotation       TestObject.java impo

spring 06通過註解實現

實現方式： 第一步 增加maven依賴 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:sc

go語音之進階篇通過switch實現型別斷言

1、通過switch實現型別斷言 示例： package main import "fmt" type Student struct { name string id int } func main() { i := make([]interface{}, 3)

【例項】使用Spring AOP進行業務增強（通過註解的方式）

以下程式碼通過了編譯，可以直接執行（需要更改包名） 目的： 通過Spring AOP實現對service的transfer(轉賬)操作增加事務處理。 增強類MyAdvice package

Entity Framework 4.1/4.3 之五 (DBContext 之 2 查詢功能)

昨天我們講了 DBContext的作用及它的一些相對於ObjectContext進行的優化，今天繼續進行補充。我們還是用程式碼來說明，文章中會加入大量的程式碼。對了，倫敦奧運第三日，中國軍團再添3金，了不起。       一、DBContext 的查詢功能 (Queryi

(轉)驅動開發之五 --- TDI之六 【譯文】

http://hi.baidu.com/combojiang/item/d0287ca509180ddf5bf19132 同樣的使用TDI_RECEIVE來完成資料接收。然而我們卻沒有用它來實現。實際上，如果你注意到，你可以建立回撥來通知你資料或者其他事件什麼時候到達。

Spring程式碼例項系列-05：通過註解@Configuration、@Bean和@Import定義bean

Spring中有三種定義Bean的方式： 1. *.xml/<bean>/<import> 2. @Configuration/@Bean/@Import 3. @Component/@Controller/@Service/@

Spring入門(十五)：使用Spring JDBC操作資料庫

在本系列的之前部落格中，我們從沒有講解過操作資料庫的方法，但是在實際的工作中，幾乎所有的系統都離不開資料的持久化，所以掌握操作資料庫的使用方法就非常重要。 在Spring中，操作資料庫有很多種方法，我們可以使用JDBC、Hibernate、MyBatis或者其他的資料持久化框架，本篇部落格的重點是講解下在Sp

NLP入門（五）用深度學習實現命名實體識別（NER）

前言   在文章：NLP入門（四）命名實體識別（NER）中，筆者介紹了兩個實現命名實體識別的工具——NLTK和Stanford NLP。在本文中，我們將會學習到如何使用深度學習工具來自己一步步地實現NER，只要你堅持看完，就一定會很有收穫的。   OK，話不多說，讓我們進入正題。   幾乎所有的NLP都依賴一

通過註解實現通用匯出Excel

Javaweb開發中資料的匯入匯出很常見，每次我們都需要寫很多程式碼，所以我就在想能不能寫一些通用的方法，之前已經在網上 整理過一些通用的方法，最近在網上看到一位牛人封裝的更加簡介，自己拿過來整理了一下