軟體開發

他的英文是 Software Develope

目錄

  • 工作流
  • 軟體開發
  • 從觀點來解釋架構
  • 設計模式

工作流

寄生有寄生上流，工作也有工作上流

工作流 Workflow

用個最簡單的方式表達工作流

流程圖

工作流程 (非程式觀念)

由多個部門、多個崗位、經多個環節協調及順序工作共同完成的完整過程。

 

簡單地講，工作流程就是一組輸入轉化為輸出的過程。

 

包含元素、過程、表示

元素(表)

過程

工作流程的重要性

一方面規定了員工的工作內容；另一方面規定了員工怎樣去實現工作內容的工作流程。制度對員工在什麼崗位上要做什麼事情都規定得很好。

工作流 Workflow

工作流是一種工作流程的電腦(?)模型

 

屬於電腦支持的協同工作（Computer Supported Cooperative Work，CSCW）的一部分

 

屬於企業工程的一部分

 

有專屬的工作流引擎

 

或稱作工作流管理系統(不同於ERP)

工作流 Workflow

為了更好地實現某些業務工作目標，可以利用電腦在很多個參與人之間按某種既定原則自動傳遞文檔、資訊內容或者任務

1.流程工作流（Process Workflow）

2.專案工作流（Project Workflow）

3.案例工作流（Case Workflow）

 

Mantis 可歸類在案例工作流

軟體開發

大部分時間都在聊天(?)

軟體開發 - 開發流程

軟體開發 - 需求分析

軟體開發 - 需求分析

確認需求後，針對每個需求 ( 使用案例 ) 進行分析

每個使用案例對應一張穩健分析圖(robustness diagram)

軟體開發 - 需求分析

軟體開發 - 需求分析

確認(物件節點)流向後

每個穩健分析對應一張循序圖(sequence diagram)

軟體開發 - 系統分析

物件

生命線

控制焦點

消息

軟體開發 - 系統分析

軟體開發 - 系統分析

軟體開發 - 系統分析

軟體開發 - 系統分析

軟體開發 - 與工作流的關係

軟體開發 - 開發流程

軟體開發 - 自動化測試 (automation )

軟體開發 - 自動化測試 (automation )

軟體開發 - 自動化測試 (automation )

軟體開發 - 章節小結

從觀點解釋架構

 是一種整體觀

詳閱

架構 Architecture

若真要一言以蔽之

”架構” 是一種整體觀

需要保持從各角度看待架構時

仍有一致性與調和的觀點

架構 Architecture

一即是全，全即是一

觀點即是整體的部分

整體的部分即是觀點

金剛經有云：「凡所有相，皆屬虛妄，見諸相非相，即見如來」。

架構 Architecture

架構 Architecture

當組合起來可以做到更多功能，

才是系統存在的意義。

而設計模式則是為了實現某些架構的小模塊。

如果一個系統的功能等於其部件的功能之和，
那這個系統就沒有存在的意義，
只有在這個系統組合時能湧現出新的功能，
那才算是組成了一個系統。

架構 Architecture

public abstract class Drink {
    SugarType sugar;
    IceType ice;

    private Drink(){}

    public Drink(SugarType sugar, IceType ice) {
        this.sugar = sugar;
        this.ice = ice;
    }

    public SugarType getSugar() {
        return sugar;
    }

    public void setSugar(SugarType sugar) {
        this.sugar = sugar;
    }

    public IceType getIce() {
        return ice;
    }

    public void setIce(IceType ice) {
        this.ice = ice;
    }

    enum SugarType{
        REGULAR,LESS,HALF,QUARTER,FREE
    }

    enum IceType{
        REGULAR,EASY,FREE,HOT
    }

}

架構 Architecture

public class Tea extends Drink {

    TeaType teaType;

    public Tea(SugarType sugar, IceType ice) {
        super(sugar, ice);
    }

    public void setTeaType(TeaType teaType) {
        this.teaType = teaType;
    }

    public TeaType getTeaType() {
        return teaType;
    }

    enum TeaType{
        LEMON,OOLONG,GINGER,HONEY
    }
}

public class Coffee extends Drink {

    private CoffeeType coffeeType;

    public Coffee(SugarType sugar, IceType ice) {
        super(sugar, ice);
    }

    public CoffeeType getCoffeeType() {
        return coffeeType;
    }

    public void setCoffeeType(CoffeeType coffeeType) {
        this.coffeeType = coffeeType;
    }

    enum CoffeeType{
        LATTE,MOCHA,WHITE,BLUE_MOUNTAIN,AMERICANO,ESPRESSO
    }
}

架構 Architecture

public class DrinkShop {

    public Drink order(String drink,Drink.SugarType sugarType, Drink.IceType iceType){
        drink.toLowerCase();
        switch (drink){
            case "coffee":
                return new Coffee(sugarType,iceType);
            case "tea":
                return new Tea(sugarType,iceType);
            default:
                return null;
        }
    }

}

架構 Architecture

public class Client {
    @Test
    public void test(){
        DrinkShop drinkShop = new DrinkShop();
        
        //點一杯烏龍茶
        Tea tea = (Tea)drinkShop.order("Tea", Drink.SugarType.FREE, Drink.IceType.EASY);
        tea.setTeaType(Tea.TeaType.OOLONG);
        

        //點一杯美式
        Coffee coffee = (Coffee)drinkShop.order("coffee", Drink.SugarType.QUARTER,Drink.IceType.HOT);
        coffee.setCoffeeType(Coffee.CoffeeType.AMERICANO);
    }
}

糖度跟冰塊總共有20種組合，

咖啡有六種，茶有四種，

經過組合店員可以做出120種咖啡和80種茶。

觀點 Viewpoint

  • 需求面的觀點
  • 結構面的觀點
  • 實做面的觀點

觀點 Viewpoint - 需求面的觀點

簡而言之，一個需求便是一個使用案例 (Use Case)

 

何謂需求，代表著系統外部的觀點

 

也就是從 "Actor" 的角度去看待系統需要什麼功能

觀點 Viewpoint - 需求面的觀點

主要產出：使用案例圖

觀點 Viewpoint - 結構面的觀點

系統的結構設計

可以說才是決定系統的彈性、延展、效能、穩定等主要成敗因素。

觀點 Viewpoint - 結構面的觀點

觀點 Viewpoint - 結構面的觀點

主要產出：循序圖、設計類別圖

觀點 Viewpoint - 結構面的觀點

觀點 Viewpoint - 結構面的觀點

觀點 Viewpoint - 結構面的觀點

結構的設計，若以層次(Layer)之分，又分為高階抽象的領域模型，與細部、平台面相依的軟體規格模型。

觀點 Viewpoint - 實作面的觀點

主要產出：程式碼 Source Code

觀點 Viewpoint - 實作面的觀點

CI/CD

持續性整合與發佈

觀點 Viewpoint - 章節小結

觀點 Viewpoint - 章節小結

觀點 Viewpoint - 章節小結

設計模式

本次簡報重點終於來了

設計模式 design Pattern

什麼是設計模式

設計模式 design Pattern

  • 工廠模式
  • 單例模式
  • 策略模式

設計模式 - 工廠模式 Factory Pattern

你跟工廠說 你想要的那種規格 的商品，
而工廠負責製造 你想要的那種規格 的商品，
當中可能需要某些組裝或是特殊步驟，
但是作為消費者你不知道這些組裝方式和步驟，
你還是可以買到 你想要的東西。

設計模式 - 簡單工廠模式

public interface Product {
    //敘述自己是什麼商品
    public void describe();
}

public class SaltedFrenchFries implements Product{
    @Override
    public void describe() {
        System.out.println("我是加鹽薯條");
    }
}
public class FrenchFries implements Product{
    @Override
    public void describe() {
        System.out.println("我是無鹽薯條");
    }
}
public class FrenchFriesFactory{
	
    public static FrenchFries creatFrenchFries(String name){
    	if("加鹽".equals(name)) {
        	return new SaltedFrenchFries();
        }
        elis if("無鹽".equals(name)) {
        	return new FrenchFries();
        }
        else {
        	return null;
}	}	}

public class SimpleFactoryTest {
	public static void main(){
    	SaltedFrenchFries sf = 
        	(SaltedFrenchFries)FrenchFriesFactory.creatFrenchFries("加鹽");
        FrenchFries f = 
        	(FrenchFries)FrenchFriesFactory.creatFrenchFries("無鹽");
        sf.describe(); // 我是加鹽薯條
        f.describe(); // 我是無鹽薯條
}	}

設計模式 - 簡單工廠模式

public class PizzaStore {
    Pizza orderPizza(String type){
    	Pizza pizza;
    	if(type.equals("cheese")){
	    pizza = new CheesePizza();
    	}else if(type.equals("greek")){
	    pizza = new GreekPizza();
    	}else if(type.equals("pepperoni")){
	    pizza = new PepperoniPizza();
    	}
    	pizza.prepare();
    	pizza.cook();
    	return pizza
    }
}

設計模式 - 簡單工廠模式

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
      Pizza pizza = null;
      if(type.equals("cheese")){
          pizza = new CheesePizza();
      }
      else if(type.equals("greek")){
          pizza = new GreekPizza();
      }
      else if(type.equals("pepperoni")){
          pizza = new PepperoniPizza();
      }
      return pizza;
    }
}
public class PizzaStore {
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory) { 
		this.factory = factory;
    }
    public Pizza orderPizza(String type) {
      Pizza pizza;
      pizza = factory.createPizza(type);
      pizza.prepare();
      pizza.cook();
      return pizza;
    }
}

設計模式 - 簡單工廠模式

設計模式 - 簡單工廠模式

public class SimplePizzaFactory {
    public Pizza createPizza(String style, String type) {
	Pizza pizza = null;
	if(style.equals("NY")){
	    if(type.equals("cheese")){
	    	pizza = new NYStyleCheesePizza();
    	    }else...
	    ...
	}else if(style.equals("chicago")){
	    if(type.equals("cheese")){
                pizza = new ChicagoStyleCheesePizza();
            }else...    
            ...
	}
    	return pizza;
    }
}

設計模式 - 簡單工廠模式

public class ChicagoPizzaFactory extends SimplePizzaFactory {
    public Pizza createPizza(String type) {
      retrun super.createPizza(type);
    }
}

public class NYPizzaFactory extends SimplePizzaFactory {
    public Pizza createPizza(String type) {
      retrun super.createPizza(type);
    }
}

public class PizzaStore {
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory) { 
		this.factory = factory;
    }
    public Pizza orderPizza(String type) {
      Pizza pizza;
      pizza = factory.createPizza(type);
      pizza.prepare();
      pizza.cook();
      return pizza;
    }
}

設計模式 - 簡單工廠模式

NYPizzaFactory nyFactory = new NYPizzaFactory();
PizzaStore nyStore = new PizzaStore(nyFactory);
nyStore.orderPizza("cheese");

ChicagoPizzaFactory chicagoFactory = new ChicagoPizzaFactory()
PizzaStore chicagoStore = new PizzaStore(chicagoFactory);
chicagoStore.orderPizza("cheese");

設計模式 - 工廠方法模式

設計模式 - 工廠方法模式

public abstract class PizzaStore {
    abstract Pizza createPizza(String type);
    public Pizza orderPizza(String type) {
      Pizza pizza = createPizza(type);
      pizza.prepare();
      pizza.cook();
      return pizza;
    }
}
public class NYPizzaStore extends PizzaStore {
    Pizza createPizza(String item) {
	if (item.equals("cheese")) {
   	    return new NYStyleCheesePizza();
	} else if (item.equals("veggie")) {
	    return new NYStyleVeggiePizza();
	} else if (item.equals("clam")) {
	    return new NYStyleClamPizza();
	} else if (item.equals("pepperoni")) {
	    return new NYStylePepperoniPizza();
	} else return null;
    }
}
PizzaStore nyStore = 
	new NYPizzaStore();
Pizza pizza = 
	nyStore.orderPizza("cheese");

設計模式 - 工廠方法模式

  • Product(Pizza): 定義factoryMethod(createPizza)所造物件的介面

  • ConcreteProduct(NYStyleCheesePizza): 實作Product

  • Creator(PizzaStore): 宣告factoryMethod(必須傳回Product) 和其他client可以call的API

  • ConcreteCreator(NYPizzaStore): 實作factoryMethod 回傳ConcreteProduct的instance

設計模式 - 抽象工廠模式

設計模式 - 單例模式

我將於茫茫人海中訪我唯一靈魂之伴侶,得之,我幸;不得,我命,如此而已。或得則吾生，不或則吾滅。

                                                                         徐志摩 《致梁啟超》

設計模式 - 單例模式

設計模式 - 單例模式

public class SoulMate{
    private SoulMate() {}
}
public class SoulMate{
    private SoulMate() {}
    public SoulMate getInstance(){
	return new SoulMate();
    }
}
public class SoulMate{
    private SoulMate() {}
    public static SoulMate getInstance(){
	return new SoulMate();
    }
}
public class SoulMate{
    private static SoulMate uniqueInstance;
    private SoulMate() {}

    public static SoulMate getInstance(){
	if(uniqueInstance == null){
            uniqueInstance = new SoulMate();
	}
	return uniqueInstance;
    }
}

設計模式 - 單例模式

保證一個class只會有最多一個instance 同時提供一個存取方法

設計模式 - 策略模式

一般的 OOP 繼承

reuse code

abstract method

設計模式 - 策略模式

一般的 OOP 繼承

reuse code

abstract method

fly()

pulic fly(){
	pass
}

設計模式 - 策略模式

abstract method

fly()

pulic fly(){
	pass
}

Design Pattern rule #1: Encapsulate what varies

設計模式 - 策略模式

Design Pattern rule #1: Encapsulate what varies

aka encapsulate code that changes a lot. This basic O-O principle you may not know as well, here is a brief overview.

  • One way that ugly code arises is new code has to be patched in as new features are added
  • If you push code deeper into classes and behind encapsulation boundaries the change is isolated, code is more maintainable.
  • We will cover the JavaScript library checkout example in this blog post.

設計模式 - 策略模式

abstract method

fly()

pulic fly(){
	pass
}

Design Pattern rule #1: Encapsulate what varies

設計模式 - 策略模式

Design Pattern rule #2: Program to an interface, not an implementation

設計模式 - 策略模式

public void performFly() {
	flyBehavior.fly();
}

設計模式 - 策略模式

public class MallardDuck extends Duck {
	public MallardDuck() {
		quackBehavior = new Quack();
		flyBehavior = new FlyWithWings();
	}
	public void display() {
		System.out.println("I'm a real Mallard duck");
	}
}
MallardDuck mallard = new MallardDuck();
model.performFly();//FlyWithWings的fly實作	
model.setFlyBehavior(new FlyRocketPowered());
model.performFly();//FlyRocketPowered的fly實作

Design Pattern rule #2: Program to an interface, not an implementation

設計模式 - 策略模式

定義演算法家族 並把每個演算法封裝起來 演算法之間彼此可以互換

這個模式讓演算法的變動 不影響演算法的使用方式

把抽象的方法抽離在interface 把實作留給interface的subclass

設計模式 - 策略模式

設計模式 - 策略模式

// Context(Duck): 用ConcreteStrategy的物件 來設定自己的狀態
flyBehavior = new FlyWithWings();

// Strategy(FlyBehavior): 制定所有演算法的共同介面 
// Context透過這個interface呼叫ConcreteStrategy實作的演算法
flyBehavior.fly();

優點

  1. 針對同一種行為有不同的實作

  2. 繼承的機制可以把共有的功能提出來

  3. 好維護、好測試、好擴展

缺點

  1. 必須熟悉實作方法

  2. 有可能部分策略用不到

設計模式 - 策略模式

參考資料

單元測試

設計模式-工廠方法(Pizza

設計模式-工廠方法(薯條

系統架構

Design Pattern rule #1: Encapsulate what varies

Design Pattern rule #2: Program to an interface, not an implementation

這兩個必看

SCRUM

架構設計

[軟體開發]概述

By Raiven Kao

Made with Slides.com

[軟體開發]概述

  • 449

More from Raiven Kao