系統分析師-軟件水平考試（高級）-理論-系統規劃

前言

系統規劃是什麼東東呢？

通俗點說，就是為了實現企業的戰略目標，分析企業現狀（技術外部）與系統狀況（技術內部），從而提出新的技術要求，對現有系統進行規劃設計等變化。

1. 目標是實現企業戰略目標；
2. 分析企業現狀（了解情況了，才能下手唄。站在技術角度，企業現狀就分技術和非技術）；
3. 根據掌握的資料，對接下來的系統開發做出規劃（技術規劃，那是CTO的工作，這裏就直接系統規劃）；
4. 落實規劃，開發或改造系統，從而完成對企業戰略目標的支持。

期間會涉及對一些項目或系統（一個公司會擁有多個項目與多個系統，用於支撐公司產業線）的評估，如機會選擇，可行性分析，效益分析（分析師比架構師多了這些思量與考察，而高項則更為具體）。

XMIND

（圖片絕對清楚。如果看不清楚，請下載，或者在新頁面中打開圖片）

總結

XMIND重難點的解讀

步驟

為了幫助大家更好地理解這部分內容，我們舉個栗子。

這樣說吧，阿里巴巴定下了淘寶雙十一戰略目標。你作為CTO，就要站在公司高層，開始規劃阿里的系統，讓它為雙十一這一戰略目標服務。

具體的實施過程應該是這樣的：

1. 首先，根據雙十一這一戰略目標，你得分析阿里現在技術環境（可以做出怎樣的改變，業務上是否可以進行一定的妥協等等），並了解系統當前的狀況（是否可以承受住雙十一壓力。承受不了的話，瓶頸在哪裡等等）。無論做什麼，收集信息，了解情況都是首要的。
2. 其次，站在技術的角度，你需要確定公司信息系統該達到怎樣的目標（更大一些說，應該是技術的目標標準）。比如雙十一這樣的戰略目標，我確定公司的系統應該達到十萬的訂單處理速度（2019年，阿里的訂單創建峰值已經達到了五十萬左右），以及一系列類似的系統要求。
3. 然後，根據前面制定的一系列系統要求。開始規劃系統的拆分，將目標系統進行邏輯的拆分。但是如果已經有了系統基礎，那麼就需要在原有的系統上，進行調整。如阿里雲平台必須保證在雙十一時提供足夠強大的基礎設施支撐（可以在必要時，支撐大當量的橫向擴展）。又如支付寶需要確保在雙十一零點（流量衝擊的峰值）保證可以支撐百萬計的支付請求，並且妥善處理超出的部分。這樣就完成了目標的落地方案生成。
4. 接下來，需要確定工作的優先級別，以及開發順序。由於總的開發資源是有限的，並且不同業務之間存在各種錯綜複雜的關係，所以，需要CTO站在公司高層角度，進行這個層次的方案安排。如由於阿里雲是其它業務的支撐基礎，是實現目標的必要因素（甚至都沒有太多業務妥協的空間），那麼我們可以將它作為優先級第一的工作，並最大程度地傾斜企業資源等。其它工作以此類推。從複雜的角度，可以了解項目組合管理，以及企業戰略管理等（但是分析師考試不會這麼複雜的，這裏只是舉個栗子）。
5. 接着，我需要對這些方案進行可行性分析。畢竟這些方案可能是我根據自己的經驗，以及周邊個別的意見，花了一天的時間整合出來的。其中可能存在一些不合理，不科學的部分，而我並不了解（個人的力量與認知畢竟有限。也許我對軟件十分清楚，但是在硬件上提出了超脫物理規律的不可能方案，而我想當然地認為可以）。所以，需要進行可行性分析。甚至通過論證會議，進行具體的論證，從而確定方案是否可行，是否需要調整。
6. 最後，根據前面這些簡要的方案與意見，通過自己與下屬不斷溝通，從而形成一份具體的系統設計的方案-系統設計任務書。作為接下來實施系統建設工作的具體依據。

可行性分析

這裏着重提一下這個部分，這個部分充分體現了系統的業務特性。

從考試角度說，這個部分雖然不是一個章節，但是每次考試都會考幾分。

從實際角度來說，可能一些感興趣的比較清楚，阿里的p7-p8，騰訊的t3-t4，晉陞都是有一定困難的。晉陞條件中有一條，需要對業務有足夠的了解。就如同國外對程序員的分級看法，也對程序員的產品思維有着非常重的要求。大廠要求程序員對業務有一定的了解，一方面是確定經歷真實性，另一方面就是觀察面試者的業務思維，產品思維。可能p7，只是要求根據業務場景，實現業務方案，並適當根據技術，提出對業務的看法（如調整業務，提出新的業務特性等）。到了p8-p9就是希望你能在一個大的目標下，提出自己的產品理念。在項目經理的產品模型或產品想法的基礎上，站在技術角度，給出新的產品想法，去完善產品模型，提高產品的層次。

以上看法，不保證完全正確，畢竟不同人的解讀是不同的。但是還是值得參考一下的（日後我晉陞p8，p9，考慮回來更新一下）。

那麼可行性分析可以帶來產品思維嘛？

當然，，，不能。

但是，可行性分析，絕對是一個絕佳的入門機會。可以幫助開發人員，從一個新的角度去看待自己開發的系統。並且這個入門的門檻很低，開發人員可以很好的理解，入門。後續的道路，就需要各位自己走了。畢竟完事開頭難，開始解決了，後面走下去就行了。當然後續有更多積累了，我會分享我對產品，業務的看法。

至於其它部分，都比較簡單，就不在此深入談論了。

學習必要性

考試的必要性，我只說一句，分值可觀。

現實的意義，我總結了三點比較重要的：

• 提升高度。通過這部分的學習，可以為你晉陞公司技術高層埋下一顆種子。起碼你和Boss扯皮的時候，不再是只有技術名詞了。
• 改善眼界。通過這部分的學習，可以改變你對信息系統的純技術看法。有時候，人的改變，只是需要一個開始。
• 心中有數。通過這部分的學習，可以令你明白現有項目的一些基本商業特性。起碼你知道你的項目能走多遠，是不是該跑路了。囧

這個章節就這些內容，如果有什麼不清楚的，可以@我。如果有正在準備考試或已經通過考試的，或有交流需求的，可以@我，加群。

希望這篇博客對大家有所幫助。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步”網站設計“幫您第一時間規劃公司的門面形象

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※試算大陸海運運費!

flink 中自身雖然實現了大量的connectors，如下圖所示，也實現了jdbc的connector，可以通過jdbc 去操作數據庫，但是flink-jdbc包中對數據庫的操作是以ROW來操作並且對數據庫事務的控制比較死板，有時候操作關係型數據庫我們會非常懷念在java web應用開發中的非常優秀的mybatis框架，那麼其實flink中是可以自己集成mybatis進來的。 我們這裏以flink 1.9版本為例來進行集成。

如下圖為flink內部自帶的flink-jdbc：

創建一個flink的流式處理項目，引入flink的maven依賴和mybatis依賴（注意這裏引入的是非spring版本，也就是mybatis的單機版）：

<properties>

<flink.version>1.9.0</flink.version>
</properties>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>
<!-- flink java 包 -->
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-streaming-java_2.11</artifactId>
    <version>${flink.version}</version>
</dependency>

maven依賴引入以後，那麼需要在resources下面定義mybatis-config.xml 配置：

mybatis-config.xml 需要定義如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="BankBillPublic" type="xxxx.xx.xx.BankBillPublic" />
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://xx.xx.xx.xx:3306/hue?characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&autoReconnect=true" />
                <property name="username" value="xxxx" />
                <property name="password" value="xxxx*123%" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/xxxxxMapper.xml" />
    </mappers>
</configuration>

typeAlias 標籤中為自定義的數據類型，然後在xxxxxMapper.xml 中parameterType或者resultType就可以直接用這種定義的數據類型。

dataSource type=”POOLED” 我們使用的是mybatis中的POOLED 類型，也就是連接池的方式去使用。默認支持如下這三種類型。

 我們也可以使用阿里巴巴開源的druid連接池，那麼就需要引入對應的maven依賴，如下所示：

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.14</version>
        </dependency>　　

 然後定義一個對應的druid的DataSource，如下所示：

import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.datasource.DataSourceFactory;
import com.alibaba.druid.pool.DruidDataSource;

public class DruidDataSourceFactory implements DataSourceFactory {
    private Properties props;

    @Override
    public DataSource getDataSource() {
        DruidDataSource dds = new DruidDataSource();
        dds.setDriverClassName(this.props.getProperty("driver"));
        dds.setUrl(this.props.getProperty("url"));
        dds.setUsername(this.props.getProperty("username"));
        dds.setPassword(this.props.getProperty("password"));
        // 其他配置可以根據MyBatis主配置文件進行配置
        try {
            dds.init();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return dds;
    }

    @Override
    public void setProperties(Properties props) {
        this.props = props;
    }
}

之後就可以mybatis的配置中使用了，如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="BankBillPublic" type="xxxx.xx.xx.BankBillPublic" />
        <typeAlias alias="DRUID" 
 type="com.xx.mybatis.druid.utils.DruidDataSourceFactory" />
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="DRUID">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://xx.xx.xx.xx:3306/hue?characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&autoReconnect=true" />
                <property name="username" value="xxxx" />
                <property name="password" value="xxxx*123%" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/xxxxxMapper.xml" />
    </mappers>
</configuration>

<mappers> 下面為定義的mybatis 的xxxxxMapper文件。裏面放置的都是sql語句。

本文作者張永清，轉載請註明出處：

xxxxxMapper.xml 中的sql示例：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="xx.xx.bigdata.flink.xx.xx.mapper.UserRelaInfoMapper">
    <!--查詢關鍵字匹配 -->
    <select id="queryUserRelaInfo" parameterType="String" resultType="UserRelaInfo">
        SELECT id AS id,
        USER_NAME AS userName,
        APPL_IDCARD AS applIdCard,
        PEER_USER AS peerUser,
        RELA_TYPE AS relaType,
        CREATE_USER AS createUser,
        CREATE_TIME AS createTime
        FROM USER_RELA_INFO
        <where>
            <if test="applIdCard != null">
                APPL_IDCARD=#{applIdCard}
            </if>
            <if test="peerUser != null">
            AND PEER_USER=#{peerUser}
            </if>
        </where>
    </select>
</mapper>

 定義Mapper，一般可以定義一個interface ，和xxxxxMapper.xml中的namespace保持一致

注意傳入的參數一般加上@Param 註解，傳入的參數和xxxxxMapper.xml中需要的參數保持一致

public interface UserRelaInfoMapper {
    List<UserRelaInfo> queryUserRelaInfo(@Param("applIdCard")String applIdCard,@Param("peerUser") String peerUser);
}

定義SessionFactory工廠（單例模式）：

/**
 *
 *  sqlsession factory 單例  事務設置為手動提交
 */
public class MybatisSessionFactory {
    private static final Logger LOG = LoggerFactory.getLogger(MybatisSessionFactory.class);
    private static SqlSessionFactory sqlSessionFactory;
    private MybatisSessionFactory(){
        super();
    }
    public synchronized static SqlSessionFactory getSqlSessionFactory(){
        if(null==sqlSessionFactory){
            InputStream inputStream=null;
            try{
                inputStream = MybatisSessionFactory.class.getClassLoader().getResourceAsStream("mybatis-config.xml");
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            }
            catch (Exception e){
                LOG.error("create MybatisSessionFactory read mybatis-config.xml cause Exception",e);
            }
            if(null!=sqlSessionFactory){
                LOG.info("get Mybatis sqlsession sucessed....");
            }
            else {
                LOG.info("get Mybatis sqlsession failed....");
            }
        }
        return sqlSessionFactory;
    }
}

使用mybatis 對數據庫進行操作：

        SqlSession sqlSession = MybatisSessionFactory.getSqlSessionFactory().openSession();
        UserRelaInfoMapper  userRelaInfoMapper  = sqlSession.getMapper(UserRelaInfoMapper .class);
		//調用對應的方法
		userRelaInfoMapper.xxxx();
		//提交事務
		sqlSession.commit();
		//回滾事務，一般可以捕獲異常，在發生Exception的時候，事務進行回滾
		sqlSession.rollback();
		
		
		

這裏以mysql為示例，寫一個flink下mysql的sink示例，可以自己來靈活控制事務的提交：

public class MysqlSinkFunction<IN> extends RichSinkFunction {
    private static final Logger LOG = LoggerFactory.getLogger(MysqlSinkFunction.class);
    @Override
    public void invoke(Object value, Context context) throws Exception{
        SqlSession sqlSession = MybatisSessionFactory.getSqlSessionFactory().openSession();
        try{
                            //插入
                            LOG.info("MysqlSinkFunction start to do insert data...");
                            xxx.xxx()；
							//更新
                            LOG.info("MysqlSinkFunction start to do update data...");
							xxx.xxx()；
                            //刪除
                            LOG.info("MysqlSinkFunction start to do delete data...");
							xxx.xxx()；

                    
                
                sqlSession.commit();
                LOG.info("MysqlSinkFunction commit transaction success...");
        }
        catch (Throwable e){
            sqlSession.rollback();
            LOG.error("MysqlSinkFunction cause Exception,sqlSession transaction rollback...",e);
        }
    }
}　　

相信您如果以前在spring中用過mybatis的話，對上面的這些操作一定不會陌生。由此你也可以發現，在大數據中可以完美的集成mybatis，這樣可以發揮mybatis框架對數據庫操作的優勢，使用起來也非常簡單方便。
一旦集成了mybaitis后，在flink中就可以方便的對各種各樣的關係型數據庫進行操作了。
本文作者張永清，轉載請註明出處：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步”網站設計“幫您第一時間規劃公司的門面形象

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※試算大陸海運運費!

目錄

前面我們講的都是線性表結構，棧、隊列等等。今天我們講一種非線性表結構，樹。樹這種數據結構比線性表的數據結構要複雜得多，內容也比較多，首先我們先從樹（Tree）開始講起。
@

樹(Tree)

樹型結構是一種非線性結構，它的數據元素之間呈現分支、分層的特點。

1.樹的定義

樹(Tree)是由n(n≥0)個結點構成的有限集合T，當n=0時T稱為空樹；否則，在任一非空樹T中：
(1)有且僅有一個特定的結點，它沒有前驅結點，稱其為根(Root)結點；
(2)剩下的結點可分為m(m≥0)個互不相交的子集T1，T2，…，Tm，其中每個子集本身又是一棵樹，並稱其為根的子樹(Subtree)。

注意：樹的定義具有遞歸性，即“樹中還有樹”。樹的遞歸定義揭示出了樹的固有特性

2.什麼是樹結構

什麼是“樹”？再好的定義，都沒有圖解來的直觀。所以我在圖中畫了幾棵“樹”。你來看看，這些“樹”都有什麼特徵？

你有沒有發現，“樹”這種數據結構真的很像我們現實生活中的“樹”

3.為什麼使用樹結構

在有序數組中，可以快速找到特定的值，但是想在有序數組中插入一個新的數據項，就必須首先找出新數據項插入的位置，然後將比新數據項大的數據項向後移動一位，來給新的數據項騰出空間，刪除同理，這樣移動很費時。顯而易見，如果要做很多的插入和刪除操作和刪除操作，就不該選用有序數組。另一方面，鏈表中可以快速添加和刪除某個數據項，但是在鏈表中查找數據項可不容易，必須從頭開始訪問鏈表的每一個數據項，直到找到該數據項為止，這個過程很慢。 樹這種數據結構，既能像鏈表那樣快速的插入和刪除，又能想有序數組那樣快速查找

4.樹的常用術語

結點——包含一個數據元素和若干指向其子樹的分支
度——結點擁有的子樹個數
樹的度——該樹中結點的最大度數
恭弘=叶 恭弘子——度為零的結點
分支結點（非終端結點）——度不為零的結點
孩子和雙親——結點的子樹的根稱為該結點的孩子，相應地，該結點稱為孩子的雙親
兄弟——同一個雙親的孩子
祖先和子孫——從根到該結點所經分支上的所有結點。相應地，以某一結點為根的子樹中的任一結點稱為該結點的子孫。
結點的層次——結點的層次從根開始定義，根結點的層次為1，其孩子結點的層次為2，……
堂兄弟——雙親在同一層的結點
樹的深度——樹中結點的最大層次
有序樹和無序樹——如果將樹中每個結點的各子樹看成是從左到右有次序的(即位置不能互換)，則稱該樹為有序樹；否則稱為無序樹。
森林——m(m≥0)棵互不相交的樹的有限集合

到這裏，樹就講的差不多了，接下來講講二叉樹（Binary Tree）

二叉樹(Binary Tree）

樹結構多種多樣，不過我們最常用還是二叉樹，我們平時最常用的樹就是二叉樹。二叉樹的每個節點最多有兩個子節點，分別是左子節點和右子節點。二叉樹中，有兩種比較特殊的樹，分別是滿二叉樹和完全二叉樹。滿二叉樹又是完全二叉樹的一種特殊情況。

1．二叉樹的定義和特點

二叉樹的定義：
二叉樹(Binary Tree)是n(n≥0)個結點的有限集合BT，它或者是空集，或者由一個根結點和兩棵分別稱為左子樹和右子樹的互不相交的二叉樹組成 。
————————————
二叉樹的特點：
每個結點至多有二棵子樹(即不存在度大於2的結點)；二叉樹的子樹有左、右之分，且其次序不能任意顛倒。

2．幾種特殊形式的二叉樹

1、滿二叉樹：
定義：深度為k且有2k-1個結點的二叉樹，稱為滿二叉樹。
特點：每一層上的結點數都是最大結點數
2、完全二叉樹：
定義：
深度為k，有n個結點的二叉樹當且僅當其每一個結點都與深度為k的滿二叉樹中編號從1至n的結點一一對應時，稱為完全二叉樹
特點:
特點一 : 恭弘=叶 恭弘子結點只可能在層次最大的兩層上出現;
特點二 : 對任一結點，若其右分支下子孫的最大層次為l，則其左分支下子孫的最大層次必為l 或l+1

建議看圖對應文字綜合理解

代碼創建二叉樹：

首先，創建一個節點Node類

package demo5;
/*
 * 節（結）點類 
 */
public class Node {
    //節點的權
    int value;
    //左兒子（左節點）
    Node leftNode;
    //右兒子（右節點）
    Node rightNode;
    //構造函數，初始化的時候就給二叉樹賦上權值
    public Node(int value) {
        this.value=value;
    }
    
    //設置左兒子（左節點）
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
    //設置右兒子（右節點）
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }

接着創建一個二叉樹BinaryTree 類

package demo5;
/*
 * 二叉樹Class
 */
public class BinaryTree {
    //根節點root
    Node root;
    
    //設置根節點
    public void setRoot(Node root) {
        this.root = root;
    }
    
    //獲取根節點
    public Node getRoot() {
        return root;
    }
}

最後創建TestBinaryTree 類（該類主要是main方法用來測試）來創建一個二叉樹

package demo5;
public class TestBinaryTree {

    public static void main(String[] args) {
        //創建一顆樹
        BinaryTree binTree = new BinaryTree();
        //創建一個根節點
        Node root = new Node(1);
        //把根節點賦給樹
        binTree.setRoot(root);
        //創建一個左節點
        Node rootL = new Node(2);
        //把新創建的節點設置為根節點的子節點
        root.setLeftNode(rootL);
        //創建一個右節點
        Node rootR = new Node(3);
        //把新創建的節點設置為根節點的子節點
        root.setRightNode(rootR);
        //為第二層的左節點創建兩個子節點
        rootL.setLeftNode(new Node(4));
        rootL.setRightNode(new Node(5));
        //為第二層的右節點創建兩個子節點
        rootR.setLeftNode(new Node(6));
        rootR.setRightNode(new Node(7));
    }

}

下面將會講的遍歷、查找節點、刪除節點都將圍繞這三個類開展

不難看出創建好的二叉樹如下（畫的不好，還望各位見諒）：

3．二叉樹的兩種存儲方式

二叉樹既可以用鏈式存儲，也可以用數組順序存儲。數組順序存儲的方式比較適合完全二叉樹，其他類型的二叉樹用數組存儲會比較浪費存儲空間，所以鏈式存儲更合適。

我們先來看比較簡單、直觀的鏈式存儲法。

接着是基於數組的順序存儲法（該例子是一棵完全二叉樹）

上面例子是一棵完全二叉樹，所以僅僅“浪費”了一個下標為0的存儲位置。如果是非完全二叉樹，則會浪費比較多的數組存儲空間，如下。

還記得堆和堆排序嗎，堆其實就是一種完全二叉樹，最常用的存儲方式就是數組。

4．二叉樹的遍歷

前面我講了二叉樹的基本定義和存儲方法，現在我們來看二叉樹中非常重要的操作，二叉樹的遍歷。這也是非常常見的面試題。

經典遍歷的方法有三種，前序遍歷、中序遍歷和後序遍歷

前序遍歷是指，對於樹中的任意節點來說，先打印這個節點，然後再打印它的左子樹，最後打印它的右子樹。

中序遍歷是指，對於樹中的任意節點來說，先打印它的左子樹，然後再打印它本身，最後打印它的右子樹。

後序遍歷是指，對於樹中的任意節點來說，先打印它的左子樹，然後再打印它的右子樹，最後打印這個節點本身。

我想，睿智的你已經想到了二叉樹的前、中、後序遍歷就是一個遞歸的過程。比如，前序遍歷，其實就是先打印根節點，然後再遞歸地打印左子樹，最後遞歸地打印右子樹。

在之前創建好的二叉樹代碼之上，我們來使用這三種方法遍歷一下~

依舊是在Node節點類上添加方法：可以看出遍歷方法都是用的遞歸思想

package demo5;
/*
 * 節（結）點類 
 */
public class Node {
//===================================開始 遍歷========================================
    //前序遍歷
    public void frontShow() {
        //先遍歷當前節點的內容
        System.out.println(value);
        //左節點
        if(leftNode!=null) {
            leftNode.frontShow();
        }
        //右節點
        if(rightNode!=null) {
            rightNode.frontShow();
        }
    }

    //中序遍歷
    public void midShow() {
        //左子節點
        if(leftNode!=null) {
            leftNode.midShow();
        }
        //當前節點
        System.out.println(value);
        //右子節點
        if(rightNode!=null) {
            rightNode.midShow();
        }
    }

    //後序遍歷
    public void afterShow() {
        //左子節點
        if(leftNode!=null) {
            leftNode.afterShow();
        }
        //右子節點
        if(rightNode!=null) {
            rightNode.afterShow();
        }
        //當前節點
        System.out.println(value);
    }

}

然後依舊是在二叉樹BinaryTree 類上添加方法，並且添加的方法調用Node類中的遍歷方法

package demo5;
/*
 * 二叉樹Class
 */
public class BinaryTree {

    public void frontShow() {
        if(root!=null) {
            //調用節點類Node中的前序遍歷frontShow（）方法
            root.frontShow();
        }
    }

    public void midShow() {
        if(root!=null) {
            //調用節點類Node中的中序遍歷midShow()方法
            root.midShow();
        }
    }

    public void afterShow() {
        if(root!=null) {
            //調用節點類Node中的後序遍歷afterShow()方法
            root.afterShow();
        }
    }

}

依舊是在TestBinaryTree類中測試

package demo5;

public class TestBinaryTree {

    public static void main(String[] args) {
        //前序遍歷樹
        binTree.frontShow();
        System.out.println("===============");
        //中序遍歷
        binTree.midShow();
        System.out.println("===============");
        //後序遍歷
        binTree.afterShow();
        System.out.println("===============");
        //前序查找
        Node result = binTree.frontSearch(5);
        System.out.println(result);
        
}

如果遞歸理解的不是很透，我可以分享一個學習的小方法：我建議各位可以這樣斷點調試，一步一步調，思維跟上，仔細推敲每一步的運行相信我，你會重新認識到遞歸！（像下面這樣貼個圖再一步一步斷點思維更加清晰）

貼一下我斷點對遞歸的分析，希望對你有一定的幫助~

二叉樹遍歷的遞歸實現思路自然、簡單，易於理解，但執行效率較低。為了提高程序的執行效率，可以顯式的設置棧，寫出相應的非遞歸遍歷算法。非遞歸的遍歷算法可以根據遞歸算法的執行過程寫出。至於代碼可以嘗試去寫一寫，這也是一種提升！具體的非遞歸算法主要流程圖貼在下面了：

二叉樹遍歷算法分析：

二叉樹遍歷算法中的基本操作是訪問根結點，不論按哪種次序遍歷，都要訪問所有的結點，對含n個結點的二叉樹，其時間複雜度均為O（n）。所需輔助空間為遍歷過程中所需的棧空間，最多等於二叉樹的深度k乘以每個結點所需空間數，最壞情況下樹的深度為結點的個數n，因此，其空間複雜度也為O(n)。

5．二叉樹中節點的查找與刪除

剛才講到二叉樹的三種金典遍歷放法，那麼節點的查找同樣是可以效仿的，分別叫做前序查找、中序查找以及後序查找，下面代碼只以前序查找為例，三者查找方法思路類似~

至於刪除節點，有三種情況：

1、如果刪除的是根節點，那麼二叉樹就完全被刪了
2、如果刪除的是雙親節點，那麼該雙親節點以及他下面的所有子節點所構成的子樹將被刪除
3、如果刪除的是恭弘=叶 恭弘子節點，那麼就直接刪除該恭弘=叶 恭弘子節點

那麼，我把完整的三個類給貼出來（包含創建、遍歷、查找、刪除）

依舊是Node節點類

package demo5;
/*
 * 節（結）點類 
 */
public class Node {
    //節點的權
    int value;
    //左兒子
    Node leftNode;
    //右兒子
    Node rightNode;
    //構造函數，初始化的時候就給二叉樹賦上權值
    public Node(int value) {
        this.value=value;
    }
    
    //設置左兒子
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
    //設置右兒子
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }
    
    //前序遍歷
    public void frontShow() {
        //先遍歷當前節點的內容
        System.out.println(value);
        //左節點
        if(leftNode!=null) {
            leftNode.frontShow();
        }
        //右節點
        if(rightNode!=null) {
            rightNode.frontShow();
        }
    }

    //中序遍歷
    public void midShow() {
        //左子節點
        if(leftNode!=null) {
            leftNode.midShow();
        }
        //當前節點
        System.out.println(value);
        //右子節點
        if(rightNode!=null) {
            rightNode.midShow();
        }
    }

    //後序遍歷
    public void afterShow() {
        //左子節點
        if(leftNode!=null) {
            leftNode.afterShow();
        }
        //右子節點
        if(rightNode!=null) {
            rightNode.afterShow();
        }
        //當前節點
        System.out.println(value);
    }

    //前序查找
    public Node frontSearch(int i) {
        Node target=null;
        //對比當前節點的值
        if(this.value==i) {
            return this;
        //當前節點的值不是要查找的節點
        }else {
            //查找左兒子
            if(leftNode!=null) {
                //有可能可以查到，也可以查不到，查不到的話，target還是一個null
                target = leftNode.frontSearch(i);
            }
            //如果不為空，說明在左兒子中已經找到
            if(target!=null) {
                return target;
            }
            //查找右兒子
            if(rightNode!=null) {
                target=rightNode.frontSearch(i);
            }
        }
        return target;
    }
    
    //刪除一個子樹
    public void delete(int i) {
        Node parent = this;
        //判斷左兒子
        if(parent.leftNode!=null&&parent.leftNode.value==i) {
            parent.leftNode=null;
            return;
        }
        //判斷右兒子
        if(parent.rightNode!=null&&parent.rightNode.value==i) {
            parent.rightNode=null;
            return;
        }
        
        //遞歸檢查並刪除左兒子
        parent=leftNode;
        if(parent!=null) {
            parent.delete(i);
        }
        
        //遞歸檢查並刪除右兒子
        parent=rightNode;
        if(parent!=null) {
            parent.delete(i);
        }
    }

}

依舊是BinaryTree 二叉樹類

package demo5;
/*
 * 二叉樹Class
 */
public class BinaryTree {
    //根節點root
    Node root;
    
    //設置根節點
    public void setRoot(Node root) {
        this.root = root;
    }
    
    //獲取根節點
    public Node getRoot() {
        return root;
    }

    public void frontShow() {
        if(root!=null) {
            //調用節點類Node中的前序遍歷frontShow（）方法
            root.frontShow();
        }
    }

    public void midShow() {
        if(root!=null) {
            //調用節點類Node中的中序遍歷midShow()方法
            root.midShow();
        }
    }

    public void afterShow() {
        if(root!=null) {
            //調用節點類Node中的後序遍歷afterShow()方法
            root.afterShow();
        }
    }
    //查找節點i
    public Node frontSearch(int i) {
        return root.frontSearch(i);
    }
    //刪除節點i
    public void delete(int i) {
        if(root.value==i) {
            root=null;
        }else {
            root.delete(i);
        }
    }
    
}

依舊是TestBinaryTree測試類

package demo5;

public class TestBinaryTree {

    public static void main(String[] args) {
        //創建一顆樹
        BinaryTree binTree = new BinaryTree();
        //創建一個根節點
        Node root = new Node(1);
        //把根節點賦給樹
        binTree.setRoot(root);
        //創建一個左節點
        Node rootL = new Node(2);
        //把新創建的節點設置為根節點的子節點
        root.setLeftNode(rootL);
        //創建一個右節點
        Node rootR = new Node(3);
        //把新創建的節點設置為根節點的子節點
        root.setRightNode(rootR);
        //為第二層的左節點創建兩個子節點
        rootL.setLeftNode(new Node(4));
        rootL.setRightNode(new Node(5));
        //為第二層的右節點創建兩個子節點
        rootR.setLeftNode(new Node(6));
        rootR.setRightNode(new Node(7));
        //前序遍歷樹
        binTree.frontShow();
        System.out.println("===============");
        //中序遍歷
        binTree.midShow();
        System.out.println("===============");
        //後序遍歷
        binTree.afterShow();
        System.out.println("===============");
        //前序查找
        Node result = binTree.frontSearch(5);
        System.out.println(result);
        
        System.out.println("===============");
        //刪除一個子樹
        binTree.delete(4);
        binTree.frontShow();
        
    }

}

到這裏，總結一下，我們學了一種非線性表數據結構，樹。關於樹，有幾個比較常用的概念你需要掌握，那就是：根節點、恭弘=叶 恭弘子節點、父節點、子節點、兄弟節點，還有節點的高度、深度、層數，以及樹的高度等。我們平時最常用的樹就是二叉樹。二叉樹的每個節點最多有兩個子節點，分別是左子節點和右子節點。二叉樹中，有兩種比較特殊的樹，分別是滿二叉樹和完全二叉樹。滿二叉樹又是完全二叉樹的一種特殊情況。二叉樹既可以用鏈式存儲，也可以用數組順序存儲。數組順序存儲的方式比較適合完全二叉樹，其他類型的二叉樹用數組存儲會比較浪費存儲空間。除此之外，二叉樹里非常重要的操作就是前、中、後序遍歷操作，遍歷的時間複雜度是O(n)，你需要理解並能用遞歸代碼來實現。

如果本文章對你有幫助，哪怕是一點點，請點個讚唄，謝謝~

歡迎各位關注我的公眾號，一起探討技術，嚮往技術，追求技術…說好了來了就是盆友喔…

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步”網站設計“幫您第一時間規劃公司的門面形象

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※試算大陸海運運費!

一 Pod定義詳解

1.1 完整Pod定義文件

  1 apiVersion: v1			#必選，版本號，例如v1,版本號必須可以用 kubectl api-versions 查詢到
  2 kind: Pod				#必選，Pod
  3 metadata:				#必選，元數據
  4   name: string			#必選，Pod名稱，需符合RFC 1035規範
  5   namespace: string			#必選，Pod所屬的命名空間，默認為"default"
  6   labels:				#自定義標籤
  7     - name: string			#自定義標籤名字
  8   annotations:			#自定義註釋列表
  9     - name: string
 10 spec:				#必選，Pod中容器的詳細定義
 11   containers:			#必選，Pod中容器列表
 12   - name: string			#必選，容器名稱，需符合RFC 1035規範
 13     image: string			#必選，容器的鏡像名稱
 14     imagePullPolicy: [ Always|Never|IfNotPresent ]	#獲取鏡像的策略，Alawys表示每次都嘗試下載鏡像，IfnotPresent表示優先使用本地鏡像,否則下載鏡像，Nerver表示僅使用本地鏡像
 15     command: [string]		#容器的啟動命令列表，如不指定，使用打包時使用的啟動命令
 16     args: [string]			#容器的啟動命令參數列表
 17     workingDir: string		#容器的工作目錄
 18     volumeMounts:			#掛載到容器內部的存儲卷配置
 19     - name: string			#引用pod定義的共享存儲卷的名稱，需用volumes[]部分定義的的卷名
 20       mountPath: string		#存儲卷在容器內mount的絕對路徑，應少於512字符
 21       readOnly: boolean		#是否為只讀模式，默認為讀寫模式
 22     ports:				#需要暴露的端口庫號列表
 23     - name: string			#端口的名稱
 24       containerPort: int		#容器需要監聽的端口號
 25       hostPort: int		        #容器所在主機需要監聽的端口號，默認與Container相同
 26       protocol: string		#端口協議，支持TCP和UDP，默認TCP
 27     env:				#容器運行前需設置的環境變量列表
 28     - name: string			#環境變量名稱
 29       value: string		        #環境變量的值
 30     resources:			#資源限制和請求的設置
 31       limits:			#資源限制的設置
 32         cpu: string		        #CPU的限制，單位為core數，將用於docker run --cpu-shares參數
 33         memory: string		#內存限制，單位可以為Mib/Gib，將用於docker run --memory參數
 34       requests:			#資源請求的設置
 35         cpu: string		        #CPU請求，容器啟動的初始可用數量
 36         memory: string		#內存請求,容器啟動的初始可用數量
 37     livenessProbe:			#對Pod內各容器健康檢查的設置，當探測無響應幾次后將自動重啟該容器，檢查方法有exec、httpGet和tcpSocket，對一個容器只需設置其中一種方法即可
 38       exec:			        #對Pod容器內檢查方式設置為exec方式
 39         command: [string]		#exec方式需要制定的命令或腳本
 40       httpGet:			#對Pod內個容器健康檢查方法設置為HttpGet，需要制定Path、port
 41         path: string
 42         port: number
 43         host: string
 44         scheme: string
 45         HttpHeaders:
 46         - name: string
 47           value: string
 48       tcpSocket:			#對Pod內個容器健康檢查方式設置為tcpSocket方式
 49          port: number
 50        initialDelaySeconds: 0	#容器啟動完成后首次探測的時間，單位為秒
 51        timeoutSeconds: 0		#對容器健康檢查探測等待響應的超時時間，單位秒，默認1秒
 52        periodSeconds: 0		#對容器監控檢查的定期探測時間設置，單位秒，默認10秒一次
 53        successThreshold: 0
 54        failureThreshold: 0
 55        securityContext:
 56          privileged: false
 57     restartPolicy: [Always | Never | OnFailure]	#Pod的重啟策略，Always表示一旦不管以何種方式終止運行，kubelet都將重啟，OnFailure表示只有Pod以非0退出碼退出才重啟，Nerver表示不再重啟該Pod
 58     nodeSelector: obeject		#設置NodeSelector表示將該Pod調度到包含這個label的node上，以key：value的格式指定
 59     imagePullSecrets:		#Pull鏡像時使用的secret名稱，以key：secretkey格式指定
 60     - name: string
 61     hostNetwork: false		#是否使用主機網絡模式，默認為false，如果設置為true，表示使用宿主機網絡
 62     volumes:			#在該pod上定義共享存儲卷列表
 63     - name: string			#共享存儲卷名稱 （volumes類型有很多種）
 64       emptyDir: {}			#類型為emtyDir的存儲卷，與Pod同生命周期的一個臨時目錄。為空值
 65       hostPath: string		#類型為hostPath的存儲卷，表示掛載Pod所在宿主機的目錄
 66         path: string		#Pod所在宿主機的目錄，將被用於同期中mount的目錄
 67       secret:			#類型為secret的存儲卷，掛載集群與定義的secre對象到容器內部
 68         scretname: string
 69         items:
 70         - key: string
 71           path: string
 72       configMap:			#類型為configMap的存儲卷，掛載預定義的configMap對象到容器內部
 73         name: string
 74         items:
 75         - key: string
 76           path: string

二 Pod的基本用法

2.1 創建Pod

Pod可以由1個或多個容器組合而成，通常對於緊耦合的兩個應用，應該組合成一個整體對外提供服務，則應該將這兩個打包為一個pod。

屬於一個Pod的多個容器應用之間相互訪問只需要通過localhost即可通信，這一組容器被綁定在一個環境中。

  1 [root@k8smaster01 study]# vi frontend-localredis-pod.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: redis-php
  6   label:
  7     name: redis-php
  8 spec:
  9   containers:
 10   - name: frontend
 11     image: kubeguide/guestbook-php-frontend:localredis
 12     ports:
 13     - containersPort: 80
 14   - name: redis-php
 15     image: kubeguide/redis-master
 16     ports:
 17     - containersPort: 6379
 18 
 19 [root@k8smaster01 study]# kubectl create -f frontend-localredis-pod.yaml
 20 

2.2 查看Pod

  1 [root@k8smaster01 study]# kubectl get pods	                #READY為2/2，表示此Pod中運行了yaml定義的兩個容器
  2 NAME        READY   STATUS    RESTARTS   AGE
  3 redis-php   2/2     Running   0          7m45s
  4 [root@k8smaster01 study]# kubectl describe pod redis-php	#查看詳細信息
  5 

三 靜態Pod

3.1 靜態Pod概述

靜態pod是由kubelet進行管理的僅存在於特定Node的Pod上，他們不能通過API Server進行管理，無法與ReplicationController、Deployment或者DaemonSet進行關聯，並且kubelet無法對他們進行健康檢查。靜態Pod總是由kubelet進行創建，並且總是在kubelet所在的Node上運行。

創建靜態Pod有兩種方式：配置文件或者HTTP方式。

3.2 配置文件方式創建

  1 [root@k8snode01 ~]# mkdir -p /etc/kubelet.d
  2 [root@k8snode01 ~]# vi /etc/kubelet.d/static-web.yaml
  3 apiVersion: v1
  4 kind: Pod
  5 metadata:
  6   name: static-web
  7   label:
  8     name: static-web
  9 spec:
 10   containers:
 11   - name: static-web
 12     image: nginx
 13     ports:
 14     - name: web
 15       containersPort: 80
 16 
 17 [root@k8snode01 ~]# vi /etc/systemd/system/kubelet.service
 18 ……
 19   --config=/etc/kubelet.d/ \·				#加入此參數
 20 ……
 21 [root@k8snode01 ~]# systemctl daemon-reload
 22 [root@k8snode01 ~]# systemctl restart kubelet.service	#重啟kubelet
 23 [root@k8snode01 ~]# docker ps				#查看創建的pod

提示：由於靜態pod不能通過API Server進行管理，因此在Master節點執行刪除操作後會變為Pending狀態，且無法刪除。刪除該pod只能在其運行的node上，將定義POD的yaml刪除。

3.3 HTTP方式

通過設置kubelet的啟動參數–mainfest-url，會定期從該URL下載Pod的定義文件，並以.yaml或.json文件的格式進行解析，從而創建Pod。

四 Pod容器共享Volume

4.1 共享Volume

在同一個Pod中的多個容器能夠共享Pod級別的存儲就Volume。Volume可以被定義為各種類型，多個容器各自進行掛載操作，將一個Volume掛載為容器內部需要的目錄。


示例1：

Pod級別設置Volume “app-logs”，同時Pod包含兩個容器，Tomcat向該Volume寫日誌，busybox讀取日誌文件。

  1 [root@k8smaster01 study]# vi pod-volume-applogs.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: volume-pod
  6 spec:
  7   containers:
  8   - name: tomcat
  9     image: tomcat
 10     ports:
 11     - containerPort: 8080
 12     volumeMounts:
 13     - name: app-logs
 14       mountPath: /usr/local/tomcat/logs
 15   - name: logreader
 16     image: busybox
 17     command: ["sh","-c","tail -f /logs/catalina*.log"]
 18     volumeMounts:
 19     - name: app-logs
 20       mountPath: /logs
 21   volumes:
 22   - name: app-logs
 23     emptyDir: {}

解釋：

Volume名：app-logs；

emptyDir：為Pod分配到Node的時候創建。無需指定宿主機的目錄文件，為Kubernetes自動分配的目錄。

  1 [root@k8smaster01 study]# kubectl create -f pod-volume-applogs.yaml	#創建
  2 [root@k8smaster01 study]# kubectl get pods				#查看
  3 [root@k8smaster01 study]# kubectl logs volume-pod -c busybox	#讀取log

  1 [root@k8smaster01 study]# kubectl exec -it volume-pod -c tomcat -- ls /usr/local/tomcat/logs
  2 catalina.2019-06-29.log      localhost_access_log.2019-06-29.txt
  3 host-manager.2019-06-29.log  manager.2019-06-29.log
  4 localhost.2019-06-29.log
  5 [root@k8smaster01 study]# kubectl exec -it volume-pod -c tomcat -- tail /usr/local/tomcat/logs/catalina.2019-06-29.log

提示：通過tomcat容器可查看日誌，對比busybox通過共享Volume查看的日誌是否一致。

五 Pod配置管理

5.1 Pod配置概述

應用部署的一個最佳實踐是將應用所需的配置信息與程序進行分離，使程序更加靈活。將相應的應用打包為鏡像，可以通過環境變量或者外掛volume的方式在創建容器的時候進行配置注入，從而實現更好的復用。

Kubernetes提供一種統一的應用配置管理方案：ConfigMap。

5.2 ConfigMap概述

ConfigMap供容器使用的主要場景：

• 生成容器內部的環境變量；
• 設置容器的啟動命令的參數（需設置為環境變量）；
• 以volume的形式掛載為容器內部的文件或者目錄。

ConfigMap以一個或多個key:value的形式定義。value可以是string也可以是一個文件內容，可以通過yaml配置文件或者通過kubectl create configmap 的方式創建configMap。

5.3 創建ConfigMap資源對象——yaml方式

  1 [root@k8smaster01 study]# vi cm-appvars.yaml
  2 apiVersion: v1
  3 kind: ConfigMap
  4 metadata:
  5   name: cm-appvars
  6 data:
  7   apploglevel: info
  8   appdatadir: /var/data
  9 
 10 [root@k8smaster01 study]# kubectl create -f cm-appvars.yaml
 11 configmap/cm-appvars created
 12 [root@k8smaster01 study]# kubectl get configmaps
 13 NAME         DATA   AGE
 14 cm-appvars   2      8s
 15 [root@k8smaster01 study]# kubectl describe configmaps cm-appvars

  1 [root@k8smaster01 study]# kubectl get configmaps cm-appvars -o yaml

5.4 創建ConfigMap資源對象——命令行方式

語法1

  1 # kubectl create configmap NAME --from-file=[key=]source --from-file=[key=]source

解釋：通過–from-file參數從文件中創建，可以指定key名稱，也可以制定多個key。

語法2

  1 # kubectl create configmap NAME --from-file=config-files-dir

解釋：通過–from-file參數從目錄中創建，該目錄下的每個配置文件名都被設置為key，文件的內容被設置為value。

語法3

  1 # kubectl create configmap NAME --from-literal=key1=value1 --from-literal=key2=value2

解釋：通過–from-literal參數從文本中創建，直接將指定的key#=value#創建為ConfigMap的內容。

5.5 Pod使用ConfigMap

容器應用使用ConfigMap有兩種方式：

• 通過環境變量獲取ConfigMap中的內容；
• 通過Volume掛載的方式將ConfigMap中的內容掛載為容器內容的文件或目錄。

  1 [root@k8smaster01 study]# vi cm-test-pod.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: cm-test-pod
  6 spec:
  7   containers:
  8   - name: cm-test
  9     image: busybox
 10     command: ["/bin/sh","-c","env|grep APP"]	#容器里執行查看環境變量的命令
 11     env:
 12     - name: APPLOGLEVEL				#定義容器環境變量名稱
 13       valueFrom:
 14         configMapKeyRef:			#環境變量的值來自ConfigMap
 15           name: cm-appvars			#指定來自cm-appvars的ConfigMap
 16           key: apploglevel			#key為apploglevel
 17     - name: APPDATADIR
 18       valueFrom:
 19         configMapKeyRef:
 20           name: cm-appvars
 21           key: appdatadir
 22 
 23 [root@k8smaster01 study]# kubectl create -f cm-test-pod.yaml
 24 [root@k8smaster01 study]# kubectl get pods
 25 NAME          READY   STATUS      RESTARTS   AGE
 26 cm-test-pod   0/1     Completed   2          24s

【掛載形式-待補充】

5.6 ConfigMap限制

• Configmap必須在pod創建之間創建；
• ConfigMap受到namespace的限制，只有同一個命名空間下才能引用；
• ConfigMap暫時無法配置配額；
• 靜態的pod無法使用ConfigMap；
• 在使用volumeMount掛載的時候，configMap基於items創建的文件會整體的將掛載數據卷的容器的目錄下的文件全部覆蓋。

六 Pod獲取自身信息

6.1 Downward API

pod擁有唯一的名字、IP地址，並且處於某個Namespace中。pod的容器內獲取pod的信息科通過Downward API實現。具體有以下兩種方式：

• 環境變量：用於單個變量，可以將pod信息和container信息注入容器內部；
• volume掛載：將數組類信息生成為文件，掛載至容器內部。

舉例1：通過Downward API將Pod的IP、名稱和所在的Namespace注入容器的環境變量。

  1 [root@k8smaster01 study]# vi dapi-test-pod.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: dapi-test-pod
  6 spec:
  7   containers:
  8     - name: test-container
  9       image: busybox
 10       command: [ "/bin/sh", "-c", "env" ]
 11       env:
 12         - name: MY_POD_NAME
 13           valueFrom:
 14             fieldRef:
 15               fieldPath: metadata.name
 16         - name: MY_POD_NAMESPACE
 17           valueFrom:
 18             fieldRef:
 19               fieldPath: metadata.namespace
 20         - name: MY_POD_IP
 21           valueFrom:
 22             fieldRef:
 23               fieldPath: status.podIP
 24   restartPolicy: Never

提示：Downward API提供如下變量：

metadata.name：Pod的名稱，當Pod通過RC生成時，其名稱是RC隨機產生的唯一名稱；

status.podIP：Pod的IP地址，POd的IP屬於狀態數據，而非元數據；

metadata.namespace：Pod所在的namespace。

  1 [root@k8smaster01 study]# kubectl create -f dapi-test-pod.yaml
  2 [root@k8smaster01 study]# kubectl logs dapi-test-pod | grep MY_POD
  3 MY_POD_NAMESPACE=default
  4 MY_POD_IP=172.30.240.4
  5 MY_POD_NAME=dapi-test-pod
  6 

舉例2：通過Downward API將Container的自願請求和限制信息注入容器的環境變量。

  1 [root@k8smaster01 study]# vi dapi-test-pod-container-vars.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: dapi-test-pod-container-vars
  6 spec:
  7   containers:
  8     - name: test-container
  9       image: busybox
 10       imagePullPolicy: Never
 11       command: [ "/bin/sh", "-c" ]
 12       args:
 13       - while true; do
 14           echo -en '\n';
 15           printenv MY_CPU_REQUEST MY_CPU_LIMIT;
 16           printenv MY_MEM_REQUEST MY_MEM_LIMIT;
 17           sleep 3600;
 18         done;
 19       resources:
 20         requests:
 21           memory: "32Mi"
 22           cpu: "125m"
 23         limits:
 24           memory: "64Mi"
 25           cpu: "250m"
 26       env:
 27         - name: MY_CPU_REQUEST
 28           valueFrom:
 29             resourceFieldRef:
 30               containerName: test-container
 31               resource: requests.cpu
 32         - name: MY_CPU_LIMIT
 33           valueFrom:
 34             resourceFieldRef:
 35               containerName: test-container
 36               resource: limits.cpu
 37         - name: MY_MEM_REQUEST
 38           valueFrom:
 39             resourceFieldRef:
 40               containerName: test-container
 41               resource: requests.memory
 42         - name: MY_MEM_LIMIT
 43           valueFrom:
 44             resourceFieldRef:
 45               containerName: test-container
 46               resource: limits.memory
 47   restartPolicy: Never

提示：Downward API提供如下變量：

requests.cpu：容器的CPU請求值；

limits.cpu：容器的CPU限制值；

requests.memory：容器的內存請求值；

limits.memory：容器的內存限制值。

  1 [root@k8smaster01 study]# kubectl create -f dapi-test-pod-container-vars.yaml
  2 [root@k8smaster01 study]# kubectl logs dapi-test-pod-container-vars
  3 1
  4 1
  5 33554432
  6 67108864

舉例3：通過Downward API將Pod的Label、Annotation列表通過Volume掛載為容器內的一個文件。

  1 [root@k8smaster01 study]# vi dapi-test-pod-volume.yaml
  2 apiVersion: v1
  3 kind: Pod
  4 metadata:
  5   name: dapi-test-pod-volume
  6   labels:
  7     zone: us-est-coast
  8     cluster: test-cluster1
  9     rack: rack-22
 10   annotations:
 11     build: two
 12     builder: john-doe
 13 spec:
 14   containers:
 15     - name: test-container
 16       image: busybox
 17       imagePullPolicy: Never
 18       command: [ "/bin/sh", "-c" ]
 19       args:
 20       - while true; do
 21           if [[ -e /etc/labels ]]; then
 22             echo -en '\n\n'; cat /etc/labels; fi;
 23           if [[ -e /etc/annotations ]]; then
 24             echo -en '\n\n'; cat /etc/annotations; fi;
 25           sleep 3600;
 26         done;
 27       volumeMounts:
 28         - name: podinfo
 29           mountPath: /etc
 30           readOnly: false
 31   volumes:
 32     - name: podinfo
 33       downwardAPI:
 34         items:
 35           - path: "labels"
 36             fieldRef:
 37               fieldPath: metadata.labels
 38           - path: "annotations"
 39             fieldRef:
 40               fieldPath: metadata.annotations

注意：Volume中的ddownwardAPI的items語法，將會以path的名稱生成文件。如上所示，會在容器內生產/etc/labels和/etc/annotations兩個文件，分別包含metadata.labels和metadata.annotations的全部Label。

  1 [root@k8smaster01 study]# kubectl create -f dapi-test-pod-volume.yaml
  2 [root@k8smaster01 study]# kubectl logs dapi-test-pod-volume
  3 

提示：DownwardAPI意義：

在某些集群中，集群中的每個節點需要將自身的標識（ID）及進程綁定的IP地址等信息事先寫入配置文件中，進程啟動時讀取此類信息，然後發布到某個類似註冊服務中心。此時可通過DowanwardAPI，將一個預啟動腳本或Init Container，通過環境變量或文件方式獲取Pod自身的信息，然後寫入主程序配置文件中，最後啟動主程序。本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步”網站設計“幫您第一時間規劃公司的門面形象

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

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※試算大陸海運運費!