標籤: 收購3c

  • Gogoro 太陽能電池交換站,在新北八里驅動示範

    Gogoro 太陽能電池交換站,在新北八里驅動示範

    新創科技公司 Gogoro 睿能創意股份有限公司,28 日宣布其與新北市政府合作的首座太陽能電池交換站,正式在新北市八里區開始營運。隨著這個搭配太陽能面板的電池交換站的啟動,Gogoro 對永續能源的承諾邁出更關鍵的一步。   這座位於八里十三行博物館附近(新北市八里區文昌路與文昌一街交叉口)的 Gogoro 八里公兒四電池交換站配置 2.3kW 太陽能面板,依據天氣環境等因素,每天可以產生大約 6.21 kWH 的電力,是第一座以再生能源提供電力的 GoStation 電池交換站。太陽能電力不但可以提供電池交換站的 Gogoro 電池使用,降低發電時所產生的二氧化碳排放,更可以與全台電力網路連結,參與整體網路的電量調節。   Gogoro 執行長陸學森表示 :「Gogoro 致力發展潔淨的智慧能源,希望透過具備能源調度能力的智慧電網,成為城市的電力調節樞紐,以促成電力平衡。與新北市政府合作的太陽能八里電池交換示範站為我們上述的目標邁出了重要的一步。」   新北市政府則表示,市府一直在積極尋找降低溫室氣體排放、改善空氣污染的積極方法,與 Gogoro 合作成立全世界第一座太陽能電池交換站具有標竿式的意義。電動機車零排放的特性不但可以提升市區的空氣品質,以再生能源為來源的電力,更可以降低交通工具所帶來的碳排放。未來也將持續努力發展以再生能源補充電力的相關設施,做為新北市重要的基礎設施。   這座太陽能電池交換示範站,設有物聯網智慧平台,透過分析供電情況的螢幕,說明了包括減少碳排量,減少樹木砍伐面積,綠能總儲電量,城市電網 ,太陽能發電量等訊息,讓每名換電的民眾,清楚的知道,自己對環境的貢獻度,也具有相當程度的教育意義。   Gogoro 目前擁有 25,000 名車主,總共累計將近 500 萬次的電池交換,9,000 萬公里的總里程數,已經替地球減少 720 萬公斤的二氧化碳排放,隨著未來再生能源比例逐漸提升,Gogoro 的車主們將更對地球與環境產生更多的正面影響力。Gogoro 為鼓勵車主響應綠能電池交換站,也設計了特別的機制。凡是造訪八里公兒四站,並完成電池交換的車主,即可在 Gogoro App 上獲得「阿波羅的力量」徽章。   (合作媒體:。圖片出處:科技新報)  

    本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

    【其他文章推薦】

    ※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站,提高曝光率!!

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • .NET資源泄露與處理方案

    .NET雖然擁有強大易用的垃圾回收機制,但並不是因為這樣,你就可以對資源管理放任不管,其實在稍不注意的時候,可能就造成了資源泄露,甚至因此導致系統崩潰,到那時再來排查問題就已經是困難重重。

    ==========    ==========

    一、知識點簡單介紹

    常見的資源泄露有:

    • 內存泄漏:非託管資源沒有釋放、非靜態對象註冊了靜態實例。
    • GDI泄露:字體。
    • 句柄泄露:Socket或線程。
    • 用戶對象泄露:移除的對象未釋放。

    二、具體實例

    1. 內存泄漏

    很常見的現象是分不清哪些對象需要釋放,對於控件、Stream等一些非託管資源也只管新增,卻沒有釋放,功能是實現了,卻埋了顆不小的雷。

    private void button1_Click(object sender, EventArgs e)
    {
        for(int i=0;i<1000;i++)
            this.Controls.Add(new TabPage());
    }
    private void button1_Click(object sender, EventArgs e)
    {
        new Form2.ShowDialog();
    }

    如果你覺得寫這樣的代碼很Cool,很簡潔,你在項目中也有這麼寫代碼,那你就碰到大麻煩了,你試試在上面Form2中開個大一點的數組來檢查內存,然後運行,按幾下按鈕,你就會發現,內存一直增加,即使你調用了GC也無濟於事。所以,對於此類非託管資源要記住釋放,用完即廢可以採用using關鍵字。

    public Form2()
    {
        InitializeComponent();
        MyApp.FormChanged += FormChanged;
    }

    上面這個例子中,MyApp是一個靜態類,如果在實例對象中向這種類裏面註冊了事件,而又沒有取消註冊,這樣也會遇到大麻煩,即使在外部已經記得調用了Form2的Dispose也是沒用的。

    解決方案

    • 注意託管資源和非託管資源的釋放區別,非託管資源是需要手動釋放的。
    • ,如上面的ShowDialog問題。(using中還起到了try-catch的作用,避免由於異常未調用Dispose的情況)
    • 使用UnLoad事件或者析構函數,對註冊的全局事件進行取消註冊。
    • 特別注意自定義組件的穩定性更重要,發生問題時影響也更廣。

    2. GDI泄露

    一般會跟字體相關,例如我曾在Android上用Cocos2d做一個小遊戲時頻繁地切換字體、Dev控件的Font屬性賦值也會有這種現象。

    XXX.Font = new Font(...)

    解決方案

    • 這個問題我目前是採用字體池來解決,類似線程池的概念,相同Key值取同一個對象。若有更好方案歡迎留言討論

    3. 句柄泄露

    一般跟Socket和Thread(線程)有關

    for(int i=0;i<1000;i++){
        new Thread(()=>{
            Thread.Sleep(1000);
        }).Start();
    }

    解決方案

    • Socket的場景暫時沒遇到。
    • 線程問題採用線程池相關的輔助類能有效解決,例如ThreadPool、Task、Parallel。

    4. 用戶對象泄露

    一般跟移除的對象未釋放有關

    private void button1_Click(object sender, EventArgs e)
    {
        tab.Remove(tabPage);
    }

    三、最後特別奉送一個內存釋放的大招

    [DllImport("kernel32.dll", EntryPoint = "SetProcessWorkingSetSize")]
    public static extern int SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
    /// <summary>    
    /// 釋放內存    
    /// </summary>    
    public static void ClearMemory()
    {
        GC.Collect();
        GC.WaitForPendingFinalizers();
        if (Environment.OSVersion.Platform == PlatformID.Win32NT)
        {
            SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
        }
    }

    調用以上API能讓你的內存一下爆減,是不是很給力,一調用內存就降下來了。But,先別高興太早,這其實是偽釋放,只是暫時解決內存大量泄漏導致系統崩潰的應急處理方案。具體原因參考:,關鍵信息:物理內存轉虛擬內存,涉及磁盤讀寫。好處壞處都貼出來了,是否需要使用請君自己斟酌。

    四、總結

    實際上由於各個開發人員的水平跟接觸面不同,又沒有經過統一的培訓(各個人對資源釋放的理解與關注度不同,或者寫代碼時就沒考慮內存未被釋放這種問題),發現問題的時候項目往往已經做到了一個階段,系統也比較龐大了,這種時候才發現內存泄露的問題確實是很頭疼的。

    • 資源泄露的場景往往是相互關聯的,發生最多的就是內存泄漏,而除了寫法可能有問題外,也可能是因為句柄泄露或用戶對象泄露引起的。

    五、參考資料

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※為什麼 USB CONNECTOR 是電子產業重要的元件?

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • java中的string對象深入了解

    java中的string對象深入了解

    這裏來對Java中的String對象做一個稍微深入的了解。

    Java對象實現的演進

    String對象是Java中使用最頻繁的對象之一,所以Java開發者們也在不斷地對String對象的實現進行優化,以便提升String對象的性能。

    Java6以及之前版本中String對象的屬性

    在Java6以及之前版本中,String對象是對char數組進行了封裝實現的對象,其主要有4個成員成員變量,分別是char數組、偏移量offset、字符數量count和哈希值hash。String對象是通過offset和count兩個屬性來定位char[]數組,獲取字符串。這樣做可以高效、快速地共享數組對象,同時節省內存空間,但是這種方式卻可能會導致內存泄漏的發生。

    Java7、8版本中String對象的屬性

    從Java7版本開始,Java對String類做了一些改變,具體是String類不再有offset和count兩個變量了。這樣做的好處是String對象佔用的內存稍微少了點,同時String.substring()方法也不再共享char[]了,從而解決了使用該方法可能導致的內存泄漏問題。

    Java9以及之後版本中String對象的屬性

    從Java9版本開始,Java將char[]數組改為了byte[]數組。我們都知道,char是兩個字節的,如果用來存一個字節的情況下就會造成內存空間的浪費。而為了節約這一個字節的空間,Java開發者就改成了一個使用一個字節的byte來存儲字符串。

    另外,在Java9中,String對象維護了一個新的屬性coder,這個屬性是編碼格式的標識,在計算字符串長度或者調用indexOf()方法的時候,會需要根據這個字段去判斷如何計算字符串長度。coder屬性默認有0和1兩個值,其中0代表Latin-1(單字節編碼),1則表示UTF-16編碼。

    String對象的創建方式與在內存中的存放

    在Java中,對於基本數據類型的變量和對對象的引用,保存在棧內存的局部變量表中;而通過new關鍵字和Constructor創建的對象,則是保存在堆內存中。而String對象的創建方式一般為兩種,一種是字面量(字符串常量)的方式,一種則是構造函數(String())的方式,兩種方式在內存中的存放有所不同。

    字面量(字符串常量)的創建方式

    使用字面量的方式創建字符串時,JVM會在字符串常量池中先檢查是否存在該字面量,如果存在,則返回該字面量在內存中的引用地址;如果不存在,則在字符串常量池中創建該字面量並返回引用。使用這種方式創建的好處是避免了相同值的字符串在內存中被重複創建,節約了內存,同時這種寫法也會比較簡單易讀一些。

    String str = "i like yanggb.";

    字符串常量池

    這裏要特別說明一下常量池。常量池是JVM為了減少字符串對象的重複創建,特別維護了一個特殊的內存,這段內存被稱為字符串常量池或者字符串字面量池。在JDK1.6以及之前的版本中,運行時常量池是在方法區中的。在JDK1.7以及之後版本的JVM,已經將運行時常量池從方法區中移了出來,在Java堆(Heap)中開闢了一塊區域用來存放運行時常量池。而從JDK1.8開始,JVM取消了Java方法區,取而代之的是位於直接內存的元空間(MetaSpace)。總結就是,目前的字符串常量池在堆中。

    我們所知道的幾個String對象的特點都來源於String常量池。

    1.在常量池中會共享所有的String對象,因此String對象是不可被修改的,因為一旦被修改,就會導致所有引用此String對象的變量都隨之改變(引用改變),所以String對象是被設計為不可修改的,後面會對這個不可變的特性做一個深入的了解。

    2.String對象拼接字符串的性能較差的說法也是來源於此,因為String對象不可變的特性,每次修改(這裡是拼接)都是返回一個新的字符串對象,而不是再原有的字符串對象上做修改,因此創建新的String對象會消耗較多的性能(開闢另外的內存空間)。

    3.因為常量池中創建的String對象是共享的,因此使用雙引號聲明的String對象(字面量)會直接存儲在常量池中,如果該字面量在之前已存在,則是會直接引用已存在的String對象,這一點在上面已經描述過了,這裏再次提及,是為了特別說明這一做法保證了在常量池中的每個String對象都是唯一的,也就達到了節約內存的目的。

    構造函數(String())的創建方式

    使用構造函數的方式創建字符串時,JVM同樣會在字符串常量池中先檢查是否存在該字面量,只是檢查后的情況會和使用字面量創建的方式有所不同。如果存在,則會在堆中另外創建一個String對象,然後在這個String對象的內部引用該字面量,最後返回該String對象在內存地址中的引用;如果不存在,則會先在字符串常量池中創建該字面量,然後再在堆中創建一個String對象,然後再在這個String對象的內部引用該字面量,最後返回該String對象的引用。

    String str = new String("i like yanggb.");

    這就意味着,只要使用這種方式,構造函數都會另行在堆內存中開闢空間,創建一個新的String對象。具體的理解是,在字符串常量池中不存在對應的字面量的情況下,new String()會創建兩個對象,一個放入常量池中(字面量),一個放入堆內存中(字符串對象)。

    String對象的比較

    比較兩個String對象是否相等,通常是有【==】和【equals()】兩個方法。

    在基本數據類型中,只可以使用【==】,也就是比較他們的值是否相同;而對於對象(包括String)來說,【==】比較的是地址是否相同,【equals()】才是比較他們內容是否相同;而equals()是Object都擁有的一個函數,本身就要求對內部值進行比較。

    String str = "i like yanggb.";
    String str1 = new String("i like yanggb.");
    
    System.out.println(str == str1); // false
    System.out.println(str.equals(str1)); // true

    因為使用字面量方式創建的String對象和使用構造函數方式創建的String對象的內存地址是不同的,但是其中的內容卻是相同的,也就導致了上面的結果。

    String對象中的intern()方法

    我們都知道,String對象中有很多實用的方法。為什麼其他的方法都不說,這裏要特別說明這個intern()方法呢,因為其中的這個intern()方法最為特殊。它的特殊性在於,這個方法在業務場景中幾乎用不上,它的存在就是在為難程序員的,也可以說是為了幫助程序員了解JVM的內存結構而存在的(?我信你個鬼,你個糟老頭子壞得很)。

    /**
    * When the intern method is invoked, if the pool already contains a
    * string equal to this {@code String} object as determined by
    * the {@link #equals(Object)} method, then the string from the pool is
    * returned. Otherwise, this {@code String} object is added to the
    * pool and a reference to this {@code String} object is returned.
    **/
    public native String intern();

    上面是源碼中的intern()方法的官方註釋說明,大概意思就是intern()方法用來返回常量池中的某字符串,如果常量池中已經存在該字符串,則直接返回常量池中該對象的引用。否則,在常量池中加入該對象,然後返回引用。然後我們可以從方法簽名上看出intern()方法是一個native方法。

    下面通過幾個例子來詳細了解下intern()方法的用法。

    第一個例子

    String str1 = new String("1");
    System.out.println(str1 == str1.intern()); // false
    System.out.println(str1 == "1"); // false

    在上面的例子中,intern()方法返回的是常量池中的引用,而str1保存的是堆中對象的引用,因此兩個打印語句的結果都是false。

    第二個例子

    String str2 = new String("2") + new String("3");
    System.out.println(str2 == str2.intern()); // true
    System.out.println(str2 == "23"); // true

    在上面的例子中,str2保存的是堆中一個String對象的引用,這和JVM對【+】的優化有關。實際上,在給str2賦值的第一條語句中,創建了3個對象,分別是在字符串常量池中創建的2和3、還有在堆中創建的字符串對象23。因為字符串常量池中不存在字符串對象23,所以這裏要特別注意:intern()方法在將堆中存在的字符串對象加入常量池的時候採取了一種截然不同的處理方案——不是在常量池中建立字面量,而是直接將該String對象自身的引用複製到常量池中,即常量池中保存的是堆中已存在的字符串對象的引用。根據前面的說法,這時候調用intern()方法,就會在字符串常量池中複製出一個對堆中已存在的字符串常量的引用,然後返回對字符串常量池中這個對堆中已存在的字符串常量池的引用的引用(就是那麼繞,你來咬我呀)。這樣,在調用intern()方法結束之後,返回結果的就是對堆中該String對象的引用,這時候使用【==】去比較,返回的結果就是true了。同樣的,常量池中的字面量23也不是真正意義的字面量23了,它真正的身份是堆中的那個String對象23。這樣的話,使用【==】去比較字面量23和str2,結果也就是true了。

    第三個例子

    String str4 = "45";
    String str3 = new String("4") + new String("5");
    System.out.println(str3 == str3.intern()); // false
    System.out.println(str3 == "45"); // false

    這個例子乍然看起來好像比前面的例子還要複雜,實際上卻和上面的第一個例子是一樣的,最難理解的反而是第二個例子。

    所以這裏就不多說了,而至於為什麼還要舉這個例子,我相信聰明的你一下子就明白了(我有醫保,你來打我呀)。

    String對象的不可變性

    先來看String對象的一段源碼。

    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
        /** The value is used for character storage. */
        private final char value[];
    
        /** Cache the hash code for the string */
        private int hash; // Default to 0
    
        /** use serialVersionUID from JDK 1.0.2 for interoperability */
        private static final long serialVersionUID = -6849794470754667710L;
    }

    從類簽名上來看,String類用了final修飾符,這就意味着這個類是不能被繼承的,這是決定String對象不可變特性的第一點。從類中的數組char[] value來看,這個類成員變量被private和final修飾符修飾,這就意味着其數值一旦被初始化之後就不能再被更改了,這是決定String對象不可變特性的第二點。

    Java開發者為什麼要將String對象設置為不可變的,主要可以從以下三個方面去考慮:

    1.安全性。假設String對象是可變的,那麼String對象將可能被惡意修改。

    2.唯一性。這個做法可以保證hash屬性值不會頻繁變更,也就確保了唯一性,使得類似HashMap的容器才能實現相應的key-value緩存功能。

    3.功能性。可以實現字符串常量池(究竟是先有設計,還是先有實現呢)。

    String對象的優化

    字符串是常用的Java類型之一,所以對字符串的操作是避免不了的。而在對字符串的操作過程中,如果使用不當的話,性能可能會有天差地別,所以有一些地方是要注意一下的。

    拼接字符串的性能優化

    字符串的拼接是對字符串的操作中最頻繁的一個使用。由於我們都知道了String對象的不可變性,所以我們在開發過程中要盡量減少使用【+】進行字符串拼接操作。這是因為使用【+】進行字符串拼接,會在得到最終想要的結果前產生很多無用的對象。

    String str = 'i';
    str = str + ' ';
    str = str + 'like';
    str = str + ' ';
    str = str + 'yanggb';
    str = str + '.';
    
    System.out.println(str); // i like yanggb.

    事實上,如果我們使用的是比較智能的IDE編寫代碼的話,編譯器是會提示將代碼優化成使用StringBuilder或者StringBuffer對象來優化字符串的拼接性能的,因為StringBuilder和StringBuffer都是可變對象,也就避免了過程中產生無用的對象了。而這兩種替代方案的區別是,在需要線程安全的情況下,選用StringBuffer對象,這個對象是支持線程安全的;而在不需要線程安全的情況下,選用StringBuilder對象,因為StringBuilder對象的性能在這種場景下,要比StringBuffer對象或String對象要好得多。

    使用intern()方法優化內存佔用

    前面吐槽了intern()方法在實際開發中沒什麼用,這裏又來說使用intern()方法來優化內存佔用了,這人真的是,嘿嘿,真香。關於方法的使用就不說了,上面有詳盡的用法說明,這裏來說說具體的應用場景好了。有一位Twitter的工程師在Qcon全球軟件開發大會上分享了一個他們對String對象優化的案例,他們利用了這個String.intern()方法將以前需要20G內存存儲優化到只需要幾百兆內存。具體就是,使用intern()方法將原本需要創建到堆內存中的String對象都放到常量池中,因為常量池的不重複特性(存在則返回引用),也就避免了大量的重複String對象造成的內存浪費問題。

    什麼,要我給intern()方法道歉?不可能。String.intern()方法雖好,但是也是需要結合場景來使用的,並不能夠亂用。因為實際上,常量池的實現是類似於一個HashTable的實現方式,而HashTable存儲的數據越大,遍歷的時間複雜度就會增加。這就意味着,如果數據過大的話,整個字符串常量池的負擔就會大大增加,有可能性能不會得到提升卻反而有所下降。

    字符串分割的性能優化

    字符串的分割是字符串操作的常用操作之一,對於字符串的分割,大部分人使用的都是split()方法,split()方法在大部分場景下接收的參數都是正則表達式,這種分割方式本身沒有什麼問題,但是由於正則表達式的性能是非常不穩定的,使用不恰當的話可能會引起回溯問題並導致CPU的佔用居高不下。在以下兩種情況下split()方法不會使用正則表達式:

    1.傳入的參數長度為1,且不包含“.$|()[{^?*+\”regex元字符的情況下,不會使用正則表達式。

    2.傳入的參數長度為2,第一個字符是反斜杠,並且第二個字符不是ASCII数字或ASCII字母的情況下,不會使用正則表達式。

    所以我們在字符串分割時,應該慎重使用split()方法,而首先考慮使用String.indexOf()方法來進行字符串分割,在String.indexOf()無法滿足分割要求的時候再使用Split()方法。而在使用split()方法分割字符串時,需要格外注意回溯問題。

    總結

    雖然說在不了解String對象的情況下也能使用String對象進行開發,但是了解String對象可以幫助我們寫出更好的代碼。

     

    “只希望在故事的最後,我還是我,你也還是你。”

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

    ※評比前十大台北網頁設計台北網站設計公司知名案例作品心得分享

    ※智慧手機時代的來臨,RWD網頁設計已成為網頁設計推薦首選

  • AutoCad 二次開發 文字鏡像

    AutoCad 二次開發 文字鏡像

    AutoCad 二次開發 文字鏡像

    參考: 在autocad中如果使用Mirror命令把塊參照給鏡像了(最終得到一個對稱的塊),塊裏面的文字包括DBText和MText以及標註上面的文字都會被對稱,變得不易閱讀。而在單個字體實體和標註實體鏡像的時候只要設置系統變量mirrtext為0鏡像后的文字就不會與原文字對稱變成我們未學習過的文字了。   所以我們在鏡像塊的時候就可以先把塊炸開是用快捷鍵X,或者輸入explode,然後在使用鏡像命令。之後在把對稱后的實體集合組成一個新的塊。不過這樣操作十分的繁瑣,我覺得其中這樣做的優勢是mirror時的jig操作可以很方便的預先知道我們想要的對稱后的結果。但如果用代碼實現這種jig操作,我覺得有點複雜,目前我還不知道怎麼實現。   我要講的主要就是用代碼來實現塊的鏡像。難點就在與文字的鏡像,和標註的鏡像。這篇文章先講文字的鏡像。文字鏡像的主要步驟分為: 1.找到鏡像前文字邊界的四個角,這四個角構成了一個矩形,我們要求得這個矩形的長和寬所代表的向量。 2.判斷文字鏡像后的方向,如果是偏向朝Y軸鏡像,那麼文字鏡像后的方向是沿着X軸翻轉的,如果是偏向朝X軸鏡像,那麼文字鏡像后的方向是沿着X軸翻轉的。這裏我以沿着Y軸鏡像為例子。 3.移動鏡像后切被翻轉后的文字,這裏也是根據鏡像軸的不同,需按不同的向量來移動。   詳細情況見圖: 圖中左邊是要鏡像的文字,文字上的藍色線,和黃色線是我調試的時候加入的,黃線左端是 pt1,右端是pt2,藍線左端是pt3,右端是pt4。 中間的豎線是Y軸鏡像線,右邊就是不同情況下鏡像后的文字。其中黃色部分表示正確的鏡像結果,紅色部分表示:鏡像后延第一個步驟移動后求得的向量移動了文字的position但是沒翻轉的結果。黑色部分表示:鏡像后翻轉了文字但文字的position沒有按向量移動的結果。 下面我就來仔細分析一下代碼: 要實現第一步驟,前提是要有一段P/Invoke的代碼: 其中 引入的acdb22.dll是 autocad2018中的版本,不同版本,這個dll後面的数字不一樣。我們可以到cad安裝目錄下查找acdb幾個字,找到後面帶数字的就是了,64位的安裝目錄默認位置:C:\Program Files\Autodesk\AutoCAD 2018。這兩個函數一個是32位,一個是64位,具體用哪個後面的代碼會自動判斷。這個函數作用我覺得主要是求 這個name。   這裏用到了accore.dll,有的cad版本沒有這個dll,就用acad.exe代替就可以了。上面的acdbEntGet主要是根據entity的名字求的entity實體的Intptr,下面的函數時求的文字邊界對角點,這裏注意,我把這個兩個點用直線打印在cad空間里,發現它時在原點,沒旋轉的線,但其實文字不的position不在原點,也帶有旋轉角度。後面要求的文字邊界向量就是根據這兩個點來的。 上面求得的pt1,pt2 經過:
    pt1 = pt1.TransformBy(rotMat).Add(dbText.Position.GetAsVector());
    pt2 = pt2.TransformBy(rotMat).Add(dbText.Position.GetAsVector()); 這種操作就得到了第一幅圖中的黃線。 在經過這樣的操作,得到的pt3 和pt4就是第一幅圖的藍線。這其中的rotDir和linDir就是我們要求得的寬和長代表的向量了,然後在把它給鏡像了得到的mirRotDir和mirLinDir就是鏡像后的文字要移動的向量了,這裏第一步就結束了。 第二步,第三步:   大的話,就說明文字需要朝X軸翻轉,所以這裏的IsMirroredInX=true就代表需要朝X軸翻轉。 緊接着下面句,如果沒加mirLineDir這個向量,就會出現第一幅圖中的畫黑線的情況,如果不加IsMirrorInX就會出現畫紅線的情況。 到這裏就全部結束了。 下面給出所有代碼:

    public class MyMirror
        {
            Document Doc = Application.DocumentManager.MdiActiveDocument;
            Editor Ed = Application.DocumentManager.MdiActiveDocument.Editor;
            Database Db = Application.DocumentManager.MdiActiveDocument.Database;
    
            List<Entity> list = new List<Entity>();
            List<ObjectId> listOId = new List<ObjectId>();
    
            [CommandMethod("testM")]
    
            public void MirrorTextCmd()
    
            {
    
                Document doc = Application.DocumentManager.MdiActiveDocument;
    
                Database db = doc.Database;
    
                Editor ed = doc.Editor;
    
    
    
                //Entity selection
    
                PromptEntityOptions peo = new PromptEntityOptions(
    
                    "\nSelect a text entity:");
    
    
    
                peo.SetRejectMessage("\nMust be text entity...");
    
                peo.AddAllowedClass(typeof(DBText), true);
    
    
    
                PromptEntityResult perText = ed.GetEntity(peo);
    
    
    
                if (perText.Status != PromptStatus.OK)
    
                    return;
    
    
    
                peo = new PromptEntityOptions("\nSelect a mirror line:");
    
                peo.SetRejectMessage("\nMust be a line entity...");
    
                peo.AddAllowedClass(typeof(Line), true);
    
    
    
                PromptEntityResult perLine = ed.GetEntity(peo);
    
    
    
                if (perLine.Status != PromptStatus.OK)
    
                    return;
    
    
    
                using (Transaction tr = db.TransactionManager.StartTransaction())
    
                {
    
                    Line line = tr.GetObject(perLine.ObjectId, OpenMode.ForRead)
    
                        as Line;
    
    
    
                    Line3d mirrorLine = new Line3d(
    
                        line.StartPoint,
    
                        line.EndPoint);
    
    
    
                    MirrorText(perText.ObjectId, mirrorLine);
    
    
    
                    tr.Commit();
    
                }
    
            }
    
    
    
            void MirrorText(ObjectId oId, Line3d mirrorLine)
    
            {
    
                Database db = oId.Database;
    
    
    
                using (Transaction tr = db.TransactionManager.StartTransaction())
    
                {
    
                    // Get text entity
    
                    DBText dbText = tr.GetObject(oId, OpenMode.ForRead)
    
                        as DBText;
    
    
    
                    // Clone original entity
    
                    DBText mirroredTxt = dbText.Clone() as DBText;
    
    
    
                    // Create a mirror matrix
    
                    Matrix3d mirrorMatrix = Matrix3d.Mirroring(mirrorLine);
    
    
    
                    // Do a geometric mirror on the cloned text
    
                    mirroredTxt.TransformBy(mirrorMatrix);
    
    
    
                    // Get text bounding box
    
                    Point3d pt1, pt2, pt3, pt4;
    
                    GetTextBoxCorners(
    
                        dbText,
    
                        out pt1,
    
                        out pt2,
    
                        out pt3,
    
                        out pt4);
    
    
    
                    // Get the perpendicular direction to the original text
    
                    Vector3d rotDir =
    
                        pt4.Subtract(pt1.GetAsVector()).GetAsVector();
    
    
    
                    // Get the colinear direction to the original text
    
                    Vector3d linDir =
    
                        pt3.Subtract(pt1.GetAsVector()).GetAsVector();
    
    
    
                    // Compute mirrored directions
    
                    Vector3d mirRotDir = rotDir.TransformBy(mirrorMatrix);
    
                    Vector3d mirLinDir = linDir.TransformBy(mirrorMatrix);
    
    
    
                    //Check if we need to mirror in Y or in X
    
                    if (Math.Abs(mirrorLine.Direction.Y) >
    
                        Math.Abs(mirrorLine.Direction.X))
    
                    {
    
                        // Handle the case where text is mirrored twice
    
                        // instead of doing "oMirroredTxt.IsMirroredInX = true"
    
                        mirroredTxt.IsMirroredInX = !mirroredTxt.IsMirroredInX;
    
                        mirroredTxt.Position = mirroredTxt.Position + mirLinDir;
    
                    }
    
                    else
    
                    {
    
                        mirroredTxt.IsMirroredInY = !mirroredTxt.IsMirroredInY;
    
                        mirroredTxt.Position = mirroredTxt.Position + mirRotDir;
    
                    }
    
    
    
                    // Add mirrored text to database
    
                    //btr.AppendEntity(mirroredTxt);
    
                    //tr.AddNewlyCreatedDBObject(mirroredTxt, true);
    
                    //list.Add(mirroredTxt);
                    mirroredTxt.ToSpace();
                    tr.Commit();
    
                }
    
            }
            #region p/Invoke
    
    
            public struct ads_name
            {
    
                public IntPtr a;
    
                public IntPtr b;
    
            };
    
    
    
            // Exported function names valid only for R19
    
    
    
            [DllImport("acdb22.dll",
    
                CallingConvention = CallingConvention.Cdecl,
    
                EntryPoint = "?acdbGetAdsName@@YA?AW4ErrorStatus@Acad@@AAY01JVAcDbObjectId@@@Z")]
    
            public static extern int acdbGetAdsName32(
    
                ref ads_name name,
    
                ObjectId objId);
    
    
    
            [DllImport("acdb22.dll",
    
                CallingConvention = CallingConvention.Cdecl,
    
                EntryPoint = "?acdbGetAdsName@@YA?AW4ErrorStatus@Acad@@AEAY01_JVAcDbObjectId@@@Z")]
    
            public static extern int acdbGetAdsName64(
    
                ref ads_name name,
    
                ObjectId objId);
    
    
    
            public static int acdbGetAdsName(ref ads_name name, ObjectId objId)
    
            {
    
                if (Marshal.SizeOf(IntPtr.Zero) > 4)
    
                    return acdbGetAdsName64(ref name, objId);
    
    
    
                return acdbGetAdsName32(ref name, objId);
    
            }
    
    
    
            [DllImport("accore.dll",
    
                CharSet = CharSet.Unicode,
    
                CallingConvention = CallingConvention.Cdecl,
    
                EntryPoint = "acdbEntGet")]
    
            public static extern System.IntPtr acdbEntGet(
    
                ref ads_name ename);
    
    
    
            [DllImport("accore.dll",
    
                CharSet = CharSet.Unicode,
    
                CallingConvention = CallingConvention.Cdecl,
    
                EntryPoint = "acedTextBox")]
    
            public static extern System.IntPtr acedTextBox(
    
                IntPtr rb,
    
                double[] point1,
    
                double[] point2);
    
    
    
            void GetTextBoxCorners(DBText dbText, out Point3d pt1, out Point3d pt2, out Point3d pt3, out Point3d pt4)
    
            {
    
                ads_name name = new ads_name();
    
    
    
                int result = acdbGetAdsName(
    
                    ref name,
    
                    dbText.ObjectId);
    
    
    
                ResultBuffer rb = new ResultBuffer();
    
    
    
                Interop.AttachUnmanagedObject(
    
                    rb,
    
                    acdbEntGet(ref name), true);
    
    
    
                double[] point1 = new double[3];
    
                double[] point2 = new double[3];
    
    
    
                // Call imported arx function
    
                acedTextBox(rb.UnmanagedObject, point1, point2);
    
    
    
                pt1 = new Point3d(point1);
    
                pt2 = new Point3d(point2);
    
                var ptX = pt1 + Vector3d.XAxis * 40;
                var ptY = pt2 + Vector3d.YAxis * 50;
    
    
                var lX = new Line(pt1, ptX);
                var lY = new Line(pt2, ptY);
    
                lX.Color= Color.FromColor(System.Drawing.Color.Green);
                lY.Color= Color.FromColor(System.Drawing.Color.Orange);
    
    
                Line line = new Line(pt1, pt2);
    
                line.Color = Color.FromColor(System.Drawing.Color.Red);
    
                line.ToSpace();
                lX.ToSpace();
                lY.ToSpace();
    
                // Create rotation matrix
    
                Matrix3d rotMat = Matrix3d.Rotation(
    
                    dbText.Rotation,
    
                    dbText.Normal,
    
                    pt1);
    
    
    
                // The returned points from acedTextBox need
    
                // to be transformed as follow
    
                pt1 = pt1.TransformBy(rotMat).Add(dbText.Position.GetAsVector());
    
                pt2 = pt2.TransformBy(rotMat).Add(dbText.Position.GetAsVector());
    
                Line linetrans = new Line(pt1, pt2);
    
                linetrans.Color = Color.FromColor(System.Drawing.Color.Yellow) ;
    
                linetrans.ToSpace();
    
    
                Vector3d rotDir = new Vector3d(
    
                    -Math.Sin(dbText.Rotation),
    
                    Math.Cos(dbText.Rotation), 0);
    
    
                //求垂直於rotDir和normal的法向量
                Vector3d linDir = rotDir.CrossProduct(dbText.Normal);
    
    
    
                double actualWidth =
    
                    Math.Abs((pt2.GetAsVector() - pt1.GetAsVector())
    
                        .DotProduct(linDir));
    
    
    
                pt3 = pt1.Add(linDir * actualWidth);
    
                pt4 = pt2.Subtract(linDir * actualWidth);
    
                Line linetrans2 = new Line(pt3, pt4);
    
                linetrans2.Color = Color.FromColor(System.Drawing.Color.Blue);
    
                linetrans2.ToSpace();
            }
    
            #endregion
        }

     

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站,提高曝光率!!

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • 023.掌握Pod-Pod擴容和縮容

    023.掌握Pod-Pod擴容和縮容

    一 Pod的擴容和縮容

    Kubernetes對Pod的擴縮容操作提供了手動和自動兩種模式,手動模式通過執行kubectl scale命令或通過RESTful API對一個Deployment/RC進行Pod副本數量的設置。自動模式則需要用戶根據某個性能指標或者自定義業務指標,並指定Pod副本數量的範圍,系統將自動在這個範圍內根據性能指標的變化進行調整。

    1.1 手動縮容和擴容

      1 [root@uk8s-m-01 study]# vi nginx-deployment.yaml
      2 apiVersion: apps/v1beta1
      3 kind: Deployment
      4 metadata:
      5   name: nginx-deployment
      6 spec:
      7   replicas: 3
      8   template:
      9     metadata:
     10       labels:
     11         app: nginx
     12     spec:
     13       containers:
     14       - name: nginx
     15         image: nginx:1.7.9
     16         ports:
     17         - containerPort: 80
      1 [root@uk8s-m-01 study]# kubectl create -f nginx-deployment.yaml
      2 [root@uk8s-m-01 study]# kubectl scale deployment nginx-deployment --replicas=5	#擴容至5個
      3 [root@uk8s-m-01 study]# kubectl get pods	                                	#查看擴容后的Pod

      1 [root@uk8s-m-01 study]# kubectl scale deployment nginx-deployment --replicas=2	#縮容至2個
      2 [root@uk8s-m-01 study]# kubectl get pods

    1.2 自動擴容機制

    Kubernetes使用Horizontal Pod Autoscaler(HPA)的控制器實現基於CPU使用率進行自動Pod擴縮容的功能。HPA控制器基於Master的kube-controller-manager服務啟動參數–horizontal-pod-autoscaler-sync-period定義的探測周期(默認值為15s),周期性地監測目標Pod的資源性能指標,並與HPA資源對象中的擴縮容條件進行對比,在滿足條件時對Pod副本數量進行調整。

    • HPA原理

    Kubernetes中的某個Metrics Server(Heapster或自定義MetricsServer)持續採集所有Pod副本的指標數據。HPA控制器通過Metrics Server的API(Heapster的API或聚合API)獲取這些數據,基於用戶定義的擴縮容規則進行計算,得到目標Pod副本數量。
    當目標Pod副本數量與當前副本數量不同時,HPA控制器就向Pod的副本控制器(Deployment、RC或ReplicaSet)發起scale操作,調整Pod的副本數量,完成擴縮容操作。

    • HPA指標類型

    Master的kube-controller-manager服務持續監測目標Pod的某種性能指標,以計算是否需要調整副本數量。目前Kubernetes支持的指標類型如下:
    Pod資源使用率:Pod級別的性能指標,通常是一個比率值,例如CPU使用率。
    Pod自定義指標:Pod級別的性能指標,通常是一個數值,例如接收的請求數量。
    Object自定義指標或外部自定義指標:通常是一個數值,需要容器應用以某種方式提供,例如通過HTTP URL“/metrics”提供,或者使用外部服務提供的指標採集URL。
    Metrics Server將採集到的Pod性能指標數據通過聚合API(Aggregated API) 如metrics.k8s.io、 custom.metrics.k8s.io和external.metrics.k8s.io提供給HPA控制器進行查詢。

    • 擴縮容算法

    Autoscaler控制器從聚合API獲取到Pod性能指標數據之後,基於下面的算法計算出目標Pod副本數量,與當前運行的Pod副本數量進行對比,決定是否需要進行擴縮容操作:
    desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]

    即當前副本數 x(當前指標值/期望的指標值),將結果向上取整。
    釋義:以CPU請求數量為例,如果用戶設置的期望指標值為100m,當前實際使用的指標值為200m,則計算得到期望的Pod副本數量應為兩個(200/100=2)。如果設置的期望指標值為50m,計算結果為0.5,則向上取整值為1, 得到目標Pod副本數量應為1個。
    注意:當計算結果與1非常接近時,可以設置一個容忍度讓系統不做擴縮容操作。容忍度通過kube-controller-manager服務的啟動參數–horizontalpod-autoscaler-tolerance進行設置,默認值為0.1(即10%),表示基於上述算法得到的結果在[-10%-+10%]區間內,即[0.9-1.1],控制器都不會進行擴縮容操作
    也可以將期望指標值(desiredMetricValue)設置為指標的平均值類型,例如targetAverageValue或targetAverageUtilization,此時當前指標值(currentMetricValue) 的算法為所有Pod副本當前指標值的總和除以Pod副本數量得到的平均值。
    此外,存在幾種Pod異常的如下情況:

    • Pod正在被刪除(設置了刪除時間戳):將不會計入目標Pod副本數量。
    • Pod的當前指標值無法獲得:本次探測不會將這個Pod納入目標Pod副本數量,後續的探測會被重新納入計算範圍。
    • 如果指標類型是CPU使用率,則對於正在啟動但是還未達到Ready狀態的Pod,也暫時不會納入目標副本數量範圍。

    提示:可以通過kubecontroller-manager服務的啟動參數–horizontal-pod-autoscaler-initialreadiness-delay設置首次探測Pod是否Ready的延時時間,默認值為30s。

    另一個啟動參數–horizontal-pod-autoscaler-cpuinitialization-period設置首次採集Pod的CPU使用率的延時時間。
    當存在缺失指標的Pod時,系統將更保守地重新計算平均值。系統會假設這些Pod在需要縮容(Scale Down) 時消耗了期望指標值的100%,在需要擴容(Scale Up)時消耗了期望指標值的0%,這樣可以抑制潛在的擴縮容操作。
    此外,如果存在未達到Ready狀態的Pod,並且系統原本會在不考慮缺失指標或NotReady的Pod情況下進行擴展,則系統仍然會保守地假設這些Pod消耗期望指標值的0%,從而進一步抑制擴容操作。如果在HorizontalPodAutoscaler中設置了多個指標,系統就會對每個指標都執行上面的算法,在全部結果中以期望副本數的最大值為最終結果。如果這些指標中的任意一個都無法轉換為期望的副本數(例如無法獲取指標的值),系統就會跳過擴縮容操作。
    最後, 在HPA控制器執行擴縮容操作之前,系統會記錄擴縮容建議信息(Scale Recommendation)。控制器會在操作時間窗口(時間範圍可以配置)中考慮所有的建議信息,並從中選擇得分最高的建議。這個值可通過kube-controller-manager服務的啟動參數–horizontal-podautoscaler-downscale-stabilization-window進行配置,默認值為5min。這個配置可以讓系統更為平滑地進行縮容操作,從而消除短時間內指標值快速波動產生的影響。

    1.3 HorizontalPodAutoscaler

    Kubernetes將HorizontalPodAutoscaler資源對象提供給用戶來定義擴縮容的規則。
    HorizontalPodAutoscaler資源對象處於Kubernetes的API組“autoscaling”中, 目前包括v1和v2兩個版本。 其中autoscaling/v1僅支持基於CPU使用率的自動擴縮容, autoscaling/v2則用於支持基於任意指標的自動擴縮容配置, 包括基於資源使用率、 Pod指標、 其他指標等類型的指標數據。
    示例1:基於autoscaling/v1版本的HorizontalPodAutoscaler配置,僅可以設置CPU使用率。

      1 [root@uk8s-m-01 study]# vi php-apache-autoscaling-v1.yaml
      2 apiVersion: autoscaling/v1
      3 kind: HorizontalPodAutoscaler
      4 metadata:
      5   name: php-apache
      6 spec:
      7   scaleTargetRef:
      8     apiVersion: apps/v1
      9     kind: Deployment
     10     name: php-apache
     11   minReplicas: 1
     12   maxReplicas: 10
     13   targetCPUUtilizationPercentage: 50


    釋義:
    scaleTargetRef:目標作用對象,可以是Deployment、ReplicationController或ReplicaSet。
    targetCPUUtilizationPercentage:期望每個Pod的CPU使用率都為50%,該使用率基於Pod設置的CPU Request值進行計算,例如該值為200m,那麼系統將維持Pod的實際CPU使用值為100m。
    minReplicas和maxReplicas:Pod副本數量的最小值和最大值,系統將在這個範圍內進行自動擴縮容操作, 並維持每個Pod的CPU使用率為50%。
    為了使用autoscaling/v1版本的HorizontalPodAutoscaler,需要預先安裝Heapster組件或Metrics Server,用於採集Pod的CPU使用率。
    示例2:基於autoscaling/v2beta2的HorizontalPodAutoscaler配置。

      1 [root@uk8s-m-01 study]# vi php-apache-autoscaling-v2.yaml
      2 apiVersion: autoscaling/v2beta2
      3 kind: HorizontalPodAutoscaler
      4 metadata:
      5   name: php-apache
      6 spec:
      7   scaleTargetRef:
      8     apiVersion: apps/v1
      9     kind: Deployment
     10     name: php-apache
     11   minReplicas: 1
     12   maxReplicas: 10
     13   metrics:
     14   - type: Resource
     15     resource:
     16       name: cpu
     17       target:
     18         type: Utilization
     19         averageUtilization: 50


    釋義:
    scaleTargetRef:目標作用對象,可以是Deployment、ReplicationController或ReplicaSet。
    minReplicas和maxReplicas:Pod副本數量的最小值和最大值,系統將在這個範圍內進行自動擴縮容操作, 並維持每個Pod的CPU使用率為50%。
    metrics:目標指標值。在metrics中通過參數type定義指標的類型;通過參數target定義相應的指標目標值,系統將在指標數據達到目標值時(考慮容忍度的區間)觸發擴縮容操作。

    • metrics中的type(指標類型)設置為以下幾種:
      • Resource:基於資源的指標值,可以設置的資源為CPU和內存。
      • Pods:基於Pod的指標,系統將對全部Pod副本的指標值進行平均值計算。
      • Object:基於某種資源對象(如Ingress)的指標或應用系統的任意自定義指標。

    Resource類型的指標可以設置CPU和內存。對於CPU使用率,在target參數中設置averageUtilization定義目標平均CPU使用率。對於內存資源,在target參數中設置AverageValue定義目標平均內存使用值。指標數據可以通過API“metrics.k8s.io”進行查詢,要求預先啟動Metrics Server服務。
    Pods類型和Object類型都屬於自定義指標類型,指標的數據通常需要搭建自定義Metrics Server和監控工具進行採集和處理。指標數據可以通過API“custom.metrics.k8s.io”進行查詢,要求預先啟動自定義Metrics Server服務。
    類型為Pods的指標數據來源於Pod對象本身, 其target指標類型只能使用AverageValue,示例:

      1  metrics:
      2   - type: Pods
      3     pods:
      4       metrics:
      5         name: packets-per-second
      6       target:
      7         type: AverageValue
      8         averageValue: 1k

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※為什麼 USB CONNECTOR 是電子產業重要的元件?

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • 軟件架構模式

    軟件架構模式

    閱讀也花了較長的時間,大致也了解到整潔的架構要做到以下兩點:

    • well-isolated components:component是獨立部署的最小單元,由一系列遵循SOLID原則的module按照REP、CCP、CEP原則組成。
    • dependency rule:低層的detail去依賴高層的police

    但感覺並沒有對架構設計給出可行的參考。

    clean architecture 中的架構實例

    在的第34章 “The Missing Chapter”(由 Simon Brown 編寫)給出了一個具體的案例,用四種架構設計來實現一個 “online book store”。

    package by layer

    這是最常見的方案,從前往後分為:前端、後台(business logic)、持久化DB。

    優點是:簡單、容易上手,符合大多數公司的組織架構。

    存在的問題:

    • 軟件規模和複雜度增加時,三層架構就不夠了,需要重新考慮拆分;
    • 分層架構體現不出business domain;

    PACKAGE BY FEATURE

    垂直切分方案,所有的java代碼都放在一個package裏面

    好處在於凸顯domain concept

    PORTS AND ADAPTERS

    clean architecture這本書推薦的方案, 外層依賴於內層的domain

    PACKAGE BY COMPONENT

    本章作者 Simon Brown 提出的方案,service-centric view,將所有相關的職責打包稱一個粗粒度的Jar包

    bundling all of the responsibilities related to a single coarse-grained component into a single Java package

    看起來類似現在微服務的部署方式

    對於以上四種結構,依賴關係看起來是這樣的

    值得注意的是

    • 虛線箭頭表示component之間的依賴關係
    • PORTS AND ADAPTERS這種架構更能體現domain(business logic),即接口命名為Orders而不是OrdersRepository

    本章的作者最後還指出:++不管架構怎麼設計,粗心的implementation都可能違背最初的設計;依賴編譯器來保證架構的一以貫之,而不是自我約束或者事後檢查。++

    五種常見架構模式

    看完了clean architecture后,在網上搜索架構設計相關的書籍,發現了這本小冊子,篇幅很短,稱不上book,而是一個report。

    指出缺乏架構設計的軟件往往高度耦合,難以改變。因此,這本小冊子的目標就是介紹常用架構模式的特點、優點、缺點,幫助我們針對特定的業務需求做出合適的選擇。

    Layered Architecture

    分層架構也稱為n-tire architecture,這是最為常見的一種架構模式,一般從前往後分為四層:presentation, business, persistence, and database。如下圖所示:

    分層架構一般是一個新系統的最佳首選,因為其完美匹配傳統IT公司組織架構:一般的公司招人都是前端、後端、數據庫。

    分層架構的優點在於關注點隔離(separation of concerns),每一層做好自己這一層的職責,並向上一層提供服務即可,最為經典的案例就是七層網絡模型,這有利於開發、測試、管理與維護。

    分層架構中,需要注意的是兩個概念:closed layeropen layer

    closed layer的核心就是不要越層訪問,比如在上圖中,Presentation Layer就不應該跨國Business Layer直接去Persistence Layer訪問數據。

    A closed layer means that as a request moves from layer to layer, it must go through the layer right below it to get to the next layer below that one

    closed layer保證了層隔離( layers of isolation),使得某一層的修改影響的範圍盡可能小,比較可控。但closed layer有時候也會帶來一個問題:architecture sinkhole anti pattern(污水池反模式),具體是指,為了查簡單數據,層層轉發請求。比如為了在展示層显示玩家的某個數據,需要通過業務層、再到持久化層、再到DB層;取到數據再一層層傳遞迴來,在這個過程中,業務層並沒有對數據有邏輯上的處理。

    显示,污水池反模式衝擊了closed layer的美好想法。如何衡量這種層層轉發的請求是不是問題,可以參考80-20法則。

    如果80%是附帶邏輯的,那麼就是ok的,但如果有80% 是 simple passthrough processing,那麼就得考慮讓某些layer open。比如在複雜的業務系統中, 經常會有一些可復用的邏輯,這個時候會抽取為通用的服務層(service layer)。如下圖所示

    open layer 、close layer的概念可以幫助理清楚架構和請求流程之間的關係,讓架構師、程序員都清楚架構的邊界(boundary)在哪裡,重要的是,這個open-closed關係需要明確的文檔化,不要隨意打破,否則就會一團糟。

    Event-Driven Architecture

    The event-driven architecture pattern is a popular distributed asynchronous architecture pattern used to produce highly scalable applications.

    從上述定義可以看出事件驅動架構的幾個特點:分佈式、異步、可伸縮。其核心是:高度解耦合、專一職責的事件處理單元(Event Processor)

    事件驅動架構有兩種常見拓撲結構: the mediator and the broker.

    Mediator Topology

    需要一个中心化(全局唯一)的協調單元,用於組織一個事件中的多個步驟,這些步驟中有些是可并行的,有些必須是順序執行的,這就依賴Event Mediator的調度。如下圖所示

    Broker Topology
    這種是沒有中心的架構

    the message flow is distributed across the event processor components in a chain-like fashion through a lightweight message broker

    如下圖所示

    事件驅動的好處在於,高度可伸縮、便於部署、整體性能較好(得益於某些事件的併發執行)。但由於其分佈式異步的本性,其缺點也很明顯:開發比較複雜、維護成本較高;而且很難支持事務,尤其是一個邏輯事件跨越多個processor的時候。

    Microkernel Architecture

    微內核架構又稱之為插件式架構(plug-in architecture)。如下圖所示:

    微內核架構包含兩部分組件

    • a core system
    • plug-in modules.

    plug-in modules 是相互獨立的組件,用於增加、擴展 core system 的功能。

    這種架構非常適用於 product-based applications 即需要打包、下載、安裝的應用,比如桌面應用。最經典的例子就是Eclipse編輯器,玩遊戲的同學經常下載使用的MOD也可以看出插件。

    微內核架構通常可以是其他架構的一部分,以實現特定部分的漸進式設計、增量開發

    Microservices Architecture Pattern

    微服務架構並不是為了解決新問題而發明的新架構,而是從分層架構的單體式應用和SOA(service-oriented architecture)演化而來。

    微服務解決了分層架構潛在的成為單體式應用(Monolithic application)的問題:

    through the development of continuous delivery, separating the application into multiple deployable units

    同時,微服務還通過簡化(泛化)服務的概念,消除編排需求,簡化對服務組件的連接訪問。從而避免了SOA的各種缺點:複雜、昂貴、重度、難以理解和開發。

    The microservices architecture style addresses this complexity by simplifying the notion of a service, eliminating orchestration needs, and simplifying connectivity and access to service components.

    微服務架構如下:

    其核心是service component,這些服務組件相互解耦,易於獨立開發、部署。服務組件的粒度是微服務架構中最難的挑戰

    • 太大:失去了微服務架構的優勢
    • 太小:導致需要編排,或者服務組件間的通信、事務。

    而微服務架構相比SOA而言,其優勢就在於避免依賴和編排 — 編排引入大量的複雜工作。

    對於單個請求 如果service之間還要通信,那麼可能是就是粒度過小。解決辦法:

    • 如果通信是為了訪問數據:那麼可以通過共享db解決
    • 如果通信是為了使用功能:那麼可以考慮代碼的冗餘,雖然這違背了DRY原則。在clean architecture中也指出,component的自完備性有時候要高於代碼復用。

    Space-Based Architecture

    基於空間的架構,其核心目標是解決由於數據庫瓶頸導致的低伸縮性、低併發問題。

    分層架構中,在用戶規模激增的情況下,數據層的擴展往往會成為最後的瓶頸(相對而言,前端和業務邏輯都容易做成無狀態,比較好水平擴展)。而基於空間的架構的核心是內存複製,根本上解決了這個問題。

    High scalability is achieved by removing the central database constraint and using replicated in-memory data grids instead

    架構如下:

    其核心組件包括

    • processing unit,處理單元,其內部又包含一下組成
      • business logic
      • in-memory data grid
      • an optional asynchronous persistent store for failover
      • replication engine,用於同步數據修改
    • virtualized middleware
      • Messaging Grid: 監控processing unit可用性,路由客戶端請求到processing unit
      • Data Grid: 核心,負責processingunit之間的數據同步,毫秒級同步?
      • Processing Grid: 可選組件,如果一個請求需要多個processing unit的服務,那麼負責協調分發
      • Deployment Manager: 負責processing unit的按需啟停

    基於空間的架構很少見,而且從上面的核心組件描述來看的話,開發和維護應該都是比較負責的,由於是數據的同步這塊。而且由於數據都保存在內存中,那麼數據量就不能太大。

    基於空間的架構適用於需求變化大的小型web應用,不適用於有大量數據操作的傳統大規模關係型數據庫應用

    references

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

    ※評比前十大台北網頁設計台北網站設計公司知名案例作品心得分享

    ※智慧手機時代的來臨,RWD網頁設計已成為網頁設計推薦首選

  • HttpClient在高併發場景下的優化實戰

    HttpClient在高併發場景下的優化實戰

    在項目中使用HttpClient可能是很普遍,尤其在當下微服務大火形勢下,如果服務之間是http調用就少不了跟http客戶端找交道.由於項目用戶規模不同以及應用場景不同,很多時候可能不需要特別處理也.然而在一些高併發場景下必須要做一些優化.

    項目是快遞公司的快件軌跡查詢項目,目前平均每小時調用量千萬級別.軌跡查詢以Oracle為主要數據源,Mongodb為備用,當Oracle不可用時,數據源切換到Mongodb.今年菜鳥團隊加入后,主要數據遷移到了阿里雲上,以Hbase為主要存儲.其中Hbase數據查詢服務由數據解析組以Http方式提供.原有Mongodb棄用,雲上數據源變為主數據源,Oracle作為備用.當數據源切換以後,主要的調用方式也就變成了http方式.在第10月初第一輪雙11壓測試跑上,qps不達標.當然這個問題很好定位,因為十一假之間軌跡域組內已經進行過試跑,當時查的是oracle.十一假期回來后,只有這一處明顯的改動,很容易定位到問題出現在調用上.但具體是雲上Hbase慢,還是網絡傳輸問題(Hbase是阿里雲上的服務,軌跡查詢項目部署在IDC機房).通過雲服務,解析組和網絡運維的配合,確定問題出現在應用程序上.在Http服務調用處打日誌記錄,發現以下問題:

    可以看到每隔一段時間,就會有不少請求的耗時明顯比其它的要高.

    導致這種情況可能可能是HttpClient反覆創建銷毀造成引起來銷,首先憑經驗可能是對HttpClient進行了Dispose操作(Using(HttpClient client=new HttpClient){…})

    如果你裝了一些第三方插件,當你寫的HttpClient沒有被Using包圍的時候會給出重構建議,建議加上Using或者手動dispose.然而實際中是否要dispose還要視情況而定,對於一般項目大家的感覺可能是不加也沒有大問題,加了也還ok.但是實際項目中,一般不建議反覆重新創建這個對象,關於HttpClient是否需要Dispose請看

    在對這個問題的答案里,提問者指出微軟的一些示例也是沒有使用using的.下面一個比較熱的回答指出HttpClient生命周期應該和應用程序生命周期一致,只要應用程序需要Http請求,就不應用把它Dispose掉.下面的一個仍然相對比較熱的回答指出一般地,帶有Dispose方法的對象都應當被dispose掉,但是HttpClient是一個例外.

    當然以上只是結合自己的經驗對一個大家都可能比較困惑的問題給出一個建議,實際上對於一般的項目,用還是不用Dispose都不會造成很大問題.本文中上面提到的問題跟HttpClient也沒有關係,因為程序中使用的Http客戶端是基於HttpWebRequest封裝的.

    問題排查及優化

    經過查詢相關資料以及同行的經驗分享(給了很大啟發)

    查看代碼,request.KeepAlive = true;查詢,這個屬性其實是設置一個’Keep-alive’請求header,當時同事封裝Http客戶端的場景現場無從得知,然而對於本文中提到的場景,由於每次請求的都是同一個接口,因此保持持續連接顯然能夠減少反覆創建tcp連接的開銷.因此註釋掉這一行再發布測試,以上問題便不復出現了!

    當然實際中做的優化絕不僅僅是這一點,如果僅僅是這樣,一句話就能夠說完了,大家都記住以後就這樣做就Ok了.實際上還參考了不少大家在實際項目中的經驗或者坑.下面把整個HttpClient代碼貼出來,下面再對關鍵部分進行說明.

     public static string Request(string requestUrl, string requestData, out bool isSuccess, string contentType = "application/x-www-form-urlencoded;charset=utf8")
        {
            string apiResult = "";
            isSuccess = false;
            if (string.IsNullOrEmpty(requestData))
            {
                return apiResult;
            }
            HttpWebRequest request = null;
            HttpWebResponse response = null;
            try
            {
                byte[] buffer = Encoding.UTF8.GetBytes(requestData);
                request = WebRequest.Create($"{requestUrl}") as HttpWebRequest;
                request.ContentType = "application/json";
                request.Method = "POST";
                request.ContentLength = buffer.Length;
                request.Timeout =200;
                request.ReadWriteTimeout =  Const.HttpClientReadWriteTimeout
                request.ServicePoint.Expect100Continue = false;
                request.ServicePoint.UseNagleAlgorithm = false;
                request.ServicePoint.ConnectionLimit = 2000
                request.AllowWriteStreamBuffering = false;
                request.Proxy = null;
    
                using (var stream = request.GetRequestStream())
                {
                    stream.Write(buffer, 0, buffer.Length);
                }
                using (response = (HttpWebResponse)request.GetResponse())
                {
                    string encoding = response.ContentEncoding;
                    using (var stream = response.GetResponseStream())
                    {
                        if (string.IsNullOrEmpty(encoding) || encoding.Length < 1)
                        {
                            encoding = "UTF-8"; //默認編碼
                        }
    
                        if (stream != null)
                        {
                            using (StreamReader reader = new StreamReader(stream, Encoding.GetEncoding(encoding)))
                            {
                                apiResult = reader.ReadToEnd();
                                //byte[] bty = stream.ReadBytes();
                                //apiResult = Encoding.UTF8.GetString(bty);
                            }
                        }
                        else
                        {
                            throw new Exception("響應流為null!");
                        }
                    }
                }
                isSuccess = true;
            }
            catch (Exception err)
            {
                isSuccess = false;
                LogUtilities.WriteException(err);
            }
            finally
            {
                response?.Close();
                request?.Abort();
            }
    
            return apiResult;
        }
    • 首先是TimeOut問題,不僅僅是在高併發場景下,實際項目中建議不管是任何場景都要設置它的值.在HttpWebRequest對象中,它的默認值是100000毫秒,也就是100秒.如果服務端出現問題,默認設置將會造成嚴重阻塞,對於普通項目也會嚴重影響用戶體驗.返回失敗讓用戶重試也比這樣長時間等待體驗要好.

    • ReadWriteTimeout很多朋友可能沒有接觸過這個屬性,尤其是使用.net 4.5里HttpClient對象的朋友.有過Socket編程經驗的朋友可能會知道,socket連接有連接超時時間和傳輸超時時間,這裏的ReadWriteTimeout類似於Socket編程里的傳輸超時時間.從字面意思上看,就是讀寫超時時間,防止數據量過大或者網絡問題導致流傳入很長時間都無法完成.當然在一般場景下大家可以完全不理會它,如果由於網絡原因造成讀寫超時也很有可能造成連接超時.這裏之所以設置這個值是由於實際業務場景決定的.大家可能已經看到,以上代碼對於ReadWriteTimeout的設置並不像Timeout一樣設置為一個固定值,而是放在了一個Const類中,它實際上是讀取一個配置,根據配置動態決定值的大小.實際中的場景是這樣的,由於壓測環境無法完全模擬真實的用戶訪問場景.壓測的時候都是使用單個單號進行軌跡查詢,但是實際業務中允許用戶一次請求查詢最多多達數百個單號.一個單號的軌跡記錄一般都是幾十KB大小,如果請求的單號數量過多數量量就會極大增加長,查詢時間和傳輸時間都會極大增加,為了保證雙11期間大多數用戶能正常訪問,必要時會把這個時間設置的很小(默認是3000毫秒),讓單次查詢量大的用戶快速失敗.

    以上只是一種備用方案,不得不承認,既然系統允許一次查詢多個單號,因此在用戶在沒有達到上限之前所有的請求都是合法的,也是應該予以支持的,因此以上做法實際上有損用戶體驗的,然而系統的資源是有限的,要必要的時候只能犧牲特殊用戶的利益,保證絕大多數用戶的利益.雙11已經渡過,實際中雙11也沒有改動以上配置的值,但是做為風險防範增加動態配置是必要的.

    這裏再多差一下嘴,就是關於ContentLength它的值是可以不設置的,不設置時程序會自動計算,但是設置的時候一定要設置字節數組的長度,而不是字符串的長度,因為包含中文時,根據編碼規則的不同,中文字符可能佔用兩個字節或者更長字節長度.

    • 關於 request.ServicePoint.Expect100Continue = false; request.ServicePoint.UseNagleAlgorithm = false;這兩項筆者也不是特別清楚,看了相關文檔也沒有特別明白,還請了解的朋友指點,大家共同學習進步.

    • request.ServicePoint.ConnectionLimit = 2000是設置最大的連接數,不少朋友是把這個數值設置為65536,實際上單台服務器web併發連接遠太不到這個數值.這裏根據項目的實際情況,設置為2000.以防止處理能力不足時,請求隊列過長.

    • request.AllowWriteStreamBuffering = false;根據[微軟文檔()]這個選項設置為true時,數據將緩衝到內存中,以便在重定向或身份驗證請求時可以重新發送數據.

    最為重要的是,文檔中說將 AllowWriteStreamBuffering 設置為 true 可能會在上傳大型數據集時導致性能問題,因為數據緩衝區可能會使用所有可用內存。由於發送的請求僅僅是單號,數據量很小,並且很少有用戶一個單號反覆查詢的需求.加上可能會有副作用.這裏設置為false.

    • request.Proxy = null;這裡是參考了一個一位網友的文章,裏面提到默認的Proxy導致超時怪異行為.由於解決問題是在10月份,據寫這篇文章已經有一段時間了,因此再尋找時便找不到這篇文章了.有興趣的朋友可以自己搜索一下.

    很多朋友可能會關心,通過以上配置到底有沒有解決問題.實際中以上配置后已經經歷了雙11峰值qps過萬的考驗.下面給出寫本文時候請求耗時的監控

    可以看到,整體上請求耗時比較平穩.

    可能看了這個圖,有些朋友還是會有疑問,通過上面日誌截圖可以看到,除了耗時在100ms以上的請求外,普通的耗時在四五十毫秒的還是有很多的,但是下面這個截圖裡都是在10到20區間浮動,最高的也就30ms.這其實是由於在壓測的過程中,發現Hbase本身也有不穩定的因素(大部分請求響應耗時都很平穩,但是偶爾會有個別請求婁千甚至數萬毫秒(在監控圖上表現為一個很突兀的線,一般習慣稱為毛刺),這在高併發場景下是不能接受的,問題反饋以後阿里雲對Hbase進行了優化,優化以後耗時也有所下降.)

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站,提高曝光率!!

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • 《軟件方法(上)》讀書筆記

    《軟件方法(上)》讀書筆記

    1、建模

    1.1、業務建模之願景

    重點1:通俗一點講,一個東西的願景就是:東西最應該賣個誰,對他有什麼好處?

    重點2:願景是需求排序的主要依據。

    重點3:老大、願景、需求都是基於現狀尋找最值得的改進。改進過後,又是新的現狀了,還是基於現狀尋找最值得的改進。進一步說也可以說,需求只有真假對錯,沒有變化。說需求有變化,那是從一個靜止時間點來看的。

    1.1.1、願景




    建模之願景

    1.2、業務建模之業務用例圖

    有了願景,我們知道老大對他所代表的組織的現狀的某些指標不滿意。接下來就可以研究組織,弄清楚到底是組織的哪些環節造成了這些指標比較差,這就是業務建模(Business modeling)的主要內容。

    重點1:軟件系統只是組織的一個零件。組織裏面還有很多系統,其中最值錢的是千百年來一直在使用,現在依然是最複雜的系統——人腦系統。

    重點2:開發團隊發現需求“容易變化”。根源之一是需求的來路不正,沒有把系統當作一個零件放在組織中來看,靠拍腦袋得出需求,導致得到的系統需求是錯的。

    1.2.1、業務角色

    ① 業務執行者

    以某組織為研究對象,在組織之外和組織交互的其他組織(人群或機構)就是該組織的執行者。以一家商業銀行為研究對象,觀察在它邊界之外和它打交道的人群或機構,可以看到儲戶來存錢,企業來貸款,人民銀行要它作監督等等,這些就是該商業銀行的執行者,如下圖所示:




    業務執行者(一)

    這裏要注意的是,作為觀察者的建模人員本身是一個人腦系統,所以在觀察組織邊界時,直覺上觀察到的不是組織之間的交互,而是組織派出的系統之間的交互,但是一定要把它理解成組織間的交互,因為談論業務執行者時,研究對象是組織,所以外部對應物——業務執行者也應該是組織。例如:以某國稅局為研究對象,可以觀察到企業財務人員到國稅局報稅,但業務執行者不是企業財務人員,而是企業。也許到後來,企業財務人員和國稅系統交互,又或許再後來是企業系統與國稅系統交互,從組織的抽象級別來看,都應該理解為企業和國稅局這兩個機構之間的交互,如下圖所示:




    業務執行者(二)

    ② 業務工人

    組織內的人稱為業務工人,例如某商業銀行裏面的營業員。業務工人是可以被替換的人腦零件,它可能被其他業務工人替換,但更有可能被業務實體替換。

    ③ 業務實體

    業務實體是組織中的非人智能系統,例如銀行的ATM、點鈔機、營業系統。

    1.2.2、識別業務用例

    重點1:業務用例指業務執行者希望通過和所研究組織交互獲得的價值。業務用例是組織的價值,不會因為某個人腦系統或電腦系統的存在或消失而改變,好比如300年前的商業銀行和當前的銀行的業務用例是不變的,因為銀行提供價值的本質沒有改變。所以“這個系統的業務用例是什麼”這樣的說法是錯誤的。

    重點1:用好用例,關鍵在於理解“價值”。價值是期望和承諾的平衡點、買賣的平衡點。例如以“醫院”為研究對象,真正的用例是“患者→看病”,而不是“患者→挂號”,患者→挂號”可以是以“挂號室”為研究對象的業務用例(如下圖)。所以做任何事情之前,要搞清楚“邊界”,沒有邊界會很容易盲目“拍腦袋”做一些努力但沒效果的事情。




    業務用例識別

    1.2.2.1、識別業務用例思路

    識別業務用例的思路有兩條:

    【從外到內】從業務執行者開始考慮,思考業務執行者和組織交互的目的(主要);

    【從內到外】通過觀察組織的內部活動,一直問為什麼,向外推導出組織外部的某個業務執行者(補漏)。




    業務用例識別思路

    1.2.2.1.1、識別業務用例常犯錯誤

    錯誤1 :把業務工人的行為當做業務用例。




    錯誤用例識別(1)

    錯誤2:業務用例隨待引入系統伸縮。




    錯誤用例識別(2)

    錯誤3:把害怕遺漏掉的擴展路徑片段提升為業務用例。




    錯誤用例識別(3)

    錯誤4:管理型業務用例。




    錯誤用例識別(4)

    總結:錯誤的根源主要源於:建模人員分不清問題和問題的解決方案。

    1.3、業務建模之業務序列圖

    1.3.1、描述業務流程的手段

    本章節主要討論的是業務建模中最繁重的工作——描述業務用例的實現,即業務流程,然後改進它,推導出待引入系統的用例。目前描述業務流程的可選擇手段有文本、活動圖和序列圖,它們的主要區別如下(以財務部“員工→報銷”用例的實現為樣例):

    ● 文本




    文本樣例

    文本的缺點是不夠生動,所以在描述業務流程時很少使用文本方式。不過,描述系統用例(即系統需求)的流程時,文本是常用的,因為此時更注重精確,而且還要表達業務規則、性能等目前尚未被UML標準覆蓋的內容。

    ● 活動圖




    活動圖樣例

    序列圖是UML圖形描述業務流程的兩種選擇之一。活動圖的前身是流程圖,應該是在建模人員中使用頻率最高的圖形,是隨机械工程領域慢慢引入到計算機領域。不過,隨着編程語言表達能力越來越強,針對簡單的分支或循環邏輯畫圖在很多情況下已經變得沒有必要。

    ● 序列圖




    序列圖樣例

    序列圖與活動圖的比較如下:

    1)活動圖只關注人,序列圖把人當作系統;

    在上一章節中已經提到,現在的業務流程中已經有很多領域邏輯是封裝在業務實體而不是業務工人中,如果忽略非人智能系統,很多重要信息就丟掉了。

    2)活動圖表示動作,序列圖強迫思考動作背後的目的;

    序列圖可以更加清晰地表述業務工人或業務實體對外的責任,也就是用例的期望值。期望和承諾是用例和對象技術的關鍵思想,使用序列圖來做業務建模,“對象協作以完成用例”的思想就可以統一地慣竊業務建模和系統建模的始終。

    3)活動圖“靈活”,序列圖“不靈活”;

    不少人認為活動圖勝過序列圖的地方是它靈活,但這靈活是一把雙刃劍。活動圖很靈活,他的控制箭頭可以指向任何地方,就像編碼原始時代的“goto”語句,所以活動圖很容易畫。不過,“很容易畫”的活動圖也比較容易掩蓋建模人員對業務流程認識不足或者業務流程本身存在缺陷的事實。序列圖可通過alt、loop等結構化控製片段來描述業務流程,強迫建模人員用這種方式思考。

    1.3.2、業務序列圖要點

    1.3.2.1、消息代表責任分配而不是數據流動

    序列圖中最重要的要點是消息的含義。A指向B的消息,代表“A請求B做某事”,或者“A調用B做某事的服務”,而“做某事”是B的一個責任。




    序列圖消息含義

    1.3.2.2、抽象級別是系統之間的協作

    業務建模的研究對象是組織,出現在業務序列圖生命線上的對象,其最小顆粒是系統,包括人和非人系統,而系統之間最主要突出的是協作。所以“系統粒度”和“協作”是業務序列圖的關鍵要點,如果記住了這兩個關鍵點,就可以避免了對組織對象抽象的錯誤以及對協作理解的錯誤。




    系統內部的組件暴露



    表達了過細的交互步驟

    以上說的兩種錯誤是把需求和分析的工作流的工作帶入了業務建模。第一樣例圖提到的系統內部的組件,應該在分析和設計工作流中描述;第二樣例圖提到了交互步驟,應該在需求工作流中描述。除了以上兩種抽象級別的錯誤,還有一種是:業務序列圖的內容和業務用例圖差不多,如下所示:




    目標組織作為整體出現在業務序列圖中  

    1.3.2.3、把時間看作特殊的業務實體

    業務序列圖中,我們把時間看作特殊的業務實體。把時間看作上帝造好掛在天上的一個大鐘,向全世界各種系統發送時間消息,這樣,就和後面需要工作流中映射系統用例的時間執行者一致了,同時也幫助理清什麼情況下使用時間執行者的問題。




    把時間當作一個系統

    值得注意的一點是,時間和定時器不是一個概念,時間是“外系統”,定時器是其他系統用來和時間打交道的“邊界類”。世界上只有一個時間系統,但有無數的定時器。如果建模人員在識別系統用例時說“執行者是定時器”,那就錯了,執行者是時間。




    時間和定時器的區別

    1.3.2.4、為業務對象分配合適的責任

    分配給業務對象的責任必須是該對象有能力承擔的,這需要我們自身必須對理解要十分清晰,畢竟我們自己說話有時候的會含糊。例如“工作人員用Word寫標書”這樣的說法好像可以接受,但如果按照說話的文字不假思索地隨便畫,會很容易導致對象責任分配不準確。




    不恰當與不恰當的責任分配對比

    1.3.3、現狀業務序列圖

    業務序列圖描述的是業務流程,建模需要通過在現狀的業務序列圖基礎上找出改進的要點。如果要把現狀序列圖畫出來,就必須讓自己站在客觀的角度“親臨現場”,“如實”地把所看到的記錄下來,儘力描繪出真實的現狀。但說起來非常簡單,做到卻極其困難。總結到這裏,忽然讓我想起了彼得·德魯克。下面列出一些描述現狀時經常犯的錯誤。

    1)錯誤:把想象中的改進當成現狀

    很多時候造成這種錯誤,背後的原因很可能是根本沒有深入到組織流程中去做觀察和訪談,對現狀沒有認識,只好想像一個改進后的場景來應付。

    2)錯誤:把“現狀”誤解為“純手工”

    有的建模人員以為人做的事情才是本質,所以他畫的業務流程中,只有人,沒有非人系統,完全忽略了在技術進步下慢慢可以替代人的這些“業務實體”。

    3)錯誤:把“現狀”誤解為“本開發團隊未參与之前”

    開發團隊很容易會誤以為當他們開始參与組織流程完善而開發系統的時候當作“現狀”,這就是典型的“技術思維”,很多時候在開發團隊在參与組織流程完善前,組織已經經過了許多次“非系統級”的流程改進,這是站在組織角度去看問題的。

    4)錯誤:把“現狀”誤解為“規範”

    建模人員在建模業務流程時,照搬組織制定的規範,沒有去觀察實際工作中人們是如何做的,或者即使觀察到了人們實際沒有按照規範做,卻依然按照規範建模。這樣做,得到的業務流程是不真實的,畢竟上有政策,下有對策。

    5)錯誤:“我是創新,沒有現狀”

    互聯網創業公司的建模人員很容易犯的這個錯誤,動不動就說“我做的是互聯網創新,沒有現狀”,但他們已經忘記了歷史上所有的創新都是站在前輩這些巨人的肩膀之上這個事實。

    6)錯誤:“我做產品,沒有現狀”

    非定製系統的開發團隊進程拿這句話做接口。A公司的流程和B公司的流程有差異,中國的流程和外國的流程有差異,畫誰的現狀好的?問這個問題的時候,我想是開始開發團隊忘記了“做需求時把產品當項目做”的道理,在第2章節中也提到過“誰比誰更像”的重點。

    1.3.4、改進業務序列圖

    上面提到的現狀業務序列圖是對組織現狀的客觀描述,而改進業務序列圖是通過信息化手段去思考對業務現狀序列圖的一些改進。通常,信息化給人類的工作和生活帶來的改進有三種模式。

    1.3.4.1、改進模式一:物流變成信息流

    和信息的光電運輸比起來,用其他手段運輸的物的流轉速度就顯得太慢了,而且運輸成本會隨着距離的增加而明顯增加。如果同類物的不同實例之間可以相互取代,那麼可以提煉物中包含的部分或全部有價值的信息,在需要發生物流的地方,改為通過軟件系統交互信息,需要物的時候再將信息變成物,這樣就可以大大增加流轉速度和降低流轉成本。




    物流變成信息流改進

    1.3.4.2、改進模式二:改善信息流轉

    軟件系統越來越多,而各個軟件系統之間溝通不暢,導致一個人為了達到某個目的可能需要和多個軟件系統打交道,如果把各軟件系統之間的協調工作改為一個軟件系統來完成,人只需要和單個軟件系統打交道,信息的流轉就改進了。




    改善信息流轉

    1.3.4.3、改進模式三:封裝領域邏輯

    在業務流程中,有很多步驟是由人腦來判斷和計算的,領域邏輯封裝在人腦中。相對於計算機,人腦(業務人才)存在成本高,狀態不穩定、會徇私舞弊等問題。如果能夠提煉人腦中封裝的領域邏輯,改為封裝到軟件系統中,用軟件系統代替人腦,業務流程就得到了改進。換句話說,領域邏輯的封裝是對系統“內在”價值的提升,相對於前兩個改進模式有更高的要求和更大的困難。




    封裝領域邏輯改進

    1.3.4.4、改進思考方式:阿布爾思考法

    在軟件開發團隊中,當有人提出新的想法時,經常會被馬上否定“太難了,做不了”,最終得到一個平庸的、毫無競爭力的系統。學會像阿布(俄羅斯大富豪羅曼·阿布拉莫維奇)一樣思考,有助於克服普通人因資源受限而不敢展開想象的思維障礙。阿布思考法分兩步:

    1)假設有充足的資源去解決問題,得到一個完美的方案;

    2)用手上現有的資源去山寨這個完美的方案。

    其實,阿布思考法的核心思想就是,不要閉門造車,要“接地氣”的行動起來,主動去觀察,或主動尋找有用的信息去分析和調研,不要被各種局限被迫讓步。

    2、需求

    2.1、需求之系統用例圖

    在“建模”階段我們研究和思考的對象是組織,從組織的整體性客觀地去發現組織如何可以通過信息化手段去優化流程。有了客觀的整體性分析和改進認知,接下來的“需求”階段需要深入到系統層面去思考了。按正常邏輯,每一步都有“承上啟下”的作用,本章節所研究的系統用例就是通過上一步業務序列圖中所映射出來的。

    執行者和用例的概念在業務建模的學習中已經出現過,現在要研究的執行者和用例與業務建模時研究的執行者和用例相比,不同之處是研究對象,之前研究的是組織,現在研究的是系統。

    2.1.1、系統執行者要點

    系統執行者的定義:在所研究系統外,與該系統發生功能性交互的其他系統。

    2.1.1.1、系統是能獨立對外提供服務的整體

    封裝了自身的數據和行為,能獨立對外提供服務的東西才能稱為系統。不了解這點,建模人員很容易把“添加一些功能”當作“研發新系統”。




    劃分系統用例

    2.1.1.2、系統邊界是責任的邊界

    系統執行者不是所研究系統的一部分,是該系統邊界外的另一個系統。這裏的系統邊界不是物理的邊界,而是責任的邊界。




    錯誤的遙控軟件用例圖    



    正確的遙控軟件用例圖

     

    2.1.1.3、系統執行者和系統有交互

    外系統必須和系統有交互,否則不能算是系統的執行者。如一名旅客來到火車站售票窗口,告訴售票員目的地和車次,售票員使用售票系統幫助旅客購買火車票,這個場景中,和火車票系統交互的是售票員,他是售票系統的執行者。




    旅客不是售票系統的執行者

    如果火車售票系統現在已經提供了旅客自行購票的接口,例如互聯網購票、售票機等,這種情況下,旅客也是售票系統的執行者。不過“售票員→售票”和“旅客→購票”是兩個不同的用例。

    2.1.1.4、交互是功能性交互

    上面說的交互還引出一個問題:假設售票員使用鼠標和售票系統交互,按道理,比起銷售員,鼠標里售票系統更近,為什麼不把鼠標作為售票系統的執行者呢?還有,假設售票系統運行在Windows操作系統之上,那麼Windows是不是售票系統的執行者?其實吧,辨別這些問題的要點就是:執行者和系統發生的交互是系統的功能需求。鼠標和操作系統跟售票系統的交互都不是售票系統的核心域概念。售票員和售票系統之間的交互才是,所以售票員才是售票系統的執行者。




    售票系統的功能需求

    2.1.1.5、系統執行者可以是人或非人系統

    系統執行者可以是一個人腦系統,也可以是一個非人智能系統,甚至是一個特別的系統——時間。在軟件業的早期,一個系統的執行者往往全部都是人。隨着時間的推移,系統的執行者中非人執行者所佔的比例越來越多。用例的優勢在於“執行者”和“涉眾”的概念,把演員和觀眾分開。演員(執行者)在台上表演,觀眾(涉眾)在台下看,演員表演什麼是由觀眾的口味決定的,演員可以不是人,但觀眾肯定是人。演員如果是人類,那麼在觀眾席上也會有一個位置,不過在第幾排就不知道了(權重等級)。用例使用“執行者”和“涉眾”代替了原來的“用戶”是一個非常大的突破,建模人員如果過多地關注“用戶”,混淆了真正真正重要的前排“涉眾”的需求,把操作人員當前重要的調研對象(非關鍵人員),那麼花在重要的前排涉眾(關鍵人)身上的時間可能就不夠了。越來越多的系統執行者不是人類,也就是說沒有“用戶”。




    從“執行者都是人”到“執行者有一些是人”

     

    2.1.1、識別系統執行者

    2.1.2.1、從業務序列圖映射系統執行者

    如果沒有做業務建模,識別系統執行者只能靠頭腦風暴。例如:什麼人會使用系統來工作?什麼人負責維護系統?系統需要和哪些其他智能系統交互?有沒有定時引發的事件?等等問題。有了業務建模,可以直接從業務序列圖映射即可。業務序列圖上,和所研究系統有實線相連的對象映射為所研究系統的執行者。




    業務序列圖:需找租客線索  



    從業務序列圖映射得到系統執行者

     

    2.1.3、系統用例要點

    2.1.3.1、價值的買賣的平衡點

    系統用例的定義:系統能夠為執行者提供的、涉眾可以接受的價值。和業務用例相比,研究對象從組織變成了系統,要理解好系統用例,重點依然是之前所強調的買賣平衡點、期望和承諾平衡點。

    用例之前的許多需求方法學,把需求定義為思考系統“做什麼”,用例把需求提升到思考系統“賣什麼”的高度。這種思考是非常艱難的,因為它沒有標準答案,只有最佳答案。要得到這個答案,不能靠拍腦袋,必須揣摩涉眾。要得到合適的用例,需要有一顆善於提擦他人的心。




    ATM和程序員人腦系統的用例

    2.1.3.2、價值不等於可以這樣做

    有些人會較真,還是以ATM為例子,有些人會因為“難道ATM放在那裡我就不能登錄一下就離開嗎?我今晚下班就去ATM那裡登錄一下給你看,然後走人。”ATM確實能登錄,但登錄功能並非ATM的賣點,如果以一個“門禁系統”為研究對象,登錄就可以作為它的用例。

    還有一種情況,例如科員可以有A和B用例,科長因為比科員的權力大,所以就能擁有科員的用例。用例的執行者只是表明這個用例是為這一類執行者而做的。但不代表系統一定要有權限控制以防止其他的人或電腦系統使用該用例。即時系統確實需要有權限控制,而且角色的劃分和執行者相近,也要把這兩者分開,更不可以因為系統不設權限控制,所以把執行者的名字合併為“用戶”。




    用例劃分案例

    有些書中會給出“最佳粒度原則”。例如:一個系統的用例最好控制在XXX個之內,一個用例的基本路徑最好控制在X步到X步之間……這些是沒有根據的。市場需要各種各樣的系統,有功能眾多的,也有功能單一的,也有交付複雜的,應該把屁股坐到涉眾那邊去,揣摩涉眾的心裏,實事求是地寫下來。如果建模人員在粒度問題上激烈爭吵以及糾纏不清,有可能已經犯了錯誤,最常犯的錯誤是把步驟當作用例。




    錯誤:把步驟當作用例

    2.1.3.3、增刪改查用例的根源是從設計映射需求

    有一些用例圖,映入眼帘的用例是四個四個一組的,仔細一看,剛好對應看數據庫的四種操作。相當於把數據庫的各個表名加上新增、刪除、修改、查詢,就得到了用例的名字。有些建模人員確實也知道這個錯誤,但他們學乖了,乾脆把每四個用例合併,改名叫“管理XX”或(“XX管理”),然後新增、刪除、修改、查詢等用例再擴展它,可惜依然是換湯不換藥。




    從數據庫視角得到的用例

     

    2.1.3.4、從設計映射需求錯誤二:“復用”用例

    增刪改查用例實際上就是從設計映射需求,導致“復用”用例的一種情況。在看看以下例子:




    “復用”用例錯誤示例——缺陷管理系統

    從不同的業務序列圖分別映射得到系統有右邊四個用例,但有的建模人員會動起心思:這些實現起來不都是針對“缺陷”表來“select X X X from缺陷表where X X X”嗎,合併成一個用例“查詢缺陷”多好!於是得到左邊的結果。實際上,右邊這四個用例面對的執行者不同,背後的涉眾利益也有差別。

    當然,如果真的像這位建模人員講的,把“數據庫”,買回去就好,想怎麼折騰這信息都可以那不是更加簡單。其實,用例是涉眾願意“購買”的、對系統的一種“用法”,只要涉眾願意“購買”,當然越多越好。講到這裏,就要來說一個需求的基本要點:需求不考慮“復用”,如果考慮“復用”,要警惕自己是不是已經轉換到了設計視角來思考問題。

    2.1.3.5、系統用例不存在層次問題

    系統用例的研究對象就是某特定系統,不是組織,也不是系統內部的組件。如果存在“層次”上的疑惑,背後的原因是研究對象不知不覺改變了。

    像醫院信息系統的用例,有人會畫成如下圖所示,原因可能是前面沒有畫業務用例圖和業務序列圖,所以建模人員頭腦里不知不覺把醫院信息系統的價值和醫院的價值混在一起了。




    錯誤的“高層”用例:混淆組織的價值和系統的價值

    還有以下的防汛系統用例圖,把系統的願景當成了“高層”用例:




    錯誤的“高層”用例:把願景當作用例

    以下更為常見的錯誤,為系統的“模塊”或“子系統”畫用例圖:




    錯誤:模塊的用例  



    用例仍然是系統的用例    



    錯誤:子系統的用例

    2.1.3.6、用例的命名是動賓結構

    用例的命名是動賓結構,例如“取現金”。動詞前面可以加狀語,賓語前面可以加定語,把一句話的主語砍掉,剩下的可以用作用例的名字。

    給用例起名時不要使用弱動詞。用例之前的需求技術,可能是以“名詞+動詞”的形式命名系統的功能,例如“發票作廢”,後來要改成用例的動賓結構了,有的建模人員就在前面加一個弱動詞“進行”,就變成了“進行發票作廢”,這個也是不合適的。

    如果“名詞+動詞”已經成為行業中的一個術語,也未必要嚴格的動賓結構,例如“成果分析”是某行業的一個術語,也就不必硬要倒過來變成“分析成果”了。

    2.1.4、識別系統用例

    2.1.4.1、從業務序列圖映射系統用例

    其實,只要認真做好業務建模,從業務序列圖上映射系統用例,得到的結果自然就會符合上面說的這些要點。

    從業務序列圖中,從外部指向所研究系統的消息,可以映射為該系統的用例。現在我們繼續從“識別系統執行者”的用例中結合執行者和系統用例一起識別。




    從業務序列圖上找到從外部指向所研究系統的信息    



    從業務序列圖映射得到系統用例

     

    在以上業務序列圖中,有一處消息是“外呼人員”指向“線索管理系統”的消息為“提供本人當天名單”,但在以上系統用例圖中,用例名改為了“查看本人當天名單”。因為序列圖上的消息代表“請求某系統做某事”,用例代表“用某系統來做某事”,一定要理解兩種圖的要點,所以有的地方需要調整。

    在以上系統用例圖中,有的箭頭是從執行者指向用例,這樣的執行者稱為用例的主執行者,有的箭頭是從用例指向執行者,這樣的執行者稱為用例的輔執行者。主執行者主動發起用例的交互,輔執行者在交互的過程中被動參与進來。

    值得注意一下,輔執行者這個概念是被誤用的比較多。最常見的錯誤是把信息的接收者或者將來可能使用信息的人當成輔執行者。另一種輔執行者的誤用剛好相反,把信息的來源當作輔執行者。




    錯誤:把可能會用到所生產信息的人當作輔執行者  



    錯誤:把提供用例所需要信息的人當作輔執行者

    以上錯誤的原因很多是因為前面沒有畫業務序列圖,導致建模人員在畫系統用例圖的時候產生焦慮,總是希望在圖上多放一些信息,以免自己忘記了。一般來說,輔執行者是非人智能系統的情況較多,人腦系統作為輔執行者的情況比較少,所以碰到輔執行者是人的時候,要多留心。




    正確:合適的輔執行者(因為辦卡需要用戶輸入密碼)

     

    2.2、需求之系統用例規約

    用例圖表達了用例的目標,但是對於完整的需求來說,這是遠遠不夠的。用例的背後封裝了不同級別的相關需求,我們需要通過書寫用例規約把這些需求表達出來。用例規約就是以用例為核心來組織需求內容的需求規約。用例規約的各項內容可以通過以下類圖來展示:




    用例規約的內容

    2.2.1、前置條件和後置條件

    用例通過前置條件(precondition)、後置條件(postcondition)以契約的形式表達需求。用例相當於系統的一個承諾:在滿足前置條件時開始,按照裏面的路徑步驟走,系統就能達到後置條件。為了避免掉入“從實現角度看這樣可以那樣也可以”的陷阱,後置條件只需要寫出最想要的那個狀態即可。

    ● 前置條件:用例開始前,系統需要滿足的約束。

    ● 後置條件:用例成功結束后,系統需要滿足的約束。

    2.2.1.1、前置條件、後置條件必須是系統能檢測的




    系統必須能檢測前置、後置條件

    以上圖為例,“錄入保單”用例的前置條件是錯誤的。業務代表是否已經把保單交給內勤,系統無法檢測,不能作為前置條件;同樣,“收銀”用例的後置條件也是不對的。顧客是否已經帶着貨物離開商店,系統也無法檢測,不能作為後置條件。

    2.2.1.2、前置條件必須是用例開始前系統能檢測的




    前置條件必須是用例開始前系統能檢測的

     以上圖所示,儲戶開始取現金的交互前,系統不知道儲戶是誰,要去多少錢,所以無法檢測“儲戶賬戶里有足夠的金額”這個條件。如果把前置條件設置為類似於“存在大於最低限額的現金”這樣的背景條件作為前提條件是可以的。就算很長時間沒人來ATM取現金,這個條件是否成立就擺在那裡。

    2.2.1.3、前置後置條件是狀態,不是動作

    例如,“經理→批假”的前置條件不能寫“員工提交請假單”,因為是一個動作不是狀態,應改為“存在待審批的請假單”。特別要注意的是,寫成“員工已經提交請假單”很可能也是不對的,因為狀態和導致達到某個狀態的行為不是一一對應的,請假單未必是員工自己提交的,也可以組長負責幫本組人員請假,也可能是從另外的系統批量導入。

    如果分不清狀態和行為的區別,建模就會遇到很大的麻煩。後面的建模工作中,還會不斷討論狀態和行為的問題。

    2.2.1.4、前置後置條件要用核心域詞彙描述

    “系統正常運行”、“網絡連接正常”等放之四海而皆準的約束,和所研究系統沒有特定關係,不需要在前置條件中寫出來,否則會得到一堆沒有任何增值作用的廢話。

    後置條件也不能簡單地把用例的名字加上“成功”二字變成“XXX成功”。例如“顧客→下單”的後置條件寫成“顧客已經成功下單”,這不是廢話嗎?更合適的後置條件是“訂單信息已保存”。

    2.2.1.5、“已登錄”不應作為前置條件

    “已登錄”是一個比較有爭議的情況,以購物網站為研究對象,登錄不是用例。這一點已經在前面的已經學習過,那如何處理登錄?

    1)畫法一:把其他用例作為“登錄”的擴展




    畫法一:把其他用例作為“登錄”的擴展

     

    會員登錄后可以下單,也可以查看以往訂單,還可以退貨……所以上圖這個方法把下單、查看以往訂單畫出登錄的擴展。這是錯的。並不是先做A然後做B或C,B和C就成了A的擴展。

    2)畫法二:把“登錄”作為被包含用例




    畫法二:把“登錄”作為被包含用例

    把“登錄”變成被其他用例包含(Include)的被包含用例(Include Use Case)。這樣做是正確的。登錄用例本來不存在,後來在寫用例規約的時候,發現“下單”、“查看以往訂單”等用例都有以下步驟:




    “查看以往訂單”步驟

    為了節省書寫用例規約的工作量,考慮把這些形成一個小目標的步驟集合(不是單個步驟)分離出來,作為一個被包含用例單獨編寫規約。這個用例只被其他用例包含,不由主執行者指向。所以,如果按照這個做法的話,“下單”用例規約的步驟里,應該有表示包含“登錄”用例的步驟集合:會員【登錄】。這裏的“登錄”二字加了粗括號表示這是一個被包含用例。它的步驟和約束在另外的地方描述。當然,不喜歡用粗括號可以用下劃線等其他方法以示區分。

    3)畫法三:其他用例以“已登錄”作為前置條件




    畫法三:其他用例以“已登錄”作為前置條件

    有些人覺得畫法二會讓好些用例會出現會員【登錄】,看起來有些礙眼,就想能不能把它提到前置條件里,那就得到了畫法三。把“登錄”作為一個用例,“會員已經登錄”作為其他用例的前置條件。這樣用例的步驟看起來更清爽,但是嚴格來說這也是不對的,“登錄”不能作為購物網站的用例。

    以上章節學習過,如果在做需求時考慮復用,可能已經陷入了設計的思維。能夠在多個用例中復用登錄的狀態,這是設計人員的本事,他甚至可以做到10個用例的界面都從一個模板生成,但不能因此就把這10個用例合併成一個。

    2.2.2、涉眾利益

    前提條件是起點,後置條件是終點,中間的路該怎麼走?這就要由涉眾決定了。也就是我們需要對關鍵人按重要程度排序(從前排到後排)去考慮他們的利益,根據這些利益去梳理正確的需求。以銀行ATM為例子,儲戶在ATM取現金的時,涉及的涉眾利益如如下:

    ● 儲戶:希望方便;擔心權益受損。

    ● 銀行負責人:希望安全;希望節約運營成本。

    正是這些涉眾利益的交鋒之下,目前我們日常生活中所看到的ATM的用例片段如下:




    ATM用例片段

    從步驟1有設計約束“通過磁條卡或芯片卡提交賬戶號碼”看,這是為了照顧儲戶“方便”的利益。在銀行角度,雖然儲戶是上帝,為了儲戶更加方便,不用密碼更方便的。但從銀行角度要考慮安全問題,不可能不設置密碼,但為什麼只設置6位而不是8位或者更多呢?這又是“安全”和“方便”交鋒后的妥協……

    2.2.2.1、涉眾的來源

    1)涉眾來源一:人類執行者

    用例的執行者如果是人類,當然是用例的涉眾。執行者如果不是人類,就不是涉眾,因為它沒有利益主張。




    考慮人類執行者之後的涉眾

    上圖保險系統的“內勤→錄入保單”用例中,內勤是人類,是涉眾,而OA系統不是人類,不是涉眾。

    2)涉眾來源二:上游

    執行者要使用系統做某個用例,可能會需要一些資源,這些資源的提供者可能就是用例的涉眾。還是以“內勤→錄入保單”為例,保單由業務人員代表提供給內勤。如果內勤喝醉了酒亂錄,信息錯得一塌糊塗,業務代表的利益就被損害了。所以,考慮到上游之後,“內勤→錄入保單”用例的涉眾有內勤和業務代表了。




    考慮上游之後的涉眾

    3)涉眾來源三:下游

    執行者使用系統做某個用例,產生的後果會影響到其他人。這些受影響的人也是涉眾。還是以“內勤→錄入保單”為例,如果系統做得不好,沒有檢測內勤錄保單時是否填了必填項就放了過去,後面負責審核的經理工作量增加了。還有,OA系統雖然不是該用例的涉眾,但假如保險系統不停地向OA系統發送垃圾數據包,導致OA癱瘓,那麼OA系統維護人員的工作量就增加了。所以,OA系統維護人員也是下游的涉眾。考慮下游之後,“內勤→錄入保單”用例的涉眾如下圖所示:




    考慮下游之後的涉眾

     

    4)涉眾來源四:信息的主人

    用例會用到一些信息,這些信息會涉及某些人,雖然這些人也許並不知道這個系統的存在,但他們是用例的涉眾。還是以“內勤→錄入保單”為例,保單的信息涉及被保人,投保人和受益人,如果信息出錯或泄露,這些人就會遭殃,所以他們是涉眾。因為這類涉眾可能和系統沒什麼接口,比較容易被忽略,所以要特別需要注意。




    考慮信息的主人之後的涉眾

    其實,前面的業務建模對識別涉眾起到了非常大的幫助,如果做需求前做了業務建模,會更加了解一件事情的前因後果,大多數涉眾都能夠從業務序列圖中看出來。如下圖所示:




    業務建模可以幫助尋找涉眾

     

    2.2.2.2、尋找涉眾利益

    查理·芒格說過:說服別人要訴諸利益,而非訴諸理性。所以要學會思考涉眾的利益點是一門非常大的學問。尋找涉眾利益時,要“親兄弟,明算賬”,把不同涉眾各自關注的利益體現出來,而不是寫成一模一樣的。家裡兩夫妻對同一件事情都還有不同立場,更不用說一個組織裏面形形色色的涉眾了。例如,司機開車進廠裝化肥,工作人員通過地磅系統操縱地磅給車稱重。針對這件事,不同的涉眾可謂是“各懷鬼胎”:

    ● 化肥公司老闆——擔心公司內部人員貪污;

    ● 地磅操作員——希望操作簡便;擔心承擔責任;擔心繫統壞掉影響工作量;

    ● 倉管人員——擔心稱不準導致無謂的返工裝包;

    ● 買主——擔心進去時稱得輕了,出來時稱得重了,導致給少了化肥;

    ● 司機——擔心等候時間太長導致每天拉貨次數減少;

    即使有些利益有時不方便白紙黑字寫出來共享,但至少建模人員要心知肚明,不能一團和氣了事。建模人員要仔細觀察和揣摩涉眾的痛苦,才能找到真正的涉眾利益,否則寫出來的“涉眾利益”往往很蒼白。例如以下例子:

    ● 護士——擔心出錯

    這都是正確的無用廢話,誰都擔心出錯,但為什麼還是出錯?仔細調研過之後寫出來就生動多了:

    ● 護士——擔心自己的藥理學知識記錯,對藥物名稱相近的藥物計算錯劑量,導致給葯錯誤;

    2.2.2.3、善於積累涉眾利益

    需求是不斷變化的,我想這都是共識了,新系統肯定在功能或性能上和舊系統有所不同,否則還做什麼新系統呢。但是,背後的涉眾利益要穩定得多。看看之前ATM的例子出現的涉眾利益:

    儲戶——希望方便;擔心權益受損;

    銀行負責人——希望安全;希望節約運營成本;

    其實這些涉眾利益不止適用於ATM,也適用於清朝的錢莊櫃檯、現在的銀行櫃檯、網上銀行和手機銀行。換句話說,越本質越穩定。

    2.2.3、基本路徑

    一個用例會有多個場景,其中有一個場景描述了最成功的情況,執行者和系統的交互非常順利,一路綠燈直抵用例的後置條件。這個場景稱為基本路徑。用例把基本路徑分離出來,目的是凸顯用例的核心價值。還是以ATM為例,發生在ATM上的場景有很多:

    1)張三來了,插卡,輸入密碼,輸入金額,順順利利取到錢,高興地走了;

    2李四來了,插卡,輸密碼,密碼錯,在輸,再錯,再輸,卡被吞掉了;

    3王五來了,插卡,輸密碼,輸金額,今天取得太多不能取了……

    以上三個場景,只有場景(1)是銀行在大街上擺放一台ATM的初衷。雖然場景(2)和(3)是難以避免,但場景(1)出現得越多越好,這是涉眾對ATM的期望。

    書寫路徑步驟的時候需要注意以下一些要點。這些要點有重疊的地方,如果違反了其中一個要點,很可能會違反另外的要點。

    2.2.3.1、按照交互四步曲書寫

    執行者和系統按回合交互,直到達成目的。需要的回合數是不定的,可能一個回合足夠,也可能需要多個回合。一個回合中的步驟分為四類:請求、驗證、改變、回應。如下圖所示:




    交互四步曲

    在一個回合中,請求是必須的,同時還需要其他三類步驟中的至少一類。看看以下例子,可以看到,第一個回合只需要請求和響應,第二個回合則四類步驟都有。




    回合制的交互示例

    當時間作為主執行者而且不需要和其他輔執行者交互的用例中,可能會出現不需要回應的情況,而且只有一個回合,如下所示:




    回合制的交互示例

    在書寫步驟時要注意以下一些形式上的問題:

    1)對於時間為主執行者的用例,回合中的請求步驟不寫“時間告知時間周期到了”,而是寫“當到達時間周期時”。

    2)驗證步驟不寫“是否”。例如以上例子中,第4步寫“系統驗證註冊信息充分”,不寫“系統驗證註冊信息是否充分”,目的是要表達“充分”是基本路徑期望的驗證結果。

    3)系統和輔執行者之間的交互可以看作是一種回應步驟,寫成“系統請求輔助執行者做某事”,例如“系統請求郵件列表系統群發郵件”。

    2.2.3.2、只寫系統能感知和承諾的內容

    看看以下例子:

    ……

    4、系統反饋應收總金額

    5、顧客付款

    6、收銀員提交付款方式和金額

    7、系統計算找零金額

    8、系統反饋找零金額,打印收據

    9、收銀員找零

    ……

    顧客付款和收銀員找零是系統無法感知和承諾的。如果寫在步驟里,會讓人產生誤解:只要用了本系統,顧客就會乖乖付款,收銀員會乖乖找零——也許顧客忘記付款和收銀員忘記找零正式商場要解決的一個頭痛問題。

    2.2.3.3、使用主動語句理清責任

    把動作的責任人放在主語的位置,看看以下兩句話:

    1)伊布從瓦倫西亞處得到傳球,舒梅切爾撲救伊布的射門。

    2瓦倫西亞傳球,伊布射門,舒梅切爾撲救。

    雖然上面一句比較文藝,但下面一句把責任理得更清晰。用例步驟也是如此:

    系統從會員處獲得用戶名和密碼(錯)

    會員提交用戶名和密碼(對)

    用戶名和密碼被驗證(錯)

    系統驗證用戶名和密碼(對)

    會員要是不提交,就不要怪系統沒有動靜;會員要是提交了,系統不動彈,那就要怪系統了。做到規規矩矩說話,把責任理清楚,其實不容易。再列舉一些常見的“胡說八道”,如下所示:




    規矩用詞

    2.2.3.4、主語只能是主執行者或系統

    寫需求,就是要把系統當作一個黑箱,描述它對外提供的功能以及功能附帶的質量需求。系統如何構造,不屬於需求描述的範圍,除非是涉眾強加的設計約束。所以步驟里不能出現“執行者請求前端系統做某事,前端系統請求後端系統做某事”“執行者請求客戶端做某事,客戶端請求服務端做某事”“執行者請求A子系統做某事,A子系統請求B子系統做某事”,就算這個系統最終的組成是分解成很多個部分,分佈在一百多個國家運行,需求里也只有兩個字:系統。前面已經學習過了,系統邊界是責任邊界,而非物理邊界,如下所示:




    需求把系統看作是黑箱

     

    2.2.3.5、使用核心域術語描述

    路徑步驟應該使用核心域的術語來描述,也就是說,要說“人話”。以下以一個零件採購系統為研究對象,比較以下兩句話,哪一句是“人話”,哪一句是“鳥語”?

    1)系統建立連接,打開連接,執行SQL語句,從“零件”表查詢……

    2系統根據查詢條件搜索零件

    其實,一眼就能看出,第一句是“鳥語”,第二句是“人話”了。不同職能多少會有主觀意識,做Java開發的覺得自己做的才是技術,需求屬於業務。但需求人員卻覺得自己做的也是技術,他們所研究的客戶才是業務。但客戶覺得自己做的才是技術……,這咋看起來有點像一個鄙視鏈。其實,大家做的都是“技術”,這是領域不同而已。應該用“核心域”和“非核心域”來代替“業務”和“技術”。

    如果所研究系統是一個關係數據庫的腳本工具,核心域是關係數據庫領域,上面提到的“系統建立連接,打開連接,執行SQL語句”就成了合適的需求。

    2.2.3.6、不要涉及界面細節

    很多人寫需求的時候,會把界面的細節帶進來,例如:

    ● 會員從下拉框中選擇類別

    ● 會員從文本框中輸入查詢條件

    ● 會員單擊“確定”按鈕

    這些界面細節很可能不是需求,更多是設計方案,背後可能隱藏更多的真正需求,也許是可用性需求“操作次數不超過5次”。但畢竟我們面對的客戶各種各樣的喜好都有,可能有些前排涉眾明確要求“一定要用下拉框”,那麼“下拉框”也是需求,但依然不能寫“會員從下拉框框中選擇類別”。因為這裏涉及兩類需求,她們的穩定性和變化趨勢不同,應該分開描述:

    ● 會員選擇類別(這是步驟)

    ● 通過下拉框來實現(這是設計約束)

    用例的需求組織方式是分層的,從用例的路徑、步驟、約束,穩定性會越來越低,如下所示:




    用例規約的需求層級

    把需求分層級了,穩定和不穩定的需求就分開了,更有利於了解事情的核心本質。平時遇到的大部分“需求變更”發生在補充約束級別,例如輸入會員信息時加個微信字段(字段列表變了),調整結賬時的打折規則(業務規則變了)。級別越高的需求,內容越穩定。

    很多時候做需求會把看得見和需求混為一談,真正的需求不見得是顯而易見的。需求判斷的標準不是涉眾是否看得見,而是涉眾是否在意。第一章已經學習過,需求和設計不是一一對應的,而是多對多的。

    2.2.3.7、不要涉及交互細節

    在步驟中,除了避免描述頁面細節,還要避免描述交互細節。例如有人會這樣寫:

    ● 會員每輸入賬戶名稱的一個字符

    ● 系統在界面中驗證當前輸入信息合法

    寫的人有他的道理:系統不是等待提交后才驗證輸入信息是否合法,而是隨時驗證立即反饋,這樣使用戶體驗更好。其實,這隻是交互設計的一些技能。忍不住要在需求規約里描述界面和交互的細節,背後的原因和忍不住要思考內部代碼如何實現的原因是一樣的,都是對自己的設計技能沒有信心,害怕“現在想到了如果不忘記記下來以後就忘記了”。這些都是人性的弱點。

    用例的步驟應該把焦點放在系統必須接收什麼輸入、系統必須輸出什麼信息以及系統必須做什麼處理這三個重點上,加上字段列表、業務規則、可用性需求等約束,足以表達各種需求。

    關於用例的交互怎麼寫,是一個比較頭疼的問題。即使不涉及交互設計細節的問題,也免不了混進交互設計的成分,例如,為什麼要分兩個回合而不是一個回合?實際上涉眾更希望一個回合就能達到用例的目標。所以,建議觀點是在用例規約中把路徑步驟刪掉,只保留輸入輸出、涉眾利益和補充約束,交互的路徑步驟由交互設計人員決定。

    2.2.3.8、需求是“不這樣不行”

    許多需求人員之所以在需求崗位上,並不是因為他掌握了該掌握的需求技能,可能只是因為他工作年限足夠長該換到需求崗位了——和許多年齡到了就上崗的夫妻和父母相似。這樣的需求人員硬着頭皮做需求時,最常用的一招就是托着腦袋想“這個東西是什麼樣子”,然後畫一個界面原型拿去和涉眾確認。一旦涉眾說“差不多就這樣吧”,就把這個界面原型作為需求交給分析設計人員。在這一點上,互聯網公司的產品經理表現得尤為明顯。如果僥倖成功,就拚命鼓吹“原型大法好”,因為他只會這個。

    當需求人員問問題時都是“這樣可以嗎”,相當於:

    ● 需求人員:界面這樣布局可以嗎?

    ● 涉    眾:(好用就行,我又不會做界面,問我可不可以我當然說可以了)可以。

    ● 需求人員:代碼這樣寫可以嗎?

    ● 涉    眾:(好用就行,我又不會寫代碼,問我可不可以我當然說可以了)可以。

    如果問的問題改為“不這樣可以嗎?”,像下面這樣:

    ● 需求人員:界面不這樣布局可以嗎?

    ● 涉    眾:不可以,這是政府的規定,你們不要自己亂髮揮啊!

    ● 需求人員:代碼不這樣寫可以嗎?

    ● 涉    眾:不可以,這段代碼是我小舅子寫的,一定要這樣,否則不給錢。

    這時,界面和代碼就成為了需求,當然,只是補充約束級別的需求。說到這裏,我們歸納出需求的判斷標準:需求是“不這樣不行”,而不是“這樣也行”。

    2.2.4、擴展路徑

    基本路徑上的每個步驟都有可能發生很多意外,其實某些意外是系統要負責處理的,處理意外的路徑就是擴展路徑。因為一個步驟上出現的意外及其處理可能有多種,所以同一步驟上的擴展路徑可能有多條。




    擴展路徑和步驟

    對於擴展路徑及其步驟的標號,本書採用的是Cockburn推薦的方法。擴展路徑的標號方法是在擴展步驟的数字序號後面加上字符序號,例如2a表示步驟2的第a條擴展路徑,2b表示步驟2的第b條擴展路徑。擴展路徑條件的最後加上冒號,接下來是該擴展路徑的步驟,標號方法是在擴展路徑編號後面加上数字序號,例如2a1。也就是說,步驟的編號以数字結尾,擴展路徑編號以字母結尾。如果多重擴展,那就繼續按此形式標註。還是以之前ATM“儲戶→取現金”用例為例。該用例規約加上擴展路徑之後如下所示:

    基本路徑:

    1. 儲戶提交賬戶號碼

    2. 系統驗證賬戶號碼合法

    3. 系統提示輸入密碼

    4. 儲戶輸入密碼

    5. 系統驗證密碼合法、正確

    6. 系統提示輸入取現金額

    7. 儲戶輸入取現金額

    8. 系統驗證取現金額合法

    9. 系統記錄取現信息,更新賬戶餘額

    ……

    2a. 賬戶號碼不合法:

             2a1.系統反饋賬戶號碼不合法

             2a2.返回1

    5a. 密碼不合法:

             5a1.返回3

    5b. 密碼合法但不正確:

             5b1.系統驗證當日取款累計輸錯密碼次數不超過3

                       5b1a.當日取款累計輸錯密碼次數超過3次:

                                5b1a1.系統關閉賬戶

                                5b1a2.用例結束

             5b2.系統反饋密碼不正確

             5b3.返回3

    8a. 取現金額不合法:

             8a1.返回6

    有一點需要注意,和輔執行者交互的步驟很有可能會出現擴展。例如:

    4. 系統請求短信平台發布信息

    ……

    擴展

    ……

    4a. 短信平台無響應:

             4a1.系統反饋短信平台無響應

    ……

    但,如果系統不需要從外部系統那裡得到任何結果,這個外系統就不是輔執行者,所以它出現故障會不會導致擴展的討論是沒有意義的。例如:

    5. 系統向經理的电子郵箱通知有新的待審批申請

    除了以上步驟之外,從其他步驟產生擴展路徑一定要非常謹慎,否則容易讓不屬於需求的內容混進用例規約中。特別要注意下面幾點。

    1)能感知和要處理的意外才是擴展

    2)設計技能不足導致的錯誤不是擴展

    3)不引起交互行為變化的選擇不是擴展

    4)界面跳轉不是擴展

    2.2.5、補充約束

    路徑步驟里描述的需求是不完整的。例如:

    用例名:發布講座消息

    ……

    1. 工作人員輸入講座信息,請求發布

    2. 系統驗證講座信息充分

    3. 系統生成發布內容

    4. 系統請求短信平台發布消息

    5. 系統保存講座信息和發布情況

    6. 系統反饋信息已經保存併發布

    ……

    步驟1中的“講座信息”包括哪些內容?需要添加字段列表。步驟2中“充分”指什麼,需要添加業務規則。從步驟1到步驟6有沒有速度上的要求?需要質量需求。

    如果補充約束的內容只和單個用例相關,可以直接放在該用例的規約中;如果補充約束適用於多個用例,可以單獨集中到另外的地方,從用例規約引用。

    補充約束前面的編號不代表順序,而是表示該約束綁定的步驟編號,如果某條補充約束不是針對某一步驟,而是針對多個步驟甚至整個用例,前面的編號可以是“*”,如下所示:

    5. 發布情況=發布時間+工作人員

    補充約束的類型可用類圖表示:




    用例的補充約束

    2.2.5.1、字段列表

    字段列表用來描述步驟里某個領域概念的細節。例如上面“發布講座消息”用例的步驟中,步驟1、3、5都需要分別添加字段列表。

    字段列表可以用自然語言表達,例如:

    字段列表

    1. 講座信息包括:舉辦時間、地點、專家信息、主題、簡介。專家信息包括:姓名、單位、頭銜。

    也可以用符號表達,例如:

    字段列表

    1. 講座信息=舉辦時間+地點+專家+主題+簡介

    1. 專家=姓名+單位+頭銜

    表示的符號可以採用過去數據字典常用的符號。例如:“+”表示數據序列,“()”表示可選項,“{}”表示多個,“[|||]”表示可能的取值。例如:

    註冊信息=公司名+聯繫人+電話+{聯繫地址}

    聯繫地=州+城市+街道+(郵編)

    保存信息=註冊信息+註冊時間

    客房狀態=[空閑|已預定|佔用|維修中]

    很多時候,做需求會把設計的細節帶上,例如“電話號碼varchar(255)”或把數據模型圖附上,這是不準確的。數據模型是設計,設計應該來源於需求,而非空想一個設計,然後把他當成需求。

    2.2.5.2、業務規則

    業務規則描述步驟中系統運算的一些規則,例如上面“發布講座消息”用例的步驟2中的“充分”沒有說清楚,需要添加業務規則,例如:

    業務規則:

    2. 必須有的項包括:時間、地點、專家、主題

    其實,主要涉眾能理解,行業上適用的任何方式(例如數學、物理公式)都可以用來表達業務規則。描述業務規則時要注意:業務規則不等於實現算法。因為業務規則也是一種需求,也是從涉眾的角度看“不這樣不行”的。例如,研究一款為盲人或殘疾人而做的語音輸入軟件,用例規約有如下片段:

    3. 系統將語音輸入翻譯為文字

    業務規則

    3. 採用XX識別算法

    這樣的業務規則可能是有問題的,如果前排是盲人或殘疾人,他們是不懂什麼叫“XX算法”,也不在意你是否用了這個算法,他們在意的需求是:“背景噪音強度為XX的情況下,識別率應該在XX以上”。當然也不排除前排涉眾是有意推廣某廠家的識別技術,那麼“採用XX識別算法”也可以成為需求。

    2.2.5.3、質量需求

    系統滿足功能需求,說明系統能把事情做正確。在做正確的基礎上,系統還需要在做的過程中滿足一些指標,這些指標就是質量需求,也被稱為“非功能需求”。

    1)可用性

    可用性需求是對人類執行者和系統之間交互質量的度量。如果系統僅能正確達到用例目標,但交互太頻繁,人類執行者是不喜歡用的。在表達可用性需求時,僅僅說“系統容易使用”是不行的。這是無法量化的目標,合適的可用性需求應該是可以度量的,例如:




    可用性度量

    2)性能

    性能包括速度、容量、能力等,例如:

    ① 系統應在0.5秒之內拍攝超速車的照片(速度)

    ② 應允許1000個執行者同時使用此用例(容量)

    ③ 在標準工作負荷下,系統的CPU佔用率應少於50%(能力)

    在尋找質量需求時,性能類型的質量需求往往是最多的。

    3)可靠性

    可靠性表示系統的安全性和完整性,通常用平均無故障時間(MTBF,Mean Time Between Failures)和平均修復時間(MTTR, Mean Time To Repair)表示。可靠性需求往往不是針對單個用例,而是針對整個系統,可以在所有用例規約的最後,單獨用小篇幅描述。

    4)可支持性

    可支持性表示系統升級和修復的能力。例如:

    ① 95%的緊急錯誤應能在30個工作時內修復

    ② 在修復故障時,未修復的相關缺陷平均數應小於0.5

    ③ 升級新版本時,應保存所有系統設置和個人設置

    和可靠性一樣,可支持性需求往往不是針對單個用例,而是針對整個系統,可以在所有用例規約的最後,單獨用小篇幅描述。

    以上介紹了質量需求的種類,很多時候質量需求不用可以去尋找,按照前面說過的“不這樣行嗎”的標準,把混入需求的設計刪掉,然後問為什麼,背後往往隱含的就是質量需求,如下所示:




    質量需求

    2.2.5.4、設計約束

    設計約束是在實現系統時必須要遵守的一些約束,包括界面樣式、報表格式、平台、語言等。

    設計約束既不是功能需求,也不是質量需求。例如,“用Oracle數據庫保存數據”,其實用DB2也可以滿足同樣的功能需求和質量需求,但必須要用Oracle,因為客戶已經採購了許多Oracle數據庫軟件,如果不用,成本就會增加。

    設計約束是需求的一種,也一樣要從涉眾的視角描述。在很多需求規約中,不少來自開發人員視角的設計偽裝成設計約束,混進了需求的隊伍。例如“系統應採用三層架構方式搭建”,涉眾並不了解“三層”好在哪裡,為什麼不是四層、五層等,然後問“為什麼”,背後的真正需求可能還是性能需求。

    需求是問題,設計是解決方案,二者的穩定性不同。

     

    2.3、需求啟發

    2.3.1、需求啟發要點

    需求人員要能夠像獵人一樣,用銳利的眼睛發現隱藏在叢林中的獵物,像偵探一樣,用縝密的思維判斷出偽裝成好人的兇手。但需求人員會有許多的障礙:如

    1)需求的一個啟發障礙是知識的詛咒,意思是:一旦知道某個東西,就很難相像不知道它會是什麼樣子;

    2)知識的詛咒在需求啟發中體現為溝通的困難;

    3)需求啟發的另一個障礙是做和定義的不同;

    但理解了以下兩個要點,有助於克服需求啟發中的障礙:

    1)和涉眾交流的形式應該採用視圖,而不是模型;

    2)和涉眾交流的內容應該聚焦涉眾利益,而不是需求;

    2.3.2、需求啟發手段




    需求啟發手段

    2.3.3、需求人員的素質培養




    需求人員的素質

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※為什麼 USB CONNECTOR 是電子產業重要的元件?

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!

  • PL真有意思(三):名字、作用域和約束

    前言

    這兩篇寫了詞法分析和語法分析,比較偏向實踐。這一篇來看一下語言設計里一個比較重要的部分:名字。在大部分語言里,名字就是標識符,如果從抽象層面來看名字就是對更低一級的內存之類的概念的一層抽象。但是名字還有其它相關的比如它的約束時間和生存周期等等

    約束時間

    約束就是兩個東西之間的一種關聯,例如一個名字和它所命名的事物,約束時間就是指創建約束的時間。有關的約束可以在許多不同的時間作出

    • 語言設計時
    • 語言實現時
    • 編寫程序時
    • 編譯時
    • 鏈接時
    • 裝入時
    • 運行時

    這就是為什麼基於編譯的語言實現通常會比基於解釋器的語言的實現更高效的原因,因為基於編譯的語言在更早的時候就做了約束,比如對於全局變量在編譯時就已經確定了它在內存中的布局了

    對象生存期和存儲管理

    在名字和它們所引用的對象的約束之間有幾個關鍵事件

    • 對象的創建
    • 約束的創建
    • 對變量、子程序、類型等的引用,所有這些都使用了約束
    • 對可能暫時無法使用的約束進行失活或者重新約束
    • 約束的撤銷
    • 對象的撤銷

    對象的生存期和存儲分配機制有關

    • 靜態對象被賦予一個絕對地址,這個地址在程序的整個執行過程中都保持不變
    • 棧對象按照後進先出的方式分配和釋放,通常與子程序的調用和退出同時進行
    • 堆對象可以在任意時刻分配或者釋放,它們要求更通用的存儲管理算法

    靜態分配

    全局變量是靜態對象最顯而易見的例子,還有構成程序的機器語言翻譯結果的那些指令,也可以看作是靜態分配對象。

    還有像每次調用函數都會保持相同的值的局部變量也是靜態分配的。對於數值和字符串這些常量也是靜態分配。

    還有用來支持運行時的各種程序,比如廢料收集和異常處理等等也可以看作是靜態分配

    基於棧的分配

    如果一種語言允許遞歸,那麼局部變量就不能使用靜態分配的方式了,因為在同一時刻,一個局部變量存在的實例個數是不確定的

    所以一般對於子程序,都用棧來保存它相關的變量信息。在運行時,一個子程序的每個實例都在棧中有一個相應的棧幀,保存着它的參數、返回值、局部變量和一些簿記信息

    基於堆的分配

    堆是一塊存儲區域,其中的子存儲塊可以在任意時間分配與釋放。因為堆具有它的動態性,所以就需要對堆空間進行嚴格的管理。許多存儲管理算法都維護着堆中當前尚未使用的存儲塊的一個鏈接表,稱為自由表。

    初始時這個表只有一個塊,就是整個堆,每當遇到分配請求時,算法就在表中查找一個大小適當的塊。所以當請求次數增多,就會出現碎片問題,也需要相應的解決

    所以有廢料收集的語言其實就是對堆的管理

    作用域作用

    一個約束起作用的那一段程序正文區域,稱為這個約束的作用域。

    現在大多數語言使用的都是靜態作用域,也就是在編譯時就確定了。也有少數語言使用動態作用域,它們的約束需要等到運行時的執行流才能確定

    靜態作用域

    在使用靜態作用域的語言,也叫作詞法作用域。一般當前的約束就是程序中包圍着一個給定點的最近的,其中有與該名字匹配的聲明的那個快中建立的那個約束。比如C語言在進入子程序時,如果局部變量和全局變量,那麼當前的約束就是與局部變量關聯,直到退齣子程序才撤銷這個約束

    但是有的語言提供了一種可以提供約束的生存期的機制,比如Fortran的save和C的static

    嵌套子程序

    有許多語言允許一個子程序嵌套在另一個子程序的。這樣有關約束的定義通常來說都是首先用這個名字在當前、最內層的作用域中查找相應的聲明,如果找不到就直接到更外圍的作用域查找當前的約束,直到到達全局作用域,否則就發生一個錯誤

    訪問非局部變量

    上面提到的訪問外圍作用域的變量,但是當前子程序只能訪問到當前的棧幀,所以就需要一個調用幀鏈來讓當前的作用域訪問到外圍作用,通過調用順序形成一個靜態鏈

    聲明的順序

    關於約束還有一個問題,就是在同一作用域里,先聲明的名字是否能使用在此之後的聲明

    在Pascal里有這樣兩條規則:

    1. 修改變量要求名字在使用之前就進行聲明
    2. 但是當前聲明的作用域是整個程序塊

    所以在這兩個的相互作用下,會造成一個讓人吃驚的問題

    const N = 10;
    
    procedure foo;
    const
      M = N; (*靜態語義錯誤*)
      N = 20;

    但是在C、C++和Java等語言就不會出現這個問題,它們都規定標識符的作用域不是整個塊,而是從其聲明到塊結束的那一部分

    並且C++和Java還進一步放寬了規則,免除了使用之前必須聲明的要求

    模塊

    恰當模塊化的代碼可以減少程序員的思維負擔,因為它最大限度的減少了理解系統的任意給定部分時所需的信息量。在設計良好的程序中,模塊之間的接口應盡可能的小,所有可能改變的設計決策都隱藏在某個模塊里。

    模塊作為抽象

    模塊可以將一組對象(如子程序、變量、類型)封裝起來。使得:

    1. 這些內部的對象相互可見
    2. 但是外部對象和內部對象,除非显示的導入,否則都是不可見的

    模塊作為管理器

    模塊使我們很容易的創建各種抽象,但是如果需要多個棧的實例,那麼就需要一個讓模塊成為一個類型的管理器。這種管理器組織方式一般都是要求在模塊中增加創建/初始化函數,並給每一個函數增加一個用於描述被操作的實例

    模塊類型

    對於像這種多實例的問題,除了管理器,在許多語言里的解決方法都是可以將模塊看作是類型。當模塊是類型的時候,就可以將當前的方法認為是屬於這個類型的,簡單來說就是調用方法變化了

    push(A, x) -> A.push(x)

    本質上的實現區別不大

    面向對象

    在更面向對象里的方法里,可以把類看作是一種擴充了一種繼承機制的模塊類型。繼承機制鼓勵其中所有操作都被看作是從屬於對象的,並且新的對象可以從現有對象繼承大部分的操作,而不需要為這些操作重寫代碼。

    類的概念最早應該是起源於Simula-67,像後來的C++,Java和C#中的類的思想也都起源於它。類也是像Python和Ruby這些腳本語言的核心概念

    從模塊到模塊類型再到類都是有其思想基礎,但是最初都是為了更好的數據抽象。但是即使有了類也不能完全取代模塊,所以許多語言都提供了面向對象和模塊的機制

    動態作用域

    在使用動態作用域的語言中,名字與對象間的約束依賴於運行時的控制流,特別是依賴子程序的調用順序

    n : integer
    
    procedure first
      n := 1
    
    procedure second
      n : integer
      first()
    
    n := 2
    if read_integer() > 0
      second()
    else
      first()
    write_integer()

    這裏最後的輸出結果完全取決於read_integer讀入的数字的正負,如果為正,輸出就為2,否則就打印一個1

    作用域的實現

    為了跟蹤靜態作用域程序中的哥哥名字,編譯器需要依靠一個叫做符號表的數據結構。從本質上看,符號表就是一個記錄名字和它已知信息的映射關係的字典,但是由於作用域規則,所以還需要更強大的數據結構。像之前那個寫編譯器系列的符號表就是使用哈希表加上同一層作用域鏈表來實現的

    而對於動態作用域來說就需要在運行時執行一些操作

    作用域中名字的含義

    別名

    在基於指針的數據結構使用別名是很自然的情況,但是使用別名可能會導致編譯器難以優化或者造成像懸空引用的問題,所以需要謹慎使用

    重載

    在大多數語言中都或多或少的提供了重載機制,比如C語言中(+)可以被用在整數類型也可以用在浮點數類型,還有Java中的String類型也支持(+)運算髮

    要在編譯器的符號表中處理重載問題,就需要安排查找程序根據當前的上下文環境返回一個有意義的符號

    比如C++、Java和C#中的類方法重載都可以根據當前的參數類型和數量來判斷使用哪個符號

    內部運算符的重載

    C++、C#和Haskell都支持用戶定義的類型重載內部的算術運算符,在C++和C#的內部實現中通常是將A+B看作是operator+(A, B)的語法糖

    多態性

    對於名字,除了重載還有兩個重要的概念:強制和多態。這三個概念都用於在某些環境中將不同類型的參數傳給一個特定名字的子程序

    強制是編譯器為了滿足外圍環境要求,自動將某類型轉換為另一類型的值的操作

    所以在C中,定義一個計算整數或者浮點數兩個值中的最小值的函數

    double min(double x, double y);

    只要浮點數至少有整數那麼多有效二進制位,那麼結果就一定會是正確的。因為編譯器會對int類型強制轉換為double類型

    這是強制提供的方法,但是多態性提供的是,它使同一個子程序可以不加轉換的接受多種類型的參數。要使這個概念有意義,那麼這多種類型肯定要具有共同的特性

    顯式的參數多態性就叫做泛型,像Ada、C++、Clu、Java和C#都支持泛型機制,像剛才的例子就可以在Ada中用泛型來實現

    generic
      type T is private;
      with function "<" (x, y : T) return Boolean;
    function min(x, y : T) return T;
    
    function min(x, y : T) return T is
    begin
      if x < y then return x;
      else return y;
      end if;
    end min
    
    function string_min is new min(string, "<")
    function date_min is new min(date, date_precedes);

    像List和ML中就可以直接寫

    (define min (lambda (a b) (if (< a b) a b)))

    其中有關類型的任何細節都由解釋器處理

    引用環境的約束

    提到引用環境的約束就有兩種方式:淺約束和深約束

    推遲到調用時建立約束的方式淺約束。一般動態作用域的語言默認是淺約束,當然動態作用域和深約束也是可以組合到一起的。
    執行時依然使用傳遞時的引用環境,而非執行時的引用環境。那麼這種規則稱為深約束,一般靜態作用域的語言默認是深約束

    閉包

    為了實現神約束,需要創建引用環境的一種顯示錶示形式,並將它與對有關子程序的引用捆綁在一起,這樣的捆綁叫做閉包

    總而言之,如果子程序可以被當作參數傳遞,那麼它的引用環境一樣也會被傳遞過去

    一級值和非受限生存期

    一般而言,在語言中,如果一個值可以賦值給變量、可以當作參數傳遞、可以從子程序返回,那麼它被稱為具有一級狀態(和我們在js中說函數是一等公民一個含義)。大多數的語言中數據對象都是一級狀態。二級狀態是只能當作參數傳遞;三級值則是連參數也不能做,比如C#中一些+-*/等符號。

    在一級子程序會出現一個複雜性,就是它的生存期可能持續到這個子程序的作用域的執行期外。為了避免這一問題,大部分函數式語言都表示局部變量具有非受限的生命周期,它們的生命周期無限延長,直到GC能證明這些對象再也不使用了才會撤銷。那麼不撤銷帶來的問題就是這些子程序的存儲分配基於棧幀是不行了,只能是基於堆來分配管理。為了維持能基於棧的分配,有些語言會限制一級子程序的能力,比如C++,C#,都是不允許子程序嵌套,也就從根本上不會存在閉包帶來的懸空引用問題。

    小結

    這一篇從名字入手,介紹了名字與其背後的對象的約束關係、以及約束時間的概念;然後介紹了對象的分配策咯(靜態、棧、堆);緊接着討論了名字與對象之間建立的約束的生命周期,並由此引出了作用域的概念;進一步延伸出多個約束組成的引用環境的相關概念以及問題。

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

    ※評比前十大台北網頁設計台北網站設計公司知名案例作品心得分享

    ※智慧手機時代的來臨,RWD網頁設計已成為網頁設計推薦首選

  • (三十五)golang–面向對象之多態

    (三十五)golang–面向對象之多態

    多態:變量具有多種形態,可以用統一的接口來調用不同的實現。

    接口體現多態特徵:

    (1)多態參數:之前所講的Usb接口案例,既可以接受手機變量,也可以接受相機變量,就體現了usb接口的多態;

    (2)多態數組:

    package main
    
    import (
        "fmt"
    )
    
    type usb interface {
        start()
        stop()
    }
    
    type phone struct {
        name string
    }
    
    func (p phone) start() {
        fmt.Println(p.name, "手機開始工作")
    }
    
    func (p phone) stop() {
        fmt.Println(p.name, "手機停止工作")
    }
    
    type camera struct {
        name string
    }
    
    func (c camera) start() {
        fmt.Println(c.name, "相機開始工作")
    }
    
    func (c camera) stop() {
        fmt.Println(c.name, "相機停止工作")
    }
    
    type computer struct {
    }
    
    func (co computer) working(usb usb) {
        usb.start()
        usb.stop()
    }
    
    func main() {
        var usbArr [3]usb
        usbArr[0] = phone{"小米"}
        usbArr[1] = phone{"vivo"}
        usbArr[2] = camera{"尼康"}
        fmt.Println(usbArr)
        for i := 0; i < len(usbArr); i++ {
            usbArr[i].start()
            usbArr[i].stop()
        }
    }

    我們以前講到,數組是只能存儲同一種類型的數據,利用多態數組,就可以存儲不同的類型了;

    如何將一個接口變量賦值給一個自定義類型的變量?使用類型斷言

    類型斷言:由於接口是一般類型,不知道具體類型,如果要轉成具體類型,就需要使用類型斷言;要保持原來空接口指向的數據類型和斷言的數據類型一致;

    為了避免輸出panic報錯,可以進行斷言判斷;

    類型斷言實踐一:

    我們給phone中加入一個方法call(),在調用usb變量時,usb.call(),肯定是不對的,因為usb可能是phone,也可能是camera,而camera是沒有這個函數的,因此,在調用的時候用類型斷言。

    package main
    
    import (
        "fmt"
    )
    
    type usb interface {
        start()
        stop()
    }
    
    type phone struct {
        name string
    }
    
    func (p phone) start() {
        fmt.Println(p.name, "手機開始工作")
    }
    
    func (p phone) call() {
        fmt.Println(p.name,"手機在打電話")
    }
    
    func (p phone) stop() {
        fmt.Println(p.name, "手機停止工作")
    }
    
    type camera struct {
        name string
    }
    
    func (c camera) start() {
        fmt.Println(c.name, "相機開始工作")
    }
    
    func (c camera) stop() {
        fmt.Println(c.name, "相機停止工作")
    }
    
    type computer struct {
    }
    
    func (co computer) working(usb usb) {
        usb.start()
        //如果usb還指向phone的結構體變量,則還需要調用call方法
        if phone, ok := usb.(phone); ok { phone.call() }
        usb.stop()
    }
    
    func main() {
        var usbArr [3]usb
        usbArr[0] = phone{"小米"}
        usbArr[1] = phone{"vivo"}
        usbArr[2] = camera{"尼康"}
        var com computer
        fmt.Println(usbArr)
        for i := 0; i < len(usbArr); i++ {
            com.working(usbArr[i])
        }
    }

    類型斷言實踐2:循環判斷輸入參數的類型

    package main
    
    import (
        "fmt"
    )
    
    type student struct {
        name string
    }
    
    func typeJudge(items ...interface{}) {
        for index, x := range items {
            switch x.(type) {
            case bool:
                fmt.Printf("第%v個參數是bool類型,值是%v\n", index, x)
            case int, int32, int64:
                fmt.Printf("第%v個參數是整數類型,值是%v\n", index, x)
            case float32:
                fmt.Printf("第%v個參數是float32類型,值是%v\n", index, x)
            case float64:
                fmt.Printf("第%v個參數是float64類型,值是%v\n", index, x)
            case string:
                fmt.Printf("第%v個參數是string類型,值是%v\n", index, x)
            case student:
                fmt.Printf("第%v個參數是student類型,值是%v\n", index, x)
            case *student:
                fmt.Printf("第%v個參數是*student類型,值是%v\n", index, x)
            default:
                fmt.Printf("第%v個參數類型不確定,值是%v\n", index, x)
            }
        }
    }
    
    func main() {
        var n1 float32 = 1.1
        var n2 float64 = 1.2
        var n3 int32 = 1
        var name string = "tom"
        var n5 bool = true
    
        stu1 := student{"jack"}
        stu2 := &student{"bob"}
    
        typeJudge(n1, n2, n3, name, n5, stu1, stu2)
    }

    本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

    ※為什麼 USB CONNECTOR 是電子產業重要的元件?

    網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司,幫您輕鬆架站!

    ※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

    ※想知道最厲害的台北網頁設計公司推薦台中網頁設計公司推薦專業設計師”嚨底家”!!