1.按照順序讀取配置檔案工具類

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
/**
 * 
 * @author DencyCheng
 *
 */
public class PropertiesUtil extends Properties {  
  
    private static final long serialVersionUID = 1L;  
  
    private List<Object> keyList = new ArrayList<Object>();  
    private List<PropertiesModel> keyValueList = new ArrayList<PropertiesModel>();  
      
    /** 
     * 預設構造方法 
     */  
    public PropertiesUtil() {  
          
    }  
      
    /** 
     * 從指定路徑載入資訊到Properties 
     * @param path 
     */  
    public PropertiesUtil(String path) {  
        try {  
            InputStream is = getClass().getResourceAsStream("/homeDatacheck/"+path);
            this.load(is);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
            throw new RuntimeException("指定檔案不存在！");  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
      
    /** 
     * 重寫put方法，按照property的存入順序儲存key到keyList，遇到重複的後者將覆蓋前者。 
     */  
    @Override  
    public synchronized Object put(Object key, Object value) {  
        this.removeKeyIfExists(key);  
        keyList.add(key);  
        
        PropertiesModel m = new PropertiesModel();
        m.setKey(String.valueOf(key));
        m.setValue(String.valueOf(value));
        keyValueList.add(m);
        return super.put(key, value);  
    }  
      
  
    /** 
     * 重寫remove方法，刪除屬性時清除keyList中對應的key。 
     */  
    @Override  
    public synchronized Object remove(Object key) {  
        this.removeKeyIfExists(key);  
        return super.remove(key);  
    }  
      
    /** 
     * keyList中存在指定的key時則將其刪除 
     */  
    private void removeKeyIfExists(Object key) {  
        keyList.remove(key);  
    }  
      
    /** 
     * 獲取Properties中key的有序集合 
     * @return 
     */  
    public List<Object> getKeyList() {  
        return keyList;  
    }  
    
    
    /** 
     * 獲取Properties中key-value的有序集合 
     * @return 
     */
    public List<PropertiesModel> getKeyValueList() {
		return keyValueList;
	}
    
	/** 
     * 儲存Properties到指定檔案，預設使用UTF-8編碼 
     * @param path 指定檔案路徑 
     */  
    public void store(String path) {  
        this.store(path, "UTF-8");  
    }  
      
   

	/** 
     * 儲存Properties到指定檔案，並指定對應存放編碼 
     * @param path 指定路徑 
     * @param charset 檔案編碼 
     */  
    public void store(String path, String charset) {  
        if (path != null && !"".equals(path)) {  
            try {  
                OutputStream os = new FileOutputStream(path);  
                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os, charset));  
                this.store(bw, null);  
                bw.close();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        } else {  
            throw new RuntimeException("儲存路徑不能為空!");  
        }  
    }  
  
    /** 
     * 重寫keys方法，返回根據keyList適配的Enumeration，且保持HashTable keys()方法的原有語義， 
     * 每次都呼叫返回一個新的Enumeration物件，且和之前的不產生衝突 
     */  
    @Override  
    public synchronized Enumeration<Object> keys() {  
        return new EnumerationAdapter<Object>(keyList);  
    }  
      
    /** 
     * List到Enumeration的介面卡 
     */  
    private class EnumerationAdapter<T> implements Enumeration<T> {  
        private int index = 0;  
        private final List<T> list;  
        private final boolean isEmpty;  
          
        public EnumerationAdapter(List<T> list) {  
            this.list = list;  
            this.isEmpty = list.isEmpty();  
        }  
          
        public boolean hasMoreElements() {  
            //isEmpty的引入是為了更貼近HashTable原有的語義，在HashTable中新增元素前呼叫其keys()方法獲得一個Enumeration的引用，  
            //之後往HashTable中新增資料後，呼叫之前獲取到的Enumeration的hasMoreElements()將返回false，但如果此時重新獲取一個  
            //Enumeration的引用，則新Enumeration的hasMoreElements()將返回true，而且之後對HashTable資料的增、刪、改都是可以在  
            //nextElement中獲取到的。  
            return !isEmpty && index < list.size();  
        }  
  
        public T nextElement() {  
            if (this.hasMoreElements()) {  
                return list.get(index++);  
            }  
            return null;  
        }  
          
    }  
  
} 
 

2.使用

PropertiesUtil zqsProp = new PropertiesUtil("xxxx.properties");
		
List zqsProps =  zqsProp.getKeyList()

3.專案啟動執行

@Component
public class ReadProperty implements ApplicationRunner{

    @Override
	public void run(ApplicationArguments args) throws Exception {
        //要執行程式碼
    }
}