2020-03-04

關於GC(中)：Java垃圾回收相關基礎知識

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

Java內存模型

(圖源: )

區域名	英文名	訪問權限	作用	備註
程序計數器	Program Counter Register	線程隔離	標記待取的下一條執行的指令	執行Native方法時為空; JVM規範中唯一不會發生OutOfMemoryError的區域
虛擬機棧	VM Stack	線程隔離	每個Java方法執行時創建，用於存儲局部變量表，操作棧，動態鏈接，方法出口等信息	方法執行的內存模型
本地方法棧	Native Method Stack	線程隔離	Native方法執行時使用	JVM規範沒有強制規定，如Hotspot將VM和Native兩個方法棧合二為一
Java堆	Java Heap	線程共享	存放對象實例	更好的回收內存 vs 更快的分配內存
方法區	Method Area	線程共享	存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯后的代碼等數據	JVM規範不強制要求做垃圾收集
運行時常量池	Runtime Constant Pool	線程共享	方法區的一部分
直接內存	Direct Memory	–	堆外內存，通過堆的DirectByteBuffer訪問	不是運行時數據區的一部分，但也可能OutOfMemoryError

對象的創建——new的時候發生了什麼

討論僅限於普通Java對象，不包括數組和Class對象。

常量池查找類的常量引用，如果沒有先做類加載
分配內存，視堆內存是否是規整（由垃圾回收器是否具有壓縮功能而定）而使用“指針碰撞”或“空閑列表”模式
內存空間初始化為零值，可能提前在線程創建時分配TLAB時做初始化
設置必要信息，如對象是哪個類的示例、元信息、GC分代年齡等
調用<init>方法

垃圾回收器總結

垃圾回收，針對的都是堆。

分代

新生代：適合使用複製算法, 以下三個區一般佔比為8:1:1
- Eden 新對象誕生區
- From Survivor 上一次GC的倖存者(見“GC種類-minor GC”)
- To Survivor 本次待存放倖存者的區域
老年代：存活時間較久的，大小較大的對象，因此使用標記-整理或標記-清除算法比較合適
永久代：存放類信息和元數據等不太可能回收的信息。Java8中被元空間(Metaspace)代替，不再使用堆，而是物理內存。

分代的原因

不同代的對象生命周期不同，可以針對性地使用不同的垃圾回收算法
不同代可以分開進行回收

回收算法

名稱	工作原理	優點	缺點
標記-清除	對可回收對對象做一輪標記，標記完成后統一回收被標記的對象	易於理解，內存利用率高	效率問題;內存碎片;分配大對象但無空間時提前GC
複製	內存均分兩塊，只使用其中一塊。回收時將這一塊存活對象全部複製到另一塊	效率高	可用空間減少; 空間不夠時需老年代分配擔保
標記-整理	對可回收對對象做一輪標記，標記完成后將存活對象統一左移，清理掉邊界外內存	內存利用率高	效率問題

標記-X算法適用於老年代，複製算法適用於新生代。

GC種類

Minor GC，只回收新生代，將Eden和From Survivor區的存活對象複製到To Survivor
Major GC，清理老年代。但因為伴隨着新生代的對象生命周期升級到老年代，一般也可認為伴隨着FullGC。
FullGC，整個堆的回收
Mixed GC，G1特有，可能會發生多次回收，可以參考

垃圾回收器小結

垃圾回收器名稱	特性	目前工作分代	回收算法	可否與Serial配合	可否與ParNew配合	可否與ParallelScavenge配合	可否與SerialOld配合	可否與ParallelOld配合	可否與CMS配合	可否與G1配合
Serial	單線程	新生代	複製	–	–	–	Y	N	Y	N/A
ParNew	多線程	新生代	複製	–	–	–	N	N	Y	N/A
ParallelScavenge	多線程, 更關注吞吐量可調節	新生代	複製	–	–	–	N	N	Y	N/A
SerialOld	單線程	老年代	標記-整理	–	–	–	Y	Y	N	N/A
ParallelOld	多線程	老年代	標記-整理	N	N	Y	–	–	–	N/A
CMS	多線程，併發收集，低停頓。但無法處理浮動垃圾，標記-清除會產生內存碎片較多	老年代	標記-清除	Y	Y	N	Y	–	–	N/A
G1	并行併發收集，追求可預測但回收時間，整體內存模型有所變化	新生代/老年代	整體是標記-整理，局部(兩Region)複製	N	N	N	N	N	N	–

在本系列的上一篇文章中，減少FullGC的方式是使用G1代替CMS，計劃在下一篇文章中對比CMS和G1的區別。

理解GC日誌

只舉比較簡單的例子，具體各項的格式視情況分析，不同回收器也會有差異。

2019-11-22T10:28:32.177+0800: 60188.392: [GC (Allocation Failure) 2019-11-22T10:28:32.178+0800: 60188.392: [ParNew: 1750382K->2520K(1922432K), 0.0312604 secs] 1945718K->198045K(4019584K), 0.0315892 secs] [Times: user=0.09 sys=0.01, real=0.03 secs]

開始時間-(方括號[)-發生區域(ParNew，命名和GC回收器有關)-回收前大小-回收后大小-(方括號])-GC前堆已使用容量-GC后堆已使用容量大小-回收時間-使用時間詳情(用戶態時間-內核時間-牆上時鐘時間)

注意這裏沒有包括“2019-11-22T10:28:32.177+0800: 60188.392: [GC (Allocation Failure)”這部分的分析。

可借鑒的編程模式

對象分配的併發控制

對象創建是很頻繁的，在線程共享的堆中會遇到併發的問題。兩種解決辦法：

同步鎖定：CAS+失敗重試，確保原子性
堆中預先給每個線程劃分一小塊內存區域——本地線程分配緩衝(TLAB)，TLAB使用完並分配新的TLAB時才做同步鎖定。可看作1的優化。

CAS: Conmpare And Swap，用於實現多線程同步的原子指令。將內存位置的內容與給定值進行比較，只有在相同的情況下，將該內存位置的內容修改為新的給定值。關於CAS可以參考：

對象訪問的定位方式

前提條件：通過棧上本地變量表的reference訪問堆中的對象及它在方法區的對象類型數據(類信息)
主流的兩種方式，這兩種方式各有優點，可以看出方式2是方式1的優化，但並不是全面超越方式1，無法完全取代。
這裏可以看到要權衡垃圾回收和訪問速度兩方面。

方式1: 直接指針訪問實例數據

reference直接存放對象實例地址，只需要一次訪問即可，執行效率較高。

方式2: 使用句柄池

reference中地址穩定，對象被移動時只需要改句柄池的地址。相對的，訪問實例需要兩次指針定位。

參考資料

周志明.著《深入理解JAVA虛擬機》

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

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

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

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

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

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

2020-03-03

類加載器 – ClassLoader詳解

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

獲得ClassLoader的途徑

獲得當前類的ClassLoader
- clazz.getClassLoader()
獲得當前線程上下文的ClassLoader
- Thread.currentThread().getContextClassLoader();
獲得系統的ClassLoader
- ClassLoader.getSystemClassLoader()
獲得調用者的ClassLoader
- DriverManager.getCallerClassLoader

ClassLoader源碼解析

概述

類加載器是用於加載類的對象，ClassLoader是一個抽象類。如果我們給定了一個類的二進制名稱，類加載器應嘗試去定位或生成構成定義類的數據。一種典型的策略是將給定的二進制名稱轉換為文件名，然後去文件系統中讀取這個文件名所對應的class文件。

每個Class對象都會包含一個定義它的ClassLoader的一個引用。

數組類的Class對象，不是由類加載器去創建的，而是在Java運行期JVM根據需要自動創建的。對於數組類的類加載器來說，是通過Class.getClassLoader()返回的，與數組當中元素類型的類加載器是一樣的；如果數組當中的元素類型是一個原生類型，數組類是沒有類加載器的【代碼一】。

應用實現了ClassLoader的子類是為了擴展JVM動態加載類的方式。

類加載器典型情況下時可以被安全管理器所使用去標識安全域問題。

ClassLoader類使用了委託模型來尋找類和資源，ClassLoader的每一個實例都會有一個與之關聯的父ClassLoader，當ClassLoader被要求尋找一個類或者資源的時候，ClassLoader實例在自身嘗試尋找類或者資源之前會委託它的父類加載器去完成。虛擬機內建的類加載器，稱之為啟動類加載器，是沒有父加載器的，但是可以作為一個類加載器的父類加載器【雙親委託機制】。

支持併發類加載的類加載器叫做并行類加載器，要求在初始化期間通過ClassLoader.registerAsParallelCapable 方法註冊自身，ClassLoader類默認被註冊為可以并行，但是如果它的子類也是并行加載的話需要單獨去註冊子類。

在委託模型不是嚴格的層次化的環境下，類加載器需要并行，否則類加載會導致死鎖，因為加載器的鎖在類加載過程中是一直被持有的。

通常情況下，Java虛擬機以平台相關的形式從本地的文件系統中加載類，比如在UNIX系統，虛擬機從CLASSPATH環境所定義的目錄加載類。
然而，有些類並不是來自於文件；它們是從其它來源得到的，比如網絡，或者是由應用本身構建【動態代理】。定義類（defineClass ）方法會將字節數組轉換為Class的實例，這個新定義類的實例可以由Class.newInstance創建。

由類加載器創建的對象的方法和構造方法可能引用其它的類，為了確定被引用的類，Java虛擬機會調用最初創建類的類加載器的loadClass方法。

二進制名稱：以字符串參數的形式向CalssLoader提供的任意一個類名，必須是一個二進制的名稱，包含以下四種情況

“java.lang.String” 正常類

“javax.swing.JSpinner$DefaultEditor” 內部類

“java.security.KeyStore$Builder$FileBuilder$1″ KeyStore的內部類Builder的內部類FileBuilder的第一個匿名內部類

“java.net.URLClassLoader$3$1” URLClassLoader類的第三個匿名內部類的第一個匿名內部類

代碼一：

public class Test12 {
    public static void main(String[] args) {
        String[] strings = new String[6];
        System.out.println(strings.getClass().getClassLoader());
        // 運行結果：null

        Test12[] test12s = new Test12[1];
        System.out.println(test12s.getClass().getClassLoader());
        // 運行結果：sun.misc.Launcher$AppClassLoader@18b4aac2

        int[] ints = new int[2];
        System.out.println(ints.getClass().getClassLoader());
        // 運行結果：null
    }
}

loadClass方法

loadClass的源碼如下， loadClass方法加載擁有指定的二進制名稱的Class，默認按照如下順序尋找類：

調用findLoadedClass(String)檢查這個類是否被加載
調用父類加載器的loadClass方法，如果父類加載器為null，就會調用啟動類加載器
調用findClass(String)方法尋找

使用上述步驟如果類被找到且resolve為true，就會去調用resolveClass(Class)方法

protected Class<?> loadClass(String name, boolean resolve)
  throws ClassNotFoundException
{
  synchronized (getClassLoadingLock(name)) {
      // First, check if the class has already been loaded
      Class<?> c = findLoadedClass(name);
      if (c == null) {
          long t0 = System.nanoTime();
          try {
              if (parent != null) {
                  c = parent.loadClass(name, false);
              } else {
                  c = findBootstrapClassOrNull(name);
              }
          } catch (ClassNotFoundException e) {
              // ClassNotFoundException thrown if class not found
              // from the non-null parent class loader
          }

          if (c == null) {
              // If still not found, then invoke findClass in order
              // to find the class.
              long t1 = System.nanoTime();
              c = findClass(name);

              // this is the defining class loader; record the stats
              sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
              sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
              sun.misc.PerfCounter.getFindClasses().increment();
          }
      }
      if (resolve) {
          resolveClass(c);
      }
      return c;
  }
}

findClass方法

findClass的源碼如下，findClass尋找擁有指定二進制名稱的類，JVM鼓勵我們重寫此方法，需要自定義加載器遵循雙親委託機制，該方法會在檢查完父類加載器之後被loadClass方法調用，默認返回ClassNotFoundException異常。

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

defineClass方法

defineClass的源碼如下，defineClass方法將一個字節數組轉換為Class的實例。

protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                     ProtectionDomain protectionDomain)
    throws ClassFormatError
{
    protectionDomain = preDefineClass(name, protectionDomain);
    String source = defineClassSourceLocation(protectionDomain);
    Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
    postDefineClass(c, protectionDomain);
    return c;
}

自定義類加載器

/**
 * 繼承了ClassLoader，這是一個自定義的類加載器
 * @author 夜的那種黑丶
 */
public class ClassLoaderTest extends ClassLoader {
    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
       Class<?> clazz = loader.loadClass("classloader.Test01");
        Object object = clazz.newInstance();
        System.out.println(object);
        System.out.println(object.getClass().getClassLoader());
    }
    //------------------------------以上為測試代碼---------------------------------

    /**
     * 類加載器名稱，標識作用
     */
    private String classLoaderName;

    /**
     * 從磁盤讀物字節碼文件的擴展名
     */
    private String fileExtension = ".class";

    /**
     * 創建一個類加載器對象，將系統類加載器當做該類加載器的父加載器
     * @param classLoaderName 類加載器名稱
     */
    private ClassLoaderTest(String classLoaderName) {
        // 將系統類加載器當做該類加載器的父加載器
        super();
        this.classLoaderName = classLoaderName;
    }

    /**
     * 創建一個類加載器對象，显示指定該類加載器的父加載器
     * 前提是需要有一個類加載器作為父加載器
     * @param parent 父加載器
     * @param classLoaderName 類加載器名稱
     */
    private ClassLoaderTest(ClassLoader parent, String classLoaderName) {
        // 显示指定該類加載器的父加載器
        super(parent);
        this.classLoaderName = classLoaderName;
    }

    /**
     * 尋找擁有指定二進制名稱的類，重寫ClassLoader類的同名方法，需要自定義加載器遵循雙親委託機制
     * 該方法會在檢查完父類加載器之後被loadClass方法調用
     * 默認返回ClassNotFoundException異常
     * @param className 類名
     * @return Class的實例
     * @throws ClassNotFoundException 如果類不能被找到，拋出此異常
     */
    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        byte[] data = this.loadClassData(className);
        /*
         * 通過defineClass方法將字節數組轉換為Class
         * defineClass：將一個字節數組轉換為Class的實例，在使用這個Class之前必須要被解析
         */
        return this.defineClass(className, data, 0 , data.length);
    }

    /**
     * io操作，根據類名找到對應文件，返回class文件的二進制信息
     * @param className 類名
     * @return class文件的二進制信息
     * @throws ClassNotFoundException 如果類不能被找到，拋出此異常
     */
    private byte[] loadClassData(String className) throws ClassNotFoundException {
        InputStream inputStream = null;
        byte[] data;
        ByteArrayOutputStream byteArrayOutputStream = null;

        try {
            this.classLoaderName = this.classLoaderName.replace(".", "/");
            inputStream = new FileInputStream(new File(className + this.fileExtension));
            byteArrayOutputStream = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = inputStream.read())) {
                byteArrayOutputStream.write(ch);
            }

            data = byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            throw new ClassNotFoundException();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (byteArrayOutputStream != null) {
                    byteArrayOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return data;
    }
}

以上是一段自定義類加載器的代碼，我們執行這段代碼

classloader.Test01@7f31245a
sun.misc.Launcher$AppClassLoader@18b4aac2

可以看見，這段代碼中進行類加載的類加載器還是系統類加載器（AppClassLoader）。這是因為jvm的雙親委託機製造成的，private ClassLoaderTest(String classLoaderName)將系統類加載器當做我們自定義類加載器的父加載器，jvm的雙親委託機制使自定義類加載器委託系統類加載器完成加載。

改造以下代碼，添加一個path屬性用來指定類加載位置：

public class ClassLoaderTest extends ClassLoader {
    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
        loader.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
        Class<?> clazz = loader.loadClass("classloader.Test01");
        System.out.println("class:" + clazz);

        Object object = clazz.newInstance();
        System.out.println(object);
        System.out.println(object.getClass().getClassLoader());
    }
    //------------------------------以上為測試代碼---------------------------------

    /**
     * 從指定路徑加載
     */
    private String path;

    ......
    
    /**
     * io操作，根據類名找到對應文件，返回class文件的二進制信息
     * @param className 類名
     * @return class文件的二進制信息
     * @throws ClassNotFoundException 如果類不能被找到，拋出此異常
     */
    private byte[] loadClassData(String className) throws ClassNotFoundException {
        InputStream inputStream = null;
        byte[] data;
        ByteArrayOutputStream byteArrayOutputStream = null;

        className = className.replace(".", "/");

        try {
            this.classLoaderName = this.classLoaderName.replace(".", "/");
            inputStream = new FileInputStream(new File(this.path + className + this.fileExtension));
            byteArrayOutputStream = new ByteArrayOutputStream();

            int ch;
            while (-1 != (ch = inputStream.read())) {
                byteArrayOutputStream.write(ch);
            }

            data = byteArrayOutputStream.toByteArray();
        } catch (Exception e) {
            throw new ClassNotFoundException();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }
                if (byteArrayOutputStream != null) {
                    byteArrayOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return data;
    }

    public void setPath(String path) {
        this.path = path;
    }
}

運行一下

class:class classloader.Test01
classloader.Test01@7f31245a
sun.misc.Launcher$AppClassLoader@18b4aac2

修改一下測試代碼，並刪除工程下的Test01.class文件

public static void main(String[] args) throws Exception {
    ClassLoaderTest loader = new ClassLoaderTest("loader");
   loader.setPath("/home/fanxuan/桌面/");
    Class<?> clazz = loader.loadClass("classloader.Test01");
    System.out.println("class:" + clazz);

    Object object = clazz.newInstance();
    System.out.println(object);
    System.out.println(object.getClass().getClassLoader());
}

運行一下

class:class classloader.Test01
classloader.Test01@135fbaa4
classloader.ClassLoaderTest@7f31245a

分析

改造后的兩塊代碼，第一塊代碼中加載類的是系統類加載器AppClassLoader，第二塊代碼中加載類的是自定義類加載器ClassLoaderTest。是因為ClassLoaderTest會委託他的父加載器AppClassLoader加載class，第一塊代碼的path直接是工程下，AppClassLoader可以加載到，而第二塊代碼的path在桌面目錄下，所以AppClassLoader無法加載到，然後ClassLoaderTest自身嘗試加載並成功加載到。如果第二塊代碼工程目錄下的Test01.class文件沒有被刪除，那麼依然是AppClassLoader加載。

再來測試一塊代碼

public static void main(String[] args) throws Exception {
    ClassLoaderTest loader = new ClassLoaderTest("loader");
    loader.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
    Class<?> clazz = loader.loadClass("classloader.Test01");
    System.out.println("class:" + clazz.hashCode());

    Object object = clazz.newInstance();
    System.out.println(object.getClass().getClassLoader());

    ClassLoaderTest loader2 = new ClassLoaderTest("loader");
    loader2.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
    Class<?> clazz2 = loader2.loadClass("classloader.Test01");
    System.out.println("class:" + clazz2.hashCode());

    Object object2 = clazz2.newInstance();
    System.out.println(object2.getClass().getClassLoader());
}

結果顯而易見，類由系統類加載器加載，並且clazz和clazz2是相同的。

class:2133927002
sun.misc.Launcher$AppClassLoader@18b4aac2
class:2133927002
sun.misc.Launcher$AppClassLoader@18b4aac2

在改造一下

public static void main(String[] args) throws Exception {
    ClassLoaderTest loader = new ClassLoaderTest("loader");
    loader.setPath("/home/fanxuan/桌面/");
    Class<?> clazz = loader.loadClass("classloader.Test01");
    System.out.println("class:" + clazz.hashCode());

    Object object = clazz.newInstance();
    System.out.println(object.getClass().getClassLoader());

    ClassLoaderTest loader2 = new ClassLoaderTest("loader2");
    loader2.setPath("/home/fanxuan/桌面/");
    Class<?> clazz2 = loader2.loadClass("classloader.Test01");
    System.out.println("class:" + clazz2.hashCode());

    Object object2 = clazz2.newInstance();
    System.out.println(object2.getClass().getClassLoader());
}

運行結果

class:325040804
classloader.ClassLoaderTest@7f31245a
class:621009875
classloader.ClassLoaderTest@45ee12a7

ClassLoaderTest是顯而易見，但是clazz和clazz2是不同的，這是因為類加載器的命名空間的原因。

我們可以通過設置父類加載器來讓loader和loader2處於同一命名空間

public static void main(String[] args) throws Exception {
    ClassLoaderTest loader = new ClassLoaderTest("loader");
    loader.setPath("/home/fanxuan/桌面/");
    Class<?> clazz = loader.loadClass("classloader.Test01");
    System.out.println("class:" + clazz.hashCode());

    Object object = clazz.newInstance();
    System.out.println(object.getClass().getClassLoader());

    ClassLoaderTest loader2 = new ClassLoaderTest(loader, "loader2");
    loader2.setPath("/home/fanxuan/桌面/");
    Class<?> clazz2 = loader2.loadClass("classloader.Test01");
    System.out.println("class:" + clazz2.hashCode());

    Object object2 = clazz2.newInstance();
    System.out.println(object2.getClass().getClassLoader());
}

運行結果

class:325040804
classloader.ClassLoaderTest@7f31245a
class:325040804
classloader.ClassLoaderTest@7f31245a

擴展：命名空間

每個類加載器都有自己的命名空間，命名空間由該加載器及所有的父加載器所加載的類組成
在同一命名空間中，不會出現類的完整名字（包括類的包名）相同的兩個類
在不同的命名空間中，有可能會出現類的完整名字（包括類的包名）相同的兩個類

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

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

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

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

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

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

2020-03-02

Spring Boot2 系列教程(二十六)Spring Boot 整合 Redis

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

在 Redis 出現之前，我們的緩存框架各種各樣，有了 Redis ，緩存方案基本上都統一了，關於 Redis，松哥之前有一個系列教程，尚不了解 Redis 的小夥伴可以參考這個教程：

使用 Java 操作 Redis 的方案很多，Jedis 是目前較為流行的一種方案，除了 Jedis ，還有很多其他解決方案，如下：

除了這些方案之外，還有一個使用也相當多的方案，就是 Spring Data Redis。

在傳統的 SSM 中，需要開發者自己來配置 Spring Data Redis ，這個配置比較繁瑣，主要配置 3 個東西：連接池、連接器信息以及 key 和 value 的序列化方案。

在 Spring Boot 中，默認集成的 Redis 就是 Spring Data Redis，默認底層的連接池使用了 lettuce ，開發者可以自行修改為自己的熟悉的，例如 Jedis。

Spring Data Redis 針對 Redis 提供了非常方便的操作模板 RedisTemplate 。這是 Spring Data 擅長的事情，那麼接下來我們就來看看 Spring Boot 中 Spring Data Redis 的具體用法。

方案一：Spring Data Redis

創建工程

創建工程，引入 Redis 依賴：

創建成功后，還需要手動引入 commos-pool2 的依賴，因此最終完整的 pom.xml 依賴如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

這裏主要就是引入了 Spring Data Redis + 連接池。

配置 Redis 信息

接下來配置 Redis 的信息，信息包含兩方面，一方面是 Redis 的基本信息，另一方面則是連接池信息:

spring.redis.database=0
spring.redis.password=123
spring.redis.port=6379
spring.redis.host=192.168.66.128
spring.redis.lettuce.pool.min-idle=5
spring.redis.lettuce.pool.max-idle=10
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=1ms
spring.redis.lettuce.shutdown-timeout=100ms

自動配置

當開發者在項目中引入了 Spring Data Redis ，並且配置了 Redis 的基本信息，此時，自動化配置就會生效。

我們從 Spring Boot 中 Redis 的自動化配置類中就可以看出端倪：

@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
                    RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
    }
    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(
                    RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
    }
}

這個自動化配置類很好理解：

首先標記這個是一個配置類，同時該配置在 RedisOperations 存在的情況下才會生效(即項目中引入了 Spring Data Redis)
然後導入在 application.properties 中配置的屬性
然後再導入連接池信息（如果存在的話）
最後，提供了兩個 Bean ，RedisTemplate 和 StringRedisTemplate ，其中 StringRedisTemplate 是 RedisTemplate 的子類，兩個的方法基本一致，不同之處主要體現在操作的數據類型不同，RedisTemplate 中的兩個泛型都是 Object ，意味者存儲的 key 和 value 都可以是一個對象，而 StringRedisTemplate 的兩個泛型都是 String ，意味者 StringRedisTemplate 的 key 和 value 都只能是字符串。如果開發者沒有提供相關的 Bean ，這兩個配置就會生效，否則不會生效。

使用

接下來，可以直接在 Service 中注入 StringRedisTemplate 或者 RedisTemplate 來使用：

@Service
public class HelloService {
    @Autowired
    RedisTemplate redisTemplate;
    public void hello() {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("k1", "v1");
        Object k1 = ops.get("k1");
        System.out.println(k1);
    }
}

Redis 中的數據操作，大體上來說，可以分為兩種：

針對 key 的操作，相關的方法就在 RedisTemplate 中
針對具體數據類型的操作，相關的方法需要首先獲取對應的數據類型，獲取相應數據類型的操作方法是 opsForXXX

調用該方法就可以將數據存儲到 Redis 中去了，如下：

k1 前面的字符是由於使用了 RedisTemplate 導致的，RedisTemplate 對 key 進行序列化之後的結果。

RedisTemplate 中，key 默認的序列化方案是 JdkSerializationRedisSerializer 。

而在 StringRedisTemplate 中，key 默認的序列化方案是 StringRedisSerializer ，因此，如果使用 StringRedisTemplate ，默認情況下 key 前面不會有前綴。

不過開發者也可以自行修改 RedisTemplate 中的序列化方案，如下:

@Service
public class HelloService {
    @Autowired
    RedisTemplate redisTemplate;
    public void hello() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("k1", "v1");
        Object k1 = ops.get("k1");
        System.out.println(k1);
    }
}

當然也可以直接使用 StringRedisTemplate：

@Service
public class HelloService {
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    public void hello2() {
        ValueOperations ops = stringRedisTemplate.opsForValue();
        ops.set("k2", "v2");
        Object k1 = ops.get("k2");
        System.out.println(k1);
    }
}

另外需要注意，Spring Boot 的自動化配置，只能配置單機的 Redis ，如果是 Redis 集群，則所有的東西都需要自己手動配置，關於如何操作 Redis 集群，松哥以後再來和大家分享。

方案二：Spring Cache

通過 Spring Cache 的形式來操作 Redis，Spring Cache 統一了緩存江湖的門面，這種方案，松哥之前有過一篇專門的文章介紹，小夥伴可以移步這裏：。

方案三：回歸原始時代

第三種方案，就是直接使用 Jedis 或者其他的客戶端工具來操作 Redis ，這種方案在 Spring Boot 中也是支持的，雖然操作麻煩，但是支持，這種操作松哥之前也有介紹的文章，因此這裏就不再贅述了，可以參考。

總結

Spring Boot 中，Redis 的操作，這裏松哥給大家總結了三種方案，實際上前兩個使用廣泛一些，直接使用 Jedis 還是比較少，基本上 Spring Boot 中沒見過有人直接這麼搞。

好了，本文就說到這裏，有問題歡迎留言討論。

相關案例已經上傳到 GitHub，歡迎小夥伴們們下載：

掃碼關注松哥，公眾號後台回復 2TB，獲取松哥獨家超2TB 免費 Java 學習乾貨

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

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

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

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

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

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

2020-02-27

電動車環島不是夢，特斯拉7月將於台灣完成250座充電站

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

一台特斯拉隨隨便便就要兩、三百萬元台幣的價碼，讓不少喜愛電動車有效率、環保特性的人無法輕易擁有。特斯拉宣布他們跟台灣本地銀行提供的優惠方案，最低每月負擔36,000 元台幣，就可以將特斯拉車子開回家。另外特斯拉的超級充電站也將遍布全台，開著特斯拉環島將不是夢想。

在上週五（6/16）特斯拉Model X 交車派對上，特斯拉香港、澳門及台灣地區區域總監范菁怡表示，在台灣由星展銀行提供的優惠方案，每月最少花36,000 元，就可以開著特斯拉回家。或車主開了3 年之後，除了繼續繳每月的費用，也可以選擇回購專案，將車子賣回給特斯拉。特斯拉也有與車行合作模式，可採租賃模式駕駛特斯拉車。以上幾項不同的方案，供車主依自己的需求選擇最適合的方案。

特斯拉表示，到了7 月，開特斯拉車環島也不會是問題。台灣中部、南部的台南、高雄都將在高速公路交流道一帶設置超級充電站，而東部也會有超級充電站。未來開著特斯拉享受環島行程不再是夢想。Tesla 於今年第二季末正式在台完成超過250 座目的地充電站，分布於全台80 個地點。

▲ 在派對上交車的車輛，5~7 人座都有。

另外不少車主期待的自動輔助駕駛2.0 版與導航功能也將在台啟用，為全世界第一批啟用國家之一。不論是自動輔助轉向、跟車、防撞預警、自動換導、自動停車或是召換功能，都能在台灣使用。未來Model S 或Model X 開在台灣的道路上，透過OTA 機制更新，能夠累積台灣路況，提供最好的駕駛體驗。

▲ 特斯拉與車行合作，提供駕駛特斯拉車的不同方式。

儘管在交車派對上車主是主角，但特斯拉宣布了不少優惠專案。對車主來說，可在一個月內免費申請安裝家用充電設備，另外還有機會到SpaceX 參觀！

▲ 特斯拉在台灣與星展銀行合作，推出特斯拉優惠方案。

（合作媒體：。圖片出處：科技新報）

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

【其他文章推薦】

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

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

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

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

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

2020-02-26

Json模塊和Pickle模塊的使用

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

在對數據進行序列化和反序列化是常見的數據操作，Python提供了兩個模塊方便開發者實現數據的序列化操作，即 json 模塊和 pickle 模塊。這兩個模塊主要區別如下：

json 是一個文本序列化格式，而 pickle 是一個二進制序列化格式；
json 是我們可以直觀閱讀的，而 pickle 不可以；
json 是可互操作的，在 Python 系統之外廣泛使用，而 pickle 則是 Python 專用的；
默認情況下，json 只能表示 Python 內置類型的子集，不能表示自定義的類；但 pickle 可以表示大量的 Python 數據類型。

Json 模塊

Json 是一種輕量級的數據交換格式，由於其具有傳輸數據量小、數據格式易解析等特點，它被廣泛應用於各系統之間的交互操作，作為一種數據格式傳遞數據。它包含多個常用函數，具體如下：

dumps()函數

dumps()函數可以將 Python 對象編碼成 Json 字符串。例如：

#字典轉成json字符串 加上ensure_ascii=False以後，可以識別中文， indent=4是間隔4個空格显示

import json         
d={'小明':{'sex':'男','addr':'上海','age':26},'小紅':{ 'sex':'女','addr':'上海', 'age':24},}
print(json.dumps(d,ensure_ascii=False,indent=4))

#執行結果：
{
    "小明": {
        "sex": "男",
        "addr": "上海",
        "age": 26
    },
    "小紅": {
        "sex": "女",
        "addr": "上海",
        "age": 24
    }
}

dump()函數

dump()函數可以將 Python對象編碼成 json 字符串，並自動寫入到文件中，不需要再單獨寫文件。例如：

#字典轉成json字符串,不需要寫文件，自動轉成的json字符串寫入到‘users.json’的文件中 
import json                                                                         
d={'小明':{'sex':'男','addr':'上海','age':26},'小紅':{ 'sex':'女','addr':'上海', 'age':24},}
#打開一個名字為‘users.json’的空文件
fw =open('users.json','w',encoding='utf-8')

json.dump(d,fw,ensure_ascii=False,indent=4)

loads()函數

loads()函數可以將 json 字符串轉換成 Python 的數據類型。例如：

#這是users.json文件中的內容
{
    "小明":{
        "sex":"男",
        "addr":"上海",
        "age":26
    },
    "小紅":{
        "sex":"女",
        "addr":"上海",
        "age":24
    }
}

#!/usr/bin/python3
#把json串變成python的數據類型   
import json  
#打開‘users.json’的json文件
f =open('users.json','r',encoding='utf-8')
#讀文件
res=f.read()
print(json.loads(res))

#執行結果：
{'小明': {'sex': '男', 'addr': '上海', 'age': 26}, '小紅': {'sex': '女', 'addr': '上海', 'age': 24}}

load()函數

load()跟loads()功能相似，load()函數可以將 json 字符串轉換成 Python 數據類型，不同的是前者的參數是一個文件對象，不需要再單獨讀此文件。例如：

#把json串變成python的數據類型：字典，傳一個文件對象，不需要再單獨讀文件 
import json   
#打開文件
f =open('users.json','r',encoding='utf-8') 
print(json.load(f))

#執行結果：
{'小明': {'sex': '男', 'addr': '上海', 'age': 26}, '小紅': {'sex': '女', 'addr': '上海', 'age': 24}}

Pickle 模塊

Pickle 模塊與 Json 模塊功能相似，也包含四個函數，即 dump()、dumps()、loads() 和 load()，它們的主要區別如下：

dumps 和 dump 的區別在於前者是將對象序列化，而後者是將對象序列化並保存到文件中。
loads 和 load 的區別在於前者是將序列化的字符串反序列化，而後者是將序列化的字符串從文件讀取並反序列化。

dumps()函數

dumps()函數可以將數據通過特殊的形式轉換為只有python語言認識的字符串，例如：

import pickle
# dumps功能
import pickle
data = ['A', 'B', 'C','D']  
print(pickle.dumps(data))

b'\x80\x03]q\x00(X\x01\x00\x00\x00Aq\x01X\x01\x00\x00\x00Bq\x02X\x01\x00\x00\x00Cq\x03X\x01\x00\x00\x00Dq\x04e.'

dump()函數

dump()函數可以將數據通過特殊的形式轉換為只有python語言認識的字符串，並寫入文件。例如：

# dump功能
with open('test.txt', 'wb') as f:
    pickle.dump(data, f)
print('寫入成功')

寫入成功

loads()函數

loads()函數可以將pickle數據轉換為python的數據結構。例如：

# loads功能
msg = pickle.loads(datastr)
print(msg)

['A', 'B', 'C', 'D']

load()函數

load()函數可以從數據文件中讀取數據，並轉換為python的數據結構。例如：

# load功能
with open('test.txt', 'rb') as f:
   data = pickle.load(f)
print(data)

['A', 'B', 'C', 'D']

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

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

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

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

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

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

2020-02-25

特斯拉正式打造出第一輛Model 3！馬斯克大秀美照

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

千呼萬喚始出來！特斯拉（Tesla Inc.）終於在上週六（7月8日）順利生產出第一輛平價電動車「Model 3」（見圖），執行長馬斯克（Elon Musk）透過Twitter發布這個訊息後（），還特地秀出兩張官方照片（、）。

馬斯克在推文中表示，創投機構DBL Partners創辦人Ira Ehrenpreis原本已經下了訂金、買下第一輛Model 3，但Ehrenpreis決定把擁有第一輛Model 3的權利讓給馬斯克，作為他46歲的生日禮物。

Model 3定價35,000美元，不少人將之視為特斯拉豪華電動車「Model S」的平價版。這款全新轎車體型嬌小，但同樣也會有自駕功能，預料每次充電的里程數將有215英里。

特斯拉預定7月底生產30輛Model 3，12月會將月產能拉高至2萬輛，等於是一年生產24萬輛。至少已有38萬人支付1,000美元的訂金（可退款），但特斯拉從去年初就未曾更新過這項數據。第一批顧客只有兩種選擇：顏色和輪胎尺寸。

過去一週對特斯拉來說並不好過，第2季交貨量不如預期，再加上富豪集團（Volvo）宣布2019年起所有車款都會是電動車、成為第一家這麼做的傳統車廠，導致特斯拉股價從兩週前的386.99美元歷史高一路大跌近20%。

特斯拉才剛於7月3日公布，第2季的電動車交貨量僅略高於22,000台，不如前季的25,000台，主要是受到100 kWh電池組產能嚴重短缺的影響。特斯拉說，截至6月初為止，電池組的生產量平均比需求短少了40%。

不過，特斯拉股價在連續大跌三個交易日後，上週五（7月7日）反彈1.42%、收313.22美元。路透社報導，特斯拉表示，第二季底大約有3,500輛電動車還在運送途中、尚未交貨給客戶，這些車可在Q3計入交貨量。

（本文內容由授權使用。圖片出處：Elon Musk Twitter）

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

【其他文章推薦】

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

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

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

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

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

2020-02-21

Gogoro 雲嘉地區電池交換站正式啟用，暢騎基隆到屏東

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

Gogoro 車主們期待已久的雲嘉地區電池交換站21 日正式開通提供服務。未來，Gogoro 的車主將可以騎乘Smartscooter 智慧雙輪縱貫台灣西半部，一路從基隆暢騎到屏東。

Gogoro 於21 日宣布，雲林嘉義地區首批5 座GoStation 電池交換站正式上線，其中兩站位於雲林斗六、虎尾；另三站則分布於嘉義市區。自從Gogoro 於2015 年在台北市設立首座電池交換站以來，短短兩年的時間，已經建置將近400 座電池交換站，廣布於基隆到屏東的各個縣市，在六都甚至不到一公里就設有一站，累積提供將近500 萬次的電池交換服務，是全世界最穩定的電池交換能源網路系統。

Gogoro 台灣區行銷總監陳彥揚表示: 「雲嘉地區GoStation 電池交換站的開通有3 個劃時代的意義。首先，我們顛覆消費者對於電動機車續航力不足的刻板印象；兩年前，沒有人會相信，我們可以騎乘電動機車橫跨北高。其次，對Gogoro 車主而言，Gogoro 將不再僅是都會的通勤工具，而是更進一步深入他們的生活，成為跨縣市旅遊的另一種交通選擇；最後，我們則提供雲嘉地區民眾一個能夠改善當地空污，讓生活環境更環保、更健康的解決方案。」

日前宣布Gogoro 2 系列預購超過13,000 台，震撼市場的Gogoro 在雲林嘉義地區提供電池交換站的服務後，搭配雲嘉地區相對較高的電動機車補助，將加速當地居民的購車意願。目前，雲林縣汰換二行程機車購買電動機車的總補助金額達34,000 元，嘉義市為31,000 元，嘉義縣則為21,000 元。Gogoro 也正規劃在不久的將來於雲嘉地區增設銷售及維修據點，希望很快可以讓雲嘉的居民享有Gogoro 完整的銷售、維修、電池交換等全方位服務。

（合作媒體：。圖片出處：科技新報）

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

【其他文章推薦】

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

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

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

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

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

2020-02-20

MachO文件詳解–逆向開發

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

今天是逆向開發的第5天內容–MachO文件（Mac 和 iOS 平台可執行的文件），在逆向開發中是比較重要的，下面我們着重講解一下MachO文件的基本內容和使用。

一、MachO概述

1. 概述

Mach-O是Mach Object文件格式的縮寫，iOS以及Mac上可執行的文件格式，類似Window的exe格式，Linux上的elf格式。Mach-O是一個可執行文件、動態庫以及目標代碼的文件格式，是a.out格式的替代，提供了更高更強的擴展性。

2.常見格式

Mach-O常見格式如下：

目標文件 .o
庫文件

.a
.dylib
.framework

可執行文件
dyld
.dsym

　　通過file文件路徑查看文件類型

我們通過部分實例代碼來簡單研究一下。

2.1目標文件.o

通過test.c 文件，可以使用clang命令將其編譯成目標文件.o

我們再通過file命令（如下）查看文件類型

是個Mach-O文件。

2.2 dylib

通過cd /usr/lib命令查看dylib

通過file命令查看文件類型

2.3 .dsym

下面是一個截圖來說明.dsym是也是Mach-O文件格式

以上只是Mach-O常見格式的某一種，大家可以通過命令來嘗試。

3. 通用二進制文件

希望大家在了解App二進制架構的時候，可以先讀一下本人寫的另一篇博客關於armv7，armv7s以及arm64等的介紹。

通用二進制文件是蘋果自身發明的，基本內容如下

下面通過指令查看Macho文件來看下通用二進制文件

然後通過file指令查看文件類型

上面該MachO文件包含了3個架構分別是arm v7，arm v7s 以及arm 64 。

針對該MachO文件我們做幾個操作，利用lipo命令拆分合併架構

3.1 利用lipo-info查看MachO文件架構

3.2 瘦身MachO文件，拆分

利用lipo-thin瘦身架構

查看一下結果如下，多出來一個新建的MachO_armv7

3.3 增加架構，合併

利用lipo -create 合併多種架構

發現多出一種框架，合併成功多出Demo可執行文件。結果如下：

整理出lipo命令如下：

二、MachO文件

2.1 文件結構

下面是蘋果官方圖解釋MachO文件結構圖

MachO文件的組成結構如上，看包括了三個部分

Header包含了該二進制文件的一般信息，信息如下：

字節順序、加載指令的數量以及架構類型
快速的確定一些信息，比如當前文件是32位或者64位，對應的文件類型和處理器是什麼

Load commands 包含很多內容的表

包括區域的位置、動態符號表以及符號表等

Data一般是對象文件的最大部分

一般包含Segement具體數據

2.2 Header的數據結構

在項目代碼中，按下Command+ 空格，然後輸入loader.h

然後查看loader.h文件，找到mach_header

上面是mach_header，對應結構體的意義如下：

通過MachOView查看Mach64 Header頭部信息

2.3 LoadCommands

LoadCommand包含了很多內容的表，通過MachOView查看LoadCommand的信息，圖如下：

但是大家看的可能並不了解內容，下面有圖進行註解，可以看下主要的意思

2.4 Data

Data包含Segement，存儲具體數據，通過MachOView查看，地址映射內容

三、DYLD

3.1 dyld概述

dyld（the dynamic link editor）是蘋果動態鏈接器，是蘋果系統一個重要的組成部分，系統內核做好準備工作之後，剩下的就會交給了dyld。

3.2 dyld加載過程

程序的入口一般都是在main函數中，但是比較少的人關心main()函數之前發生了什麼？這次我們先探索dyld的加載過程。（但是比在main函數之前，load方法就在main函數之前）

3.2.1 新建項目，在main函數下斷

main()之前有個libdyld.dylib start入口，但是不是我們想要的，根據dyld源碼找到__dyld_start函數

3.2.2 dyld main()函數

dyld main()函數是關鍵函數，下面是函數實現內容。（此時的main實現函數和程序App的main 函數是不一樣的，因為dyld也是一個可執行文件，也是具有main函數的）

//
// Entry point for dyld.  The kernel loads dyld and jumps to __dyld_start which
// sets up some registers and call this function.
//
// Returns address of main() in target program which __dyld_start jumps to
//
uintptr_t
_main(const macho_header* mainExecutableMH, uintptr_t mainExecutableSlide, 
        int argc, const char* argv[], const char* envp[], const char* apple[], 
        uintptr_t* startGlue)
{
    // Grab the cdHash of the main executable from the environment
    // 第一步，設置運行環境
    uint8_t mainExecutableCDHashBuffer[20];
    const uint8_t* mainExecutableCDHash = nullptr;
    if ( hexToBytes(_simple_getenv(apple, "executable_cdhash"), 40, mainExecutableCDHashBuffer) )
        // 獲取主程序的hash
        mainExecutableCDHash = mainExecutableCDHashBuffer;

    // Trace dyld's load
    notifyKernelAboutImage((macho_header*)&__dso_handle, _simple_getenv(apple, "dyld_file"));
#if !TARGET_IPHONE_SIMULATOR
    // Trace the main executable's load
    notifyKernelAboutImage(mainExecutableMH, _simple_getenv(apple, "executable_file"));
#endif

    uintptr_t result = 0;
    // 獲取主程序的macho_header結構
    sMainExecutableMachHeader = mainExecutableMH;
    // 獲取主程序的slide值
    sMainExecutableSlide = mainExecutableSlide;

    CRSetCrashLogMessage("dyld: launch started");
    // 設置上下文信息
    setContext(mainExecutableMH, argc, argv, envp, apple);

    // Pickup the pointer to the exec path.
    // 獲取主程序路徑
    sExecPath = _simple_getenv(apple, "executable_path");

    // <rdar://problem/13868260> Remove interim apple[0] transition code from dyld
    if (!sExecPath) sExecPath = apple[0];

    if ( sExecPath[0] != '/' ) {
        // have relative path, use cwd to make absolute
        char cwdbuff[MAXPATHLEN];
        if ( getcwd(cwdbuff, MAXPATHLEN) != NULL ) {
            // maybe use static buffer to avoid calling malloc so early...
            char* s = new char[strlen(cwdbuff) + strlen(sExecPath) + 2];
            strcpy(s, cwdbuff);
            strcat(s, "/");
            strcat(s, sExecPath);
            sExecPath = s;
        }
    }

    // Remember short name of process for later logging
    // 獲取進程名稱
    sExecShortName = ::strrchr(sExecPath, '/');
    if ( sExecShortName != NULL )
        ++sExecShortName;
    else
        sExecShortName = sExecPath;
    
    // 配置進程受限模式
    configureProcessRestrictions(mainExecutableMH);


    // 檢測環境變量
    checkEnvironmentVariables(envp);
    defaultUninitializedFallbackPaths(envp);

    // 如果設置了DYLD_PRINT_OPTS則調用printOptions()打印參數
    if ( sEnv.DYLD_PRINT_OPTS )
        printOptions(argv);
    // 如果設置了DYLD_PRINT_ENV則調用printEnvironmentVariables()打印環境變量
    if ( sEnv.DYLD_PRINT_ENV ) 
        printEnvironmentVariables(envp);
    // 獲取當前程序架構
    getHostInfo(mainExecutableMH, mainExecutableSlide);
    //-------------第一步結束-------------
    
    // load shared cache
    // 第二步，加載共享緩存
    // 檢查共享緩存是否開啟，iOS必須開啟
    checkSharedRegionDisable((mach_header*)mainExecutableMH);
    if ( gLinkContext.sharedRegionMode != ImageLoader::kDontUseSharedRegion ) {
        mapSharedCache();
    }
    ...

    try {
        // add dyld itself to UUID list
        addDyldImageToUUIDList();

        // instantiate ImageLoader for main executable
        // 第三步 實例化主程序
        sMainExecutable = instantiateFromLoadedImage(mainExecutableMH, mainExecutableSlide, sExecPath);
        gLinkContext.mainExecutable = sMainExecutable;
        gLinkContext.mainExecutableCodeSigned = hasCodeSignatureLoadCommand(mainExecutableMH);

        // Now that shared cache is loaded, setup an versioned dylib overrides
    #if SUPPORT_VERSIONED_PATHS
        checkVersionedPaths();
    #endif


        // dyld_all_image_infos image list does not contain dyld
        // add it as dyldPath field in dyld_all_image_infos
        // for simulator, dyld_sim is in image list, need host dyld added
#if TARGET_IPHONE_SIMULATOR
        // get path of host dyld from table of syscall vectors in host dyld
        void* addressInDyld = gSyscallHelpers;
#else
        // get path of dyld itself
        void*  addressInDyld = (void*)&__dso_handle;
#endif
        char dyldPathBuffer[MAXPATHLEN+1];
        int len = proc_regionfilename(getpid(), (uint64_t)(long)addressInDyld, dyldPathBuffer, MAXPATHLEN);
        if ( len > 0 ) {
            dyldPathBuffer[len] = '\0'; // proc_regionfilename() does not zero terminate returned string
            if ( strcmp(dyldPathBuffer, gProcessInfo->dyldPath) != 0 )
                gProcessInfo->dyldPath = strdup(dyldPathBuffer);
        }

        // load any inserted libraries
        // 第四步 加載插入的動態庫
        if  ( sEnv.DYLD_INSERT_LIBRARIES != NULL ) {
            for (const char* const* lib = sEnv.DYLD_INSERT_LIBRARIES; *lib != NULL; ++lib)
                loadInsertedDylib(*lib);
        }
        // record count of inserted libraries so that a flat search will look at 
        // inserted libraries, then main, then others.
        // 記錄插入的動態庫數量
        sInsertedDylibCount = sAllImages.size()-1;

        // link main executable
        // 第五步 鏈接主程序
        gLinkContext.linkingMainExecutable = true;
#if SUPPORT_ACCELERATE_TABLES
        if ( mainExcutableAlreadyRebased ) {
            // previous link() on main executable has already adjusted its internal pointers for ASLR
            // work around that by rebasing by inverse amount
            sMainExecutable->rebase(gLinkContext, -mainExecutableSlide);
        }
#endif
        link(sMainExecutable, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);
        sMainExecutable->setNeverUnloadRecursive();
        if ( sMainExecutable->forceFlat() ) {
            gLinkContext.bindFlat = true;
            gLinkContext.prebindUsage = ImageLoader::kUseNoPrebinding;
        }

        // link any inserted libraries
        // do this after linking main executable so that any dylibs pulled in by inserted 
        // dylibs (e.g. libSystem) will not be in front of dylibs the program uses
        // 第六步 鏈接插入的動態庫
        if ( sInsertedDylibCount > 0 ) {
            for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
                ImageLoader* image = sAllImages[i+1];
                link(image, sEnv.DYLD_BIND_AT_LAUNCH, true, ImageLoader::RPathChain(NULL, NULL), -1);
                image->setNeverUnloadRecursive();
            }
            // only INSERTED libraries can interpose
            // register interposing info after all inserted libraries are bound so chaining works
            for(unsigned int i=0; i < sInsertedDylibCount; ++i) {
                ImageLoader* image = sAllImages[i+1];
                image->registerInterposing();
            }
        }

        // <rdar://problem/19315404> dyld should support interposition even without DYLD_INSERT_LIBRARIES
        for (long i=sInsertedDylibCount+1; i < sAllImages.size(); ++i) {
            ImageLoader* image = sAllImages[i];
            if ( image->inSharedCache() )
                continue;
            image->registerInterposing();
        }
        ...

        // apply interposing to initial set of images
        for(int i=0; i < sImageRoots.size(); ++i) {
            sImageRoots[i]->applyInterposing(gLinkContext);
        }
        gLinkContext.linkingMainExecutable = false;
        
        // <rdar://problem/12186933> do weak binding only after all inserted images linked
        // 第七步 執行弱符號綁定
        sMainExecutable->weakBind(gLinkContext);

        // If cache has branch island dylibs, tell debugger about them
        if ( (sSharedCacheLoadInfo.loadAddress != NULL) && (sSharedCacheLoadInfo.loadAddress->header.mappingOffset >= 0x78) && (sSharedCacheLoadInfo.loadAddress->header.branchPoolsOffset != 0) ) {
            uint32_t count = sSharedCacheLoadInfo.loadAddress->header.branchPoolsCount;
            dyld_image_info info[count];
            const uint64_t* poolAddress = (uint64_t*)((char*)sSharedCacheLoadInfo.loadAddress + sSharedCacheLoadInfo.loadAddress->header.branchPoolsOffset);
            // <rdar://problem/20799203> empty branch pools can be in development cache
            if ( ((mach_header*)poolAddress)->magic == sMainExecutableMachHeader->magic ) {
                for (int poolIndex=0; poolIndex < count; ++poolIndex) {
                    uint64_t poolAddr = poolAddress[poolIndex] + sSharedCacheLoadInfo.slide;
                    info[poolIndex].imageLoadAddress = (mach_header*)(long)poolAddr;
                    info[poolIndex].imageFilePath = "dyld_shared_cache_branch_islands";
                    info[poolIndex].imageFileModDate = 0;
                }
                // add to all_images list
                addImagesToAllImages(count, info);
                // tell gdb about new branch island images
                gProcessInfo->notification(dyld_image_adding, count, info);
            }
        }

        CRSetCrashLogMessage("dyld: launch, running initializers");
        ...
        // run all initializers
        // 第八步 執行初始化方法
        initializeMainExecutable(); 

        // notify any montoring proccesses that this process is about to enter main()
        dyld3::kdebug_trace_dyld_signpost(DBG_DYLD_SIGNPOST_START_MAIN_DYLD2, 0, 0);
        notifyMonitoringDyldMain();

        // find entry point for main executable
        // 第九步 查找入口點並返回
        result = (uintptr_t)sMainExecutable->getThreadPC();
        if ( result != 0 ) {
            // main executable uses LC_MAIN, needs to return to glue in libdyld.dylib
            if ( (gLibSystemHelpers != NULL) && (gLibSystemHelpers->version >= 9) )
                *startGlue = (uintptr_t)gLibSystemHelpers->startGlueToCallExit;
            else
                halt("libdyld.dylib support not present for LC_MAIN");
        }
        else {
            // main executable uses LC_UNIXTHREAD, dyld needs to let "start" in program set up for main()
            result = (uintptr_t)sMainExecutable->getMain();
            *startGlue = 0;
        }
    }
    catch(const char* message) {
        syncAllImages();
        halt(message);
    }
    catch(...) {
        dyld::log("dyld: launch failed\n");
    }
    ...
    
    return result;
}

View Code

摺疊開dyld main函數，步驟總結如下

對待dyld的講述，是非常不易的，因為本身過程是比較複雜的，上面僅僅是自身的抽出來的。下面再畫一張流程圖，幫助大家理解。

四、總結

MachO文件對於逆向開發是非常重要的，通過本次講解，希望對大家理解逆向開發有所幫助，也希望大家真正可以提高技術，應對iOS市場的大環境，下一篇我們將講述Hook原理–逆向開發。謝謝！！！

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

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

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

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

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

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

2020-02-19

Docker基礎與實戰，看這一篇就夠了

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

docker 基礎

什麼是Docker

Docker 使用 Google 公司推出的 Go 語言進行開發實現，基於 Linux 內核的 cgroup，namespace，以及 AUFS 類的 Union FS 等技術，對進程進行封裝隔離，屬於操作系統層面的虛擬化技術。由於隔離的進程獨立於宿主和其它的隔離的進程，因此也稱其為容器。

Docker 在容器的基礎上，進行了進一步的封裝，從文件系統、網絡互聯到進程隔離等等，極大的簡化了容器的創建和維護。使得 Docker 技術比虛擬機技術更為輕便、快捷。

記住最重要的一點，Dokcer實際是宿主機的一個普通的進程，這也是Dokcer與傳統虛擬化技術的最大不同。

為什麼要使用Docker

使用Docker最重要的一點就是Docker能保證運行環境的一致性，不會出現開發、測試、生產由於環境配置不一致導致的各種問題，一次配置多次運行。使用Docker，可更快地打包、測試以及部署應用程序，並可減少從編寫到部署運行代碼的周期。

docker 安裝

Docker 要求 CentOS 系統的內核版本高於 3.10 ，查看本頁面的前提條件來驗證你的CentOS 版本是否支持 Docker 。
uname -r
更新yum,升級到最新版本
yum update
卸載老版本的docker(若有)
yum remove docker docker-common docker-selinux docker-engine
執行該命令只會卸載Docker本身，而不會刪除Docker存儲的文件，例如鏡像、容器、卷以及網絡文件等。這些文件保存在/var/lib/docker 目錄中，需要手動刪除。
查看yum倉庫，查看是否有docker
ll /etc/yum.repos.d/

如果用的廠商的服務器（阿里雲、騰訊雲）一般都會有docker倉庫，如果用的是虛擬機或者公司的服務器基本會沒有。
安裝軟件包, yum-util 提供yum-config-manager功能，另外兩個是devicemapper驅動依賴的
yum install -y yum-utils device-mapper-persistent-data lvm2
安裝倉庫
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
查看docker版本
yum list docker-ce --showduplicates | sort -r
安裝docker
yum install docker-ce
以上語句是是安裝最新版本的Docker，你也可以通過yum install docker-ce-<VERSION> 安裝指定版本
啟動docker
systemctl start docker
驗證安裝是否正確
dokcer run hello-world

docker 重要命令

鏡像相關

搜索鏡像docker search
如docker search nginx Docker就會在Docker Hub中搜索含有“nginx”這個關鍵詞的鏡像倉庫
下載鏡像docker pull
如docker pull nginx Docker就會在Docker Hub中下載含有“nginx”最新版本的鏡像
當然也可以使用docker pull reg.jianzh5.com/nginx:1.7.9 下載指定倉庫地址標籤的nginx鏡像
列出鏡像docker images
刪除鏡像docker rmi
如docker rmi hello-world刪除我們剛剛下載的hello-world鏡像
構建鏡像docker build
通過Dockerfile構建鏡像，這個我們等下再拿出來詳細說明。

容器相關

新建啟動鏡像docker run
這個命令是我們最常用的命令，主要使用以下幾個選項
① -d選項：表示後台運行
② -P選項（大寫）：隨機端口映射
③ -p選項（小寫）：指定端口映射,前面是宿主機端口後面是容器端口，如docker run nginx -p 8080:80，將容器的80端口映射到宿主機的8080端口，然後使用localhost:8080就可以查看容器中nginx的歡迎頁了
④ -v選項：掛載宿主機目錄，前面是宿主機目錄，後面是容器目錄,如docker run -d -p 80:80 -v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf nginx 掛載宿主機的/dockerData/nginx/conf/nginx.conf的文件，這樣就可以在宿主機對nginx進行參數配置了,注意目錄需要用絕對路徑，不要使用相對路徑，如果宿主機目錄不存在則會自動創建。
⑤–rm : 停止容器後會直接刪除容器，這個參數在測試是很有用，如docker run -d -p 80:80 --rm nginx
⑥–name : 給容器起個名字，否則會出現一長串的自定義名稱如 docker run -name niginx -d -p 80:80 - nginx
列出容器 docker ps
這個命令可以列出當前運行的容器，使用-a參數后列出所有的容器（包括已停止的）
停止容器docker stop
docker stop 5d034c6ea010 後面跟的是容器ID，也可以使用容器名稱
啟動停止的容器docker start
docker run是新建容器並啟動，docker start 是啟動停止的容器,如docker start 5d034c6ea010
重啟容器docker restart
此命令執行的過程實際是先執行docker stop,然後再執行docker start，如docker restart 5d034c6ea010
進入容器docker exec -it 容器id /bin/bash
如 docker exec -it 5d034c6ea010 /bin/bash,就相當於進入了容器本身的操作系統
刪除容器 docker rm
如docker rm 5d034c6ea010 後面跟的是容器ID,刪除容器之前需要先停止容器運行
數據拷貝docker cp
此命令用於容器與宿主機之間進行數據拷貝,如 docker cp 5d034c6ea010: /etc/nginx/nginx.conf /dockerData/nginx/conf/nginx.conf 將容器的目錄文件拷貝到宿主機指定位置,容器ID可以替換成容器名。

命令實戰

如果我們需要一個nginx容器，並且需要在宿主機上直接修改nginx的配置文件、默認主頁，在宿主機可以實時看到容器nginx的日誌。我們可以按照如下的方式一步一步完成。

使用–rm參數啟動容器，方便刪除
docker run -d -p 8081:80 --name nginx --rm nginx
進入容器，查看容器中配置文件、項目文件、日誌文件的目錄地址
docker exec -it 9123b67e428e /bin/bash
導出容器的配置文件
docker cp nginx:/etc/nginx/nginx.conf /dockerData/nginx/conf/nginx.conf導出配置文件 nginx.conf
docker cp nginx:/etc/nginx/conf.d /dockerData/nginx/conf/conf.d導出配置目錄 conf.d
停止容器docker stop 9123b67e428e，由於加了–rm參數，容器會自動刪除
再以如下命令啟動容器，完成目錄掛載
shell docker run -d -p 8081:80 --name nginx \ -v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \ -v /dockerData/nginx/conf/conf.d:/etc/nginx/conf.d \ -v /dockerData/nginx/www:/usr/share/nginx/html \ -v /dockerData/nginx/logs:/var/log/nginx nginx
訪問服務器地址http://192.168.136.129:8081/

訪問報錯，這時候就進入宿主機的日誌目錄/dockerData/nginx/logs查看日誌
2019/11/23 10:08:11 [error] 6#6: *1 directory index of “/usr/share/nginx/html/” is forbidden, client: 192.168.136.1, server: localhost, request: “GET / HTTP/1.1”, host: “192.168.136.129:8081”
因為/usr/share/nginx/html/被掛載到了服務器上面的/dockerData/nginx/www目錄下，原來的歡迎頁面在dockerData/nginx/www是沒有的，所有就報錯了，這裏我們隨便建一個。
建立默認主頁
shell #打開項目文件 cd /dockerData/nginx/www #使用vim 創建並編輯文件 vi index.html #此時我們會進入vim界面，按 i 插入，然後輸入 <h1 align="center">Hello,Welcome to Docker World</h1> #輸入完后，按 esc，然後輸入 :wq
再次訪問瀏覽器地址

Dockerfile

我們可以使用Dockfile構建一個鏡像，然後直接在docker中運行。Dockerfile文件為一個文本文件，裡面包含構建鏡像所需的所有的命令，首先我們來認識一下Dockerfile文件中幾個重要的指令。

指令詳解

FROM
選擇一個基礎鏡像，然後在基礎鏡像上進行修改，比如構建一個SpringBoot項目的鏡像，就需要選擇java這個基礎鏡像，FROM需要作為Dockerfile中的第一條指令
如：FROM openjdk:8-jdk-alpine 基礎鏡像如果可以的話最好使用alpine版本的，採用alpline版本的基礎鏡像構建出來的鏡像會小很多。
RUN
RUN指令用來執行命令行命令的。它有一下兩種格式：
- shell 格式：RUN ，就像直接在命令行中輸入的命令一樣。 RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
- exec 格式：RUN [“可執行文件”, “參數1”, “參數2”]，這更像是函數調用中的格式。
CMD
此指令就是用於指定默認的容器主進程的啟動命令的。
CMD指令格式和RUN相似，也是兩種格式
- shell 格式：CMD
- exec 格式：CMD [“可執行文件”, “參數1”, “參數2″…]
- 參數列表格式：CMD [“參數1”, “參數2″…]。在指定了 ENTRYPOINT 指令后，用 CMD 指定具體的參數。
ENTRYPOINT
ENTRYPOINT 的格式和 RUN 指令格式一樣，分為 exec 格式和 shell 格式。 ENTRYPOINT 的目的和 CMD 一樣，都是在指定容器啟動程序及參數。ENTRYPOINT 在運行時也可以替代，不過比 CMD 要略顯繁瑣，需要通過 docker run 的參數 --entrypoint 來指定。
當指定了 ENTRYPOINT 后，CMD 的含義就發生了改變，不再是直接的運行其命令，而是將 CMD 的內容作為參數傳給 ENTRYPOINT 指令，換句話說實際執行時，將變為：
<ENTRYPOINT> "<CMD>"
COPY & ADD
這2個指令都是複製文件，它將從構建上下文目錄中的文件/目錄複製到新的一層的鏡像內的位置。比如： COPY demo-test.jar app.jar 或 ADD demo-test.jar app.jar。
ADD指令比 COPY高級點，可以指定一個URL地址，這樣Docker引擎會去下載這個URL的文件，如果 ADD後面是一個 tar文件的話，Dokcer引擎還會去解壓縮。
我們在構建鏡像時盡可能使用 COPY，因為 COPY 的語義很明確，就是複製文件而已，而 ADD 則包含了更複雜的功能，其行為也不一定很清晰。
EXPOSE
聲明容器運行時的端口，這隻是一個聲明，在運行時並不會因為這個聲明應用就會開啟這個端口的服務。在 Dockerfile 中寫入這樣的聲明有兩個好處，一個是幫助鏡像使用者理解這個鏡像服務的守護端口，以方便配置映射；另一個用處則是在運行時使用隨機端口映射時，也就是 docker run -P 時，會自動隨機映射 EXPOSE 的端口。
要將 EXPOSE 和在運行時使用 -p <宿主端口>:<容器端口> 區分開來。-p，是映射宿主端口和容器端口，換句話說，就是將容器的對應端口服務公開給外界訪問，而 EXPOSE 僅僅是聲明容器打算使用什麼端口而已，並不會自動在宿主進行端口映射。
ENV
這個指令很簡單，就是設置環境變量，無論是後面的其它指令，如 RUN，還是運行時的應用，都可以直接使用這裏定義的環境變量。它有如下兩種格式：
- ENV <key> <value>
- ENV <key1>=<value1> <key2>=<value2>...
VOLUME
該指令使容器中的一個目錄具有持久化存儲的功能，該目錄可被容器本身使用，也可共享給其他容器。當容器中的應用有持久化數據的需求時可以在Dockerfile中使用該指令。如VOLUME /tmp
這裏的 /tmp 目錄就會在運行時自動掛載為匿名卷，任何向 /tmp 中寫入的信息都不會記錄進容器存儲層，從而保證了容器存儲層的無狀態化。當然，運行時可以覆蓋這個掛載設置。比如：
docker run -d -v mydata:/tmp xxxx
LABEL
你可以為你的鏡像添加labels，用來組織鏡像，記錄版本描述，或者其他原因，對應每個label，增加以LABEL開頭的行，和一個或者多個鍵值對。如下所示：
LABEL version="1.0" LABEL description="test"

Dockerfile實戰

我們以一個簡單的SpringBoot項目為例構建基於SpringBoot應用的鏡像。
功能很簡單，只是對外提供了一個say接口，在進入這個方法的時候打印出一行日誌，並將日誌寫入日誌文件。

@SpringBootApplication
@RestController
@Log4j2
public class DockerApplication {

    public static void main(String[] args) {
        SpringApplication.run(DockerApplication.class, args);
    }

    @GetMapping("/say")
    public String say(){
        log.info("get say request...");
        return "Hello,Java日知錄";
    }
    
}

我們使用maven將其打包成jar文件，放入一個單獨的文件夾,然後按照下面步驟一步步構建鏡像並執行

在當前文件夾建立Dockerfile文件，文件內容如下：
properties FROM openjdk:8-jdk-alpine #將容器中的/tmp目錄作為持久化目錄 VOLUME /tmp #暴露端口 EXPOSE 8080 #複製文件 COPY docker-demo.jar app.jar #配置容器啟動后執行的命令 ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
使用如下命令構建鏡像
docker built -t springboot:v1.0 .

-t 指定鏡像的名稱及版本號，注意後面需要以 . 結尾。
查看鏡像文件
運行構建的鏡像
docker run -v /app/docker/logs:/logs -p 8080:8080 --rm --name springboot springboot:v1.0
瀏覽器訪問http://192.168.136.129:8080/say
在宿主機上實時查看日誌
tail -100f /app/docker/logs/docker-demo-info.log

請關注個人公眾號:JAVA日知錄

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

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

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

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

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

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

2020-02-18

this綁定方式總結

Post By admin 網路資訊 iphone手機收購, USB CONNECTOR, 二手iphone收購, 二手筆電回收, 平板收購, 網站設計, 網頁設計公司, 電動車

最近在回顧js的一些基礎知識，把《你不知道的js》系列又看了一遍，this始終是重中之重，還是決定把this相關知識做一個系統的總結，也方便自己日後回顧。

this的四條綁定規則

1.默認綁定

這是最常用的函數調用類型：獨立函數調用（即函數是直接使用不帶任何修飾的函數引用進行調用的）。可以把這條規則看作是無法應用其他規則時的默認規則。
默認綁定的this在非嚴格模式下指向window,嚴格模式下指向undefined,比如下面的函數foo在非嚴格模式下：

var a = 2;
function foo(){
    var a = 3;
    console.log(this.a);
}
foo(); //2

這裏的foo()方法內的this指向了window，因此window.a = 2;

嚴格模式下，this.指向undefined，因此訪問this.a會報錯：

var a = 2;
function foo(){
    "use strict";
    var a = 3;
    console.log(this.a);
}
foo(); //Uncaught TypeError: Cannot read property 'a' of undefined

2.隱式綁定

如果調用位置上有上下文對象，或者說被某個對象“擁有”或者“包
含”，則使用隱式綁定。

function foo() {
    console.log( this.a );
}
var obj = {
    a: 2,
    foo: foo
};
obj.foo(); // 2

上例中的foo是通過obj.foo()的方式調用的，調用位置會使用obj上下文來引用函數，因此foo中的this指向了obj。
另外foo是當做引用被加入到obj中的，但是無論是直接在obj 中定義還是先定義再添加為引用屬性，foo嚴格上來說都不屬於obj,因此上述定義裏面的“擁有”與“包含”加上了引號，這樣說是為了方便理解。
常見的隱式調用場景：
obj.fn();
arguments[i]();//其實就是將點的調用方式變為了[]調用
el.onClick(function(){console.log(this);//this指向el})

隱式丟失

先來看一段代碼：

function foo() {
    console.log( this.a );
}
var obj = {
    a: 2,
    foo: foo
};
var bar = obj.foo; // 函數別名！
var a = "global"; // a 是全局對象的屬性
bar(); // "global"

上述代碼其實只用看調用的方式：bar()，這其實是一個不帶任何修飾的函數調用，因此應用了默認綁定。
還有一種參數傳遞的方式也會發生隱式丟失，原理其實跟上述例子一樣：

function foo() {
    console.log( this.a );
}
function doFoo(fn) {
    // fn 其實引用的是foo
    fn(); // <-- 調用位置！
}
var obj = {
    a: 2,
    foo: foo
};
var a = "global"; // a 是全局對象的屬性
doFoo( obj.foo ); // "global"

显示綁定

使用call,apply和bind方法可以指定綁定函數的this的值，這種綁定方法叫显示綁定。

function foo() {
    console.log( this.a );
}
var obj = {
    a:2
};
foo.call( obj ); // 2

通過foo.call(obj)，我們可以在調用foo 時強制把它的this 綁定到obj 上

new綁定

new操作符可以基於一個“構造函數”新創建一個對象實例，new的實例化過程如下：

創建（或者說構造）一個全新的對象。
這個新對象會被執行[[ 原型]] 連接。
這個新對象會綁定到函數調用的this。
如果函數沒有返回其他對象，那麼new 表達式中的函數調用會自動返回這個新對象。
明確了new的實例化過程后，思考如下代碼：

function foo(a) {
    this.a = a;
}
var bar = new foo(2);
console.log( bar.a ); // 2

new foo(2)后新創建了個實例對象bar,然後把這個新對象bar綁定到了foo函數中的this，因此執行this.a = a后其實是把a賦給了bar.a

優先級

一般情況下this的綁定會根據上述四條綁定規則來，那麼他們同時出現時，該以怎樣的順序來判斷this的指向？下面是具體的規則：

函數是否在new 中調用（new 綁定）？如果是的話this 綁定的是新創建的對象（ var bar = new foo() ）。
函數是否通過call、apply（顯式綁定）或者硬綁定調用？如果是的話，this 綁定的是指定的對象（ var bar = foo.call(obj2) ）。
函數是否在某個上下文對象中調用（隱式綁定）？如果是的話，this 綁定的是那個上下文對象。（ var bar = obj1.foo() ）
如果都不是的話，使用默認綁定。如果在嚴格模式下，就綁定到undefined，否則綁定到全局對象。（ var bar = foo() ）

綁定例外

1.使用call,appy,bind這種顯式綁定的方法，參數傳入null或者undefined作為上下文時，函數調用還是會使用默認綁定

function foo() {
    console.log( this.a );
}
var a = 2;
foo.call( null ); // 2

什麼情況下需要將上下文傳為null呢？
1.使用bind函數來實現柯里化

function foo(a,b) {
    console.log(a,b);
}
// 使用 bind(..) 進行柯里化
var bar = foo.bind( null, 2 );
bar( 3 ); // 2,3

2.使用apply(..) 來展開一個數組，併當作參數傳入一個函數

function foo(a,b) {
    console.log(a,b);
}
// 把數組展開成參數
foo.apply( null, [2, 3] ); // 2,3

其實上面兩種使用場景其實都不關心call/app/bind第一個參數的值是什麼，只是想傳個佔位值而已。
但是總是傳入null可能會出現一些難以追蹤的bug，比如說當你在使用的第三方庫中的某個函數中有this時，this會被錯誤的綁定到全局對象上，造成一些難以預料的後果（修改全局變量）

var a = 1;//全局變量
const Utils = {
    a: 2,
    changeA: function(a){
        this.a = a;
    }
}
Utils.changeA(3);
Utils.a //3
a //1
Utils.changeA.call(null,4);
Utils.a //3
a //4,修改了全局變量a！

更安全的做法：

var o = Object.create(null);
Utils.changeA.call(o,6);
a //1, 全局變量沒有修改
o.a // 6 改的是變量o

2.間接引用

function foo() {
    console.log( this.a );
}
var a = 2;
var o = { a: 3, foo: foo };
var p = { a: 4 };
o.foo(); // 3
(p.foo = o.foo)(); // 2

賦值表達式p.foo = o.foo 的返回值是目標函數的引用，因此調用位置是foo() 而不是p.foo() 或者o.foo()。根據我們之前說過的，這裡會應用默認綁定。

this詞法（箭頭函數）

上述的幾種規則適用於所有的正常函數，但不包括ES6的箭頭函數。箭頭函數不使用this的四種標準規則，而是根據外層（函數或者全局）作用域（詞法作用域）來決定this

function foo() {
// 返回一個箭頭函數
    return (a) => {
        //this 繼承自foo()
        console.log( this.a );
    };
}
var obj1 = {
    a:2
};
var obj2 = {
    a:3
};
var bar = foo.call( obj1 );
bar.call( obj2 ); // 2, 不是3 ！

foo() 內部創建的箭頭函數會捕獲調用時foo() 的this。由於foo() 的this 綁定到obj1，bar（引用箭頭函數）的this 也會綁定到obj1，箭頭函數的綁定無法被修改。（new 也不行！）

幾個例子加深理解

this的理論知識講解得差不多了，來幾個例子看看自己有沒有理解全面：
1.經典面試題：以下輸出結果是什麼

var length = 10;
function fn() {
    console.log(this.length);
}
var obj = {
  length: 5,
  method: function(fn) {
    fn();
    arguments[0]();
  }
};
obj.method(fn, 1);

obj中method方法裏面調用了兩次fn。第一次是直接調用的“裸露”的fn,因此fn()中this使用默認綁定，this.length為10.第二次調用時通過arguments的方式調用的，arguments[0]其實指向的就是fn，但是是通過obj[fn]這種對象上下文的隱式綁定的，因此this指向arguments，而arguments只有一個一項(method中只有fn一個參數)，因此arguments.length為1。因此打印的結果為：

10
1

2.以下輸出什麼

var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = function () {
            return new Date().getFullYear() - this.birth; // this指向window或undefined
        };
        return fn();
    }
};
obj.getAge();

答案是嚴格模式下會報錯，非嚴格模式下輸出NaN
原因也是因為在調用obj.getAge()后，getAge方法內的this使用隱式綁定。但是return fn()的時候用的是“裸露的fn”使用默認綁定，fn裏面的this指向window或者undefined。
使用箭頭函數來修正this的指向：

var obj = {
    birth: 1990,
    getAge: function () {
        var b = this.birth; // 1990
        var fn = () => new Date().getFullYear() - this.birth; // this指向obj對象
        return fn();
    }
};
obj.getAge(); // 25

使用箭頭函數后，fn中的this在他的詞法分析階段就已經確定好了（即fn定義的時候），跟調用位置無關。fn的this指向外層的作用域（即getAge中的this）
3.以下輸出為什麼是’luo’

var A = function( name ){ 
    this.name = name;
};
var B = function(){ 
    A.apply(this,arguments);
};
B.prototype.getName = function(){ 
    return this.name;
};
var b=new B('sven');  // B {name: "luo"}
console.log( b.getName() ); // 輸出:  'luo'

執行new B(‘seven’)後會返回一個新對象b,並且B函數中的this會綁定到新對象b上，B的函數體內執行A.apply(this.arguments)也就是執行b.name = name;這個時候b的值就是{name:’luo’},所以b.getName()就能輸出’luo’啦~

實際在業務使用中，邏輯會更複雜一些，但是萬變不離其宗，都按照上面寫的規則來代入就好了

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

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

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

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

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

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

【其他文章推薦】

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

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

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

Java內存模型

對象的創建——new的時候發生了什麼

垃圾回收器總結

分代

分代的原因

回收算法

GC種類

垃圾回收器小結

理解GC日誌

可借鑒的編程模式

對象分配的併發控制

對象訪問的定位方式

方式1: 直接指針訪問實例數據

方式2: 使用句柄池

參考資料

獲得ClassLoader的途徑

ClassLoader源碼解析

概述

loadClass方法

findClass方法

defineClass方法

自定義類加載器

擴展：命名空間

方案一：Spring Data Redis

創建工程

配置 Redis 信息

自動配置

使用

方案二：Spring Cache

方案三：回歸原始時代

總結

掃碼關注松哥，公眾號後台回復 2TB，獲取松哥獨家 超2TB 免費 Java 學習乾貨

Json 模塊

dumps()函數

dump()函數

loads()函數

load()函數

Pickle 模塊

dumps()函數

dump()函數

loads()函數

load()函數

一、MachO概述

1. 概述

2.常見格式

2.1目標文件.o

2.2 dylib

2.3 .dsym

3. 通用二進制文件

3.1 利用lipo-info查看MachO文件架構

3.2 瘦身MachO文件，拆分

3.3 增加架構，合併

二、MachO文件

2.1 文件結構

2.2 Header的數據結構

2.3 LoadCommands

2.4 Data

三、DYLD

3.1 dyld概述

3.2 dyld加載過程

3.2.1 新建項目，在main函數下斷

3.2.2 dyld main()函數

四、總結

docker 基礎

什麼是Docker

為什麼要使用Docker

docker 安裝

docker 重要命令

鏡像相關

容器相關

命令實戰

Dockerfile

指令詳解

Dockerfile實戰

this的四條綁定規則

1.默認綁定

2.隱式綁定

隱式丟失

显示綁定

new綁定

掃碼關注松哥，公眾號後台回復 2TB，獲取松哥獨家超2TB 免費 Java 學習乾貨