2. 程式人生 > >Spring IOC 一——Spring容器裝配Bean

Spring IOC 一——Spring容器裝配Bean

阿新 • • 發佈：2019-05-10

寫在前面

這篇文章去年寫的，緣起於去年某段時間被領導臨時“抓壯丁”般的叫過去做java開發，然後在網上找了一個 SpringMVC 的 demo，學習一下，然後依葫蘆畫瓢，開始了自己的專案開發，也還順利完成了任務。在使用 SpringMVC 的過程中，我被這個被稱作“最優秀”的 java 框架 —— Spring 深深地吸引了，那些曾經掌握的多種設計模式的思想在其中都有實現，比如工廠模式、單例模式、觀察者模式等等，於是在工作之餘認真地學習了這個框架。
學習新東西總是令人興奮的，然而大多數學過的知識很容易又會忘記，所以便想整理一下，寫點筆記，方便自己以後複習檢視。

部分參考資料：
《Spring實戰（第4版）》

《輕量級 JavaEE 企業應用實戰（第四版）》
Spring 官方文件
W3CSchool Spring教程
易百教程 Spring教程

一、Spring簡介

Spring是一個開源框架，Spring是於2003年興起的一個輕量級的Java開發框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中闡述的部分理念和原型衍生而來。它是為了解決企業應用開發的複雜性而建立的。框架的主要優勢之一就是其分層架構，分層架構允許使用者選擇使用哪一個元件。Spring提供了約20多個元件，開發者可以根據自己需要選擇元件。Spring的核心是控制反轉(IoC)和麵向切面程式設計(AOP)

  • IoC：控制反轉。
    控制反轉（Inversion of Control），又叫依賴注入（Dependency Injection）。舉例來說，在之前的操作中，比方說有一個類，我們想要呼叫類裡面的方法(不是靜態方法)，就要建立類的物件，使用物件呼叫方法實現。對於Spring來說，Spring建立物件的過程，不是在程式碼裡面實現的，而是交給Spring來進行配置實現的。
  • AOP：面向切面程式設計。
    面向切面程式設計（Aspect Orient Programming）支援允許將一些通用的任務入安全、事物、日誌、快取等進行集中式處理，從而提供了更好的複用，AOP通常用來處理一些具有橫切性質的系統級服務。

二、Hello Spring 例項

從最簡單的 Hello，Spring 例子來體會一下使用 Spring 框架。首先看看不使用 Spring 框架的程式碼：
HelloSpring.java 類：

package com.sharpcj;

public class HelloSpring {
    private String name;

    public void sayHello() {
        System.out.println("Hello," + name + "!");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Test.java 類：

package com.sharpcj;

public class Test {
    public static void main(String[] args) {
        HelloSpring hs = new HelloSpring();
        hs.setName("Spring");
        hs.sayHello();
    }
}

輸出結果：

Hello,Spring!

下面我們用 Spring 框架來實現這個例子。
Spring 框架官方下載地址: http://repo.springsource.org/libs-release-local/
Spring 框架阿里雲下載地址：http://maven.aliyun.com/nexus/content/groups/public/springframework/

新增從 Spring 框架核心 JAR 檔案：

  • commons-logging-1.1.1
  • spring-aop-5.0.6.RELEASE
  • spring-aspects-5.0.6.RELEASE
  • spring-beans-5.0.6.RELEASE
  • spring-context-5.0.6.RELEASE
  • spring-context-support-5.0.6.RELEASE
  • spring-core-5.0.6.RELEASE
  • spring-expression-5.0.6.RELEASE
  • spring-instrument-5.0.6.RELEASE
  • spring-instrument-tomcat-5.0.6.RELEASE
  • spring-jdbc-5.0.6.RELEASE
  • spring-jms-5.0.6.RELEASE
  • spring-messaging-5.0.6.RELEASE
  • spring-orm-5.0.6.RELEASE
  • spring-oxm-5.0.6.RELEASE
  • spring-test-5.0.6.RELEASE
  • spring-tx-5.0.6.RELEASE
  • spring-web-5.0.6.RELEASE
  • spring-webmvc-5.0.6.RELEASE
  • spring-webmvc-portlet-5.0.6.RELEASE
  • spring-websocket-5.0.6.RELEASE

這裡只是使用Spring的基本功能，所以需要使用到下面的這幾個Jar包:

這裡我使用的 idea，用 gradle 編譯的（用 maven 過程類似）。為了提高下載速度，我使用了阿里雲的 maven 倉庫，然後新增依賴，最新穩定版本是 5.0.6 ， build.gradle檔案部分截圖：

程式碼更改如下：
HelloSpring.java 類

package com.sharpcj;

public class HelloSpring {
    private String name;

    public void sayHello() {
        System.out.println("Hello," + name + "!");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Test.java 類

package com.sharpcj;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext("src/beans.xml");
        HelloSpring hs = context.getBean("helloSpring", HelloSpring.class);
        hs.sayHello();
    }
}

此時在 src 目錄下新建了一個檔案 beans.xml :

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="helloSpring" class="com.sharpcj.HelloSpring">
        <property name="name" value="Spring"/>
    </bean>

</beans>

此時執行 Test.java 的 main 方法，列印結果如下：

Hello,Spring!

這樣我們就用 Spring 框架實現了最簡單的 Hello Spring 程式。

三、認識 spring 容器和 Bean

上面用 Spring 框架實現的程式碼中，我們在 Test.java 類中，並沒有通過 “new HelloSpring()” 這樣的呼叫 Spring 構造方法去建立 HelloSpring 的物件，而是使用 Spring 核心容器建立的。

  • 第一步是我們使用框架 API FileSystemXmlApplicationContext() 來建立應用程式的上下文。這個 API 載入 beans 的配置檔案並最終基於所提供的 API，它處理建立並初始化所有的物件，即在配置檔案中提到的 beans。

  • 第二步是使用已建立的上下文的 getBean() 方法來獲得所需的 bean。這個方法使用 bean 的 ID 返回一個最終可以轉換為實際物件的通用物件。一旦有了物件，你就可以使用這個物件呼叫任何類的方法。能通過這種方式建立的物件，一定是在 beans.xml 檔案中配置的。

Spring 核心容器就好像是一個超級大的工廠，在配置檔案中配置過的物件都會被當成 Spring 容器管理的物件。Spring 把容器中的一切物件統稱為 Bean 。 Spring 中的 Bean 與傳統的 java Bean 不同，對 Spring 而言，任何一個 java 類，都可以當成是 Bean 來處理。

四、Spring容器裝配Bean的三種方式

  • 在XML中進行裝配
  • 自動裝配 bean
  • 在Java中進行裝配

還是用上面 HelloSpring 的例子，該例子實在過於簡單，只有一個 bean, 沒有涉及到兩個 bean 之間的依賴關係，不過還是可以用它來理解Spring容器裝配Bean的三種裝配方式。為了說明依賴注入的場景，舉個其它例子：
人用筆寫字。虛擬碼如下：
Pen 類：

public class Pen {
    // property 暫不關心
}

Person 類：

public class Person {
    private Pen pen;

    public Person(Pen pen) {
        this.pen = pen;
    }

    public Pen getPen() {
        return this.pen;
    }

    public void setPen(Pen pen) {
        this.pen = pen;
    }

    // 這裡我們暫不關心該方法
    public void write() {

    }
}

下面對於這種依賴關係，將分別用虛擬碼來說明構造注入和設定注入。

在 XML 中進行裝配

基本使用

上面例子即是，不再贅述。

依賴注入

如果存在多個Bean, 之間有依賴關係：
構造注入：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="pen" class="com.sharpcj.Pen"> </bean>

    <bean id="person" class="com.sharpcj.Person">
        <constructor-arg name = "pen", ref = "pen">
    </bean>
</beans>

設值注入：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="pen" class="com.sharpcj.Pen"> </bean>

    <bean id="person" class="com.sharpcj.Person">
        <property name = "pen",  ref = "pen">
    </bean>
</beans>

4.2 自動裝配 bean

基本使用

com.sharpcj.HelloSpring.java 程式碼如下：

package com.sharpcj;

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

@Component
public class HelloSpring {
    private String name;

    public void sayHello() {
        System.out.println("Hello," + name + "!");
    }

    public String getName() {
        return name;
    }

    @Value("Spring")
    public void setName(String name) {
        this.name = name;
    }
}

建立類 com.sharpcj.HelloConfig.java用來開啟元件掃描：

package com.sharpcj;

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

@Configuration
@ComponentScan
public class HelloConfig {
}

修改com.sharpcj.Test.java

package com.sharpcj;

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

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(com.sharpcj.HelloConfig.class);
        HelloSpring hello = context.getBean("helloSpring", HelloSpring.class);
        hello.sayHello();
    }
}

@Component 註解的類即為 Bean 。 @Configuration 註解的即為配置檔案，@ComponentScan 註解表示開啟自動掃描，預設掃描該配置類所在的包，如果掃描其它包，多個包，形式如下：

@Configuration
@ComponentScan(basePackageClasses = {com.a.A.class, com.b.B.class})

也可以每個包內配置之後，再配置一個總的配置檔案：

@Configuration
@Import({com.a.AConfig.class, com.b.BConfig.class})
public class TotalConfig {
}

依賴注入

如果存在多個Bean, 之間有依賴關係：

// pen 類:

@Component
public class Pen {
    // property 暫不關心
}

構造注入：

@Component
public class Person {

    private Pen pen;
    
    @Autowired
    public Person(Pen pen) {
        this.pen = pen;
    }

    public Pen getPen() {
        return this.pen;
    }

    public void setPen(Pen pen) {
        this.pen = pen;
    }

    // 這裡我們暫不關心該方法
    public void write() {

    }
}

設值注入：

@Component
public class Person {

    private Pen pen;

    public Pen getPen() {
        return this.pen;
    }

    @Autowired
    public void setPen(Pen pen) {
        this.pen = pen;
    }

    // 這裡我們暫不關心該方法
    public void write() {

    }
}

通過 java 程式碼進行裝配

基本使用

此時 java 類無需使用註解。
同樣建立一個類，com.sharpcj.HelloConfig.java來進行裝配 Bean。

package com.sharpcj;

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

@Configuration
public class HelloConfig {
    @Bean
    public HelloSpring helloSpring(){
        return new HelloSpring();
    }
}

被 @Bean 標註的方法返回的即為唯一 Bean（預設單例模式），方法名隨便取。

Test:

ApplicationContext context=new AnnotationConfigApplicationContext(com.sharpcj.HelloConfig.class);
Person person = context.getBean(Person.class);
person.write();

依賴注入

如果存在多個Bean, 之間有依賴關係：
構造注入：

@Configuration
public class PConfig {
    @Bean
    public GPen hehe() {
        return new GPen();
    }

    @Bean
    public QPen haha() {
        return new QPen();
    }

    @Bean
    public Person xixi() {
        Person person = new Person(hehe());
        return person;
    }
}

設值注入：

@Configuration
public class PConfig {
    @Bean
    public GPen hehe() {
        return new GPen();
    }

    @Bean
    public QPen haha() {
        return new QPen();
    }

    @Bean
    public Person xixi() {
        Person person = new Person();
        person.setPen(hehe());
        return person;
    }
}

寫在後面

這篇文章記錄了Spring容器和Bean的概念，Spring 的基本使用，以及Spring容器裝配Bean的三種方式。關於Spring 容器的知識點比較多，下篇文章接著寫點 Spring 容器裝配 Bean 的高階知識點。

相關推薦

Spring IOC 一——Spring容器裝配Bean

寫在前面 這篇文章去年寫的，緣起於去年某段時間被領導臨時“抓壯丁”般的叫過去做java開發，然後在網上找了一個 SpringMVC 的 demo，學習一下，然後依葫蘆畫瓢，開始了自己的專案開發，也還順利完成了任務。在使用 SpringMVC 的過程中，我被這個被稱作“最優秀”的 java 框架 —— Spri

Spring之IOC容器裝配Bean

1、Spring裝配Bean的過程大致如下：     Spring啟動時讀取應用程式提供的bean配置資訊，並在Spring容器中生成一份該Bean的配置資訊登錄檔，再根據該登錄檔例項化Bean，裝配Bean的屬性資訊，Bean之間的依賴關係和Bean的行為配置。需要滿足的三個條件：Sp

JAVAWEB開發之Spring詳解之——Spring的入門以及IOC容器裝配Bean(xml和註解的方式)、Spring整合web開發、整合Junit4測試

public class BeanFactory{    public UserService getUserService(){         // 反射+配置檔案        return Class.forName(類名).newInStance();     } } xml、pro

十年架構師詳解，Spring-IoC容器裝配Bean

  先看一下Spring容器內部是如何協助的，也就是Spring容器、Bean的配置資訊、Bean的實現類及應用程

Spring IoC 之Spring Bean的裝配

一、裝配Bean概述 Spring提供了三種方法進行Bean的配置： 在XML中進行配置 在java介面和類中用註解進行配置 隱式Bean的發現機制和自動裝配原則 在現實工作中，這三種方式都會被用到，並常常混合使用。基於“約定優於配置”的原則，最優先的

Spring之IOC、核心容器和Bean概念詳解

    這一週忙了很多與程式碼無關的事，感覺心態上還是有些急躁，週中挑幾個晚上看了一些文章，上午起來總結了一下，下午開始寫部落格，因為沒有時間擼程式碼，所以就打算先把看到的概念梳理梳理，磨刀不誤砍柴工。    首先來看一看什麼是IOC，他的全稱是Inversion of Co

Spring學習系列(二) 自動化裝配Bean

can one bean 工作 顯式 實例 cnblogs con frame 一、Spring裝配-自動化裝配 @[email protected]/* */ 通過spring註解（@Component）來表明該類會作為組件類，並告知Spring要為這類創建b

Spring實戰之通過XML裝配bean

compact 接受 per 基本 構造 根據 cbe 就是 定義 　　盡管Spring長期以來確實與XML有著關聯，但現在需要明確的是，XML不再是配置Spring的唯一可選方案。Spring現在有了強大的自動化配置和基於Java的配置，XML不應該再是你的第一選擇了。不

Spring in action 第二章 裝配Bean

在Spring中，物件無需自己查詢或建立與其關聯的其他物件，容器負責把相互協作的物件引用賦予各個物件。 裝配：建立應用物件之間協作關係的行為 2.2 自動化裝配bean @Component 註解：表明該類會作為元件類，並告知Spring要為這個類建立bean @Component 註解：能夠在Spr

Spring學習一(spring概念和ioc入門)

  Spring概念     Spring是一個開源輕量級框架，Spring是於2003 年興起的一個輕量級的Java 開發框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Des

Spring Ioc 源碼分析之Bean的加載和構造

!= tel string ebean cti name wired resource 事情 我們都知道，Spring Ioc和Aop是Spring的核心的功能，因此花一點時間去研究還是很有意義的，如果僅僅是知其所以然，也就體會不到大師設計Spring的精華，還記得那句話，

Spring框架入門之Spring IOC（XML）& Bean工廠

1、Spring框架入門之Spring IOC（XML）& Bean工廠 1.1 什麼是Spring框架？          Spring是一個開源框架，Spring是於2003年興起的一個輕量級的J

spring IOC用ref屬性實現bean之間的引用

如下圖所示，用ref屬性建立bean之間的引用 <bean id="person" class="com.beans.Person"> <property name="name" value="tom"></property> <

Spring學習筆記之自動化裝配Bean

在Spring中可以使用Java程式碼、XML和自動化裝配三種方式來裝配Bean。從便利性角度來說，最強大的還是Spring的自動化配置，如果Spring能夠進行自動化裝配的話，那何苦還要顯式的將這些Bean裝配在一起呢？ Spring從兩個角度來實現自動化裝配： 元件

Spring的基本原理-容器和bean

  在Spring中，那些組成你應用程式的主體及由Spring Ioc容器所管理的物件，都被稱之為bean。簡單來講，bean就是Spring容器的初始化、配置及管理的物件。除此之外，bean就與應用程式中的其他物件沒有什麼區別了。而bean定義以及bean相互間的依賴關係將

Spring入門(二)：自動化裝配bean

pep 自動化 tdi req ngs mcr 完成 injection 實現類 Spring從兩個角度來實現自動化裝配： 組件掃描(component scanning)：Spring會自動發現應用上下文中需要創建的bean。 自動裝配(autowiring)：Spri

Spring---IOC原理 Spring的IOC原理[通俗解釋一下]

Spring的IOC原理(轉載) 在網上看到一篇文章，感覺寫得挺不錯的，轉載一下，本文轉載自：http://blog.csdn.net/m13666368773/article/details/7802126 Spring的IOC原理[通俗解釋

spring ioc原理 spring ioc原理（看完後大家可以自己寫一個spring）

原 spring ioc原理（看完後大家可以自己寫一個spring） 2009年08月02日 20:33:00 超級谷歌 閱讀數：332663

【Spring IOC】Spring：原始碼解讀Spring IOC原理

一、什麼是Ioc/DI？     IoC 容器：最主要是完成了完成物件的建立和依賴的管理注入等等。 先從我們自己設計這樣一個視角來考慮： 所謂控制反轉，就是把原先我們程式碼裡面需要實現的物件建立、依賴的程式碼，反轉給容器來幫忙實現。那麼必然的我們需要建立一個容器

Spring IOC和Spring AOP的實現原理(原始碼主線流程)

寫在前面      正本文參考了《spring技術內幕》和spring 4.0.5原始碼。本文只描述原理流程的主線部分，其他比如驗證，快取什麼可以具體參考原始碼理解。Spring IOC一、容器初始化      容器的初始化首先是在對應的構造器中進行，在application