1 继承JavaCore的File类，封装为统一文件概念的类。
1 package waf.file;
2
3 import java.io.*;
4
5
6 /**
7 *
8 * @author waf.wang
9 *
10 */
11 public class File extends java.io.File
12 {
13 /**
14 *
15 */
16 private static final long serialVersionUID = -4251424686894034621L;
17 private boolean bOpenForWrite=false;
18 private boolean bOpenForRead=false;
19 private boolean isSynchronizedWrite=false;
20 public File(String pathname)
21 {
22 super(pathname);
23 }
24
25
26 java.io.BufferedReader bufferReader=null;
27 java.io.DataOutputStream objWriter=null;
28 java.io.DataInputStream objReader=null;
29 public static void main(String[] args)
30 {
31 String[] aa=new waf.file.File("d:\\temp\\src\\").list();
32 waf.file.File file=new waf.file.File("e:\\asssbc.txt");
33 file.openForWrite(true);
34 file.openForRead();
35 {
36 String str=file.readLine();
37 str=file.readLine();
38 str=file.readLine();
39 str=file.readLine();
40 str=file.readLine();
41 str=file.readLine();
42 str=file.readLine();
43 str=file.readLine();
44 }
45
46 {
47 file.openForWrite(false);
48 file.writeByte((byte)300);
49 file.flush();
50 file.writeString("abc锟叫癸拷");
51 file.writeString("\r\n");
52 file.writeString("abc锟叫癸拷");
53 file.writeString("\r\n");
54 file.flush();
55 file.close();
56 }
57 {
58 String strLine="";
59
60 String strAry[]=null;
61
62 System.out.println(file.readGB());
63 }
64
65 file.close();
66
67 }
68
69
70
71 public boolean openForRead()
72 {
73
74 boolean bRet=false;
75 try
76 {
77 if(this.exists())
78 {
79 FileInputStream fis=new FileInputStream(this);
80 this.bufferReader=new BufferedReader(new InputStreamReader(fis,"utf-8"));
81 this.objReader= new DataInputStream(new BufferedInputStream(fis));
82 this.bOpenForRead=true;
83 bRet=true;
84 }
85 }
86 catch (Exception e)
87 {
88 e.printStackTrace();
89 bRet=false;
90 }
91 return bRet;
92 }
93
94 public boolean close()
95 {
96 try
97 {
98 if(this.objReader!=null)
99 {
100 this.objReader.close();
101 this.bOpenForRead=false;
102 }
103 if(this.objWriter!=null)
104 {
105 this.objWriter.flush();
106 this.objWriter.close();
107 this.bOpenForWrite=false;
108 }
109 }
110 catch (IOException e)
111 {
112
113 }
114
115 return true;
116 }
117
118 public String readLine()
119 {
120 String strLine="";
121 if(this.bOpenForRead==false)
122 {
123 this.openForRead();
124 }
125 try
126 {
127 if(this.canRead())
128 {
129 strLine=this.bufferReader.readLine();
130 }
131 }
132 catch (IOException e)
133 {
134 e.printStackTrace();
135 }
136 return strLine;
137 }
138
139 public String readAll()
140 {
141 String strContent="";
142
143 strContent=this.readAllByCharset("");
144
145 return strContent;
146 }
147
148 public String readGB()
149 {
150 return this.readAllByCharset("GBK");
151 }
152
153 public String readUTF8()
154 {
155 return this.readAllByCharset("utf-8");
156 }
157 public String readAllByCharset(String strCharset)
158 {
159 String strContent="";
160
161 byte[] byteData=this.readAllByte();
162
163 if(byteData!=null)
164 {
165 try
166 {
167 if(strCharset.length()==0)
168 {
169 strContent=new String(byteData);
170 }
171 else
172 {
173 strContent=new String(byteData,strCharset);
174 }
175 }
176 catch(UnsupportedEncodingException e)
177 {
178 e.printStackTrace();
179 }
180 }
181 return strContent;
182 }
183 public byte[] readAllByte()
184 {
185 if(this.bOpenForRead==false)
186 {
187 this.openForRead();
188 }
189 byte[] byteData=null;
190 try
191 {
192 int iFileLen=(int)this.length();
193
194 byteData=new byte[iFileLen];
195
196 if(objReader!=null)
197 {
198 this.objReader.read(byteData);
199 }
200 }
201 catch (IOException e)
202 {
203 e.printStackTrace();
204 }
205
206 return byteData;
207 }
208
209 public boolean openForWrite(boolean bAppend)
210 {
211 boolean bRet=true;
212 try
213 {
214 this.objWriter=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(this,bAppend)));
215 this.bOpenForWrite=true;
216 }
217 catch (Exception e)
218 {
219 e.printStackTrace();
220 bRet=false;
221 }
222 return bRet;
223 }
224
225 public boolean writeLine(String line)
226 {
227 return this.writeByte((line+"\r\n").getBytes());
228 }
229 public boolean writeWinLine(String line)
230 {
231 return this.writeByte((line+"\r\n").getBytes());
232 }
233 public boolean writeUnixLine(String line)
234 {
235 return this.writeByte((line+"\n").getBytes());
236 }
237 public boolean writeString(String strContent)
238 {
239 return this.writeByte(strContent.getBytes());
240 }
241
242 public boolean writeLineFlush(String line)
243 {
244 boolean ret=this.writeLine(line);
245 this.flush();
246 return ret;
247 }
248 public boolean writeStringFlush(String line)
249 {
250 boolean ret=this.writeString(line);
251 this.flush();
252 return ret;
253 }
254 public boolean writeString(String strContent,String strCharset)
255 {
256 byte[] byteData=null;
257 try
258 {
259 if(strCharset.length()==0)
260 {
261 byteData = strContent.getBytes();
262 }
263 else
264 {
265 byteData = strContent.getBytes(strCharset);
266 }
267 }
268 catch (UnsupportedEncodingException e)
269 {
270 e.printStackTrace();
271 }
272 return this.writeByte(byteData);
273 }
274
275 public boolean writeByte(byte aByte)
276 {
277 boolean bRet=true;
278 if(this.bOpenForWrite==false)
279 {
280 this.openForWrite(true);
281 }
282 try
283 {
284 if(this.canWrite())
285 {
286 this.objWriter.write(new byte[]{aByte});
287 bRet=true;
288 }
289
290 }
291 catch (IOException e)
292 {
293 e.printStackTrace();
294 bRet=false;
295 }
296 return bRet;
297
298 }
299 public boolean writeByte(byte[] byteContent)
300 {
301 boolean bRet=true;
302 if(this.bOpenForWrite==false)
303 {
304 this.openForWrite(true);
305 }
306 try
307 {
308 if(this.canWrite())
309
310 {
311
312 if(isSynchronizedWrite)
313 {
314 synchronized(objWriter)
315 {
316 this.objWriter.write(byteContent);
317 this.objWriter.flush();
318 bRet=true;
319 }
320 }
321 else
322 {
323 this.objWriter.write(byteContent);
324 this.objWriter.flush();
325 bRet=true;
326 }
327
328 }
329 else
330 {
331 bRet=false;
332 }
333
334 }
335 catch (IOException e)
336 {
337 e.printStackTrace();
338 bRet=false;
339 }
340 return bRet;
341 }
342
343 public boolean writeInt(int i)
344 {
345 boolean bRet=true;
346 if(this.bOpenForWrite==false)
347 {
348 this.openForWrite(true);
349 }
350 try
351 {
352 if(this.canWrite())
353 {
354 this.objWriter.writeInt(i);
355 bRet=true;
356 }
357
358 }
359 catch (IOException e)
360 {
361 e.printStackTrace();
362 bRet=false;
363 }
364 return bRet;
365 }
366
367 public boolean flush()
368 {
369 boolean bRet=false;
370 try
371 {
372 if(objWriter!=null)
373 {
374 this.objWriter.flush();
375 bRet=true;
376 }
377 }
378 catch (Exception e)
379 {
380 bRet=false;
381 e.printStackTrace();
382 }
383
384 return bRet;
385 }
386
387
388 public boolean isSynchronizedWrite()
389 {
390 return isSynchronizedWrite;
391 }
392
393 public void setSynchronizedWrite(boolean isSynchronizedWrite)
394 {
395 this.isSynchronizedWrite = isSynchronizedWrite;
396 }
397
398 }
2 文件Util类
1 package waf.file;
2
3 import java.io.BufferedInputStream;
4 import java.io.File;
5 import java.io.FileInputStream;
6 import java.io.FileOutputStream;
7 import java.io.IOException;
8 import java.io.InputStream;
9 import java.util.ArrayList;
10 import java.util.List;
11
12 import org.mozilla.universalchardet.UniversalDetector;
13
14 import waf.convert.Conv;
15
16 /**
17 *
18 * @author waf.wang
19 *
20 */
21 public class FileUtil
22 {
23
24 public static void main(String[] args)
25 {
26 detectCharset("j:\\10w.csv");
27 File[] files=FileUtil.listFiles("j:\\article\\jkzg-nhfpc,健康中国,MjM5NjI2ODA4Mw==");
28 for (File file : files)
29 {
30 if(file.isFile())
31 {
32 System.out.println(detectCharset(file.getAbsolutePath()));
33 }
34 }
35
36 }
37 public static void writeLine(String filePath,String line)
38 {
39
40 waf.file.File file=new waf.file.File(filePath);
41 file.openForWrite(true);
42 file.writeLine(line);
43 file.flush();
44 file.close();
45 }
46
47 public static void write(String filePath,String content,boolean append)
48 {
49
50 waf.file.File file=new waf.file.File(filePath);
51 file.openForWrite(append);
52 file.writeString(content);
53 file.flush();
54 file.close();
55 }
56 public static void write(String filePath,byte[] bytes,boolean append)
57 {
58
59 waf.file.File file=new waf.file.File(filePath);
60 file.openForWrite(append);
61 file.writeByte(bytes);
62 file.flush();
63 file.close();
64 }
65
66
67 public static void writeLine(String filePath,String line,boolean append)
68 {
69
70 waf.file.File file=new waf.file.File(filePath);
71 file.openForWrite(append);
72 file.writeLine(line);
73 file.flush();
74 file.close();
75 }
76
77 public static void writeLines(String filePath,List<String> list)
78 {
79 waf.file.File file=new waf.file.File(filePath);
80 file.openForWrite(true);
81 for(String line:list)
82 {
83 file.writeLine(line);
84 }
85 file.flush();
86 file.close();
87 }
88
89 public static String getContent(String filePath)
90 {
91 return new waf.file.File(filePath).readAll();
92 }
93
94 public static int getLines(String filePath)
95 {
96 int lines=0;
97 String line=null;
98 waf.file.File file=new waf.file.File(filePath);
99 if(file.openForRead())
100 {
101 while((line=file.readLine())!=null)
102 {
103 lines++;
104 if(lines>100000&&lines%100000==0)
105 {
106 System.out.println(lines);
107 }
108 }
109
110 }
111 return lines;
112
113 }
114
115 public static List<String> getLineList(String filePath)
116 {
117 List<String> lst=new ArrayList<String>();
118 String line=null;
119 waf.file.File file=new waf.file.File(filePath);
120 if(file.openForRead())
121 {
122 while((line=file.readLine())!=null)
123 {
124 lst.add(line);
125 }
126
127 }
128 return lst;
129
130 }
131
132 public static void delete(String filePath)
133 {
134 waf.file.File file=new waf.file.File(filePath);
135 if(file.exists())
136 {
137 file.delete();
138 }
139 }
140
141 public static String readAll(Class cls,String fileName)
142 {
143 String path=waf.system.System.getRunPath(cls)+fileName;
144 return readAll(path);
145 }
146 public static String readAll(String filePath)
147 {
148 String ret="";
149 waf.file.File file=new waf.file.File(filePath);
150 if(file.exists()&&file.openForRead())
151 {
152 ret=file.readAll();
153 }
154 return ret;
155 }
156
157 public static String readAll(String filePath,String charaset)
158 {
159 String ret="";
160 waf.file.File file=new waf.file.File(filePath);
161 if(file.exists()&&file.openForRead())
162 {
163 ret=file.readAllByCharset(charaset);
164 }
165 return ret;
166 }
167
168 public static byte[] readAllBytes(String filePath)
169 {
170 byte[] ret=null;
171 waf.file.File file=new waf.file.File(filePath);
172 if(file.exists()&&file.openForRead())
173 {
174 ret=file.readAllByte();
175 }
176 return ret;
177 }
178
179 public static boolean detectCharsetByWords(String words)
180 {
181 boolean ret=false;
182 if( words.contains("的") ||
183 words.contains("了") ||
184 words.contains("是") ||
185 words.contains("，") ||
186 words.contains("。")
187 )
188 {
189 ret=true;
190 }
191 return ret;
192 }
193 public static String detectCharset(String filePath)
194 {
195 String encoding="";
196 String encoding2="";
197 try
198 {
199 InputStream is=new FileInputStream(new File(filePath));
200 BufferedInputStream reader=new BufferedInputStream(is);
201 byte[] buff=new byte[1024];
202 int len=0;
203 // 检测文件编码
204 UniversalDetector detector=new UniversalDetector(null);
205 while((len=reader.read(buff))!=-1&&!detector.isDone())
206 {
207 detector.handleData(buff,0,len);
208 }
209 detector.dataEnd();
210 encoding=detector.getDetectedCharset();
211
212 if(encoding==null)
213 {
214 if(len==-1)
215 {
216 encoding="UTF-8";
217 }
218 else
219 {
220 String utf8=Conv.bytes2Utf8(buff);
221 String gbk=Conv.bytes2Gbk(buff);
222 if(detectCharsetByWords(utf8))
223 {
224 encoding="utf-8";
225 }
226
227 if(detectCharsetByWords(gbk))
228 {
229 encoding="gbk";
230 }
231 }
232 }
233
234
235
236 if(encoding==null)
237 {
238 System.out.println(filePath+"No encoding detected.");
239 }
240
241
242 detector.reset();
243 reader.close();
244
245 }
246 catch(IOException e)
247 {
248 e.printStackTrace();
249 }
250
251 return encoding;
252 }
253
254 public static List<String> listSubDirs(String parentDir)
255 {
256 List<String> ret=new ArrayList<String>();
257
258 java.io.File[] files=new File(parentDir).listFiles();
259 for(java.io.File file:files)
260 {
261 if(file.isDirectory())
262 {
263 ret.add(file.getAbsolutePath());
264 }
265 }
266 return ret;
267 }
268
269 public static long length(String filePath)
270 {
271 waf.file.File file=new waf.file.File(filePath);
272 return file.length();
273 }
274
275 public static boolean exists(String filePath)
276 {
277 waf.file.File file=new waf.file.File(filePath);
278 return file.exists();
279 }
280
281 public static boolean exists(Class cls,String fileName)
282 {
283 String path=waf.system.System.getRunPath(cls)+fileName;
284 return exists(path);
285 }
286
287 public static boolean mkdir(String filePath)
288 {
289 boolean ret=true;
290 waf.file.File file=new waf.file.File(filePath);
291 if(!file.exists())
292 {
293 ret=file.mkdirs();
294 }
295 return ret;
296 }
297
298 public static boolean copyFile(String fileFrom,String fileTo)
299 {
300 return copyFile(fileFrom,fileTo,true,8192);
301 }
302
303 public static boolean copyFile(InputStream is,String fileTo)
304 {
305 return copyFile(is,fileTo,4906);
306 }
307
308 public static boolean copyFile(InputStream is,String fileTo,int bufsize)
309 {
310 try
311 {
312 FileOutputStream out=new FileOutputStream(fileTo);
313 byte[] bt=new byte[bufsize];
314 int count;
315 while((count=is.read(bt))>0)
316 {
317 out.write(bt,0,count);
318 }
319 out.close();
320 return true;
321 }
322 catch(IOException ex)
323 {
324 return false;
325 }
326 }
327
328 public static boolean copyFile(String fileFrom,String fileTo,boolean overwrite,int bufsize)
329 {
330 try
331 {
332 // waf.file.File destFile=new waf.file.File(fileTo);
333 // if(waf.file.File.exists(fileFrom) && destFile.exists() &&
334 // overwrite)
335 // {
336 // destFile.delete();
337 // }
338
339 FileInputStream in=new java.io.FileInputStream(fileFrom);
340 // FileOutputStream out = new FileOutputStream(fileTo);
341 // byte[] bt = new byte[bufsize];
342 // int count;
343 // while ((count = in.read(bt)) > 0) {
344 // out.write(bt, 0, count);
345 // }
346 //
347 // out.close();
348 copyFile(in,fileTo,bufsize);
349 in.close();
350 return true;
351 }
352 catch(IOException ex)
353 {
354 return false;
355 }
356 }
357
358 public static File[] listFiles(String dir)
359 {
360 File file=new File(dir);
361 return file.listFiles();
362 }
363 public static String[] list(String dir)
364 {
365 return new File(dir).list();
366 }
367
368 /**
369 * 删除文件
370 *
371 * @param filePathAndName
372 * String 文件路径及名称 如c:/fqf.txt
373 * @param fileContent
374 * String
375 * @return boolean
376 */
377 public static void delFile(String filePathAndName)
378 {
379 try
380 {
381 String filePath=filePathAndName;
382 filePath=filePath.toString();
383 java.io.File myDelFile=new java.io.File(filePath);
384 myDelFile.delete();
385
386 }
387 catch(Exception e)
388 {
389 System.out.println("删除文件操作出错");
390 e.printStackTrace();
391
392 }
393
394 }
395
396 /**
397 * 删除文件夹
398 *
399 * @param filePathAndName
400 * String 文件夹路径及名称 如c:/fqf
401 * @param fileContent
402 * String
403 * @return boolean
404 */
405 public static void delFolder(String folderPath)
406 {
407 try
408 {
409 delAllFile(folderPath); // 删除完里面所有内容
410 String filePath=folderPath;
411 filePath=filePath.toString();
412 java.io.File myFilePath=new java.io.File(filePath);
413 myFilePath.delete(); // 删除空文件夹
414
415 }
416 catch(Exception e)
417 {
418 System.out.println("删除文件夹操作出错");
419 e.printStackTrace();
420
421 }
422
423 }
424
425 /**
426 * 删除文件夹里面的所有文件
427 *
428 * @param path
429 * String 文件夹路径 如 c:/fqf
430 */
431 public static void delAllFile(String path)
432 {
433 File file=new File(path);
434 if(!file.exists())
435 {
436 return;
437 }
438 if(!file.isDirectory())
439 {
440 return;
441 }
442 String[] tempList=file.list();
443 File temp=null;
444 for(int i=0;i<tempList.length;i++)
445 {
446 if(path.endsWith(java.io.File.separator))
447 {
448 temp=new File(path+tempList[i]);
449 }
450 else
451 {
452 temp=new File(path+java.io.File.separator+tempList[i]);
453 }
454 if(temp.isFile())
455 {
456 temp.delete();
457 }
458 if(temp.isDirectory())
459 {
460 delAllFile(path+"/"+tempList[i]);// 先删除文件夹里面的文件
461 delFolder(path+"/"+tempList[i]);// 再删除空文件夹
462 }
463 }
464 }
465
466 /**
467 * 复制整个文件夹内容
468 *
469 * @param oldPath
470 * String 原文件路径 如：c:/fqf
471 * @param newPath
472 * String 复制后路径 如：f:/fqf/ff
473 * @return boolean
474 */
475 public static void copyFolder(String oldPath,String newPath)
476 {
477
478 try
479 {
480 (new File(newPath)).mkdirs(); // 如果文件夹不存在 则建立新文件夹
481 File a=new File(oldPath);
482 String[] file=a.list();
483 File temp=null;
484 for(int i=0;i<file.length;i++)
485 {
486 if(oldPath.endsWith(java.io.File.separator))
487 {
488 temp=new File(oldPath+file[i]);
489 }
490 else
491 {
492 temp=new File(oldPath+java.io.File.separator+file[i]);
493 }
494
495 if(temp.isFile())
496 {
497 FileInputStream input=new FileInputStream(temp);
498 FileOutputStream output=new FileOutputStream(newPath+"/"+(temp.getName()).toString());
499 byte[] b=new byte[1024*5];
500 int len;
501 while((len=input.read(b))!=-1)
502 {
503 output.write(b,0,len);
504 }
505 output.flush();
506 output.close();
507 input.close();
508 }
509 if(temp.isDirectory())
510 {// 如果是子文件夹
511 copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
512 }
513 }
514 }
515 catch(Exception e)
516 {
517 System.out.println("复制整个文件夹内容操作出错");
518 e.printStackTrace();
519
520 }
521
522 }
523
524 /**
525 * 移动文件到指定目录
526 *
527 * @param oldPath
528 * String 如：c:/fqf.txt
529 * @param newPath
530 * String 如：d:/fqf.txt
531 */
532 public static void moveFile(String oldPath,String newPath)
533 {
534 copyFile(oldPath,newPath);
535 delFile(oldPath);
536
537 }
538
539 /**
540 * 移动文件到指定目录
541 *
542 * @param oldPath
543 * String 如：c:/fqf.txt
544 * @param newPath
545 * String 如：d:/fqf.txt
546 */
547 public static void moveFolder(String oldPath,String newPath)
548 {
549 copyFolder(oldPath,newPath);
550 delFolder(oldPath);
551
552 }
553 }
3 Ini文件类
1 package waf.file;
2
3 import java.io.*;
4 import java.util.Enumeration;
5 import java.util.HashMap;
6 import java.util.Map;
7 import java.util.Properties;
8
9
10 /**
11 *
12 * @author waf.wang
13 *
14 */
15
16 public class IniFile
17 {
18 private Map<String,String> confData=new HashMap<String,String>();
19
20 private String filePath="";
21
22 public void load(String filePath)
23 {
24 this.filePath=filePath;
25 this.confData=readIni(filePath);
26 }
27 public String getString(String key)
28 {
29 return this.confData.get(key);
30 }
31 public Integer getInt(String key)
32 {
33 Integer ret=null;
34 String value=getString(key);
35 if(waf.convert.Conv.isInt(value))
36 {
37 ret=Integer.parseInt(value);
38 }
39 return ret;
40 }
41
42 public void writeString(String key,String value)
43 {
44 writeIni(this.filePath,key,value);
45 }
46
47
48
49
50
51 // 根据key读取value
52 public static String readString(String filePath,String key)
53 {
54 Properties props = new Properties();
55 try
56 {
57 InputStream in = new BufferedInputStream (new FileInputStream(filePath));
58 props.load(in);
59 String value = props.getProperty (key);
60 return value;
61 }
62 catch (Exception e)
63 {
64 e.printStackTrace();
65 return null;
66 }
67 }
68
69 public static int readInt(String filePath,String key)
70 {
71 return Integer.parseInt(readString(filePath,key));
72 }
73 // 读取properties的全部信息
74
75 public static Map<String,String> readIni(String filePath)
76 {
77 Map<String,String> map=new HashMap<String,String>();
78 Properties props = new Properties();
79 try
80 {
81 InputStream in = new BufferedInputStream (new FileInputStream(filePath));
82 props.load(in);
83 Enumeration en = props.propertyNames();
84 while (en.hasMoreElements())
85 {
86 String key = (String) en.nextElement();
87 String Property = props.getProperty (key);
88 // Property=Property.replace("\t", "");
89 // Property=Property.replace(" ", "");
90 //Property=Property.trim();
91 map.put(key, Property);
92 }
93 in.close();
94 }
95 catch (Exception e)
96 {
97 e.printStackTrace();
98 }
99 return map;
100 }
101
102
103 public static void writeIni(String filePath,String parameterName,String parameterValue) {
104 Properties prop = new Properties();
105 try {
106 InputStream fis = new FileInputStream(filePath);
107 //从输入流中读取属性列表(键和元素对)
108 prop.load(fis);
109 //调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。
110 //强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
111 OutputStream fos = new FileOutputStream(filePath);
112 prop.setProperty(parameterName, parameterValue);
113 //以适合使用 load 方法加载到 Properties 表中的格式，
114 //将此 Properties 表中的属性列表(键和元素对)写入输出流
115 //prop.store(fos, "Update '" + parameterName + "' value");
116 prop.store(fos,"");
117 }
118 catch (IOException e)
119 {
120 System.err.println("Visit "+filePath+" for updating "+parameterName+" value error");
121 }
122 }
123
124 public static void main(String[] args)
125 {
126
127 }
128 }
4 Ini文件管理类
1 package waf.file;
2
3 import java.util.HashMap;
4 import java.util.Map;
5
6 /**
7 *
8 * @author waf.wang
9 *
10 */
11
12 /**
13 * 在servlet中不能IniFileManager.load()方式使用，因为隐含使用了同一个静态变量
14 * 所有的的servlet在同一个进程空间内，静态变量会导致脏数据覆盖
15 *
16 */
17 public class IniFileManager
18 {
19 private static IniFileManager instance = null;
20 private static Map<String,IniFile> iniMap=new HashMap<String,IniFile>();
21 private static IniFile firstIni=null;
22
23 public static synchronized IniFileManager getInstance()
24 {
25 if(instance==null)
26 {
27 instance=new IniFileManager();
28 }
29 return instance;
30 }
31
32 public static void load(String fileCode,String filePath)
33 {
34 IniFile ini=new IniFile();
35 ini.load(filePath);
36 iniMap.put(fileCode,ini);
37 }
38
39 public static void load(Class cls,String fileName)
40 {
41 String path=waf.system.System.getRunPath(cls)+fileName;
42 load(path);
43 }
44
45 public static void load(String filePath)
46 {
47 load("",filePath);
48 }
49
50 public static String readString(String fileCode,String key)
51 {
52 String ret="";
53 IniFile ini=iniMap.get(fileCode);
54 if(ini!=null)
55 {
56 ret=ini.getString(key);
57 }
58 return ret;
59 }
60 public static int readInt(String fileCode,String key)
61 {
62 int ret=0;
63 IniFile ini=iniMap.get(fileCode);
64 if(ini!=null)
65 {
66 ret=ini.getInt(key);
67 }
68 return ret;
69 }
70
71 public static void writeInt(String key,int value)
72 {
73 int ret=0;
74 getFirstIniFile();
75
76 if(firstIni!=null)
77 {
78 firstIni.writeString(key,""+value);
79 }
80 }
81
82 public static void writeString(String key,String value)
83 {
84 int ret=0;
85 getFirstIniFile();
86
87 if(firstIni!=null)
88 {
89 firstIni.writeString(key,value);
90 }
91 }
92
93 public static String readString(String key)
94 {
95 String ret="";
96
97 getFirstIniFile();
98
99 if(firstIni!=null)
100 {
101 ret=firstIni.getString(key);
102 }
103 return ret;
104 }
105 public static Integer readInt(String key)
106 {
107 Integer ret=null;
108
109 getFirstIniFile();
110
111 if(firstIni!=null)
112 {
113 ret=firstIni.getInt(key);
114 }
115 return ret;
116 }
117
118 private static IniFile getFirstIniFile()
119 {
120 //if(firstIni==null)
121 {
122 for(String fileCode:iniMap.keySet())
123 {
124 firstIni=iniMap.get(fileCode);
125 break;
126 }
127 }
128 return firstIni;
129 }
130
131
132
133
134 }
1239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
