2. 程式人生 > >Spring 5 設計模式 - 開始

Spring 5 設計模式 - 開始

阿新 • • 發佈：2018-12-12

Spring 5 設計模式 - 開始

依賴注入

物件之間的依賴增加複雜性，導致物件之間緊耦合。
比如下面的TransferService元件依賴其他兩個元件：TransferRepository和AccountRepository：
TransferService

如果直接使用例項：

public class TransferService {
    private AccountRepository accountRepository;
    
    public
 
 TransferService () {
        this.accountRepository = new AccountRepository();
    }
    
    public void transferMoney(Account a, Account b) {
        accountRepository.transfer(a, b);
    }
}

TransferService物件需要一個AccountRepository物件，實現賬戶A到賬戶B的轉賬功能。於是，直接增加AccountRepository的例項。這樣很難維護，也很難做TransferService的單元測試。

也可以使用工廠模式實現該功能：

public class TransferService {
    private AccountRepository accountRepository;
    
    public TransferService() {
        this.accountRepository = AccountRepositoryFactory.getInstance("jdbc");
    }
    
    public void transferMoney(Account a, Account b) {
        accountRepository.
 
transfer(a, b);
    }
}

上面的程式碼，我們使用工廠模式增加AccountRepository類的物件。更好的做法是program-to-interface，針對這個具體問題，我們可以增加一個介面，降低耦合：

public interface AccountRepository {
    void transfer();
    //other methods
}

我們可以增加JdbcAccountRepositry類，實現AccountRepository介面：

public class JdbcAccountRepositry implements AccountRepositry{
    //實現AccountRepositry定義的方法
    // 實現其他方法
}

這樣，由工廠類增加的物件很容易維護。使用工廠類，也可以增加可配置的物件。但是，為了降低耦合，獲取協作元件的時候在業務元件裡增加了工廠類。讓我們看看依賴注入怎麼解決這個問題。

對於依賴注入模式，我們只是定義依賴性，而不用解決物件之間的依賴。看下圖，我們會在需要物件的時候注入他們：

Dependency injection

TransferService依賴AccountRepository和TransferRepository。TransferService可以使用多種TransferRepository完成轉賬功能，比如可以使用JdbcTransferRepository或者是JpaTransferRepository，依賴哪個，由部署環境決定。

public class TransferServiceImpl implements TransferService {
    private TransferRepository transferRepository;
    private AccountRepository accountRepository;
    
    public TransferServiceImpl(TransferRepository transferRepository, AccountRepository accountRepository) {
        this.transferRepository = transferRepository;//TransferRepository is injected
        this.accountRepository = accountRepository;//AccountRepository is injected
    }
    public void transferMoney(Long a, Long b, Amount amount) {
        Account accountA = accountRepository.findByAccountId(a);
        Account accountB = accountRepository.findByAccountId(b);
        transferRepository.transfer(accountA, accountB, amount);
    }
}

TransferServiceImpl沒有增加自己的repositories實現，而是在構造器裡通過構造引數傳遞的。這叫構造器注入。這樣，TransferServiceImpl沒有和任何repositories的實現相耦合，可以根據需要切換不同的實現。
Spring提供了把程式的各個部件組裝成程式的支援：

  • 部件不用擔心找不到對方
  • 任何部件都可以很容易地被替換

配置程式碼可以是這的：

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

@Configuration
public class AppConfig {
    @Bean
    public TransferService transferService(){
        return new TransferServiceImpl(accountRepository(), transferRepository());
    }
    @Bean
    public AccountRepository accountRepository() {
        return new JdbcAccountRepository();
    }
    @Bean
    public TransferRepository transferRepository() {
        return new JdbcTransferRepository();
    }
}

Spring程式，使用程式上下文的一個實現載入bean定義，放進Spring容器。比如下面的程式碼，就使用AnnotationConfigApplicationContext載入配置類AppConfig，得到AccountService的一個物件：

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

public class TransferMain {
    public static void main(String[] args) {
        //載入上下文
        ConfigurableApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(AppConfig.class);
        //得到 TransferService bean
        TransferService transferService =
                applicationContext.getBean(TransferService.class);
        //轉賬
        transferService.transferAmmount(100l, 200l, new Amount(2000.0));
        applicationContext.close();
    }
}

AOP

依賴注入讓元件之間鬆耦合，面向切面程式設計（Spring AOP）可以捕獲程式中重複出現的常用功能。能以最優雅的方式，把下列功能分開。可以通過宣告的方式，透明地應用這些服務：

  • 日誌和跟蹤
  • 事務管理
  • 安全
  • 快取
  • 錯誤處理
  • 效能監視
  • 自定義業務規則

列表中的元件不是你核心程式的一部分，但是他們是額外的責任，通常稱為cross-cutting concerns，在核心責任之上跨多個元件。如果你把這些元件放到你的核心功能，而沒有模組化，會導致兩個主要問題：

  • Code tangling：比如安全、事務、日誌等程式碼和業務邏輯耦合在一起
  • Code scattering：相同的concern散佈在模組之間
    Cross-cutting concerns

Spring AOP可以把cross-cutting concern模組化。Spring AOP是通過代理模式實現的:

  • 實現程式邏輯：你實現業務邏輯的時候，不需要擔心附加功能，比如日誌、安全等。
  • 寫aspects，實現cross-cutting concerns
  • 在程式裡Weave aspects：把cross-cutting行為放到正確的位置，可以通過宣告的方式注入

AOP-based

比如，使用LoggingAspect實現日誌功能：

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect {
    @Before("execution(* *.transferAmount(..))")
    public void logBeforeTransfer(){
        System.out.println("####LoggingAspect.logBeforeTransfer() method called before transfer amount####");
    }
    @After("execution(* *.transferAmount(..))")
    public void logAfterTransfer(){
        System.out.println("####LoggingAspect.logAfterTransfer() method called after transfer amount####");
    }
}

修改AppConfig：

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

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public TransferService transferService(){
        return new TransferServiceImpl(accountRepository(), transferRepository());
    }
    @Bean
    public AccountRepository accountRepository() {
        return new JdbcAccountRepository();
    }
    @Bean
    public TransferRepository transferRepository() {
        return new JdbcTransferRepository();
    }
    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

template

在企業程式裡，經常會看到很多相似的程式碼。比如使用JDBC，經常會寫相同的程式碼，處理下列問題：

  • 從連線池獲取連線
  • 增加PreparedStatement物件
  • 繫結SQL引數
  • 執行PreparedStatement物件
  • 從ResultSet物件檢索資料，填充資料容器
  • 釋放資料庫資源

比如getAccountById方法的程式碼可能是這樣的：

    public Account getAccountById(long id) {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = dataSource.getConnection();
            stmt = conn.prepareStatement(
                    "select id, name, amount from " +
                            "account where id=?");
            stmt.setLong(1, id);
            rs = stmt.executeQuery();
            Account account = null;
            if (rs.next()) {
                account = new Account();
                account.setId(rs.getLong("id"));
                account.setName(rs.getString("name"));
                account.setAmount(rs.getString("amount"));
            }
            return account;
        } catch (SQLException e) {
        } finally {
            if(rs != null) {
                try {
                    rs.close();
                } catch(SQLException e) {}
            }
            if(stmt != null) {
                try {
                    stmt.close();
                } catch(SQLException e) {}
            }
            if(conn != null) {
                try {
                    conn.close();
                } catch(SQLException e) {}
            }
        }
        return null;
    }

Spring JDBC使用模板設計模式，讓資料訪問程式碼更簡潔，也能防止連線洩漏：

    public Account getAccountById(long id) {
        return jdbcTemplate.queryForObject(
                "select id, name, amoount" +
                        "from account where id=?",
                new RowMapper<Account>() {
                    public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
                        account = new Account();
                        account.setId(rs.getLong("id"));
                        account.setName(rs.getString("name"));
                        account.setAmount(rs.getString("amount"));
                        return account;
                    }
                },
                id);
    }

Spring容器

有兩種不同的Spring容器：

  • Bean factory：物件池，通過配置建立和管理物件
  • Application contexts：bean工廠的簡單包裝，還提供了額外的程式上下文

bean的生命週期

life cycle

  • 載入所有的bean定義，增加有序圖（ordered graph）
  • 例項化，執行BeanFactoryPostProcessors（可以在這裡修改bean定義）
  • 例項化每個bean
  • 把值和bean引用注入bean的屬性
  • 如果bean實現了BeanNameAware介面，就呼叫setBeanName()方法設定bean的ID
  • 如果bean實現了BeanFactoryAware，就呼叫setBeanFactory()方法設定bean工廠的引用
  • 如果bean實現了ApplicationContextAware，就呼叫setApplicationContext()方法設定程式上下文的引用
  • 如果bean實現了BeanPostProcessor，呼叫postProcessBeforeInitialization()修改bean的例項
  • 如果bean實現了InitializingBean，呼叫afterPropertiesSet()方法做初始化或者載入資源。也可以用其他方法實現這一步，比如@PostConstruct註解
  • 如果bean實現了BeanPostProcessor，呼叫postProcessAfterInitialization()，在初始化之後修改bean。此時，bean已經可以使用，你的程式可以通過使用getBean()訪問這個bean。呼叫程式上下文的close()之前，bean一直活著
  • 如果bean實現了DisposibleBean，Spring呼叫它的destroy()方法執行銷燬過程，釋放資源。也可以用其他方法實現這一步，@PreDestroy

相關推薦

Spring 5 設計模式 - 開始

Spring 5 設計模式 - 開始 依賴注入 AOP template Spring容器 bean的生命週期 依賴注入 物件之間的依賴增加複雜性，導致物件之間緊耦合。 比如下面的TransferServi

Spring 5 設計模式 - 使用代理和裝飾模式的Spring AOP

Spring 5 設計模式 - 使用代理和裝飾模式的Spring AOP Spring中的代理模式 什麼是AOP AOP要解決的問題 程式碼糾纏 程式碼分散 解決 AOP的核心術語

Spring 5 設計模式 - bean生命週期和使用的模式

Spring 5 設計模式 - bean生命週期和使用的模式 生命週期和階段 初始化階段 載入bean定義 初始化bean例項 使用BeanPostProcessor自定義bean 初始化擴充套件點

Spring 5 設計模式 - Dependency Injection

Spring 5 設計模式 - Dependency Injection 依賴注入模式 依賴注入模式的型別 基於構造器的 基於Setter方法的 二者的比較 使用Spring配置依賴注入模式 Java-based

Spring 5 設計模式 - Structural

Spring 5 設計模式 - Structural adapter Spring使用的介面卡模式 簡單的實現 Bridge Spring中的應用 簡單的實現 Composite

Spring 5 設計模式 - Creational

Spring 5 設計模式 - Creational Factory Spring的工廠模式 簡單的例子 Abstract factory Spring中的Abstract factory 簡單的例子

spring的設計模式模式

spring中的設計模式 Spring框架是由於軟體開發的複雜性而建立的。Spring使用的是基本的JavaBean來完成以前只可能由EJB完成的事情。然而，Spring的用途不僅僅限於伺服器端的開發。從簡單性、可測試性和鬆耦合性角度而言，絕大部分Java應用都

Spring框架設計模式分析

在Java web的開發過程中，目前企業級應用程式採用較多的開發框架是SSH（Spring+SpringMVC+Hibernate，用SpringMVC來代替Struts）。本文通過閱讀Spring的官方手冊和原始碼來分析Spring建立者的設計理念，主要梳理在

spring 與設計模式（建立型）之Builder模式

一、前言 將一個複雜的物件構建與它的表示分離，使得同樣的構建過程可以建立不同的表示，實現構建物件的過程與部件解耦。生活中許多這樣的例子，例如大學4年的學習，每一年的學習成績會最終影響4後的績點。電腦汽

大話設計模式開始篇

看《大話設計模式》（程傑著）這本書也有一段時間了，但是對裡面的講到的設計模式都沒有進行了實際的程式碼去體驗，我覺得像這種動手操作的書籍最好還是自己去敲程式碼，所以，從現在開始，我從部落格這裡記錄一下我自己親身體驗設計模

不寫垃圾程式碼，從學會這個設計模式開始

大家好，我們今天來一起學習一個新的設計模式，叫做媒介模式。 所謂的媒介其實是一種封裝的思想，把某些功能共同的邏輯抽象出來做成一箇中間的媒介，從而減少程式碼之間的耦合，提升拓展性，更加方便日後的需求變更。 簡單案例 我們用一個實際的例子來認知一下媒介這個設計模式。 假設我們要做一個聊天室，如果真要去做的話，這裡

設計模式的征途—5.原型（Prototype）模式

pla width 共享 太多的 isp text 一模一樣 軟件 集合 相信大多數的人都看過《西遊記》，對孫悟空拔毛變出小猴子的故事情節應該都很熟悉。孫悟空可以用猴毛根據自己的形象復制出很多跟自己一模一樣的小猴兵出來，其實在設計模式中也有一個類似的模式，我們可以通過一個原

《大話設計模式》——讀後感 （5）雷鋒依然在人間？——工廠方法模式

pri sys rod 加法 完全 .cn 依賴關系 style 優點 什麽是工廠方法模式： 工廠方法UML結構圖： 從圖中我獲取以下信息： 1、 Product是個接口，而Creator是個抽象類（我還是試試接口） 2、ConcreateProduct和Concret

《從零開始學Swift》學習筆記（Day67）——Cocoa Touch設計模式及應用之MVC模式

table control sdn rate term targe rac uitabbar bsp 原創文章，歡迎轉載。轉載請註明：關東升的博客 MVC（Model-View-Controller，模型-視圖-控制器）模式是相當古老的設計模式之中的一個，它最早出如今

設計模式解密（5）- 外觀模式（門面模式）

src 內部 耦合度 解決 臺電 統一 方法 英文 適配器 1、簡介 外觀模式提供了一個統一的接口，用來訪問子系統中的一群接口。外觀定義了一個高層接口，讓子系統更容易使用。 使用外觀模式時，我們創建了一個統一的類，用來包裝子系統中一個或多個復雜的類，客戶端可以直接通

【設計模式】代理模式：靜態代理，動態代理，spring aop

spring 實現接口 找到 master 代碼 -s result java 統一 代理模式分為靜態代理和動態代理。我們拿鏈家來舉例子，我們本人是真實的對象，有真實的業務需求：需要去找房子；鏈家是中介，是代理類，他來幫我執行找房子的這個操作。 靜態代理： 　　1.實現一個

Spring 框架的設計理念與設計模式分析

問題 面向對象編程 -h oop ram 重要 原因 依賴 object 轉自： https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/ Spring 的設計理念 前面介紹了 Spring 的三

設計模式5（命令模式，叠代器模式）

對象的訪問 叠代器模式 元素 div 使用 ble col top 執行 命令模式 本質是封閉請求,其關鍵是把請求封閉成對象，也就是命令對象，並定義了統一的執行操作的接口，這個命令可以存儲、轉發、記錄、處理、撤消等。整個命令模式都是圍繞這個對象進行。 命令

java之Spring（AOP）前奏-動態代理設計模式（上）

對象 .cn 分享圖片 賦值 alt his 編程習慣 輸出 style 我們常常會遇到這樣的事，項目經理讓你為一個功能類再加一個功能A，然後你加班為這個類加上了功能A； 過了兩天又來了新需求，再在A功能後面加上一個新功能B，你加班寫好了這個功能B，加在了A後面；又過

5.單例設計模式

斷開 沒有 有一個 查看 餓漢 sync 線程池 即使 是否 　為什麽需要單例設計模式？ 　　我們在系統設計的時候，出於對性能，或者安全性等多種因素考慮，有些對象我們只需要一個。可能是全局只需要一個，也可能是整個系統只需要一個。 　　　　這個時候我們就需要用到單例模式了。比