EAR、JAR文件的读写

1. 读取Jar包里的MANIFEST.MF文件（读取EAR包里的文件相同的操作），大概步骤如下：

    1）用Jar包的绝对路径作为构参，New一个JarFile类

    2）用Jar包里的一个文件文件的相对路径作为参数，调用JarFile类的一个getJarEntry的方法，得到一个JarEntry类

    3）再用这个Entry类作为参数，调用JarFile的getInputStream文法，得到这个文件的InputStream

    4）接下来对InputSteam的操作与普通读取文件的方法相同

 

Java代码  

1. StringBuffer sb = new StringBuffer();  
2. try  
3. {  
4.     JarFile testJarFile = new JarFile("c:/test/common.jar");  
5.     JarEntry jarEntry = testJarFile.getJarEntry("META-INF/MANIFEST.MF");  
6.     InputStream jarEntryInputStream = testJarFile.getInputStream(jarEntry);  
7.   
8.     BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(jarEntryInputStream));  
9.     String readLine = null;  
10.     while ((readLine = bufferedReader.readLine()) != null)  
11.     {  
12.         sb.append(readLine);  
13.         sb.append("\r\n");  
14.     }  
15.   
16.     System.out.println(sb.toString());  
17. }  
18. catch (IOException e)  
19. {  
20.     e.printStackTrace();  
21. }  

 

2. 输出ear包里的jar到其它目录，与从Jar包读取相似，操作步骤如下

    1）用Ear包的绝对路径作为构参，New一个JarFile类

    2）用目标Jar包的相对路径作为参数，调用JarFile的getJarEntry方法，得到一个JarEntry类

    3）用这个JarEntry作为参数，调用JarFile的getInputStream方法，取得这个Jar包文件的InputStream

    4）接下来对InputStream的操作与普通写文件操作相同

Java代码  

1. try  
2. {  
3.     JarFile testEarFile = new JarFile("C:/test/test.ear");  
4.     JarEntry jarEntry = testEarFile.getJarEntry("target.jar");  
5.     InputStream jarEntryInputStream = testEarFile.getInputStream(jarEntry);  
6.     FileOutputStream fileOutputStream = new FileOutputStream("c:/test/target.jar", true);  
7.     int b = 0;  
8.     while ((b = jarEntryInputStream.read()) != -1)  
9.     {  
10.         fileOutputStream.write(b);  
11.     }  
12.     fileOutputStream.flush();  
13.     fileOutputStream.close();  
14. }  
15. catch (IOException e)  
16. {  
17.     e.printStackTrace();  
18. }  

 

 3. 替换Ear包里的某些Jar包， 相对之前几个实例，这个会相对复杂一些，步骤如下：

     1）创建一个目标的Ear包File类，然后再得到一个JarOutputStream，接下来会往这里添加需要的Jar包

     2）读取源Ear包，然后JarFile类的entries()方法遍历源Ear包的所有文件

     3）判断要替换的Jar文件，跳过它，其它的文件马上写入目标的Ear包里

     4）关闭源Ear包

     5）建立要替换进来的Jar包的JarEntry，用FileInputStream类读取这个Jar包，然后马上写进目标Ear包里

     6）Flush JarOutputStream

     7）依次关闭其它仍未关闭的资源

Java代码  

1. try  
2. {  
3.     //先创建目标的ear包，再New一个JarOutputStream，以备输出目标Ear包之用  
4.     File targetEarFile = new File("c:/test/target.ear");  
5.     targetEarFile.createNewFile();  
6.     FileOutputStream targetEarFileOutputStream = new FileOutputStream(targetEarFile);  
7.     JarOutputStream newJarOutputStream = new JarOutputStream(targetEarFileOutputStream);  
8.     byte buffer[] = new byte[100];  
9.     int bytesRead;  
10.   
11.     //循环读取源Ear包里除开要替换的Jar包外的其它文件，并将这些文件写到目标Ear包里去  
12.     JarFile sourceEarFile = new JarFile("c:/test/sourceEar.ear");  
13.     Enumeration sourceEarJarEnties = sourceEarFile.entries();  
14.     while (sourceEarJarEnties.hasMoreElements())  
15.     {  
16.         JarEntry jarEntry = (JarEntry) sourceEarJarEnties.nextElement();  
17.   
18.         //要替换Jar包，跳过它  
19.         if (jarEntry.toString().equals("sourceJar.jar"))  
20.         {  
21.             continue;  
22.         }  
23.   
24.         //其它文件马上写到目标Ear包里去  
25.         InputStream jarInputStream = sourceEarFile.getInputStream(jarEntry);  
26.         newJarOutputStream.putNextEntry(jarEntry);  
27.         while ((bytesRead = jarInputStream.read(buffer)) != -1)  
28.         {  
29.             newJarOutputStream.write(buffer, 0, bytesRead);  
30.         }  
31.         newJarOutputStream.flush();  
32.         jarInputStream.close();  
33.     }  
34.     //到这里源Ear包己经没有用了，close掉  
35.     sourceEarFile.close();  
36.   
37.     JarEntry targetJarEntry = new JarEntry("targetJar.jar");  
38.     newJarOutputStream.putNextEntry(targetJarEntry);  
39.     FileInputStream targetJarFileInputStream = new FileInputStream("c:/test/targetJar.jar");  
40.     while ((bytesRead = targetJarFileInputStream.read(buffer)) != -1)  
41.     {  
42.         newJarOutputStream.write(buffer, 0, bytesRead);  
43.     }  
44.     newJarOutputStream.flush();  
45.     targetJarFileInputStream.close();  
46.     newJarOutputStream.close();  
47.     targetEarFileOutputStream.close();  
48. }  
49. catch (Exception ex)  
50. {  
51.     ex.printStackTrace();  
52. }