package com.guanghua.brick.util;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.jar.JarFile;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* @author leeon
* 对类路径上的文件或者文件系统上的文件进行搜索的工具类
*/
public class FileUtil {
private static Log logger = LogFactory.getLog(FileUtil.class);
/**
* 在文件系统的某个目录中搜索符合pattern要求的文件，filePath就是搜索的目录的全路径
* 比如filePath路径是c:/foo/bar，那么就是搜索c:/foo/bar下的所有符合patter格式的文件
* 如果filePath的不是目录或者不存在，那么返回一个空列表。
* @param filePath 需要搜索的目录路径
* @param pattern 文件名(不包括文件路径)符合的模版，正则表达式的模版
* @return 返回搜索到的文件全路径列表
*/
public static List<String> searchFileFromFolder(String filePath,
String pattern) {
return searchFileFromFolder(getFileResource(filePath), pattern,
null);
}
/**
* 检查文件系统某个目录下所有名字(非路径,只包括文件名)符合正则表达式pattern要求的文件
* 返回的结果是一个String的列表，可以有两种结果
* 如果prefix为null，列表里的字符串就是符合要求的文件的绝对路径
* 如果prefix不为null，列表里的字符串就是类路径格式的字符串，比如在c:/foo/bar下搜索,prefix为foo1/bar1
* 搜索到一个文件是c:/foo/bar/test/Test.class,那么返回的list中的字符串就是foo1/bar1/test/Test.class
* 如果prefix传的是"",那么返回的字符串就是/test/Test.class
* @param folder, 开始搜索的文件夹，如果文件夹为空，或者不存在，或者不是文件夹，那么返回空列表
* @param pattern, 搜索用的正则表达式
* @param prefix, 返回类路径或者是文件绝对路径的标志，如果是null，返回文件绝对路径
* @return 返回list,符合list要求的每一个对象是该文件的绝对路径
*/
public static List<String> searchFileFromFolder(File folder,
final String pattern, String prefix) {
List<String> re = new ArrayList<String>();
//给prefix加上/，以便于递归
if (prefix != null && prefix.length() != 0)
prefix = prefix + "/";
//当文件夹存在，并且是文件夹时，才进行搜索
if (folder.exists() && folder.isDirectory()) {
//获取符合pattern条件的文件列表
File[] files = folder.listFiles(new FileFilter() {
public boolean accept(File file) {
//如果该文件是隐藏的,不继续寻找
if (file.isHidden())
return false;
else {
//如果该文件是目录那么继续寻找他的儿子
if (file.isDirectory())
return true;
else {
//如果不是目录,则检验其文件名是否满足要求
return Pattern.matches(pattern, file
.getName());
}
}
}
});
//遍历文件列表，看是否是目录或者文件，是目录就递归，是文件就根据prefix返回
for (int i = 0; files != null && i < files.length; i++) {
if (files[i].isDirectory()) {
re.addAll(searchFileFromFolder(files[i], pattern,
prefix == null ? null : prefix
+ files[i].getName()));
} else {
//需要返回文件路径
if (prefix == null)
re.add(files[i].getAbsolutePath());
//需要返回类路径
else
re.add(prefix + files[i].getName());
}
}
}
return re;
}
/**
* 检查zip包中某个目录下的所有文件名(不包括文件路径)符合正则表达式pattern要求的文件
* 返回一个文件类路径的列表.
* folderPath是搜索的zip包中的类路径文件夹,prefix是一个其实搜索和返回路径的前缀，主要用于搜索war包时
* 比如一个war包，foo.war，那么zipFile时foo.war的ZipFile，要搜索pattern为*.hbm.xml，搜索的类路径就是com/guanghua/domain，而搜索的前缀就应该是/WEB-INF/classes
* 这时候，真正开始搜索的zip包路径是/WEB-INF/classes/com/guanghua/domain，而返回的文件类路径却是com/guanghua/domain/Test.hbm.xml的形式，返回结果会自动截取前缀
* 同样在搜索ear包时，也同理可以这样做。搜索jar包的化，prefix传入""即可
* @param zipFile 被搜索的zip文件
* @param pattern 文件名必须符合的正则表达式的pattern
* @param folderPath
* @param prefix
* @return zip文件夹中所有符合条件的文件的类路径列表
*/
public static List<String> searchFileFromZip(ZipFile zipFile,
String pattern, String folderPath, String prefix) {
List<String> list = new ArrayList<String>();
//拿到zip中所有的entry
Enumeration e = zipFile.entries();
folderPath = folderPath.startsWith("/") ? prefix + folderPath
: prefix + "/" + folderPath;
while (e.hasMoreElements()) {
ZipEntry zipEntry = (ZipEntry) e.nextElement();
//获取zip中文件的路径
String zip = zipEntry.getName();
zip = zip.startsWith("/") ? zip : "/" + zip;
//如果zipEntry的开头是prefix，那么说明这是prefix目录下的一个文件
if (!zipEntry.isDirectory() && zip.startsWith(folderPath)) {
//获取真实的文件名
String jarFileName = zip
.substring(zip.lastIndexOf("/") + 1);
//文件名符合pattern的要求
if (Pattern.matches(pattern, jarFileName))
list.add(zip.substring(prefix.length() + 1));
}
}
return list;
}
/**
* 在指定的类路径中搜索文件名符合pattern要求的文件
* 比如要搜索com/guanghua/brick下所有符合.hbm.xml结尾的文件就可以使用该方法
* 返回的结果是符合要求的文件的类路径,比如com/guanghua/brick/domain/foo.hbm.xml
* @param classPath 指定的类路径
* @param pattern 文件名必须符合的pattern
* @return 返回在指定类路径中文件名符合要求的类路径列表
* @throws Exception
*/
public static List<String> searchFileFromClassPath(
String classPath, String pattern) throws IOException {
//获取指定的类路径的定位URL
URL[] urls = BeanUtil.getClassPathFileURLs(classPath);
//返回的是list，但是利用set来保证没有重复的url
List<String> list = new ArrayList<String>();
Set<String> set = new HashSet<String>();
//没有找到对应的url list，返回空
if (urls == null)
return list;
for (int i = 0; i < urls.length; i++) {
//将搜索到的结果放入set
set.addAll(searchFileFromClassPath(urls[i], classPath,
pattern));
}
list.addAll(set);
return list;
}
/**
* 根据URL确定搜索文件的路径，然后根据classPath确定搜索的类路径，再搜索文件名符合pattern格式的文件
* classPath所在的位置可能是jar，可能是war，可能是folder，但必须和url的位置一致。
* 在类路径中搜索符合pattern要求的文件
* @param url 搜索的jar包或者文件夹所在的url路径，
* @param classPath 搜索的类路径
* @param pattern 文件名符合的模版
* @return 返回在指定类路径中文件名符合要求的类路径列表
* @throws IOException
*/
public static List<String> searchFileFromClassPath(URL url,
String classPath, String pattern) throws IOException {
logger.debug("search file type: [" + pattern + "]");
logger.debug("search file in classpath: [" + classPath + "]");
logger.debug("the real filepath is : [" + url + "]");
if (url == null)
return new ArrayList<String>();
//处理文件名
String file = url.getFile();
int i = file.indexOf("!");
file = (i != -1) ? file.substring(0, i) : file;
//获取协议
String protocol = url.getProtocol();
//如果类所在的文件路径是jar包
if ("jar".equals(protocol)) {
JarURLConnection jc = (JarURLConnection) url
.openConnection();
logger.debug("search jar file from :[" + url + "]");
return searchFileFromZip(jc.getJarFile(), pattern,
classPath, "");
//如果类所在的文件路径是wsjar包
} else if ("wsjar".equals(protocol)) {
//wsjar需要去掉file:/才能在ws下识别
if (file.startsWith("file:/"))
file = file.substring(6);
logger.debug("search wsjar file from :[" + file + "]");
JarFile jarFile = new JarFile(new File(URLDecoder.decode(
file, "UTF-8")));
return searchFileFromZip(jarFile, pattern, classPath, "");
//如果类所在的文件路径是zip包
} else if ("zip".equals(protocol)) {
//如果类所在的文件路径是war包
if (file.endsWith("war")) {
logger.debug("search war file from :[" + file + "]");
ZipFile zipFile = new ZipFile(new File(URLDecoder
.decode(file, "UTF-8")));
return searchFileFromZip(zipFile, pattern, classPath,
"/WEB-INF/classes");
//如果类所在的文件路径是普通zip包
} else {
logger.debug("search zip file from :[" + file + "]");
ZipFile zipFile = new ZipFile(new File(URLDecoder
.decode(file, "UTF-8")));
return searchFileFromZip(zipFile, pattern, classPath,
"");
}
//如果是普通的文件协议
} else if ("file".equals(protocol)) {
logger
.debug("search filesystem folder from :[" + url
+ "]");
return searchFileFromFolder(new File(URLDecoder.decode(url
.getFile(), "UTF-8")), pattern, classPath);
//其余情况返回空列表
} else
return new ArrayList<String>();
}
/**
* 根据传入文件完整路径，获取文件所在的文件夹路径
* 原理是截取最后一个"/"之前的字符串作为文件夹名称
* @param filePath 文件完整路径
* @return 文件夹名称
*/
public static String getFloderName(String filePath) {
return filePath.substring(0, filePath.lastIndexOf("/"));
}
/**
* 根据传入的文件完整路径，获取文件的名称
* 原理是截取最后一个"/"之后的字符串作为文件名
* @param filePath 文件完整路径
* @return 文件名
*/
public static String getFileName(String filePath) {
return filePath.substring(filePath.lastIndexOf("/") + 1);
}
/**
* 根据文件路径（绝对路径）直接返回文件对象。
* 相当于new File(filePath)
* @param filePath 文件的绝对路径
* @return 文件对象
*/
public static File getFileResource(String filePath) {
return new File(filePath);
}
}
