java分享第十六天（ java讀取properties文件的幾種方法&java配置文件持久化：static塊的做用）

 java讀取properties文件的幾種方法

1、項目中常常會須要讀取配置文件(properties文件)，所以讀取方法總結以下： 
一、經過java.util.Properties讀取
Properties p=new Properties();  
//p須要InputStream對象進行讀取文件，而獲取InputStream有多種方法：  
//一、經過絕對路徑:InputStream is=new FileInputStream(filePath);  
//二、經過Class.getResourceAsStream(path);  
//三、經過ClassLoader.getResourceAsStream(path);   
p.load(InputStream is);  
is.close();  
p.getString(String(key))
二、經過java.util.ResourceBundle讀取
ResourceBundle rb=ResourceBundle.getBundle(packageName);  
rb.getString(String key);  
2、Class.getResourceAsStream與ClassLoader.getResourceAsStream的區別 
首先，Java中的getResourceAsStream有如下幾種：
Class.getResourceAsStream(String path) ： path 不以’/’開頭時默認是今後類所在的包下取資源，以’/’開頭則是從ClassPath根下獲取。其只是經過path構造一個絕對路徑，最終仍是由 ClassLoader獲取資源。
Class.getClassLoader.getResourceAsStream(String path) ：默認則是從ClassPath根下獲取，path不能以’/’開頭，最終是由ClassLoader獲取資源。
ServletContext. getResourceAsStream(String path)：默認從WebAPP根目錄下取資源，Tomcat下path是否以’/’開頭無所謂，固然這和具體的容器實現有關。
Jsp下的application內置對象就是上面的ServletContext的一種實現。
其次，getResourceAsStream 用法大體有如下幾種：
第一： 要加載的文件和.class文件在同一目錄下，例如：com.x.y 下有類me.class ,同時有資源文件myfile.xml
那麼，應該有以下代碼：
me.class.getResourceAsStream("myfile.xml");
第二：在me.class目錄的子目錄下，例如：com.x.y 下有類me.class ,同時在 com.x.y.file 目錄下有資源文件myfile.xml
那麼，應該有以下代碼：
me.class.getResourceAsStream("file/myfile.xml");
第三：不在me.class目錄下，也不在子目錄下，例如：com.x.y 下有類me.class ,同時在 com.x.file 目錄下有資源文件myfile.xml
那麼，應該有以下代碼：
me.class.getResourceAsStream("/com/x/file/myfile.xml");
總結一下，可能只是兩種寫法
第一：前面有 「 / 」
「 / 」表明了工程的根目錄，例如工程名叫作myproject，「 / 」表明了myproject
me.class.getResourceAsStream("/com/x/file/myfile.xml");
第二：前面沒有 「 / 」
表明當前類的目錄
me.class.getResourceAsStream("myfile.xml");
me.class.getResourceAsStream("file/myfile.xml");
最後，本身的理解：  

 getResourceAsStream讀取的文件路徑只侷限與工程的源文件夾中，包括在工程src根目錄下，以及類包裏面任何位置，可是若是配置文件路徑是在除了源文件夾以外的其餘文件夾中時，該方法是用不了的。
錯誤： 
class.getClassLoader().getResource(「***「);這一句拋出空指針異常java.lang.NullPointerException，定位爲getClassLoader()返回null
若是一個類是經過bootstrap 載入的，那咱們經過這個類去得到classloader的話，有些jdk的實現是會返回一個null的, 
解決： 
修改代碼以下:
InputStream inputStream;        
ClassLoader cl = XXX. class .getClassLoader();        
if  (cl !=  null ) {        
         inputStream = cl.getResourceAsStream( "xx.properties" );        
}  else {        
         inputStream = ClassLoader.getSystemResourceAsStream( "xx.properties" );        
}        
Properties dbProps =  new  Properties();        
dbProps.load(inputStream);        
inputStream.close();   

 static{}(即static塊)，會在類被加載的時候執行且僅會被執行一次，通常用來初始化靜態變量和調用靜態方法，下面咱們詳細的討論一下該語句塊的特性及應用。

1、在程序的一次執行過程當中，static{}語句塊中的內容只被執行一次，看下面的示例:
示例一
class Test{  
        public static int X=100;  
    public final static int Y;=200  
    public Test(){  
        System.out.println("Test構造函數執行");  
    }  
    static{  
        System.out.println("static語句塊執行");  
    }  
    public static void display(){  
        System.out.println("靜態方法被執行");  
    }  
    public void display_1(){  
        System.out.println("實例方法被執行");  
    }  
}  
public class StaticBlockTest{  
    public static void main(String args[]){  
        try{  
                Class.forName("Test");     
                    Class.forName("Test");   
        }catch(ClassNotFoundException e){  
            e.printStackTrace();  
        }  

    }     
}  
結果:你會發現雖然執行了兩條Class.forName(「Test」)語句，可是，只輸出了一條」靜態方法被執行」語句；其實第二條Class.forName()語句已經無效了，由於在虛擬機的生命週期中一個類只被加載一次；又由於static{}是伴隨類加載執行的，因此，無論你new多少次對象實例，static{}都只執行一次。 –關於類加載請看本文的附錄。
2、static{}語句塊執行的時機(其實就是附錄中類加載的時機)
上面說到static{}會在類被加載的時候執行，咱們必須準確理解類加載的準確含義，含義以下:
一、用Class.forName()顯示加載的時候，如上面的示例一;
二、實例化一個類的時候，如將main()函數的內容改成:Test t=new Test();//這種形式其實和1相比，原理是相同的，都是顯示的加載這個類，讀者能夠驗證Test t=new Test();和Test t=(Test)Class.forName().newInstance();這兩條語句效果相同。
三、調用類的靜態方法的時候，如將main()函數的內容改成:Test.display();
四、調用類的靜態變量的時候，如將main()函數的內容改成:System.out.println(Test.X);
整體來講就這四種狀況，可是咱們特別須要注意一下兩點:
一、調用類的靜態常量的時候，是不會加載類的，即不會執行static{}語句塊，讀者能夠本身驗證一下(將main()函數的內容改成System.out.println(Test.Y);)，你會發現程序只輸出了一個200；(這是java虛擬機的規定，當訪問類的靜態常量時，若是編譯器能夠計算出常量的值，則不會加載類，不然會加載類)
二、用Class.forName()形式的時候，咱們也能夠本身設定要不要加載類，如將Class.forName(「Test」)改成 Class.forName(「Test」,false,StaticBlockTest.class.getClassLoader())，你會發現程序什麼都沒有輸出，即Test沒有被加載，static{}沒有被執行。 

 3、static{}語句塊的執行次序
一、當一個類中有多個static{}的時候，按照static{}的定義順序，從前日後執行；
二、先執行完static{}語句塊的內容，纔會執行調用語句；
示例二
public class TestStatic{
    static{
        System.out.println(1);
    }
    static {
        System.out.println(2);
    }
    static {
        System.out.println(3);
    }
    public static void main(String args[]){
        System.out.println(5);
    }
    static {
        System.out.println(4);
    }
}
結果:程序會輸出1，2，3，4，5
三、若是靜態變量在定義的時候就賦給了初值(如 static int X=100)，那麼賦值操做也是在類加載的時候完成的，而且當一個類中既有static{}又有static變量的時候，一樣遵循「先定義先執行」的原則；
示例三
 class Test{
 public static int X=300;
 static{
  System.out.println(X);
  X=200;
  System.out.println(X);
 }
}
public class StaticBlockTest{
 public static void main(String args[]){
  System.out.println(Test.X);
 }
}
結果:程序會依次輸出300，200，200，先執行完X=300，再執行static{}語句塊。

 4、static{}語句塊應用
一、JDBC中的應用
熟悉JDBC的讀者應該知道，java中有一個DriverManager類，用於管理各類數據庫驅動程序、創建新的數據庫鏈接。DriverManager類包含一些列Drivers類，這些Drivers類必須經過調用DriverManager的registerDriver()方法來對本身進行註冊，那麼註冊是何時發生的呢？下面會給出答案:
全部Drivers類都必須包含有一個靜態方法，利用這個靜態方法能夠建立該類的實例，而後在加載該實例時向DriverManage類進行註冊。咱們常常用Class.forName()對驅動程序進行加載，那麼註冊就發生在這條語句的執行過程當中，前面說的Drivers的靜態方法是放在static{}中的，當對驅動程序進行加載的時候，會執行該static{}，便完成了註冊。
二、hibernate中的應用
hibernate中的SessionFactory是一個重量級的類，建立該類的對象實例會耗費比較多的系統資源，若是每次須要時都建立一個該類的實例，顯然會下降程序的執行效率，因此常常將對該類的實例化放在一個static{}中，只需第一次調用時執行，提升程序的執行效率，以下:
static {
     try {
   configuration.configure(configFile);
   sessionFactory = configuration.buildSessionFactory();
  } catch (Exception e) {
   System.err.println("%%%% Error Creating SessionFactory %%%%");
   e.printStackTrace();
  }
    }
5、附錄
類加載:Java命令的做用是啓動虛擬機，虛擬機經過輸入流，從磁盤上將字節碼文件(.class文件)中的內容讀入虛擬機，並保存起來的過程就是類加載。
加載特性 :
  *在虛擬機的生命週期中一個類只被加載一次。
  *類加載的原則：延遲加載，能少加載就少加載，由於虛擬機的空間是有限的。
  *類加載的時機：
  1）第一次建立對象要加載類.
  2）調用靜態方法時要加載類,訪問靜態屬性時會加載類。
  3）加載子類時一定會先加載父類。
  4）建立對象引用不加載類.
  5) 子類調用父類的靜態方法時
      (1)當子類沒有覆蓋父類的靜態方法時，只加載父類，不加載子類
      (2)當子類有覆蓋父類的靜態方法時，既加載父類，又加載子類
  6）訪問靜態常量，若是編譯器能夠計算出常量的值，則不會加載類,例如:public static final int a =123;不然會加載類,例如:public static final int a = math.PI。