Eclipse用Runnable JAR file方式打jar包，并用该jar包进行二次开发

目录：

1.eclipse创建Java项目（带jar包的）

2. eclipse用Export的Runnable JAR file方式打jar包（带jar包的）

打jar包

1）class2json1.jar  （把引入的json相关的jar包转换成class，还有自己的类）

2）class2json2.jar （引入的json相关的jar包保留在该jar包内，还有自己的类）

3）class2json3.jar （只有自己的类）

3. 用该jar包进行二次开发

    命令行测试

Java变成测试jar包

        1） 新建TestClass2Json1项目，测试第一个jar包

2） 还是在TestClass2Json1项目中，测试第二个jar包 （先把引入的jar包去掉）

        3） 还是在TestClass2Json1项目中，测试第三个jar包（先把引入的jar包去掉）

1.eclipse创建Java项目（带jar包的）

eclipse，创建java Project项目后，右键项目new一个名为lib的file Folder，用来存放需要的额外jar包，本项目需要用到JSON，所以需要引入相关jar包。

我设计了三个类，分别是 PersonData.java、DataClass2Json.java以及 TestDataClass2Json.java，具体代码如下所示：

PersonData.java是个人员数据类，主要存储人员数据的。

package com.zc.dataclass.main;

import java.io.Serializable;

public class PersonData implements Serializable {
    private static final long serialVersionUID = 1L;

    private String xm;  //姓名
    private String xb;  //性别
    private String sr;  //生日
    public String getXm() {
        return xm;
    }
    public void setXm(String xm) {
        this.xm = xm;
    }
    public String getXb() {
        return xb;
    }
    public void setXb(String xb) {
        this.xb = xb;
    }
    public String getSr() {
        return sr;
    }
    public void setSr(String sr) {
        this.sr = sr;
    }

}

DataClass2Json.java 主要是将数据类转换成JSON

package com.zc.class2json.trans.main;

import java.util.List;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

/**
 * @author zhangchao
 * @date 2018-08-22
 * 将数据类转换成Json格式数据
 */
public class DataClass2Json {
    public JSONObject data2JsonObj(Object obj) {
        JSONObject jsonObj = JSONObject.fromObject(obj);
        return jsonObj;
    }

    public JSONArray data2JsonArr(Object obj) {
        JSONArray jsonArr = JSONArray.fromObject(obj);
        return jsonArr;
    }

    public JSONArray data2JsonArr(List<Object> list) {
        JSONArray jsonArr = JSONArray.fromObject(list);
        return jsonArr;
    }
}

TestDataClass2Json.java 测试

package com.zc.class2json.trans.test;

import java.util.ArrayList;
import java.util.List;

import com.zc.class2json.trans.main.DataClass2Json;
import com.zc.dataclass.main.PersonData;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class TestDataClass2Json {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<PersonData> listPD = getPersonData();
        DataClass2Json dcj = new DataClass2Json();
        JSONArray jsonArr = dcj.data2JsonArr(listPD);
        System.out.println(jsonArr.toString());
        //System.out.println(dcj.data2JsonObj(listPD).toString());

        PersonData pd1 = new PersonData();
        pd1.setXm("张三");
        pd1.setXb("男");
        pd1.setSr("1988-07-20");
        JSONObject jsonObj = dcj.data2JsonObj(pd1);
        System.out.println(jsonObj.toString());

        JSONArray jsonArr1 = dcj.data2JsonArr(pd1);
        System.out.println(jsonArr1.toString());
    }

    /*
     * 获取类数据
     */
    public static List<PersonData> getPersonData() {
        PersonData pd1 = new PersonData();
        pd1.setXm("李四");
        pd1.setXb("男");
        pd1.setSr("1991-01-12");

        PersonData pd2 = new PersonData();
        pd2.setXm("张楠");
        pd2.setXb("女");
        pd2.setSr("1995-05-10");

        List<PersonData> pd = new ArrayList<PersonData>();
        pd.add(pd1);
        pd.add(pd2);
        //System.out.println("");

        return pd;
    }
}

运行结果如下所示：

[{"sr":"1991-01-12","xb":"男","xm":"李四"},{"sr":"1995-05-10","xb":"女","xm":"张楠"}]
{"sr":"1988-07-20","xb":"男","xm":"张三"}
[{"sr":"1988-07-20","xb":"男","xm":"张三"}]

2. eclipse用Export的Runnable JAR file方式打jar包（带jar包的）

右键该项目选择Export，弹出的对话框，选择Java中的Runnable JAR File

点击next

    

Launch configuration  选择jar包默认运行的主类（包含main方法），Export destination 选择jar包的存放位置以及名称。

之后是3种打Runnable JAR file方式的方式，我们每个都试了下，分别对应class2json1.jar、class2json2.jar以及 （ class2json3.jar 和 class2json3_lib）

library handling中，（自己这三种都试一下）
第一个为提取extract需要的依赖的库或jar合成到jar文件里；
 （把自己的项目class以及lib中jar包中的class，混合在一起）；
  其它项目中直接引用该jar包，不需要加入它所需的额外jar包，就可以执行我们的类（但可能和项目引入的额外jar包引起jar包冲突）；命令行也可以直接运行 java -jar XXX.jar
第二个则仅仅打包依赖库到jar文件；
  (把依赖的外部jar包，引入我们jar文件中)
  其它项目中直接引用该jar包，但需要加入它所需的额外jar包，才可以执行我们的类，造成jar包重复；命令行也可以直接运行 java -jar XXX.jar
第三个则把依赖库放到一个文件夹中。
  （没有外部依赖的jar包，只有自己的类）
  其它项目中直接引用该jar包，需要加入它所需的额外jar包，就可以执行我们的类；命令行也需要引入依赖jar包，才能运行 java -jar XXX.jar

由项目可知，运行我们的项目包括3部分：

1： 我们自己编写的java
2： java运行jdk中的jar包
3.：我们引入的额外的jar包

 

1）class2json1.jar  （把引入的json相关的jar包转换成class，还有自己的类）

com：中都是我自己写的类编译后的class文件
META-INF：
net：引入的JSON相关jar包中的类，转化成class
org：引入的JSON相关jar包中的类，转化成class

2）class2json2.jar （引入的json相关的jar包保留在该jar包内，还有自己的类）

com：中都是我自己写的类编译后的class文件
META-INF：
org：是eclipse自动生成的jar包加载类
下面就是引入的相关jar包

3）class2json3.jar （只有自己的类）

com：中都是我自己写的类编译后的class文件
META-INF：

class2json3_lib

所以class2json3.jar 和class2json3_lib在一个文件下，命令行才可以执行，因为META-INF/MANIFEST.MF，即该jar包会关联class2json3_lib中这些相关jia包

Manifest-Version: 1.0
Class-Path: . class2json3_lib/commons-beanutils-1.8.0.jar class2json3_
 lib/commons-collections-3.2.1.jar class2json3_lib/commons-lang-2.4.ja
 r class2json3_lib/commons-logging-1.1.3.jar class2json3_lib/ezmorph-1
 .0.6.jar class2json3_lib/json-lib-2.3-jdk15.jar
Main-Class: com.zc.class2json.trans.test.TestDataClass2Json

3. 用该jar包进行二次开发

命令行测试：

我们现在命令行测试一下：

java -jar class2json1.jar

java -jar class2json2.jar

java -jar class2json3.jar

结果：

其实：

class2json1.jar和class2json2.jar都可以单独运行；
而 class2json3.jar不能单独运行，必须和class2json3_lib放在一起。

Java变成测试jar包

1） 新建TestClass2Json1项目，测试第一个jar包

TestJar1.java  和最开始的项目的主类一样，只是类名不一样

import java.util.ArrayList;
import java.util.List;

import com.zc.class2json.trans.main.DataClass2Json;
import com.zc.dataclass.main.PersonData;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class TestJar1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<PersonData> listPD = getPersonData();
        DataClass2Json dcj = new DataClass2Json();
        JSONArray jsonArr = dcj.data2JsonArr(listPD);
        System.out.println(jsonArr.toString());
        //System.out.println(dcj.data2JsonObj(listPD).toString());

        PersonData pd1 = new PersonData();
        pd1.setXm("张三");
        pd1.setXb("男");
        pd1.setSr("1988-07-20");
        JSONObject jsonObj = dcj.data2JsonObj(pd1);
        System.out.println(jsonObj.toString());

        JSONArray jsonArr1 = dcj.data2JsonArr(pd1);
        System.out.println(jsonArr1.toString());
    }

    /*
     * 获取类数据
     */
    public static List<PersonData> getPersonData() {
        PersonData pd1 = new PersonData();
        pd1.setXm("李四");
        pd1.setXb("男");
        pd1.setSr("1991-01-12");

        PersonData pd2 = new PersonData();
        pd2.setXm("张楠");
        pd2.setXb("女");
        pd2.setSr("1995-05-10");

        List<PersonData> pd = new ArrayList<PersonData>();
        pd.add(pd1);
        pd.add(pd2);
        //System.out.println("");

        return pd;
    }

}

结果：

[{"sr":"1991-01-12","xb":"男","xm":"李四"},{"sr":"1995-05-10","xb":"女","xm":"张楠"}]
{"sr":"1988-07-20","xb":"男","xm":"张三"}
[{"sr":"1988-07-20","xb":"男","xm":"张三"}]

结论：

我们只是引入了class2json1.jar，就可以运行。
注意，不要再在项目里引入json相关jar包，会冲突

2） 还是在TestClass2Json1项目中，测试第二个jar包 （先把引入的jar包去掉）

  

因此，只引入class2json2.jar会报错，因为不识别头部的json包。原因是该jar包内部的json相关的jar包不能被外部的Java文件识别。

所以还要再引入json相关jar包，如下。因此这种方法不适合Java二次开发。

这时就没有报错，结果如下：

结果：

[{"sr":"1991-01-12","xb":"男","xm":"李四"},{"sr":"1995-05-10","xb":"女","xm":"张楠"}]
{"sr":"1988-07-20","xb":"男","xm":"张三"}
[{"sr":"1988-07-20","xb":"男","xm":"张三"}]

结论：

我们只是引入了class2json2.jar，不可以执行，因为该jar包内部的json相关的jar包不能被外部的Java文件识别。必须再引入json相关jar包，才可以运行。

3） 还是在TestClass2Json1项目中，测试第三个jar包（先把引入的jar包去掉）

  

因此，只引入class2json3.jar会报错，因为不识别头部的json包。原因是jar文件只有自己的class文件，没有json相关jar包的class。

所以还要再引入json相关jar包，如下。

这时就没有报错，结果如下：

结果：

[{"sr":"1991-01-12","xb":"男","xm":"李四"},{"sr":"1995-05-10","xb":"女","xm":"张楠"}]
{"sr":"1988-07-20","xb":"男","xm":"张三"}
[{"sr":"1988-07-20","xb":"男","xm":"张三"}]

结论：

我们只是引入了class2json3.jar，不可以执行，因为缺少json相关jar包。必须再引入json相关jar包，才可以运行。