大綱

————————-學前必讀———————————-

學習不能快速成功,但一定可以快速入門
整體課程思路:
1.實踐為主,理論化偏少
2.課程筆記有完整的案例和代碼,(為了學習效率)再開始之前我會簡單粗暴的介紹知識點案例思路,
有基礎的同學聽了之後可以直接結合筆記寫代碼,
如果沒聽懂再向下看視頻,我會手把手編寫代碼和演示測試結果;
3.重要提示,學編程和學游泳一樣,多實踐學習效率才高,理解才透徹;
4.編碼功底差的建議每個案例代碼寫三遍,至於為什麼…<<賣油翁>>…老祖宗的智慧

————————————————————————-

 1.線程

1.1.什麼是線程

線程（英語：thread）是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以併發多個線程，每條線程并行執行不同的任務。在Unix System V及SunOS中也被稱為輕量進程（lightweight processes），但輕量進程更多指內核線程（kernel thread），而把用戶線程（user thread）稱為線程。(來自百度百科)

一個進程可以有很多線程，每條線程并行執行不同的任務。

1.2.多線程hello word

需求:模擬在計算上一邊聽歌一邊打遊戲

三種實現方案如下:

TestDemo

 1 package com.wfd360.thread;
 2 
 3 import com.wfd360.thread.demo01.GameRunnable;
 4 import com.wfd360.thread.demo01.MusicRunnable;
 5 import com.wfd360.thread.demo02.GameThread;
 6 import com.wfd360.thread.demo02.MusicThread;
 7 import org.junit.Test;
 8 
 9 /**
10  * @author 姿勢帝-博客園
11  * @address https://www.cnblogs.com/newAndHui/
12  * @WeChat 851298348
13  * @create 05/03 5:27
14  * @description 需求分析：
15  * 1.模擬一邊打遊戲一邊聽音樂，在控制台打印輸出模擬
16  * 2.把兩個業務封裝成獨立的線程，實現接口Runnable或繼承Thread，通過看源碼你會發現Thread類實現了接口Runnable，使用本質上這兩種方法時一樣的。
17  * 3.Thread類提供兩個方法，線程主題方法run，啟動線程方法start
18  */
19 public class TestDemo {
20     /**
21      * 方式1：實現接口Runnable
22      */
23     @Test
24     public void testRunnable() throws InterruptedException {
25         System.out.println("-------test start-------");
26         // 實例對象
27         MusicRunnable music = new MusicRunnable();
28         GameRunnable game = new GameRunnable();
29         // 創建線程
30         Thread musicThread = new Thread(music);
31         Thread gameThread = new Thread(game);
32         // 啟動線程
33         musicThread.start();
34         gameThread.start();
35         System.out.println("--------等待其他線程執行--------------");
36         Thread.sleep(5 * 1000);
37         System.out.println("-------test end-------");
38     }
39 
40     /**
41      * 方式2：繼承Thread
42      */
43     @Test
44     public void testThread() throws InterruptedException {
45         System.out.println("-------test start-------");
46         // 創建線程
47         MusicThread musicThread = new MusicThread();
48         GameThread gameThread = new GameThread();
49         // 啟動線程
50         musicThread.start();
51         gameThread.start();
52         System.out.println("--------等待其他線程執行--------------");
53         Thread.sleep(5 * 1000);
54         System.out.println("-------test end-------");
55     }
56 
57     /**
58      * 方式3：簡寫,這種寫法一般我們在做模擬測試的使用,在正式代碼中建議不使用,可讀性較差
59      */
60     @Test
61     public void testThreadSimple() throws InterruptedException {
62         System.out.println("-------test start-------");
63         // 創建線程
64         Thread musicThread = new Thread(() -> {
65             for (int i = 0; i < 100; i++) {
66                 System.out.println("=======聽音樂中============" + i);
67             }
68         });
69         Thread gameThread = new Thread(() -> {
70             for (int i = 0; i < 100; i++) {
71                 System.out.println("=======打遊戲中============" + i);
72             }
73         });
74         // 啟動線程
75         musicThread.start();
76         gameThread.start();
77         System.out.println("--------等待其他線程執行--------------");
78         Thread.sleep(5 * 1000);
79         System.out.println("-------test end-------");
80     }
81 }

 實現接口Runnable

 1 package com.wfd360.thread.demo01;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/03 5:31
 8  * @description
 9  */
10 public class GameRunnable implements Runnable {
11     @Override
12     public void run() {
13         for (int i = 0; i < 100; i++) {
14             System.out.println("=======打遊戲中============" + i);
15         }
16     }
17 }

GameRunnable

 1 package com.wfd360.thread.demo01;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/03 5:29
 8  * @description
 9  */
10 public class MusicRunnable implements Runnable {
11     @Override
12     public void run() {
13         for (int i = 0; i < 100; i++) {
14             System.out.println("=======聽音樂中============"+i);
15         }
16     }
17 }

MusicRunnable

 繼承Thread

 1 package com.wfd360.thread.demo02;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/03 6:00
 8  * @description
 9  */
10 public class GameThread extends Thread {
11     @Override
12     public void run() {
13         for (int i = 0; i < 100; i++) {
14             System.out.println("-------遊戲中----------"+i);
15         }
16     }
17 }

GameThread GameThread

 1 package com.wfd360.thread.demo02;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/03 6:00
 8  * @description
 9  */
10 public class MusicThread extends Thread {
11     @Override
12     public void run() {
13         for (int i = 0; i < 100; i++) {
14             System.out.println("-------音樂中----------" + i);
15         }
16     }
17 }

 總結

啟動線程兩種方式:

    1.通過繼承Thread類

    2.實現Runnable接口

 使用哪種方式更好?

區別: 

一個類如果繼承了其他類，就無法在繼承Thread類，在Java中，一個類只能繼承一個類，而一個類如果實現了一個接口，還可以實現其他接口，接口是可以多實現的，所以說

Runable的擴展性更強,但是繼承的方式更簡單,個人建議一般情況下使用Thread;

實現接口Runnable或繼承Thread，通過看源碼你會發現Thread類實現了接口Runnable，使用本質上這兩種方法是一樣的

啟動線程流程:

    創建啟動線程的方式一：繼承Thread類

       1.將業務方法封裝成線程對象,自定義類t extends Thread類； 

       2.覆寫run方法: 覆寫第一步中的run方法;

       3.創建自定義對象t

       4.啟動線程 t.start();

   創建啟動線程方式二：實現Runnable接口

      1.將業務方法封裝成線程對象,自定義類t implements Runnable接口；

      2.實現第一步中的run方法

      3.創建自定義對象t

      4.啟動線程 new Thread(t).start();

1.3.對主線程與創建線程執行順序的理解

問題:
直接寫一個簡單的HelloWorld 程序，有沒有線程？
==>有一個主線程，在垃圾回收的時候，有gc 線程。

 1 package com.wfd360.thread;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * @author 姿勢帝-博客園
 7  * @address https://www.cnblogs.com/newAndHui/
 8  * @WeChat 851298348
 9  * @create 05/04 11:09
10  * @description <p>
11  * 問題:
12  * 直接寫一個簡單的HelloWorld 程序，有沒有線程？
13  * ==>有一個主線程，在垃圾回收的時候，有gc 線程。
14  * 結論：一旦線程啟動起來之後就是獨立的，和創建環境沒有關係；
15  * 啟動線程不能直接調用run方法，必須調用start方法；
16  * </p>
17  */
18 public class TestDemo02 {
19     /**
20      * 如果把創建線程放在循環語句的 下 面，會交替出現嗎
21      * ==>否,因為主線程執行完成后才會啟動hello線程
22      *
23      * @throws Exception
24      */
25     @Test
26     public void test1() throws Exception {
27         System.out.println("---test start-------");
28         // 執行主線程
29         for (int i = 0; i < 100; i++) {
30             System.out.println("-----test1--------" + i);
31         }
32         // 啟動hello線程
33         new HelloThread().start();
34         System.out.println("=======等待執行完成===========");
35         Thread.sleep(5 * 1000);
36         System.out.println("---test end-------");
37     }
38 
39     /**
40      * 如果把創建線程放在循環語句的 上 面，會交替出現嗎
41      * ==>可能會，可能不會，可能出現for循環完之後，線程還沒有啟動完;
42      *
43      * @throws Exception
44      */
45     @Test
46     public void test2() throws Exception {
47         System.out.println("---test start-------");
48         // 啟動hello線程
49         new HelloThread().start();
50         // 執行主線程
51         for (int i = 0; i < 100; i++) {
52             System.out.println("-----test1--------" + i);
53         }
54         System.out.println("=======等待執行完成===========");
55         Thread.sleep(5 * 1000);
56         System.out.println("---test end-------");
57     }
58 
59     /**
60      * 採用內部類的方式定義一個hello線程對象
61      */
62     class HelloThread extends Thread {
63         @Override
64         public void run() {
65             for (int i = 0; i < 100; i++) {
66                 System.out.println("-----HelloThread--------" + i);
67             }
68         }
69     }
70 }

TestDemo02

結論：一旦線程啟動起來之後就是獨立的，和創建環境沒有關係；
啟動線程不能直接調用run方法，必須調用start方法；

 1.4.對sleep方法的理解

package com.wfd360.thread;

/**
 * @author 姿勢帝-博客園
 * @address https://www.cnblogs.com/newAndHui/
 * @WeChat 851298348
 * @create 05/04 11:34
 * @description <p>
 * Thread類的方法:
 * static void sleep(long millis) 在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）；
 * </p>
 */
public class TestSleep {
    /**
     * 做一個簡易倒計時,10秒鐘,控制台每一秒輸出一個数字,如10,9,8,7.....0
     */
    public static void main(String[] args) throws Exception {
        System.out.println("---test start-------");
        for (int i = 10; i >= 0; i--) {
            Thread.sleep(1 * 1000);
            System.out.println(i);
        }
        System.out.println("---test end-------");
    }
}

1.5.線程名稱的設置與獲取

繼承方式

簡單需求:使用多線程模擬多窗口售票

 1 package com.wfd360.thread.demo03Ticket;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/04 11:55
 8  * @description <p>
 9  * 模擬多線程售票
10  * </p>
11  */
12 public class TicketThread extends Thread {
13     // 假定票總是100張
14     private static Integer num = 100;
15 
16     @Override
17     public void run() {
18         // 只要有票就一直售票
19         while (num > 0) {
20             System.out.println("正在出售第" + num + "張票");
21             --num;
22         }
23         System.out.println("===售票結束===");
24     }
25 }

TicketThread

test

/**
     * 測試模擬三個窗口售票
     * @throws InterruptedException
     */
    @Test
    public void testTicketThread() throws InterruptedException {
        System.out.println("---test start-------");
        // 模擬多3個窗口售票
        TicketThread ticketThread1 = new TicketThread();
        TicketThread ticketThread2 = new TicketThread();
        TicketThread ticketThread3 = new TicketThread();
        // 啟動線程售票
        ticketThread1.start();
        ticketThread2.start();
        ticketThread3.start();
        System.out.println("======等待售票============");
        Thread.sleep(5 * 1000);
        System.out.println("---test end-------");
    }

結果:

1.在售票過程中不能區分售出的票是那個窗口售出的,解決通過線程名稱判斷

2.有重複售出的票(後面的線程同步解決)

解決第一個問題,設置獲取線程名稱,通過Thread對象裏面自帶的getName,setName方法

 具體代碼

設置線程名稱

 獲取線程名稱

 上面講了繼承的方式獲取線程名稱,那麼實現接口Runnable的方式怎麼獲取設置勒

繼承Thread的方式，可以通過getName的方式獲取當前線程的名稱?
那使用Runnable的方式，能通過getName獲取嘛？

getName方法是Thread類的，但是TicketThread現在並沒有繼承Thread類，而是實現了Runnable接口.

問題：如果實現Runnable接口，怎麼獲取線程名稱？

　思考：TicketThread類裏面的代碼要執行，它肯定存在於某個線程中， 就比如寫個helloword打印語句，是不是也處於一個主線程中，那這裏怎麼獲取線程名稱?
通過動態獲取，當程序正在執行的時候，獲取當前正在執行的線程名稱。怎麼獲取?
在Thread類裏面有個靜態的方法currentThread() 方法，返回當前正在執行的線程引用；

Thread.currentThread().getName

那怎麼設置線程名稱?

Thread類裏面有個name字段，相當於Thread類把它包裝了一下:

通過源碼可以發現,構造方法裏面還有可以傳一個名字：

具體實現代碼如下

 

 總結:

繼承方式設置\獲取線程名稱通過 Thread對象裏面的 setName,getName方法;

實現接口方式設置名稱通過 new Thread(‘線程實例對象’, “線程名稱”),獲取線程名稱通過:Thread.currentThread().getName

1.6.Thread的join方法

void join() 方法 ：等待該線程終止
void join(long millis) 方法 ：等待該線程終止的時間最長為millis毫秒

需求: 當主線程運行到20的時候（i =20）的時候，讓JoinThread線程加進來直到執行完成,在執行主線程.

 1 package com.wfd360.thread;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * @author 姿勢帝-博客園
 7  * @address https://www.cnblogs.com/newAndHui/
 8  * @WeChat 851298348
 9  * @create 05/04 6:31
10  * @description
11  */
12 public class Test05Join {
13     /**
14      * 需求:
15      * 當主線程for循環到i=20時,等JoinThread線程執行完成后,在執行for循環的線程
16      * @throws InterruptedException
17      */
18     @Test
19     public void testJoinThread() throws InterruptedException {
20         System.out.println("---test start-------");
21         // 開啟線程
22         JoinThread thread = new JoinThread();
23         thread.start();
24         // 循環打印線程
25         for (int i = 0; i < 100; i++) {
26             System.out.println("======testJoinThread=========="+i);
27             Thread.sleep(1);
28             if (i==20){
29                 // 等線程JoinThread執行完成
30                 thread.join();
31             }
32         }
33         System.out.println("=============等待線程執行完成===================");
34         Thread.sleep(10*1000);
35         System.out.println("---test end-------");
36     }
37     
38     class JoinThread extends Thread {
39         @Override
40         public void run() {
41             for (int i = 0; i < 100; i++) {
42                 System.out.println("=====JoinThread=======" + i);
43                 // 模擬處理很多業務耗時1毫秒
44                 try {
45                     Thread.sleep(1);
46                 } catch (InterruptedException e) {
47                     e.printStackTrace();
48                 }
49             }
50         }
51     }
52 }

Test05Join

1.7.線程優先級

直接上代碼

 1 package com.wfd360.thread;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/05 8:17
 8  * @description <p>
 9  * 1.==>線程優先級的理解:
10  * 線程的優先級和生活中類似,高優先級線程的執行優先於低優先級線程;
11  * 並不是絕對的,可能優先級高的線程優先 比 優先級低的線程先執行,只能說，高優先級的線程優先執行的幾率更多;
12  * （比如兩個線程，一個優先級高，一個優先級低，如果一共運行一個小時，優先級高的線程執行遠遠大於優先級低的但是並不是說優先級高的先執行完，
13  * 在執行優先級低的）
14  * 2.==>重新設置線程優先級
15  * int getPriority() 返回線程的優先級。
16  * void setPriority(int newPriority) 更改線程的優先級。Java線程的優先級從1到10級別，值越大優先級越高.
17  * 3.==>線程的默認優先級受創建線程的環境影響,默認值5,自定義線程的默認優先級和創建它的環境的線程優先級一致
18  * </p>
19  */
20 public class Test06Priority {
21     /**
22      * 測試獲取線程優先級,設置線程優先級,驗證線程優先級受創建環境影響
23      * @param args
24      */
25     public static void main(String[] args) {
26         Thread threadMain = Thread.currentThread();
27         // 獲取默認優先級数字
28         System.out.println("main線程默認優先級:" +threadMain.getPriority());// 5
29         // 重新設置默認優先級数字
30         threadMain.setPriority(8);
31         // 再次重新獲取優先級数字
32         System.out.println("main線程修改后的優先級:" +threadMain.getPriority());// 8
33         // 創建一個線程查看優先級
34         Thread thread = new Thread();
35         System.out.println("thread線程的優先級:" +thread.getPriority());// 8 受創建環境影響
36     }
37 }

1.8.後台線程,即守護線程

直接看代碼

 1 package com.wfd360.thread;
 2 
 3 import com.wfd360.thread.demo04Daemon.DaemonThreaad;
 4 
 5 /**
 6  * @author 姿勢帝-博客園
 7  * @address https://www.cnblogs.com/newAndHui/
 8  * @WeChat 851298348
 9  * @create 05/05 9:12
10  * @description <p>
11  * 後台線程,即守護線程
12  * 後台線程：指為其他線程提供服務的線程，也稱為守護線程。JVM的垃圾回收線程就是一個後台線程。
13  * 需求:嘗試把線程標記為後台線程或者標記為（前台）線程；
14  * Thread類提供的方法：
15  * 方法1： void setDaemon(boolean on) 將該線程標記為守護線程或用戶線程,true為後台線程,false為用戶線程(前台線下)
16  * 怎樣測試該線程是否是守護線程？
17  * 方法2：isDaemon()  測試該線程是否為守護線程. true為後台線程,false為用戶線程(前台線下)
18  * <p>
19  * 結論1：活動的線程(已經在執行的線程t.start())不能設置後台線程，即主線程不能設置為後台線程。
20  * 結論2: 自定義線程的默認狀態和環境有關，後台線程中創建的線程默認是後台線程，前台線程中創建的線程為前台線程.
21  * 結論3: 前台線程執行完后,會直接關閉後台線程,即自定義的後台線程不一定能執行完成
22  * </p>
23  */
24 public class Test07Daemon {
25     /**
26      * 測試1
27      * 查看主線程的狀態，嘗試更改
28      * 結論:活動的線程不能設置為後台線程
29      *
30      * @param args
31      */
32     public static void main1(String[] args) {
33         Thread threadMain = Thread.currentThread();
34         System.out.println("是後台線程么:" + threadMain.isDaemon());// false
35         threadMain.setDaemon(true); // 報錯,活動的線程不能設置為後台線程
36         System.out.println("修改后是後台線程么:" + threadMain.isDaemon());
37     }
38 
39     /**
40      * 測試2
41      * 查看主線程中 創建線程的狀態，嘗試更改；
42      *
43      * @param args
44      */
45     public static void main2(String[] args) {
46         Thread thread = new Thread();
47         // false
48         System.out.println("是後台線程么:" + thread.isDaemon());
49         // 修改為後台線程
50         thread.setDaemon(true);
51         System.out.println("修改后是後台線程么:" + thread.isDaemon());
52     }
53 
54     /**
55      * 測試3
56      * 查看主線程中 創建線程的狀態，嘗試更改,讓線程處於活動狀態在修改->報錯；
57      *
58      * @param args
59      */
60     public static void main3(String[] args) {
61         DaemonThread thread = new DaemonThread();
62         // 讓線程處於活躍狀態
63         thread.start();
64         // false
65         System.out.println("是後台線程么:" + thread.isDaemon());
66         // 修改為後台線程,報錯,當前已經是活躍狀態(thread.start())不能修改為後台線程
67         thread.setDaemon(true);
68         System.out.println("修改后是後台線程么:" + thread.isDaemon());
69     }
70 
71     /**
72      * 測試4
73      * 前台線程執行完后,會直接關閉後台線程,即如果後台線程不一定能執行完成
74      * 可以通過修改等待執行時間來觀察DaemonThread線程的數組輸出變化
75      *
76      * @param args
77      */
78     public static void main(String[] args) throws InterruptedException {
79         DaemonThread thread = new DaemonThread();
80         // 修改為後台線程
81         thread.setDaemon(true);
82         // 讓線程處於活躍狀態
83         thread.start();
84         System.out.println("========等待後台線程執行============");
85         Thread.sleep(5 * 1000);
86     }
87 }

 1 package com.wfd360.thread.demo04Daemon;
 2 
 3 /**
 4  * @author 姿勢帝-博客園
 5  * @address https://www.cnblogs.com/newAndHui/
 6  * @WeChat 851298348
 7  * @create 05/05 9:27
 8  * @description
 9  */
10 public class DaemonThread extends Thread {
11     @Override
12     public void run() {
13         for (int i = 0; i < 10; i++) {
14             System.out.println("===="+i);
15             try {
16                 Thread.sleep(1000);
17             } catch (InterruptedException e) {
18                 e.printStackTrace();
19             }
20         }
21     }
22 }

DaemonThread

線程基礎相關的方法定義就先到這裏,下一篇我們將進入線程同步.

https://www.cnblogs.com/newAndHui/p/12831089.html

系統化的在線學習：點擊進入學習

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

【其他文章推薦】

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

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

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

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

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

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

內飾方面也保持了旗艦車型應有的氣場，棕色為主的色調，大量實木材質飾板提升了不少檔次感，沉穩而大方，電動吸合門這麼高逼格的配置40。90萬的輝昂居然配備了，要知道同價位的BBA都沒有的東西，檔次感一下子就上去了。

在外打拚多年的老陳買了輛車子，過年帶着媳婦回到村子。

村民都投來了羡慕的眼光，鄰居家小黃問他：“陳哥賺了不少錢吧，都換了五六十萬的車子了”。

老陳心裏偷着樂：“嘿嘿，這豪華中大型轎車裸車才20幾萬呢，氣場就是強大，”

一說起豪華中大型轎車，大家都犹如耳濡目染，基本是被德系車如奧迪A6L、奔馳E級、寶馬5系等車型所包攬，但是如果價格去到30萬出頭，就只能是買到乞丐版車型了，那還不如買一些擁有強大氣場而且有着很高行車品質的車型，而且性價比也比較高，一起來看一下吧！

雷克薩斯-ES

指導價：29.80-49.80萬

說起雷克薩斯品牌總是給人一種溫文爾雅的感覺，前臉誇張的紡錘形設計進氣格柵，搭配外圈鍍鉻飾條，極具視覺衝擊感，提升了不少氣場，流暢的車身線條，立體感十足的尾燈，使得整輛車的氣質都提升了。

不同配置間的車型內飾材質也是略有不同，但是做工和品質還是一如既往的上乘，即使是最低配車型，也配備了胎壓監測、無鑰匙啟動/進入、上坡輔助、電動天窗、倒車影像、自動頭燈等配置，非常實用。

座椅採用了打孔皮革材料，坐上去感覺很厚實，與身體十分貼合，舒適性好，動力方面提供了2.0L最大功率167馬力或者2.5L最大功率184馬力的發動機，匹配6擋手自一體變速器，輕鬆好開才是重點，輸出和換擋都非常平順。

上汽大眾-輝昂

指導價：34.90-65.90萬

輝昂是上汽大眾打造的首款中大型轎車，與奧迪A6L出自MLB同一平台，足以吸引人的眼球，在大眾透視套娃式的外觀設計中，輝昂還是有這獨特的氣質的，寬大的前臉線條，雙邊四齣的排氣管裝飾罩，氣場還是挺嚇唬人的。

內飾方面也保持了旗艦車型應有的氣場，棕色為主的色調，大量實木材質飾板提升了不少檔次感，沉穩而大方，電動吸合門這麼高逼格的配置40.90萬的輝昂居然配備了，要知道同價位的BBA都沒有的東西，檔次感一下子就上去了。

輝昂的軸距達到了3009mm，想怎麼坐就怎麼坐，蹺二郎腿什麼的不在話下，寬厚的座椅設計人體工程學很到位，乘坐舒適性良好，動力提供了2.0T或者3.0T V6發動機的選擇，搭配7擋雙離合變速器，開起來很輕鬆就能上手駕馭，整車調校偏舒適，底盤是一如既往的沉穩。

英菲尼迪(進口)-Q70

指導價：39.98-64.98萬

作為英菲尼迪家族的旗艦豪華轎車，Q70L有着略帶攻擊性的外觀設計，菱形進氣格柵變得更加年輕了，犀利的全LED大燈組被大面積的鍍鉻飾條包裹，豪華氛圍濃厚，而車尾部的造型非常的飽滿、健碩，整體風格更加運動化。

環抱式的內飾設計給人很熟悉的感覺，真皮包裹的中控台手感很好，大量木紋飾板的點綴，加上中控上的石英鐘，豪華感非常強，除了最低配車型外，全系標配BOSE音響，還有電動吸合門也是全系標配的，這配置實在夠強大的。

座椅寬大厚實，對身體的各部位支撐到位，乘坐感受很出色，後排空間絕對是Q70L的一大亮點，3050mm的軸距競爭力很強，動力提供了V6布局的2.5L或者3.5L自然吸氣發動機，全系標配駕駛模式切換，動力輸出很線性，發動機聲音在高轉速是令人興奮的，但是不會給人很激烈駕駛的慾望。

總結：30萬左右的價格，選擇這些非主流的中大型豪華轎車，卻有着50萬級別車該有的氣場，而且配置上比寶馬奔馳奧迪那些主流品牌車型更為豐富，可以作為購車的一個新選擇。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

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

關於《SpringBoot-2.3容器化技術》系列

《SpringBoot-2.3容器化技術》系列，旨在和大家一起學習實踐2.3版本帶來的最新容器化技術，讓咱們的Java應用更加適應容器化環境，在雲計算時代依舊緊跟主流，保持競爭力；

全系列文章分為主題和輔助兩部分，主題部分如下：

1. 《體驗SpringBoot(2.3)應用製作Docker鏡像(官方方案)》；
2. 《詳解SpringBoot(2.3)應用製作Docker鏡像(官方方案)》；
3. 《掌握SpringBoot-2.3的容器探針：基礎篇》；
4. 《掌握SpringBoot-2.3的容器探針：深入篇》；
5. 《掌握SpringBoot-2.3的容器探針：實戰篇》；

輔助部分是一些參考資料和備忘總結，如下：

1. 《SpringBoot-2.3鏡像方案為什麼要做多個layer》；
2. 《設置非root賬號不用sudo直接執行docker命令》；
3. 《開發階段，將SpringBoot應用快速部署到K8S》；

本篇簡介

在前文，咱們快速體驗了官方推薦的docker鏡像製作方案，但也產生了幾個疑問：

1. SpringBoot-2.3版本推薦的鏡像構建方案和舊版本比有什麼不同？
2. pom.xml中spring-boot-maven-plugin插件新增的參數，到底做了什麼？
3. Dockerfile中，java -Djarmode=layertools -jar application.jar extract這個操作啥意思?

本篇的目標就是解答上述問題，在尋找答案的過程中不斷補全知識點，提升自己；

關鍵知識點：鏡像layer

前文多次提到的鏡像layer到底是什麼，為什麼會有多層layer？有必要先把這個知識點夯實了，請參考文章《SpringBoot-2.3鏡像方案為什麼要做多個layer》

老版本SpringBoot的官方方案

以SpringBoot-2.2.0.RELEASE版本為例，官方文檔(
https://docs.spring.io/spring-boot/docs/2.2.0.RELEASE/reference/pdf/spring-boot-reference.pdf)給出的做法如下：

1. 將SpringBoot工程編譯構建，在target目錄得到jar；
2. 在target目錄新建dependency文件夾；
3. 將jar解壓到dependency文件夾；
4. 編寫Dockerfile文件，內容如下：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG DEPENDENCY=target/dependency
COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
COPY ${DEPENDENCY}/META-INF /app/META-INF
COPY ${DEPENDENCY}/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.MyApplication"]

1. 可見，官方推薦的做法是將整個jar文件解壓，在Dockerfile中多次用COPY命令分別複製，這樣做的好處顯而易見：多個layer，如果鏡像的新版本中只修改了應用代碼，那麼下載鏡像時只會下載/app這個layer，其他部分直接使用本地緩存，這是docker鏡像的常規優化手段；
2. 上述方案有個小問題：麻煩！！！
3. 於是2.3.0.RELEASE版本做了些優化，讓事情變得簡單些；

2.3.0.RELEASE版本方案和舊版的區別

2.3.0.RELEASE版本構建Docker的步驟如下：

1. pom.xml中的spring-boot-maven-plugin插件增加一個配置項；
   2.編譯構建生成jar；
2. 編寫Dockerfile，裏面用到了多階段構建(multi-stage builds)，用工具從jar中提取拆分后，再多次執行COPY命令將拆分后的內容放入鏡像，達到多個layer的目的；

因此，2.3.0.RELEASE版本和舊版本相比有如下變化：

1. pom.xml中多了個參數；
2. 構建好jar后，無需自己解壓jar；
3. Dockefile內容不一樣，舊版是手動解壓jar，再在Dockerfile分別複製，2.3.0.RELEASE是通過java命令從jar中提取出各部分內容；

搞清楚了新舊版本的區別，咱們繼續研究下一個問題吧；

pom.xml中spring-boot-maven-plugin插件新增的參數

1. pring-boot-maven-plugin插件新增參數如下圖所示：

2. 上述參數有啥用？我這邊編譯構建了兩次jar，第一次有上述參數，第二次沒有，將兩次生成的jar解壓后對比，發現用了上述參數后，生成的jar會多出下圖紅框中的兩個文件：

1. 看看layers.idx文件的內容，如下圖：

1. 上圖中的內容分別是什麼意思呢？官方已給出了詳細解釋，如下圖紅框：

1. 綜上所述，layers.idx文件是個清單，裏面記錄了所有要被複制到鏡像中的信息，接下來看看如何使用layers.idx文件，這就涉及到jar包中新增的另一個文件：spring-boot-jarmode-layertools-2.3.0.RELEASE.jar

spring-boot-jarmode-layertools工具

1. 前面已經介紹過jar中除了layers.idx，還多了個文件：spring-boot-jarmode-layertools-2.3.0.RELEASE.jar ，來看看這個文件的用處；
2. 進入工程的target目錄，這裏面是編譯后的jar文件(我這裏文件名為dockerlayerdemo-0.0.1-SNAPSHOT.jar)，注意此時的spring-boot-maven-plugin插件是帶上了下圖紅框中的參數的：

1. 執行以下命令：

java -Djarmode=layertools -jar dockerlayerdemo-0.0.1-SNAPSHOT.jar list

1. 得到結果如下圖所示，是layers.idx文件的內容：

1. 來看看官方對這個layertools的解釋，list參數的作用上面我們已經體驗過了，重點是紅框中的extract參數，它的作用是從jar中提取構建鏡像所需的內容：

1. 看到這裏，您是否想到了《體驗SpringBoot(2.3)應用製作Docker鏡像(官方方案)》中Dockerfile的內容，請看下圖的紅框和紅字，是否有種恍然大悟的感覺：jar構建生成清單layers.idx，Dockerfile中根據清單從jar提取文件放入鏡像：

至此，三個問題都已經找到了答案，小結一下：

SpringBoot-2.3.0.RELEASE推薦的鏡像構建方案和舊版本相比有什麼不同

1. pom.xml中的spring-boot-maven-plugin插件增加一個配置項；
2. 構建好jar后，舊版本要自己解壓jar，新版不需要；
3. 新版本的jar中，多了個文件清單layers.idx和鏡像文件處理工具spring-boot-jarmode-layertools-2.3.0.RELEASE.jar；
4. 舊版的Dockefile內容：因為前面解壓好了，所有在Dockerfile里直接複製前面解壓的內容，這裏就有個風險：前一步解壓和當前複製的文件位置要保證一致；
5. 新版的Dockerfile內容：使用工具spring-boot-jarmode-layertools-2.3.0.RELEASE.jar，根據的layers.idx內容從jar中提取文件，複製到鏡像中；
6. 新版的Dockerfile中，由於使用了分階段構建，因此從jar提取文件的操作不會保存到鏡像的layer中；

pom.xml中spring-boot-maven-plugin插件新增的參數，到底做了什麼

spring-boot-maven-plugin插件新增的參數，使得編譯構建得到jar中多了兩個文件，如下圖所示：

Dockerfile中，java -Djarmode=layertools -jar application.jar extract這個操作啥意思

1. java -Djarmode=layertools -jar application.jar extract的作用是從jar中提取文件，這些文件是docker鏡像的一部分；
2. 上述操作的參數是extract，另外還有兩個參數，官方解釋它們的作用如下：

至此，問題已全部澄清，相信您對SpringBoot-2.3.0.RELEASE官方的鏡像構建方案也足夠了解了，最後是我根據自己的認識畫的流程圖，幫助您快速理解整個構建流程：

歡迎訪問我的GitHub

• 地址：https://github.com/zq2599/blog_demos
• 內容：原創文章分類匯總，及配套源碼，涉及Java、Docker、K8S、DevOPS等

歡迎關注我的公眾號：程序員欣宸

https://github.com/zq2599/blog_demos

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

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

※超省錢租車方案

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!

※推薦台中搬家公司優質服務,可到府估價

目錄

• 簡介
• 監控的痛點
• WatchService和文件系統
• WatchSerice的使用和實現本質
• 總結

簡介

小師妹這次遇到了監控文件變化的問題，F師兄給小師妹介紹了JDK7 nio中引入的WatchService，沒想到又順道普及了一下文件系統的概念，萬萬沒想到。

監控的痛點

小師妹：F師兄最近你有沒有感覺到呼吸有點困難，后領有點涼颼颼的，說話有點不順暢的那種？

沒有啊小師妹，你是不是秋衣穿反了？

小師妹：不是的F師兄，我講的是心裏的感覺，那種莫須有的壓力，還有一絲悸動纏繞在心。

別繞彎子了小師妹，是不是又遇到問題了。

更多精彩內容且看：

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

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

小師妹：還是F師兄懂我，這不上次的Properties文件用得非常上手，每次修改Properties文件都要重啟java應用程序，真的是很痛苦。有沒有什麼其他的辦法呢？

辦法當然有，最基礎的辦法就是開一個線程定時去監控屬性文件的最後修改時間，如果修改了就重新加載，這樣不就行了。

小師妹：寫線程啊，這麼麻煩，有沒有什麼更簡單的辦法呢？

就知道你要這樣問，還好我準備的比較充分，今天給你介紹一個JDK7在nio中引入的類WatchService。

WatchService和文件系統

WatchService是JDK7在nio中引入的接口：

監控的服務叫做WatchService，被監控的對象叫做Watchable：

WatchKey register(WatchService watcher,
                      WatchEvent.Kind<?>[] events,
                      WatchEvent.Modifier... modifiers)
        throws IOException;
WatchKey register(WatchService watcher, WatchEvent.Kind<?>... events)
        throws IOException;

Watchable通過register將該對象的WatchEvent註冊到WatchService上。從此只要有WatchEvent發生在Watchable對象上，就會通知WatchService。

WatchEvent有四種類型：

1. ENTRY_CREATE 目標被創建
2. ENTRY_DELETE 目標被刪除
3. ENTRY_MODIFY 目標被修改
4. OVERFLOW 一個特殊的Event，表示Event被放棄或者丟失

register返回的WatchKey就是監聽到的WatchEvent的集合。

現在來看WatchService的4個方法：

1. close 關閉watchService
2. poll 獲取下一個watchKey，如果沒有則返回null
3. 帶時間參數的poll 在等待的一定時間內獲取下一個watchKey
4. take 獲取下一個watchKey，如果沒有則一直等待

小師妹：F師兄，那怎麼才能構建一個WatchService呢？

上次文章中說的文件系統，小師妹還記得吧，FileSystem中就有一個獲取WatchService的方法：

public abstract WatchService newWatchService() throws IOException;

我們看下FileSystem的結構圖：

在我的mac系統上，FileSystem可以分為三大類，UnixFileSystem，JrtFileSystem和ZipFileSystem。我猜在windows上面應該還有對應的windows相關的文件系統。小師妹你要是有興趣可以去看一下。

小師妹：UnixFileSystem用來處理Unix下面的文件，ZipFileSystem用來處理zip文件。那JrtFileSystem是用來做什麼的？

哎呀，這就又要扯遠了，為什麼每次問問題都要扯到天邊….

從前當JDK還是9的時候，做了一個非常大的改動叫做模塊化JPMS（Java Platform Module System），這個Jrt就是為了給模塊化系統用的，我們來舉個例子：

public void useJRTFileSystem(){
        String resource = "java/lang/Object.class";
        URL url = ClassLoader.getSystemResource(resource);
        log.info("{}",url);
    }

上面一段代碼我們獲取到了Object這個class的url，我們看下如果是在JDK8中，輸出是什麼：

jar:file:/Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/rt.jar!/java/lang/Object.class

輸出結果是jar:file表示這個Object class是放在jar文件中的，後面是jar文件的路徑。

如果是在JDK9之後：

jrt:/java.base/java/lang/Object.class

結果是jrt開頭的，java.base是模塊的名字，後面是Object的路徑。看起來是不是比傳統的jar路徑更加簡潔明了。

有了文件系統，我們就可以在獲取系統默認的文件系統的同時，獲取到相應的WatchService：

WatchService watchService = FileSystems.getDefault().newWatchService();

WatchSerice的使用和實現本質

小師妹：F師兄，WatchSerice是咋實現的呀？這麼神奇，為我們省了這麼多工作。

其實JDK提供了這麼多類的目的就是為了不讓我們重複造輪子，之前跟你講監控文件的最簡單辦法就是開一個獨立的線程來監控文件變化嗎？其實…..WatchService就是這樣做的！

PollingWatchService() {
        // TBD: Make the number of threads configurable
        scheduledExecutor = Executors
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
                 @Override
                 public Thread newThread(Runnable r) {
                     Thread t = new Thread(null, r, "FileSystemWatcher", 0, false);
                     t.setDaemon(true);
                     return t;
                 }});
    }

上面的方法就是生成WatchService的方法，小師妹看到沒有，它的本質就是開啟了一個daemon的線程，用來接收監控任務。

下面看下怎麼把一個文件註冊到WatchService上面：

private void startWatcher(String dirPath, String file) throws IOException {
        WatchService watchService = FileSystems.getDefault().newWatchService();
        Path path = Paths.get(dirPath);
        path.register(watchService, ENTRY_MODIFY);

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                watchService.close();
            } catch (IOException e) {
                log.error(e.getMessage());
            }
        }));

        WatchKey key = null;
        while (true) {
            try {
                key = watchService.take();
                for (WatchEvent<?> event : key.pollEvents()) {
                    if (event.context().toString().equals(fileName)) {
                        loadConfig(dirPath + file);
                    }
                }
                boolean reset = key.reset();
                if (!reset) {
                    log.info("該文件無法重置");
                    break;
                }
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
    }

上面的關鍵方法就是path.register，其中Path是一個Watchable對象。

然後使用watchService.take來獲取生成的WatchEvent，最後根據WatchEvent來處理文件。

總結

道生一，一生二，二生三，三生萬物。一個簡簡單單的功能其實背後隱藏着…道德經，哦，不對，背後隱藏着道的哲學。

本文的例子https://github.com/ddean2009/learn-java-io-nio

本文作者：flydean程序那些事

本文鏈接：http://www.flydean.com/java-io-file-watchservice/

本文來源：flydean的博客

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

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

【其他文章推薦】

※回頭車貨運收費標準

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

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

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

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

※台中搬家公司教你幾個打包小技巧,輕鬆整理裝箱!

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!

廣汽菲克Jeep-自由光 指導價：20。98-31。58萬如果要數國產化之後表現會比進口版還要優秀的車子，叫獸相信廣汽菲克Jeep自由光算是一輛。國產的自由光在動力匹配和車廂隔音這兩個方面都比進口版的自由光要優秀，實際上在國產中型SUV市場上，自由光也算是一位表現出色的傢伙。

前段時間，二胎政策的放鬆，不少家用車消費者一下子都把目光投向了七座車上面，然而實際上坐滿七個座位的情況真的不多，而且很多時候七座SUV的第三排都是雞肋，成年人坐進去就會很憋屈。所以何苦為難自己和乘客？一輛大五座的汽車其實更加適合我們的日常使用，這甚至已經逐漸變成一種潮流。今天就和看看有哪些大五座的SUV值得我們關注吧。

上汽通用別克-昂科威 指導價：20.99-34.99萬元

昂科威是比較早期的“大五座”SUV，其實以昂科威的車身尺寸，要做七座車型並不是不可以，但它偏偏以座位布置上的差異與同價位的競爭對手漢蘭達錯位競爭，為自己創造出更大的生存空間，而後來火爆的銷量也說明了昂科威的路線是正確的。

外觀上，昂科威的造型飽滿修長又不乏時尚感，大氣得來又不會太老土，這樣的風格符合大部分消費者的審美。飽滿的前臉毫無疑問的採用了別克家族的網瀑式格柵，頗顯霸氣，大燈為氙氣光源並帶透鏡和LED燈帶，大燈造型和車身的匹配也毫無違和感。至於側面和車尾就以簡潔為主了，但是前後的線條在布局上互相溝通，整體感很強。

別克在車廂內飾豪華感的營造上可謂是業界的老手了，用料方面，上方的搪塑材料、中間的木紋飾板以及包圍的真皮面料，絲毫沒有怠慢；而設計上也不低調，懷抱式的布局加寬大的扶手，非對稱式的中控台，按鍵的布局也很合理，既有層次感又實用。多媒體方面，搭載了安吉星系統，支持手機互聯和導航等，功能豐富。

空間方面，調整好座椅以後，身高178cm的體驗者在駕駛位能取得一拳的頭部空間，在後排則有三指的頭部和一拳四指的腿部空間。值得一提的是昂科威的後排地板是全平的，而且後排座椅靠背也可以調節，只是可惜在頭部空間方面稍顯局促。

動力方面，昂科威搭載1.5T+七速雙離合或者2.0T+6AT的動力系統，最大馬力分別是169ps和260ps，1.5T車型的話動力還是稍失從容，畢竟馬力和車重都擺在那，需要拉高轉速來維持較理想的動力輸出，雙離合的低速頓挫則依舊存在，且對急加速的響應不夠迅速。相對來說，2.0T版本無論是動力強度還是變速箱的表現都要從容穩定更多，動力輸出流暢有後勁，所以更推薦2.0T的昂科威。

廣汽本田-冠道 指導價：26.98-32.98萬元

冠道這款車還未上市的時候就已經賺足眼球了，畢竟它是本田在國內的第一款中型SUV，但同時，冠道身上又集合了很多新技術，如2.0T的地球夢發動機，以及ZF的9AT變速箱，都是第一次出現在國內的本田車上，所以該車自然就吸引了不少的眼球了。

冠道的外觀硬朗且有肌肉感，雖然車身的高度略矮，但給人的感覺還是很壯碩的。中網寬大的鍍鉻飾條和車身造型很匹配，共同營造出冠道的“大塊頭”形象。細節處也頗具心思，如LED大燈、LED日行燈等的加入，側面的三條曲線更凸顯了車身的肌肉感，至於車尾的設計就稍顯普通，但是LED尾燈和雙排氣的設計還是不輸氣勢的。

內飾方面，冠道採用了懸浮式的中控屏和按鍵式排擋設計，科技感十足，同時用料方面也不會十分寒酸，中控台上方採用搪塑+縫線的設計，中間也加入了仿木紋啞光飾板，檔次感更強。而配置方面，座椅加熱和通風、手機互聯、HUD、車道偏離預警等功能都一應俱全，頗有豪華車的風範。

至於空間就是冠道的一大優勢了，前排調整好坐姿之後，身高182cm的體驗者在駕駛座仍有一拳一指的頭部空間，至於他去到後排之後，則有兩拳有餘的腿部和四指的頭部空間，空間表現十分寬裕，只是後排座椅靠背角度不支持調節，這有點可惜。

動力方面前面也提過，2.0T的發動機搭配采埃孚的9AT變速箱，最大馬力272ps，動力輸出比較線性，雖然不是很有爆發力的輸出，但信心還是很充足的，所以動力方面無需擔心。冠道底盤的舒適性也很值得肯定，濾震效果很徹底，但是時速60以上過彎的話，車輛的循跡性就會明顯下降，另外冠道對於高速行駛時遇到的顛簸還是處理得不夠從容，除此以外，冠道可以說本田有史以來隔音做得最好的車子了。

廣汽菲克Jeep-自由光 指導價：20.98-31.58萬

如果要數國產化之後表現會比進口版還要優秀的車子，叫獸相信廣汽菲克Jeep自由光算是一輛。國產的自由光在動力匹配和車廂隔音這兩個方面都比進口版的自由光要優秀，實際上在國產中型SUV市場上，自由光也算是一位表現出色的傢伙。

外觀尺寸方面，自由光比昂科威、冠道等同級對手要稍微小一點。但這也絲毫掩飾不了它的硬漢外形，全車身的黑色下包圍和七孔的豎狀中網，都凸顯了自由光作為一輛Jeep汽車該有的運動氣息，頗具特色的是七孔的中網還使用了曲折式的設計，比傳統的Jeep中網更有個性。

內飾方面，自由光並不像其他的Jeep車型那樣走硬朗的越野風，更多的是體現出一輛城市該有的細膩和豪華。中控台採用了軟質材料，而且上方有雙縫線工藝，提升了檔次感，真皮方向盤很粗壯，握感飽滿。多媒體方面，8.4英寸的Uconnect屏幕包含了導航、倒車影像等功能，功能上不會落後。

座椅的填充厚實，而且前排兩張座椅都有電動調節，算是順應了國內消費者的需求。空間方面，調整好坐姿之後，身高174cm的體驗者在前排有四指的頭部空間，在後排則有兩拳的腿部和兩指的頭部空間，可惜後排的地板凸起比較高，不利於中間位置的乘坐，所以自由光的後排空間表現只能算是中規中矩。

國產自由光的動力系統有兩種，分別是2.0L和2.4L的發動機，搭配9AT的變速箱，最大馬力分別是155ps和175ps，採用了全自然吸氣的班底，算是現時少有的了。兩個排量的自由光都不是以動力為賣點，而且變速箱的降擋反應並不积極，僅能滿足日常的駕駛，所以2.0L的自由光並不適合激烈的駕駛。底盤則偏向於城市SUV的調校，偏向舒適且濾震效果不錯。

上汽大眾斯柯達-柯迪亞克預計上市時間：2017年夏季

斯柯達和大眾之間有着一些微妙的關係，一般這兩個品牌同一時期的同級別同平台車輛的話，先上市的一般是斯柯達的車，速派和邁騰就是這種關係。而在中型SUV領域，柯迪亞克和新途觀之間也是類似的這種微妙關係。至於个中原因，就是大眾決策層的經營策略了，我們也不好猜測。

還是先把注意力放回柯迪亞克身上吧，從“Kodiaq”的名字我們就會知道這輛車的體型不會小，而且外觀風格也會比較硬朗，實際也是如此。前臉雖然依舊是斯柯達家族式的中網，但線條會更加硬朗，而中網兩邊的大燈也是斯柯達首次使用的LED大燈，科技感十足。側面造型修長且硬朗，尾部造型則和速派旅行版相仿，家族氣息更濃，辨識度也不低。

來到內飾，熟悉MQB平台車輛（高爾夫7、速派）的人都不會感到陌生了，平直的線條、對稱式的布局，嚴謹的設計風格。但柯迪亞克的內飾還是比其他大眾系的車輛要顯得開揚一點，簡單說就是更大氣了。配置方面，常規B級車的駕駛輔助和舒適性方面的配置都沒有或缺，另外要說的是該車的儲物空間挺豐富的，而且加入了全景天窗，比較對消費者的胃口。

部分車型（估計是高配）座椅面料為Alcantara加真皮，看着顯檔次，坐着也舒適，比較喜歡這種座椅。空間方面，前排調整好之後，身高185cm的體驗者還能有一拳的頭部空間，而他去到後排則有一拳有餘的腿部和四指的頭部空間，這個表現對於普通身材的成年人來說已經足夠寬敞，不用擔心空間問題。

目前已知柯迪亞克會推出兩種動力系統，分別是1.8T和2.0T的排量，搭配7速DSG變速箱，最大馬力為180ps和220ps，動力表現和速派這類大眾車類似，起步時油門會稍顯慵懶，但隨着油門深度的加大，動力的充沛感會愈加明顯。底盤則維持了德系車紮實質感的基礎上會稍偏硬，但舒適性並不差，只是這種車體型大，方向盤也很輕，駕駛感不太明顯。

總結：越來越多的廠商重視“大五座”SUV這個細分市場，事實上大部分消費者在預算足夠的情況下都更願意買大點的車，至於七座與否，似乎並不是最重要的點。相對緊湊型車，這個級別有更多的空間來提升車輛的產品力，所以這也是建立品牌口碑的一個很好的途徑，相信中型SUV市場的競爭會越來越激烈，更多的好車也會不斷湧出。本站聲明:網站內容來源於http://www.auto6s.com/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

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

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

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

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

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

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

系列文章

1. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用 abp cli 搭建項目
2. 基於 abp vNext 和 .NET Core 開發博客項目 – 給項目瘦身，讓它跑起來
3. 基於 abp vNext 和 .NET Core 開發博客項目 – 完善與美化，Swagger登場
4. 基於 abp vNext 和 .NET Core 開發博客項目 – 數據訪問和代碼優先
5. 基於 abp vNext 和 .NET Core 開發博客項目 – 自定義倉儲之增刪改查
6. 基於 abp vNext 和 .NET Core 開發博客項目 – 統一規範API，包裝返回模型
7. 基於 abp vNext 和 .NET Core 開發博客項目 – 再說Swagger，分組、描述、小綠鎖
8. 基於 abp vNext 和 .NET Core 開發博客項目 – 接入GitHub，用JWT保護你的API
9. 基於 abp vNext 和 .NET Core 開發博客項目 – 異常處理和日誌記錄
10. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用Redis緩存數據
11. 基於 abp vNext 和 .NET Core 開發博客項目 – 集成Hangfire實現定時任務處理
12. 基於 abp vNext 和 .NET Core 開發博客項目 – 用AutoMapper搞定對象映射
13. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（一）
14. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（二）
15. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰（三）
16. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（一）
17. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（二）
18. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（三）
19. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇（四）

上篇文章完成了文章詳情頁數據查詢和清除緩存的功能。

本篇繼續完成分類、標籤、友情鏈接的後台操作接口，還是那句話，這些純CRUD的內容，建議還是自己動手完成比較好，本篇將不再啰嗦，直接貼代碼，以供參考。

分類

添加接口：查詢分類列表QueryCategoriesForAdminAsync()、新增分類InsertCategoryAsync(...)、更新分類UpdateCategoryAsync(...)、刪除分類DeleteCategoryAsync(...)

#region Categories

/// <summary>
/// 查詢分類列表
/// </summary>
/// <returns></returns>
Task<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>> QueryCategoriesForAdminAsync();

/// <summary>
/// 新增分類
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> InsertCategoryAsync(EditCategoryInput input);

/// <summary>
/// 更新分類
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> UpdateCategoryAsync(int id, EditCategoryInput input);

/// <summary>
/// 刪除分類
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<ServiceResult> DeleteCategoryAsync(int id);

#endregion Categories

查詢分類列表需要返回的模型類QueryCategoryForAdminDto.cs。

//QueryCategoryForAdminDto.cs
namespace Meowv.Blog.Application.Contracts.Blog
{
    public class QueryCategoryForAdminDto : QueryCategoryDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

新增分類和更新分類需要的輸入參數EditCategoryInput.cs，直接繼承CategoryDto即可。

//EditCategoryInput.cs
namespace Meowv.Blog.Application.Contracts.Blog.Params
{
    public class EditCategoryInput : CategoryDto
    {
    }
}

分別實現這幾個接口。

/// <summary>
/// 查詢分類列表
/// </summary>
/// <returns></returns>
public async Task<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>> QueryCategoriesForAdminAsync()
{
    var result = new ServiceResult<IEnumerable<QueryCategoryForAdminDto>>();

    var posts = await _postRepository.GetListAsync();

    var categories = _categoryRepository.GetListAsync().Result.Select(x => new QueryCategoryForAdminDto
    {
        Id = x.Id,
        CategoryName = x.CategoryName,
        DisplayName = x.DisplayName,
        Count = posts.Count(p => p.CategoryId == x.Id)
    });

    result.IsSuccess(categories);
    return result;
}

/// <summary>
/// 新增分類
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> InsertCategoryAsync(EditCategoryInput input)
{
    var result = new ServiceResult();

    var category = ObjectMapper.Map<EditCategoryInput, Category>(input);
    await _categoryRepository.InsertAsync(category);

    result.IsSuccess(ResponseText.INSERT_SUCCESS);
    return result;
}

這裏需要一條AutoMapper配置，將EditCategoryInput轉換為Category，忽略Id字段。

CreateMap<EditCategoryInput, Category>().ForMember(x => x.Id, opt => opt.Ignore());

/// <summary>
/// 更新分類
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> UpdateCategoryAsync(int id, EditCategoryInput input)
{
    var result = new ServiceResult();

    var category = await _categoryRepository.GetAsync(id);
    category.CategoryName = input.CategoryName;
    category.DisplayName = input.DisplayName;

    await _categoryRepository.UpdateAsync(category);

    result.IsSuccess(ResponseText.UPDATE_SUCCESS);
    return result;
}

/// <summary>
/// 刪除分類
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ServiceResult> DeleteCategoryAsync(int id)
{
    var result = new ServiceResult();

    var category = await _categoryRepository.FindAsync(id);
    if (null == category)
    {
        result.IsFailed(ResponseText.WHAT_NOT_EXIST.FormatWith("Id", id));
        return result;
    }

    await _categoryRepository.DeleteAsync(id);

    result.IsSuccess(ResponseText.DELETE_SUCCESS);
    return result;
}

在BlogController.Admin.cs中添加接口。

#region Categories

/// <summary>
/// 查詢分類列表
/// </summary>
/// <returns></returns>
[HttpGet]
[Authorize]
[Route("admin/categories")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult<IEnumerable<QueryCategoryForAdminDto>>> QueryCategoriesForAdminAsync()
{
    return await _blogService.QueryCategoriesForAdminAsync();
}

/// <summary>
/// 新增分類
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
[Route("category")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> InsertCategoryAsync([FromBody] EditCategoryInput input)
{
    return await _blogService.InsertCategoryAsync(input);
}

/// <summary>
/// 更新分類
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
[HttpPut]
[Authorize]
[Route("category")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> UpdateCategoryAsync([Required] int id, [FromBody] EditCategoryInput input)
{
    return await _blogService.UpdateCategoryAsync(id, input);
}

/// <summary>
/// 刪除分類
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete]
[Authorize]
[Route("category")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> DeleteCategoryAsync([Required] int id)
{
    return await _blogService.DeleteCategoryAsync(id);
}

#endregion Categories

標籤

添加接口：查詢標籤列表QueryTagsForAdminAsync()、新增標籤InsertTagAsync(...)、更新標籤UpdateTagAsync(...)、刪除標籤DeleteTagAsync(...)

#region Tags

/// <summary>
/// 查詢標籤列表
/// </summary>
/// <returns></returns>
Task<ServiceResult<IEnumerable<QueryTagForAdminDto>>> QueryTagsForAdminAsync();

/// <summary>
/// 新增標籤
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> InsertTagAsync(EditTagInput input);

/// <summary>
/// 更新標籤
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> UpdateTagAsync(int id, EditTagInput input);

/// <summary>
/// 刪除標籤
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<ServiceResult> DeleteTagAsync(int id);

#endregion Tags

查詢標籤列表需要返回的模型類QueryTagForAdminDto.cs。

//QueryTagForAdminDto.cs
namespace Meowv.Blog.Application.Contracts.Blog
{
    public class QueryTagForAdminDto : QueryTagDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

新增標籤和更新標籤需要的輸入參數EditTagInput.cs，直接繼承TagDto即可。

//EditTagInput.cs
namespace Meowv.Blog.Application.Contracts.Blog.Params
{
    public class EditTagInput : TagDto
    {
    }
}

分別實現這幾個接口。

/// <summary>
/// 查詢標籤列表
/// </summary>
/// <returns></returns>
public async Task<ServiceResult<IEnumerable<QueryTagForAdminDto>>> QueryTagsForAdminAsync()
{
    var result = new ServiceResult<IEnumerable<QueryTagForAdminDto>>();

    var post_tags = await _postTagRepository.GetListAsync();

    var tags = _tagRepository.GetListAsync().Result.Select(x => new QueryTagForAdminDto
    {
        Id = x.Id,
        TagName = x.TagName,
        DisplayName = x.DisplayName,
        Count = post_tags.Count(p => p.TagId == x.Id)
    });

    result.IsSuccess(tags);
    return result;
}

/// <summary>
/// 新增標籤
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task<ServiceResult> InsertTagAsync(EditTagInput input)
{
    var result = new ServiceResult();

    var tag = ObjectMapper.Map<EditTagInput, Tag>(input);
    await _tagRepository.InsertAsync(tag);

    result.IsSuccess(ResponseText.INSERT_SUCCESS);
    return result;
}

這裏需要一條AutoMapper配置，將EditCategoryInput轉換為Tag，忽略Id字段。

CreateMap<EditTagInput, Tag>().ForMember(x => x.Id, opt => opt.Ignore());

/// <summary>
/// 更新標籤
/// </summary>
/// <param name="id"></param>
/// <param name="dto"></param>
/// <returns></returns>
public async Task<ServiceResult> UpdateTagAsync(int id, EditTagInput input)
{
    var result = new ServiceResult();

    var tag = await _tagRepository.GetAsync(id);
    tag.TagName = input.TagName;
    tag.DisplayName = input.DisplayName;

    await _tagRepository.UpdateAsync(tag);

    result.IsSuccess(ResponseText.UPDATE_SUCCESS);
    return result;
}

/// <summary>
/// 刪除標籤
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ServiceResult> DeleteTagAsync(int id)
{
    var result = new ServiceResult();

    var tag = await _tagRepository.FindAsync(id);
    if (null == tag)
    {
        result.IsFailed(ResponseText.WHAT_NOT_EXIST.FormatWith("Id", id));
        return result;
    }

    await _tagRepository.DeleteAsync(id);
    await _postTagRepository.DeleteAsync(x => x.TagId == id);

    result.IsSuccess(ResponseText.DELETE_SUCCESS);
    return result;
}

在BlogController.Admin.cs中添加接口。

#region Tags

/// <summary>
/// 查詢標籤列表
/// </summary>
/// <returns></returns>
[HttpGet]
[Authorize]
[Route("admin/tags")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult<IEnumerable<QueryTagForAdminDto>>> QueryTagsForAdminAsync()
{
    return await _blogService.QueryTagsForAdminAsync();
}

/// <summary>
/// 新增標籤
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
[Route("tag")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> InsertTagAsync([FromBody] EditTagInput input)
{
    return await _blogService.InsertTagAsync(input);
}

/// <summary>
/// 更新標籤
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
[HttpPut]
[Authorize]
[Route("tag")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> UpdateTagAsync([Required] int id, [FromBody] EditTagInput input)
{
    return await _blogService.UpdateTagAsync(id, input);
}

/// <summary>
/// 刪除標籤
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete]
[Authorize]
[Route("tag")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> DeleteTagAsync([Required] int id)
{
    return await _blogService.DeleteTagAsync(id);
}

#endregion Tags

友鏈

添加接口：查詢友鏈列表QueryFriendLinksForAdminAsync()、新增友鏈InsertFriendLinkAsync(...)、更新友鏈UpdateFriendLinkAsync(...)、刪除友鏈DeleteFriendLinkAsync(...)

#region FriendLinks

/// <summary>
/// 查詢友鏈列表
/// </summary>
/// <returns></returns>
Task<ServiceResult<IEnumerable<QueryFriendLinkForAdminDto>>> QueryFriendLinksForAdminAsync();

/// <summary>
/// 新增友鏈
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> InsertFriendLinkAsync(EditFriendLinkInput input);

/// <summary>
/// 更新友鏈
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
Task<ServiceResult> UpdateFriendLinkAsync(int id, EditFriendLinkInput input);

/// <summary>
/// 刪除友鏈
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<ServiceResult> DeleteFriendLinkAsync(int id);

#endregion FriendLinks

查詢友鏈列表需要返回的模型類QueryFriendLinkForAdminDto.cs。

//QueryFriendLinkForAdminDto.cs
namespace Meowv.Blog.Application.Contracts.Blog
{
    public class QueryFriendLinkForAdminDto : FriendLinkDto
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int Id { get; set; }
    }
}

新增友鏈和更新友鏈需要的輸入參數EditFriendLinkInput.cs，直接繼承FriendLinkDto即可。

//EditFriendLinkInput .cs
namespace Meowv.Blog.Application.Contracts.Blog.Params
{
    public class EditFriendLinkInput : FriendLinkDto
    {
    }
}

分別實現這幾個接口。

/// <summary>
/// 查詢友鏈列表
/// </summary>
/// <returns></returns>
public async Task<ServiceResult<IEnumerable<QueryFriendLinkForAdminDto>>> QueryFriendLinksForAdminAsync()
{
    var result = new ServiceResult<IEnumerable<QueryFriendLinkForAdminDto>>();

    var friendLinks = await _friendLinksRepository.GetListAsync();

    var dto = ObjectMapper.Map<List<FriendLink>, IEnumerable<QueryFriendLinkForAdminDto>>(friendLinks);

    result.IsSuccess(dto);
    return result;
}

/// <summary>
/// 新增友鏈
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> InsertFriendLinkAsync(EditFriendLinkInput input)
{
    var result = new ServiceResult();

    var friendLink = ObjectMapper.Map<EditFriendLinkInput, FriendLink>(input);
    await _friendLinksRepository.InsertAsync(friendLink);

    // 執行清除緩存操作
    await _blogCacheService.RemoveAsync(CachePrefix.Blog_FriendLink);

    result.IsSuccess(ResponseText.INSERT_SUCCESS);
    return result;
}

/// <summary>
/// 更新友鏈
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task<ServiceResult> UpdateFriendLinkAsync(int id, EditFriendLinkInput input)
{
    var result = new ServiceResult();

    var friendLink = await _friendLinksRepository.GetAsync(id);
    friendLink.Title = input.Title;
    friendLink.LinkUrl = input.LinkUrl;

    await _friendLinksRepository.UpdateAsync(friendLink);

    // 執行清除緩存操作
    await _blogCacheService.RemoveAsync(CachePrefix.Blog_FriendLink);

    result.IsSuccess(ResponseText.UPDATE_SUCCESS);
    return result;
}

/// <summary>
/// 刪除友鏈
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ServiceResult> DeleteFriendLinkAsync(int id)
{
    var result = new ServiceResult();

    var friendLink = await _friendLinksRepository.FindAsync(id);
    if (null == friendLink)
    {
        result.IsFailed(ResponseText.WHAT_NOT_EXIST.FormatWith("Id", id));
        return result;
    }

    await _friendLinksRepository.DeleteAsync(id);

    // 執行清除緩存操作
    await _blogCacheService.RemoveAsync(CachePrefix.Blog_FriendLink);

    result.IsSuccess(ResponseText.DELETE_SUCCESS);
    return result;
}

其中查詢友鏈列表和新增友鏈中有兩條AutoMapper配置。

CreateMap<FriendLink, QueryFriendLinkForAdminDto>();

CreateMap<EditFriendLinkInput, FriendLink>().ForMember(x => x.Id, opt => opt.Ignore());

在BlogController.Admin.cs中添加接口。

#region FriendLinks

/// <summary>
/// 查詢友鏈列表
/// </summary>
/// <returns></returns>
[HttpGet]
[Authorize]
[Route("admin/friendlinks")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult<IEnumerable<QueryFriendLinkForAdminDto>>> QueryFriendLinksForAdminAsync()
{
    return await _blogService.QueryFriendLinksForAdminAsync();
}

/// <summary>
/// 新增友鏈
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
[HttpPost]
[Authorize]
[Route("friendlink")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> InsertFriendLinkAsync([FromBody] EditFriendLinkInput input)
{
    return await _blogService.InsertFriendLinkAsync(input);
}

/// <summary>
/// 更新友鏈
/// </summary>
/// <param name="id"></param>
/// <param name="input"></param>
/// <returns></returns>
[HttpPut]
[Authorize]
[Route("friendlink")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> UpdateFriendLinkAsync([Required] int id, [FromBody] EditFriendLinkInput input)
{
    return await _blogService.UpdateFriendLinkAsync(id, input);
}

/// <summary>
/// 刪除友鏈
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpDelete]
[Authorize]
[Route("friendlink")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult> DeleteFriendLinkAsync([Required] int id)
{
    return await _blogService.DeleteFriendLinkAsync(id);
}

#endregion

Next

截止本篇，基於 abp vNext 和 .NET Core 開發博客項目 系列的後台API部分便全部開發完成了。

本博客項目系列是我一邊寫代碼一邊記錄后的成果，並不是開發完成后再拿出來寫的，涉及到東西也不是很多，對於新手入門來說應該是夠了的，如果你從中有所收穫請多多轉發分享。

在此，希望大家可以關注一下我的微信公眾號：『阿星Plus』，文章將會首發在公眾號中。

現在有了API，大家可以選擇自己熟悉的方式去開發前端界面，比如目前我博客的線上版本就是用的 ASP.NET Core Web ，感興趣的可以去 release 分支查看。

關於前端部分，看到有人呼籲vue，說實話前端技術不是很厲害，本職主要是後端開發，可能達不到預期效果。

所以我準備入坑 Blazor ，接下來就現學現賣吧，一起學習一起做項目一起進步，加油

開源地址：https://github.com/Meowv/Blog/tree/blog_tutorial

搭配下方課程學習更佳 ↓ ↓ ↓

http://gk.link/a/10iQ7

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

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

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

※台中搬家公司教你幾個打包小技巧,輕鬆整理裝箱!

※台中搬家公司費用怎麼算?