在应用程序中处理Jar文件简单介绍了如何使用java.util.jar包提供的API操作jar文件，下面通过一个相对复杂的例子讲述一些Jar文件相关的高级应用。仔细读读这篇文章并参考一下相关的java doc会对你学习java语言有很大的帮助。
 
下面的应用程序将实现从http服务器装载并执行一个jar文件的功能，比如你的Jar文件的地址为hello.jar。要实现这个功能我们应该首先建立与这个文件的连接然后通过MANIFEST的信息描述得到Main-Class的值，最后装载并运行这个class。这里面需要用到java.net和反射的一些重要知识。这个应用程序由两个类组成：JarClassLoader和JarRunner。
 
JarClassLoader扩展了URLClassLoader，它有一个成员为URL类型的url变量。
 
publicJarClassLoader(URL url)
 
{super(newURL[] { url });this.url =url;
 
}
 
它的两个重要方法是getMainClassName()和invokeClass()，其中前者的目的是通过URL和jar取得连接后，读取MANIFEST的Main-Class属性从而得到应用程序的入点，这非常重要。得到入点后我们就可以通过反射机制装载和运行得到的主类。
 
public String getMainClassName() throwsIOException {
 
URL u= new URL("jar", "", url + "!/");
 
JarURLConnection uc=(JarURLConnection)u.openConnection();
 
Attributes attr=uc.getMainAttributes();return attr != null
 
?attr.getValue(Attributes.Name.MAIN_CLASS)
 
:null;
 
}public voidinvokeClass(String name, String[] args)throwsClassNotFoundException,
 
NoSuchMethodException,
 
InvocationTargetException
 
{
 
Class c= this.loadClass(name);
 
Method m= c.getMethod("main", newClass[] { args.getClass() });
 
m.setAccessible(true);int mods =m.getModifiers();if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||
 
!Modifier.isPublic(mods)) {throw new NoSuchMethodException("main");
 
}try{
 
m.invoke(null, newObject[] { args });
 
}catch(IllegalAccessException e) {//This should not happen, as we have disabled access checks
 
}
 
}
 
URL u= new URL("jar", "", url + "!/");
 
JarURLConnection uc= (JarURLConnection)u.openConnection();
 
这两段代码构造一个JarURLConnection的实例，注意!/的分隔符的意思是这个url表示的是整个jar文件。这样我们就建立了和jar文件的通信。方法中的后面两句话得到jar文件的主类。在invokeClass方法中，我们首先通过ClassLoader的方法得到包括程序入口的主类，然后得到main方法，判断main方法为我们需要的方法后则调Method的invoke方法执行这个应用程序。
 
下面是源程序的代码
 
importjava.net.URL;importjava.net.URLClassLoader;importjava.net.JarURLConnection;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;importjava.lang.reflect.InvocationTargetException;importjava.util.jar.Attributes;importjava.io.IOException;class JarClassLoader extendsURLClassLoader {privateURL url;publicJarClassLoader(URL url) {super(newURL[] { url });this.url =url;
 
}public String getMainClassName() throwsIOException {
 
URL u= new URL("jar", "", url + "!/");
 
JarURLConnection uc=(JarURLConnection)u.openConnection();
 
Attributes attr=uc.getMainAttributes();return attr != null ? attr.getValue(Attributes.Name.MAIN_CLASS) : null;
 
}public voidinvokeClass(String name, String[] args)throwsClassNotFoundException,
 
NoSuchMethodException,
 
InvocationTargetException
 
{
 
Class c= this.loadClass(name);
 
Method m= c.getMethod("main", newClass[] { args.getClass() });
 
m.setAccessible(true);int mods =m.getModifiers();if (m.getReturnType() != void.class || !Modifier.isStatic(mods) ||
 
!Modifier.isPublic(mods)) {throw new NoSuchMethodException("main");
 
}try{
 
m.invoke(null, newObject[] { args });
 
}catch(IllegalAccessException e) {//This should not happen, as we have disabled access checks
 
}
 
}
 
}
 
importjava.io.IOException;importjava.net.URL;importjava.net.MalformedURLException;importjava.lang.reflect.InvocationTargetException;/*** Runs a jar application from any url. Usage is 'java JarRunner url [args..]'
 
* where url is the url of the jar file and args is optional arguments to
 
* be passed to the application's main method.*/
 
public classJarRunner {public static voidmain(String[] args) {if (args.length < 1) {
 
usage();
 
}
 
URL url= null;try{
 
url= new URL(args[0]);
 
}catch(MalformedURLException e) {
 
fatal("Invalid URL: " + args[0]);
 
}//Create the class loader for the application jar file
 
JarClassLoader cl = newJarClassLoader(url);//Get the application's main class name
 
String name = null;try{
 
name=cl.getMainClassName();
 
}catch(IOException e) {
 
System.err.println("I/O error while loading JAR file:");
 
e.printStackTrace();
 
System.exit(1);
 
}if (name == null) {
 
fatal("Specified jar file does not contain a 'Main-Class'" +
 
" manifest attribute");
 
}//Get arguments for the application
 
String[] newArgs = new String[args.length - 1];
 
System.arraycopy(args,1, newArgs, 0, newArgs.length);//Invoke application's main class
 
try{
 
cl.invokeClass(name, newArgs);
 
}catch(ClassNotFoundException e) {
 
fatal("Class not found: " +name);
 
}catch(NoSuchMethodException e) {
 
fatal("Class does not define a 'main' method: " +name);
 
}catch(InvocationTargetException e) {
 
e.getTargetException().printStackTrace();
 
System.exit(1);
 
}
 
}private static voidfatal(String s) {
 
System.err.println(s);
 
System.exit(1);
 
}private static voidusage() {
 
fatal("Usage: java JarRunner url [args..]");
 
}
 
}
 
我们编写一个简单的HelloWorld程序，然后打个jar包，注意你的jar包内的MANIFEST文件一定要包括Main-Class: HelloWorld，否则的话找不到程序的入口。把它放在一个web服务器上比如http://localhost/hello.jar。编译源程序后执行
 
java JarRunner http://localhost/hello.jar (可以含有参数)在控制台我们会看到hello world的字样输出！

 
1、使用JarFile类读取jar包MANIFEST.MF中的Main-Class，如果没有设置Main-Class则调用方法中指定执行函数
 
2、解压jar文件
 
3、设置classPath
 
4、利用反射取得class和method，并运行该method
 
如下代码Run.java将被打包到jar文件中，使用Maven构建并打包：
 
package com.chenzehe.runjar;
 
public class Run {
 
/**
 
* @param args
 
*/
 
public static void main(String[] args) {
 
System.out.println("run......");
 
if (args.length > 0) {
 
System.out.println("args: " + args[0]);
 
}
 
}
 
}
 
开始打包没有指定在MANIFEST.MF中指定Main-Class，下面运行时只能指定要运行的类。
 
RunJar.java为解析并执行该jar文件方法的类：
 
package com.chenzehe.runjar;
 
import java.io.File;
 
import java.io.FileOutputStream;
 
import java.io.IOException;
 
import java.io.InputStream;
 
import java.io.OutputStream;
 
import java.lang.reflect.Array;
 
import java.lang.reflect.InvocationTargetException;
 
import java.lang.reflect.Method;
 
import java.net.URL;
 
import java.net.URLClassLoader;
 
import java.util.ArrayList;
 
import java.util.Arrays;
 
import java.util.Enumeration;
 
import java.util.jar.JarEntry;
 
import java.util.jar.JarFile;
 
import java.util.jar.Manifest;
 
public class RunJar {
 
/**
 
* @param args
 
*/
 
public static void main(String[] args) throws Throwable {
 
String usage = "RunJar jarFile [mainClass] args...";
 
if (args.length < 1) {
 
System.err.println(usage);
 
System.exit(-1);
 
}
 
int firstArg = 0;
 
String fileName = args[firstArg++];
 
File file = new File(fileName);
 
// 从jar文件MANIFEST.MF中读取Main-Class
 
String mainClassName = null;
 
JarFile jarFile;
 
try {
 
jarFile = new JarFile(fileName);
 
} catch (IOException io) {
 
throw new IOException("Error opening job jar: " + fileName)
 
.initCause(io);
 
}
 
Manifest manifest = jarFile.getManifest();
 
if (manifest != null) {
 
mainClassName = manifest.getMainAttributes().getValue("Main-Class");
 
}
 
jarFile.close();
 
if (mainClassName == null) {
 
if (args.length < 2) {
 
System.err.println(usage);
 
System.exit(-1);
 
}
 
// 如果MANIFEST.MF未设置Main-Class,则用户输入
 
mainClassName = args[firstArg++];
 
}
 
mainClassName = mainClassName.replaceAll("/", ".");
 
final File workDir = File.createTempFile("unjar", "",
 
new File(System.getProperty("user.dir")));
 
workDir.delete();
 
workDir.mkdirs();
 
if (!workDir.isDirectory()) {
 
System.err.println("Mkdirs failed to create " + workDir);
 
System.exit(-1);
 
}
 
// 解压jar文件
 
unJar(file, workDir);
 
// 设置classPath
 
ArrayList classPath = new ArrayList();
 
classPath.add(new File(workDir + "/").toURL());
 
classPath.add(file.toURL());
 
ClassLoader loader = new URLClassLoader(classPath.toArray(new URL[0]));
 
Thread.currentThread().setContextClassLoader(loader);
 
// 利用反射取得class和method
 
Class> mainClass = Class.forName(mainClassName, true, loader);
 
Method main = mainClass.getMethod("main", new Class[] { Array
 
.newInstance(String.class, 0).getClass() });
 
String[] newArgs = Arrays.asList(args).subList(firstArg, args.length)
 
.toArray(new String[0]);
 
try {
 
// 运行方法
 
main.invoke(null, new Object[] { newArgs });
 
} catch (InvocationTargetException e) {
 
throw e.getTargetException();
 
}
 
}
 
//解压jar包中的文件到toDir目录
 
public static void unJar(File jarFile, File toDir) throws IOException {
 
JarFile jar = new JarFile(jarFile);
 
try {
 
Enumeration entries = jar.entries();
 
while (entries.hasMoreElements()) {
 
JarEntry entry = (JarEntry) entries.nextElement();
 
if (!entry.isDirectory()) {
 
InputStream in = jar.getInputStream(entry);
 
try {
 
File file = new File(toDir, entry.getName());
 
if (!file.getParentFile().mkdirs()) {
 
if (!file.getParentFile().isDirectory()) {
 
throw new IOException(
 
"Mkdirs failed to create "
 
+ file.getParentFile()
 
.toString());
 
}
 
}
 
OutputStream out = new FileOutputStream(file);
 
try {
 
byte[] buffer = new byte[8192];
 
int i;
 
while ((i = in.read(buffer)) != -1) {
 
out.write(buffer, 0, i);
 
}
 
} finally {
 
out.close();
 
}
 
} finally {
 
in.close();
 
}
 
}
 
}
 
} finally {
 
jar.close();
 
}
 
}
 
}
 
该代码为Hadoop中job提交到服务器调用的代码RunJar。

 
在学习和开发java项目中，我们经常会用到第三方提供的一些jar。使用这些第三方工具包，可以提高我们开发的效率，缩短开发的时间。有的第三方工具，提供详细的使用说明和源代码，有时有的却不提供源代码，使用说明也不是很详细，这对我们使用就非常不方便。
 

 
有道是，知其然才知其所以然。有时候，我们必须读取jar里的打包的类。而有时还有可能要对它进行小量修改，使之适用于自己的特殊需求。
 
前期准备
 
Java反编译工具：
 
强烈推荐，小颖java源代码反编译系列专家1.4终极版。
 
压缩工具：
 
Winrar
 
开始
 
1. 将jar包解压
 
我们可以使用winrar工具将jar解压到指定目录
 
2. 反编译class
 
使用 Java 反编译工具，将class文件反编译为java文件。(大多数反编译工具只提供单个class文件的反编译，这里推荐"小颖JAVA源代码反编译"工具，可以反编译一个目录下的所有class文件)
 
3. 构建项目
 
我们将反编译后的java文件设为项目的源文件目录。
 
将jar，及jar所需要的其它lib，作为libraries加入项目中，这样可以保证我们的java文件可以编译。
 
4. 对反编译的java进行修改
 
通过反编译的java文件，可能还有错误，不能编译通过，在不影响作者原始意图的前提下，我们必须对它进行小量修改，保证可编译通过。
 
保证java文件可以编译通过后，我们再在其基础上进行修改，使之符合自己的需求。
 
5. 编译修改的java
 
编译修改后的java文件，注意的是，最好只编译修改的单个java文件。
 
编译完成后，我们进行测试，保证修改无误。因为JVM会先找寻classes目录下的class文件，并率先加入，这样我们修改编译后的class文件，便是测试时使用的class文件。
 
重复这个过程，直至java达到我们的目的。
 
6. Jar打包
 
将修改生成后的class文件，替换我们将jar解压缩目录下的相应class文件，重新打包生成jar。
 
我们可以使用jar命令进行打包，也可以使用winrar工具进行打包。使用winrar工具打包时，要注意选择压缩文件格式为zip，并将生成的压缩包文件的后缀名设置为jar。
 
替换原来的jar。再进行最后一次测试。
 
总结
 
由于Java的跨平台性，使得java的class文件可以进行反编译，我们可以对jar文件进行修改，使之适用于自己的需求。
 
对jar文件进行修改，我们必须首先获得jar开发者的同意。
 
对jar文件进行修改，首先必须对反编译的java文件比较熟悉。这就必须有良好的代码阅读能力，清楚作者的技术架构和开发设计思想。如果没有把握，最好能与jar开发者联系，提出你的需求。
 
对于某些java开发者来说，并不希望将自己辛辛苦苦写的code公布于众，为了避免他人反编译，可以使用混淆器，但也只是增加代码阅读的困难性。如果不是作为商业运用，我们还是希望开发者能够提供源代码，互相学习探讨。

 
解析xml文件用到了dom4j-1.6.1.jar包，具体版本可能有新旧之分，我提供如下某度云盘，供下载测试用。
 
链接：http://pan.baidu.com/s/1i5Aw8Jz 密码：qma7
 
下面是我的测试代码：
 
先是主要测试文件：
 
package com.lxk.xmlTest;
 
import com.google.common.collect.Lists;
 
import org.dom4j.Document;
 
import org.dom4j.DocumentException;
 
import org.dom4j.Element;
 
import org.dom4j.io.SAXReader;
 
import java.io.File;
 
import java.util.Arrays;
 
import java.util.List;
 
/**
 
* Created by lxk on 2016/11/10
 
*/
 
public class XmlTest {
 
public static void main(String[] args) {
 
xmlTest();
 
}
 
/**
 
* 测试解析xml文件
 
*/
 
@SuppressWarnings("unchecked")
 
private static void xmlTest() {
 
SAXReader reader = new SAXReader();
 
reader.setEncoding("utf-8");
 
Document document;
 
try {
 
document = reader.read(new File("src/testConfig.xml"));
 
Element root = document.getRootElement();//得到xml跟标签，此处是
 
List list = root.elements("stream");
 
List xmlNodeList = Lists.newArrayList();//得到xml文件的配置信息
 
for (Element e : list) {
 
List streamIds = Arrays.asList(e.element("streamId").getStringValue().split(","));
 
XmlModel temp = new XmlModel(streamIds, e.element("name").getStringValue());
 
xmlNodeList.add(temp);
 
}
 
for (XmlModel xmlModel : xmlNodeList) {
 
System.out.println(xmlModel);
 
}
 
} catch (DocumentException e) {
 
e.printStackTrace();
 
}
 
}
 
}
 
然后是节点model文件：
 
package com.lxk.xmlTest;
 
import java.util.List;
 
/**
 
* 配置文件节点 model
 
* 
 
* Created by lxk on 2016/11/10
 
*/
 
public class XmlModel {
 
/**
 
* 流ID
 
*/
 
private List streamIds;
 
/**
 
* 流名称
 
*/
 
private String name;
 
/**
 
* 默认构造函数
 
* (在构造model的时候，若要添加新的带参数构造函数，那么这个默认函数一定要写。避免出现你不知道的错)
 
*/
 
public XmlModel() {
 
}
 
/**
 
* 带参构造函数
 
*/
 
public XmlModel(List streamIds, String name) {
 
this.streamIds = streamIds;
 
this.name = name;
 
}
 
public List getStreamIds() {
 
return streamIds;
 
}
 
public void setStreamIds(List streamIds) {
 
this.streamIds = streamIds;
 
}
 
public String getName() {
 
return name;
 
}
 
public void setName(String name) {
 
this.name = name;
 
}
 
@Override
 
public String toString() {
 
return "单个节点{" +
 
"streamIds=" + streamIds +
 
", name='" + name + '\'' +
 
'}';
 
}
 
}
 
最后是xml配置文件：(里面的标签随自己意取名，在Java文件对应就可以)
 
576a32b7393048060fdeb463,57198f91c5e62fca950103fd
 
借记卡及贷记卡总量
 
57ba9ea8e4b040a7317c86a0,57f88f52e4b0fbcf8381665f
 
支付宝-借记卡
 
580f0b32e4b034a9cf9eaaa6
 
支付宝-贷记卡
 
580f058ee4b034a9cf9eaaa2
 
财付通-借记卡
 
57918dade4b0e55b2369e165
 
财付通-贷记卡
 
579af7c3e4b0c5e678ed9853
 
其他借记卡快捷类交易
 
580f0c2ae4b034a9cf9eaaa8
 
其他贷记卡快捷类交易
 
运行结果：