搭建轻量级Jave Web框架----------读取配置文件

Posted 2020-10-04

? 版权声明：本文为博主原创文章，转载请注明出处

目录：

　　1.搭建轻量级Jave Web框架----------框架说明

　　2.搭建轻量级Java Web框架----------读取配置文件

说明：

　　搭建框架的第一步就是配置文件的读取，这里使用jdk自带的Properties类读取配置文件。

　　为了准确获取配置文件中的各个键值对的信息，还需要一个工具类进行强制类型转换。

　　读取过程中还需要进行一些非空的校验等，因此还需要一个工具类对String的一些常用操作进行封装。

　　总结一下，需要四个java类完成配置文件的读取。

　　ConfigConstant：属性文件常量类。将配置文件中的键都对应到java中的一个常量。

　　　　原因：若不使用常量去对应键，后续修改键的话需要修改整个项目。对应之后再修改键只需修改常量类中的对应即可。

　　PropsUtil：属性文件工具类。加载并读取配置文件中的各项信息。

　　CastUtil：强制类型转换工具类。实现一些常用的强制类型转换方法，如强制转换为String、int、double、long、boolean等。

　　　　原因：将常用的类型转换方法封装后，使用、维护都更为方便。

　　StringUtil：String型数值工具类。实现一些常用的String型数值的方法，如空、非空的判断等。

　　　　原因：commons-lang3包中的StringUtils类毕竟是第三方的，后续不知会不会进行修改。因此再次进行封装，维护和使用更为方便。

代码：

1.项目结构

2.pom.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5     <modelVersion>4.0.0</modelVersion>
 6 
 7     <groupId>org.unicorn</groupId>
 8     <artifactId>unicorn</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10     <packaging>jar</packaging>
11 
12     <dependencies>
13         <!-- slf4j + log4j -->
14         <dependency>
15             <groupId>org.slf4j</groupId>
16             <artifactId>slf4j-log4j12</artifactId>
17             <version>1.7.21</version>
18         </dependency>
19         <!-- commons-lang3 -->
20         <dependency>
21             <groupId>org.apache.commons</groupId>
22             <artifactId>commons-lang3</artifactId>
23             <version>3.4</version>
24         </dependency>
25     </dependencies>
26 
27 </project>

pom.xml

3.ConfigConstant.java

 1 package org.unicorn.constant;
 2 
 3 /**
 4  * 属性文件常量类
 5  */
 6 public interface ConfigConstant {
 7 
 8     // 配置文件名称
 9     String CONFIG_FILE = "corn.properties";
10 
11     // 数据库相关常量
12     final String JDBC_DATABASE = "jdbc_database";// 数据库类型
13     final String JDBC_URL = "jdbc_url";// 数据库url
14     final String JDBC_DRIVER = "jdbc_driver";// 数据库驱动
15     final String JDBC_USERNAME = "jdbc_username";// 数据库连接名
16     final String JDBC_PASSWORD = "jdbc_password";// 数据库连接密码
17 
18     // 项目相关常量
19     final String PROJECT_BASE = "project_base_package";// java文件根目录
20     final String PROJECT_JSP = "project_jsp";// jsp文件所在目录
21     final String PROJECT_RESOURCES = "project_resources";// 资源文件所在目录(CSS、JS、image...)
22 
23 }

ConfigConstant.java

4.StringUtil.java

 1 package org.unicorn.util;
 2 
 3 import org.apache.commons.lang3.StringUtils;
 4 
 5 /**
 6  * String型数值工具类
 7  */
 8 public final class StringUtil {
 9 
10     /**
11      * 判断String型数值是否为空
12      *
13      * @param value
14      *              String型数值
15      * @return
16      *              true-空 false-非空
17      */
18     public static boolean isEmpty(String value) {
19 
20         if (value != null) {
21             value = value.trim();// 去空格
22         }
23         return StringUtils.isEmpty(value);
24 
25     }
26 
27     /**
28      * 判断String型数值是否非空
29      *
30      * @param value
31      *              String型数值
32      * @return
33      *              true-非空 false-空
34      */
35     public static boolean isNotEmpty(String value) {
36 
37         return !isEmpty(value);
38 
39     }
40 
41 }

StringUtil.java

5.CastUtil.java

  1 package org.unicorn.util;
  2 
  3 /**
  4  * 强制类型转换工具类
  5  */
  6 public final class CastUtil {
  7 
  8     /**
  9      * 将Object型数值转为String型数值（不可指定默认值）
 10      *
 11      * @param obj
 12      *              Object型数值
 13      * @return
 14      *              String数值
 15      */
 16     public static String castString(Object obj) {
 17 
 18         return castString(obj, "");
 19 
 20     }
 21 
 22     /**
 23      * 将Object型数值转为String型数值（可指定默认值）
 24      *
 25      * @param obj
 26      *              Object型数值
 27      * @param defaultValue
 28      *              String型默认值
 29      * @return
 30      *              String数值
 31      */
 32     public static String castString(Object obj, String defaultValue) {
 33 
 34         return obj == null ? String.valueOf(obj) : defaultValue;
 35 
 36     }
 37 
 38     /**
 39      * 将Object型数值转为int型数值（不可指定默认值）
 40      *
 41      * @param obj
 42      *              Object型数值
 43      * @return
 44      *              int型数值
 45      */
 46     public static int castInt(Object obj) {
 47 
 48         return castInt(obj, 0);
 49 
 50     }
 51 
 52     /**
 53      * 将Object型数值转为int型数值（可指定默认值）
 54      *
 55      * @param obj
 56      *              Object型数值
 57      * @param defaultValue
 58      *              int型默认值
 59      * @return
 60      *              int型数值
 61      */
 62     public static int castInt(Object obj, int defaultValue) {
 63 
 64         int value = defaultValue;
 65         if (obj != null) {
 66             String strValue = castString(obj);
 67             if (StringUtil.isNotEmpty(strValue)) {
 68                 try {
 69                     value = Integer.parseInt(strValue);
 70                 } catch (NumberFormatException e) {
 71                     value = defaultValue;
 72                 }
 73 
 74             }
 75         }
 76         return value;
 77 
 78     }
 79 
 80     /**
 81      * 将Object型数值转为boolean型数值（不可指定默认值）
 82      *
 83      * @param obj
 84      *              Object型数值
 85      * @return
 86      *              boolean型数值
 87      */
 88     public static boolean castBoolean(Object obj) {
 89 
 90         return castBoolean(obj, false);
 91 
 92     }
 93 
 94     /**
 95      * 将Object型数值转为boolean型数值（可指定默认值）
 96      *
 97      * @param obj
 98      *              Object型数值
 99      * @param defaultValue
100      *              boolean型默认值
101      * @return
102      *              boolean型数值
103      */
104     public static boolean castBoolean(Object obj, boolean defaultValue) {
105 
106         boolean value = defaultValue;
107         if (obj != null) {
108             String strValue = castString(obj);
109             if (StringUtil.isNotEmpty(strValue)) {
110                 try {
111                     value = Boolean.parseBoolean(strValue);
112                 } catch (NumberFormatException e) {
113                     value = defaultValue;
114                 }
115             }
116         }
117         return value;
118 
119     }
120 
121     /**
122      * 将Object型数值转为long型数值（不可指定默认值）
123      *
124      * @param obj
125      *              Object型数值
126      * @return
127      *              long型数值
128      */
129     public static long castLong(Object obj) {
130 
131         return castLong(obj, 0L);
132 
133     }
134 
135     /**
136      * 将Object型数值转为long型数值（可指定默认值）
137      *
138      * @param obj
139      *              Object型数值
140      * @param defaultValue
141      *              long型默认值
142      * @return
143      *              long型数值
144      */
145     public static long castLong(Object obj, long defaultValue) {
146 
147         long value = defaultValue;
148         if (obj != null) {
149             String strValue = castString(obj);
150             if (StringUtil.isNotEmpty(strValue)) {
151                 try {
152                     value = Long.parseLong(strValue);
153                 } catch (NumberFormatException e) {
154                     value = defaultValue;
155                 }
156             }
157         }
158         return value;
159 
160     }
161 
162     /**
163      * 将Object型数值转为double型数值（不可指定默认值）
164      *
165      * @param obj
166      *              Object型数值
167      * @return
168      *              double型数值
169      */
170     public static double castDouble(Object obj) {
171 
172         return castDouble(obj, 0d);
173 
174     }
175 
176     /**
177      * 将Object型数值转为double型数值（可指定默认值）
178      *
179      * @param obj
180      *              Object型数值
181      * @param defaultValue
182      *              double型默认值
183      * @return
184      *              double型数值
185      */
186     public static double castDouble(Object obj, double defaultValue) {
187 
188         double value = defaultValue;
189         if (obj != null) {
190             String strValue = castString(obj);
191             if (StringUtil.isNotEmpty(strValue)) {
192                 try {
193                     value = Double.parseDouble(strValue);
194                 } catch (NumberFormatException e) {
195                     value = defaultValue;
196                 }
197             }
198         }
199         return value;
200 
201     }
202 
203 }

CastUtil.java

6.PropsUtil.java

  1 package org.unicorn.util;
  2 
  3 import org.slf4j.Logger;
  4 import org.slf4j.LoggerFactory;
  5 
  6 import java.io.FileNotFoundException;
  7 import java.io.IOException;
  8 import java.io.InputStream;
  9 import java.util.Properties;
 10 
 11 /**
 12  * 属性文件工具类
 13  */
 14 public final class PropsUtil {
 15 
 16     private static final Logger LOGGER = LoggerFactory.getLogger(PropsUtil.class);
 17 
 18     /**
 19      * 加载属性文件
 20      *
 21      * @param fileName
 22      *                  文件名称
 23      * @return
 24      *                  Properties对象
 25      */
 26     public static Properties loadProps(String fileName) {
 27 
 28         Properties props;
 29         InputStream inputStream = null;
 30         try {
 31             inputStream = Thread.currentThread().getContextClassLoader()
 32                     .getResourceAsStream(fileName);
 33             if (inputStream == null) {
 34                 LOGGER.error("文件[" + fileName + "]没有被发现");
 35                 throw new FileNotFoundException("文件[" + fileName + "]没有被发现");
 36             }
 37             props = new Properties();// 创建属性文件对象
 38             props.load(inputStream);// 加载属性文件
 39         } catch (IOException e) {
 40             LOGGER.error("加载属性文件失败", e);
 41             throw new RuntimeException("加载属性文件失败", e);
 42         } finally {
 43             if (inputStream != null) {
 44                 try {
 45                     inputStream.close();
 46                 } catch (IOException e) {
 47                     LOGGER.error("输入流[" + inputStream.toString() + "]关闭失败");
 48                 }
 49             }
 50         }
 51         return props;
 52 
 53     }
 54 
 55     /**
 56      * 获取String型属性值（不可指定默认值）
 57      *
 58      * @param props
 59      *              Properties对象
 60      * @param key
 61      *              键
 62      * @return
 63      *              键对应的String型数值
 64      */
 65     public static String getString(Properties props, String key) {
 66 
 67         return getString(props, key, "");
 68 
 69     }
 70 
 71     /**
 72      * 获取String型属性值（可指定默认值）
 73      *
 74      * @param props
 75      *              Properties对象
 76      * @param key
 77      *              键
 78      * @param defaultValue
 79      *              String型默认值
 80      * @return
 81      *              键对应的String型数值
 82      */
 83     public static String getString(Properties props, String key, String defaultValue) {
 84 
 85         String value = defaultValue;
 86         if (props.containsKey(key)) {
 87             value = props.getProperty(key);
 88         }
 89         return value;
 90 
 91     }
 92 
 93     /**
 94      * 获取int型属性值（不可指定默认值）
 95      *
 96      * @param props
 97      *              Properties对象
 98      * @param key
 99      *              键
100      * @return
101      *              键对应的int型数值
102      */
103     public static int getInt(Properties props, String key) {
104 
105         return getInt(props, key, 0);
106 
107     }
108 
109     /**
110      * 获取int型属性值（可指定默认值）
111      *
112      * @param props
113      *              Properties对象
114      * @param key
115      *              键
116      * @param defaultValue
117      *              int型默认值
118      * @return
119      *              键对应的int型数值
120      */
121     public static int getInt(Properties props, String key, int defaultValue) {
122 
123         int value = defaultValue;
124         if (props.containsKey(key)) {
125             value = CastUtil.castInt(props.getProperty(key));
126         }
127         return value;
128 
129     }
130 
131     /**
132      * 获取boolean型属性值（不可指定默认值）
133      *
134      * @param props
135      *              Properties对象
136      * @param key
137      *              键
138      * @return
139      *              键对应的boolean型数值
140      */
141     public static boolean getBoolean(Properties props, String key) {
142 
143         return getBoolean(props, key, false);
144 
145     }
146 
147     /**
148      * 获取boolean型属性值（可指定默认值）
149      *
150      * @param props
151      *              Properties对象
152      * @param key
153      *              键
154      * @param defaultValue
155      *              boolean型默认值
156      * @return
157      *              键对应的boolean型数值
158      */
159     public static boolean getBoolean(Properties props, String key, boolean defaultValue) {
160 
161         boolean value = defaultValue;
162         if (props.containsKey(key)) {
163             value = CastUtil.castBoolean(props.getProperty(key));
164         }
165         return value;
166 
167     }
168 
169     /**
170      * 获取long型属性值（不可指定默认值）
171      *
172      * @param props
173      *              Properties对象
174      * @param key
175      *              键
176      * @return
177      *              键对应的long型数值
178      */
179     public static long getLong(Properties props, String key) {
180 
181         return getLong(props, key, 0L);
182 
183     }
184 
185     /**
186      * 获取long型属性值（可指定默认值）
187      *
188      * @param props
189      *              Properties对象
190      * @param key
191      *              键
192      * @param defaultValue
193      *              long型默认值
194      * @return
195      *              键对应的long型数值
196      */
197     public static long getLong(Properties props, String key, long defaultValue) {
198 
199         long value = defaultValue;
200         if (props.containsKey(key)) {
201             value = CastUtil.castLong(props.getProperty(key));
202         }
203         return value;
204 
205     }
206 
207     /**
208      * 获取double型属性值（不可指定默认值）
209      *
210      * @param props
211      *                  Properties对象
212      * @param key
213      *                  键
214      * @return
215      *                  键对应的double型数值
216      */
217     public static double getDouble(Properties props, String key) {
218 
219         return getDouble(props, key, 0d);
220 
221     }
222 
223     /**
224      * 获取double型属性值（可指定默认值）
225      *
226      * @param props
227      *                  Properties对象
228      * @param key
229      *                  键
230      * @param defaultValue
231      *                  double型默认值
232      * @return
233      *                  键对应的double型数值
234      */
235     public static double getDouble(Properties props, String key, double defaultValue) {
236 
237         double value = defaultValue;
238         if (props.containsKey(key)) {
239             value = CastUtil.castDouble(props.getProperty(key));
240         }
241         return value;
242 
243     }
244 
245 }

PropsUtil.java