? 版权声明：本文为博主原创文章，转载请注明出处
目录：
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
时间： 2024-11-06 07:40:06