package top.thinkin.wjcli.util;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class FileUtil {
/**
* 获得资源相对路径对应的URL
* @param resource 资源相对路径
* @param baseClass 基准Class，获得的相对路径相对于此Class所在路径，如果为{@code null}则相对ClassPath
* @return {@link URL}
*/
public static URL getResource(String resource, Class<?> baseClass){
return (null != baseClass) ? baseClass.getResource(resource) : getClassLoader().getResource(resource);
}
public static ClassLoader getClassLoader() {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if (classLoader == null) {
classLoader = FileUtil.class.getClassLoader();
if (null == classLoader) {
classLoader = ClassLoader.getSystemClassLoader();
}
}
return classLoader;
}
/**
* 修复路径<br>
* 如果原路径尾部有分隔符，则保留为标准分隔符（/），否则不保留
* <ol>
* <li>1. 统一用 /</li>
* <li>2. 多个 / 转换为一个 /</li>
* <li>3. 去除两边空格</li>
* <li>4. .. 和 . 转换为绝对路径，当..多于已有路径时，直接返回根路径</li>
* </ol>
*
* 栗子：
*
* <pre>
* "/foo//" =》 "/foo/"
* "/foo/./" =》 "/foo/"
* "/foo/../bar" =》 "/bar"
* "/foo/../bar/" =》 "/bar/"
* "/foo/../bar/../baz" =》 "/baz"
* "/../" =》 "/"
* "foo/bar/.." =》 "foo"
* "foo/../bar" =》 "bar"
* "foo/../../bar" =》 "bar"
* "//server/foo/../bar" =》 "/server/bar"
* "//server/../bar" =》 "/bar"
* "C:\\foo\\..\\bar" =》 "C:/bar"
* "C:\\..\\bar" =》 "C:/bar"
* "~/foo/../bar/" =》 "~/bar/"
* "~/../bar" =》 "bar"
* </pre>
*
* @param path 原路径
* @return 修复后的路径
*/
public static String normalize(String path) {
if (path == null) {
return null;
}
// 兼容Spring风格的ClassPath路径，去除前缀，不区分大小写
String pathToUse = StrUtil.removePrefixIgnoreCase(path, "classpath:");
// 去除file:前缀
pathToUse = StrUtil.removePrefixIgnoreCase(pathToUse, "file:");
// 统一使用斜杠
pathToUse = pathToUse.replaceAll("[/\\\\]{1,}", "/").trim();
int prefixIndex = pathToUse.indexOf(StrUtil.COLON);
String prefix = "";
if (prefixIndex > -1) {
// 可能Windows风格路径
prefix = pathToUse.substring(0, prefixIndex + 1);
if (StrUtil.startWith(prefix, StrUtil.C_SLASH)) {
// 去除类似于/C:这类路径开头的斜杠
prefix = prefix.substring(1);
}
if (false == prefix.contains("/")) {
pathToUse = pathToUse.substring(prefixIndex + 1);
} else {
// 如果前缀中包含/,说明非Windows风格path
prefix = StrUtil.EMPTY;
}
}
if (pathToUse.startsWith(StrUtil.SLASH)) {
prefix += StrUtil.SLASH;
pathToUse = pathToUse.substring(1);
}
List<String> pathList = StrUtil.split(pathToUse, StrUtil.C_SLASH);
List<String> pathElements = new LinkedList<String>();
int tops = 0;
String element;
for (int i = pathList.size() - 1; i >= 0; i--) {
element = pathList.get(i);
if (StrUtil.DOT.equals(element)) {
// 当前目录，丢弃
} else if (StrUtil.DOUBLE_DOT.equals(element)) {
tops++;
} else {
if (tops > 0) {
// 有上级目录标记时按照个数依次跳过
tops--;
} else {
// Normal path element found.
pathElements.add(0, element);
}
}
}
return prefix + ArrayUtil.join(pathElements, StrUtil.SLASH);
}
/**
* 以 conjunction 为分隔符将集合转换为字符串<br>
* 如果集合元素为数组、{@link Iterable}或{@link Iterator}，则递归组合其为字符串
*
* @param <T> 集合元素类型
* @param iterator 集合
* @param conjunction 分隔符
* @return 连接后的字符串
*/
public static <T> String join(Iterator<T> iterator, CharSequence conjunction) {
if (null == iterator) {
return null;
}
final StringBuilder sb = new StringBuilder();
boolean isFirst = true;
T item;
while (iterator.hasNext()) {
if (isFirst) {
isFirst = false;
} else {
sb.append(conjunction);
}
item = iterator.next();
if (ArrayUtil.isArray(item)) {
sb.append(ArrayUtil.join(ArrayUtil.wrap(item), conjunction));
} else if (item instanceof Iterable<?>) {
sb.append(ArrayUtil.join((Iterable<?>) item, conjunction));
} else if (item instanceof Iterator<?>) {
sb.append(ArrayUtil.join((Iterator<?>) item, conjunction));
} else {
sb.append(item);
}
}
return sb.toString();
}
/**
* 从URL对象中获取不被编码的路径Path<br>
* 对于本地路径，URL对象的getPath方法对于包含中文或空格时会被编码，导致本读路径读取错误。<br>
* 此方法将URL转为URI后获取路径用于解决路径被编码的问题
*
* @param url {@link URL}
* @return 路径
* @since 3.0.8
*/
public static String getDecodedPath(URL url) {
String path = null;
try {
// URL对象的getPath方法对于包含中文或空格的问题
path = toURI(url).getPath();
} catch (RuntimeException e) {
// ignore
}
return (null != path) ? path : url.getPath();
}
/**
* 转URL为URI
*
* @param url URL
* @return URI
* @exception RuntimeException 包装URISyntaxException
*/
public static URI toURI(URL url) throws RuntimeException {
if (null == url) {
return null;
}
try {
return url.toURI();
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
}
/**
* 获取绝对路径<br>
* 此方法不会判定给定路径是否有效（文件或目录存在）
*
* @param path 相对路径
* @param baseClass 相对路径所相对的类
* @return 绝对路径
*/
public static String getAbsolutePath(String path, Class<?> baseClass) {
String normalPath;
if (path == null) {
normalPath = StrUtil.EMPTY;
} else {
normalPath = normalize(path);
if (isAbsolutePath(normalPath)) {
// 给定的路径已经是绝对路径了
return normalPath;
}
}
// 相对于ClassPath路径
final URL url = getResource(normalPath, baseClass);
if (null != url) {
// 对于jar中文件包含file:前缀，需要去掉此类前缀，在此做标准化，since 3.0.8 解决中文或空格路径被编码的问题
return normalize(getDecodedPath(url));
}
// 如果资源不存在，则返回一个拼接的资源绝对路径
final String classPath = getClassPath();
if (null == classPath) {
throw new NullPointerException("ClassPath is null !");
}
// 资源不存在的情况下使用标准化路径有问题，使用原始路径拼接后标准化路径
return normalize(classPath.concat(path));
}
/**
* 获得ClassPath，将编码后的中文路径解码为原字符<br>
* 这个ClassPath路径会文件路径被标准化处理
*
* @return ClassPath
*/
public static String getClassPath() {
return getClassPath(false);
}
/**
* 获得ClassPath，这个ClassPath路径会文件路径被标准化处理
*
* @param isEncoded 是否编码路径中的中文
* @return ClassPath
* @since 3.2.1
*/
public static String getClassPath(boolean isEncoded) {
final URL classPathURL = getClassPathURL();
String url = isEncoded ? classPathURL.getPath() : getDecodedPath(classPathURL);
return FileUtil.normalize(url);
}
/**
* 获得ClassPath URL
*
* @return ClassPath URL
*/
public static URL getClassPathURL() {
return getResourceURL(StrUtil.EMPTY);
}
/**
* 获得资源的URL<br>
* 路径用/分隔，例如:
*
* <pre>
* config/a/db.config
* spring/xml/test.xml
* </pre>
*
* @param resource 资源（相对Classpath的路径）
* @return 资源URL
*/
public static URL getResourceURL(String resource) throws RuntimeException {
return getResource(resource,null);
}
/**
* 给定路径已经是绝对路径<br>
* 此方法并没有针对路径做标准化，建议先执行{@link #normalize(String)}方法标准化路径后判断
*
* @param path 需要检查的Path
* @return 是否已经是绝对路径
*/
public static boolean isAbsolutePath(String path) {
if (StrUtil.isEmpty(path)) {
return false;
}
if (StrUtil.C_SLASH == path.charAt(0) || path.matches("^[a-zA-Z]:/.*")) {
// 给定的路径已经是绝对路径了
return true;
}
return false;
}
public static String readToString(String fileName) throws Exception {
String encoding;
byte[] filecontent;
FileInputStream in = null;
try {
encoding = "UTF-8";
File file = new File(fileName);
Long filelength = file.length();
filecontent = new byte[filelength.intValue()];
in = new FileInputStream(file);
in.read(filecontent);
} finally {
if (in != null) {
in.close();
}
}
return new String(filecontent, encoding);
}
public static String readResourceToString(String getClassPath, Class<?> baseClass) throws Exception {
InputStream is = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
is = baseClass.getResourceAsStream(getClassPath);
int i = -1;
while ((i = is.read()) != -1) {
baos.write(i);
}
} finally {
if (is != null) {
is.close();
}
}
return baos.toString("UTF-8");
}
public static String readToString(File file) throws Exception {
String encoding;
byte[] filecontent;
FileInputStream in = null;
try {
encoding = "UTF-8";
Long filelength = file.length();
filecontent = new byte[filelength.intValue()];
in = new FileInputStream(file);
in.read(filecontent);
} finally {
if (in != null) {
in.close();
}
}
return new String(filecontent, encoding);
}
}
