java jar包解析:打包文件，引入文件
cmd下：
jar命令:package包打包
javac命令:普通类文件打包
Hello.java:
package org.lxh.demo;
public class Hello{
public void print()
{
System.out.println("hello world");
}
}
1例如：
生成class可以执行文件：
javac -d . Hello.java
#前提：先手动生成org目录
#系统会自动生成 org.lxh.demo目录，并把hello.java文件生成在里面,
运行文件：
java hello
2.jar
jar -c 创建新的文档
-t 列出存档的内容的列表
-x 展开存档中的命令的文件
-u 更新一集存在的文档
-v 生成详细输出到输出标准上
-f 指定存档的文件名
例如：
将生成的 org目录打包成jar包
jar -cvf my.jar org
3.导入包
#导入此包下的所有文件
package  demo; #给此文件安排一个包，要不然编译错误
import org.lxh.demo.*;
public class Test{
public static void main(String args[])
{
Hello hello = new Hello();
hello.print();
}
}
4.如果运行Test.java报错，找不到jar路径，需要把jar包下的路径，加入
到系统路径里
cmd:
set classpath=.;d:/work/33/my.jar
或者在系统环境里面配置，新建CLASSPATH路径
例如：
cmd:
javac -d . Test.java
java demo.Test

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。

在应用程序中处理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的字样输出！

在学习和开发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公布于众，为了避免他人反编译，可以使用混淆器，但也只是增加代码阅读的困难性。如果不是作为商业运用，我们还是希望开发者能够提供源代码，互相学习探讨。