一个简单的Ear包实用类

一个简单的Ear包实用类，可以进行简单的Ear包内Jar文件的插入，替换，删除，但是它只能处理一个层次的文件操作，如果是想对Ear包里面的Jar包的文件进行操作等类似需求，则此类暂不能提供此功能

 

public class EarFileUtil
{
    private String sourceEarFilePath;
    private String targetEarFilePath;

    private static final String MODE_REPLACE = "replace";
    private static final String MODE_INSERT = "insert";
    private static final String MODE_DELETE = "delete";
    
    public static void main(String[] args)
    {
//        args = new String[5];
//        args[0] = "delete";
//        args[1] = "c:/test/source.ear";
//        args[2] = "c:/test/target.ear";
//        args[3] = "c:/test/targetJar.jar";
//        args[4] = "jarInEar.sar";
        List<String> commandList = new ArrayList();
//        commandList.add("replace c:/test/target.ear c:/test/target.ear jarInEar.jar c:/test/targetJar.jar");
//        commandList.add("insert c:/test/target.ear c:/test/target2.ear jarInEar.jar c:/test/targetJar.jar");
        commandList.add("delete c:/test/target.ear c:/test/target3.ear jarInEar");

        for (String commandStr : commandList)
        {
            System.out.println("executing command '" + commandStr + "'");

            args = commandStr.split(" ");

            EarFileUtil util = new EarFileUtil();
            if (args.length < 4)
            {
                util.printUsage();
                return;
            }

            String operate = args[0];

            String sourceEarFile = args[1];
            String targetEarFile = args[2];
            util.init(sourceEarFile, targetEarFile);

            if (operate.equals(MODE_REPLACE))
            {
                if (args.length < 5)
                {
                    util.printUsage();
                }
                String filePathInEar = args[3];
                String targetFile = args[4];

                util.operate(MODE_REPLACE, filePathInEar, targetFile);
            }
            else if (operate.equals(MODE_INSERT))
            {
                if (args.length < 5)
                {
                    util.printUsage();
                }

                String filePathInEar = args[3];
                String targetFile = args[4];

                util.operate(MODE_INSERT, filePathInEar, targetFile);
            }
            else if (operate.equals(MODE_DELETE))
            {
                String filePathInEar = args[3];

                util.operate(MODE_DELETE, filePathInEar, null);
            }
            else
            {
                util.printUsage();
            }
        }
    }

    public EarFileUtil()
    {
        
    }

    public void init(String sourceEarFilePath, String targetEarFilePath)
    {
        this.sourceEarFilePath = sourceEarFilePath;
        this.targetEarFilePath = targetEarFilePath;
    }

    public void printUsage()
    {
        System.out.println("Usage:");
        System.out.println("-------------------------------");
        System.out.println("  replace sourceEarFile targetEarFile filePathInEar targetPath");
        System.out.println("  insert sourceEarFile targetEarFile filePathInEar targetPath");
        System.out.println("  delete sourceEarFile targetEarFile filePathInEar");
        System.out.println("-------------------------------");
    }

    public void operate(String mode, String filePathInEar, String targetFile)
    {
        try
        {
            //先创建目标的ear包，再New一个JarOutputStream，以备输出目标Ear包之用
            File targetEarFile = new File(this.targetEarFilePath);
            targetEarFile.createNewFile();
            FileOutputStream targetEarFileOutputStream = new FileOutputStream(targetEarFile);
            JarOutputStream newJarOutputStream = new JarOutputStream(targetEarFileOutputStream);
            byte buffer[] = new byte[100];
            int bytesRead;

            //循环读取源Ear包里除开要替换的Jar包外的其它文件，并将这些文件写到目标Ear包里去
            JarFile sourceEarFile = new JarFile(this.sourceEarFilePath);
            Enumeration sourceEarJarEnties = sourceEarFile.entries();
            while (sourceEarJarEnties.hasMoreElements())
            {
                JarEntry jarEntry = (JarEntry) sourceEarJarEnties.nextElement();

                //要替换Jar包，跳过它
                if (mode.equals(MODE_REPLACE) || mode.equals(MODE_DELETE))
                {
                    System.out.println(jarEntry.toString());
                    if (jarEntry.toString().equals(filePathInEar))
                    {
                        continue;
                    }
                }

                //其它文件马上写到目标Ear包里去
                InputStream jarInputStream = sourceEarFile.getInputStream(jarEntry);
                newJarOutputStream.putNextEntry(jarEntry);
                while ((bytesRead = jarInputStream.read(buffer)) != -1)
                {
                    newJarOutputStream.write(buffer, 0, bytesRead);
                }
                newJarOutputStream.flush();
                jarInputStream.close();
            }
            //到这里源Ear包己经没有用了，close掉
            sourceEarFile.close();

            if (mode.equals(MODE_INSERT) || mode.equals(MODE_REPLACE))
            {
                JarEntry targetJarEntry = new JarEntry(filePathInEar);
                newJarOutputStream.putNextEntry(targetJarEntry);
                FileInputStream targetJarFileInputStream = new FileInputStream(targetFile);
                while ((bytesRead = targetJarFileInputStream.read(buffer)) != -1)
                {
                    newJarOutputStream.write(buffer, 0, bytesRead);
                }
                targetJarFileInputStream.close();
            }

            newJarOutputStream.flush();
            newJarOutputStream.close();
            targetEarFileOutputStream.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}