WarUtil.java Source code

Java tutorial

Introduction

Here is the source code for WarUtil.java

Source

/*
 * Copyright 2005-2010 the original author or authors.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
//package sdloader.util;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Properties;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;

/**
 * WarUtil
 * 
 * @author c9katayama
 */
public class WarUtil {

    //private static SDLoaderLog log = SDLoaderLogFactory.getLog(WarUtil.class);

    private static final String LAST_MODIFIED_FILE = ".warlastmodified";

    /**
     * War?????????
     * 
     * @param warFileName
     * @return
     */
    public static String getArchiveName(final String warFileName) {
        return warFileName.substring(0, warFileName.length() - ".war".length());
    }

    private static long readLastModifiled(File file) {
        if (file.exists()) {
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new FileReader(file));
                return Long.valueOf(reader.readLine());
            } catch (Exception e) {
                //   log.debug(e.getMessage(), e);
            }
        }
        return 0;
    }

    private static void writeLastModifiled(File file, long time) {
        BufferedWriter writer = null;
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            writer = new BufferedWriter(new FileWriter(file));
            writer.write(Long.toString(time));
            writer.flush();
        } catch (Exception e) {

        }
    }

    /**
     * WAR???????????
     * 
     * @param warFile
     * @param directory
     * @throws IOException
     */
    public static void extractWar(File warFile, File directory) throws IOException {
        try {
            long timestamp = warFile.lastModified();
            File warModifiedTimeFile = new File(directory, LAST_MODIFIED_FILE);
            long lastModified = readLastModifiled(warModifiedTimeFile);

            if (timestamp == lastModified) {
                //      log.info("war file " + warFile.getName() + " not modified.");
                return;
            }
            if (directory.exists()) {
                //         IOUtil.forceRemoveDirectory(directory);
                directory.mkdir();
            }

            //         log.info("war extract start. warfile=" + warFile.getName());

            JarInputStream jin = new JarInputStream(new BufferedInputStream(new FileInputStream(warFile)));
            JarEntry entry = null;

            while ((entry = jin.getNextJarEntry()) != null) {
                File file = new File(directory, entry.getName());

                if (entry.isDirectory()) {
                    if (!file.exists()) {
                        file.mkdirs();
                    }
                } else {
                    File dir = new File(file.getParent());
                    if (!dir.exists()) {
                        dir.mkdirs();
                    }

                    FileOutputStream fout = null;
                    try {
                        fout = new FileOutputStream(file);
                        ResourceUtil.copyStream(jin, fout);
                    } finally {
                        fout.flush();
                        fout.close();
                        fout = null;
                    }

                    if (entry.getTime() >= 0) {
                        file.setLastModified(entry.getTime());
                    }
                }
            }

            writeLastModifiled(warModifiedTimeFile, timestamp);

            //log.info("war extract success. lastmodified=" + timestamp);
        } catch (IOException ioe) {
            //log.info("war extract fail.");
            throw ioe;
        }
    }
}

class ResourceUtil {

    private static final int DEFAULT_BUFFER_SIZE = 16 * 1024;

    private static final String SLASH = "/";
    private static final String FILE_PROTOCOL = "file";

    public static String stripFirstProtocolPart(String path) {
        return path.substring(path.indexOf(":") + 1, path.length());
    }

    public static String stripExtension(String value) {
        int dot = value.lastIndexOf(".");
        if (dot >= 0) {
            value = value.substring(0, dot);
        }
        return value;
    }

    public static URL createURL(final String url) {
        try {
            return new URL(url);
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    public static URL createURL(final URL baseURL, String relativeURL) {
        try {
            String protocol = baseURL.getProtocol();
            relativeURL = relativeURL.replace("\\", SLASH);
            // TODO
            if (protocol.startsWith(FILE_PROTOCOL)) {
                if (relativeURL.startsWith(SLASH)) {
                    relativeURL = relativeURL.substring(1, relativeURL.length());
                }
                return new URL(baseURL, relativeURL);
            } else {
                // TODO
                String baseArchivePath = baseURL.toExternalForm();
                if (baseArchivePath.endsWith(SLASH)) {
                    baseArchivePath = baseArchivePath.substring(0, baseArchivePath.length() - 1);
                }
                if (baseArchivePath.endsWith("!")) {
                    baseArchivePath = baseArchivePath.substring(0, baseArchivePath.length() - 1);
                }
                if (!relativeURL.startsWith(SLASH)) {
                    relativeURL = SLASH + relativeURL;
                }
                return new URL(baseArchivePath + "!" + relativeURL);
            }
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
    }

    public static boolean isAbsoluteURL(String url) {
        return (url.indexOf(":/") != -1);
    }

    public static boolean isResourceExist(URL resource) {
        if (resource.getProtocol().equals(FILE_PROTOCOL)) {
            try {
                File file = new File(resource.toURI());
                return file.exists();
            } catch (URISyntaxException e) {
                return false;
            }
        }
        InputStream is = null;
        try {
            is = resource.openStream();
            return (is != null);
        } catch (Exception ioe) {
            return false;
        }
    }

    public static boolean isFileResource(URL resource) {
        return !resource.toExternalForm().endsWith(SLASH);
    }

    public static boolean isDirectoryResource(URL resource) {
        return resource.toExternalForm().endsWith(SLASH);
    }

    public static Properties loadProperties(String path, Class<?> caller) {
        InputStream is = getResourceAsStream(path, caller);
        if (is == null) {
            return null;
        }
        Properties p = new Properties();
        try {
            p.load(is);
        } catch (IOException ioe) {
            return null;
        }
        return p;
    }

    /**
     * ?????????????????
     * 
     * @param path
     * @param caller
     * @return
     */
    public static InputStream getResourceAsStream(String path, Class<?> caller) {

        String resource = path;
        if (resource.startsWith(SLASH)) {
            resource = resource.substring(1);
        }

        InputStream is = null;
        File file = new File(path);
        if (file.exists() && file.isFile()) {
            try {
                is = new FileInputStream(file);
            } catch (FileNotFoundException e) {
            }
        }
        if (is == null) {
            ClassLoader tcl = Thread.currentThread().getContextClassLoader();
            if (tcl != null) {
                is = tcl.getResourceAsStream(resource);
            }
        }
        if (is == null) {
            is = caller.getResourceAsStream(path);
        }
        if (is == null) {
            is = ClassLoader.class.getResourceAsStream(path);
        }
        if (is == null) {
            is = ClassLoader.getSystemResourceAsStream(resource);
        }

        return is;
    }

    /**
     * ?????????????
     * 
     * @param in
     * @param out
     * @param ???????
     * @return ?????????
     * @throws IOException
     */
    public static final long copyStream(InputStream in, OutputStream out) throws IOException {
        return copyStream(in, out, DEFAULT_BUFFER_SIZE);
    }

    /**
     * ?????????????
     * 
     * @param in
     * @param out
     * @return ?????????
     * @throws IOException
     */
    public static final long copyStream(InputStream in, OutputStream out, int bufferSize) throws IOException {
        byte[] buf = new byte[bufferSize];
        long totalSize = 0;
        int s = -1;
        while ((s = in.read(buf)) != -1) {
            out.write(buf, 0, s);
            totalSize += s;
        }
        buf = null;
        return totalSize;
    }

    /**
     * InputStream??byte[]???????
     * 
     * @param is
     * @return
     * @throws IOException
     */
    public static final byte[] getBytes(InputStream is) throws IOException {
        ByteDataBuffer buf = new ByteDataBuffer();
        copyStream(is, buf.getOutputStream());
        return buf.toByteArray();
    }
}