Apache commons-net用法的一个示例

jar:

commons-io-2.4.jar
commons-net-3.3.jar

Code：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketException;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;

import entity.Config;

public class FTPUtil {
    private Config _config;

    public FTPUtil(Config config) {
        this._config = config;
    }

    public void download(String remoteDir, List<String> remoteFileNames, String localDir) throws IOException{
        FTPClient ftp = new FTPClient();
        try {
            connectServer(ftp);
            configFTPClient(ftp);
            ftp.changeWorkingDirectory(remoteDir);

            for (String remote : remoteFileNames) {
                long begin=System.currentTimeMillis();

                OutputStream local = new FileOutputStream(new File(localDir,remote));
                ////retrieveFile的第一个参数需要是 ISO-8859-1 编码
                //new String(fileName.getBytes("GBK"),"ISO-8859-1")
                boolean result = ftp.retrieveFile(remote, local);

                long end=System.currentTimeMillis();
                System.out.println(remote+":"+(end-begin)+"ms");

                System.out.println("result:"+result);
                local.flush();
                local.close();
            }

        } finally {
            closeFtpClient(ftp);
        }
    }

    public void upload(String remoteDir,String localDir, List<String> localFileNames) throws IOException{
        FTPClient ftp = new FTPClient();
        try {
            connectServer(ftp);
            configFTPClient(ftp);
            ftp.changeWorkingDirectory(remoteDir);

            for (String localFileName : localFileNames) {
                long begin=System.currentTimeMillis();

                InputStream local=new FileInputStream(new File(localDir,localFileName));
                boolean result = ftp.storeFile(localFileName,local);

                long end=System.currentTimeMillis();
                System.out.println(localFileName+":"+(end-begin)+"ms");

                System.out.println("result:"+result);
                IOUtils.closeQuietly(local);
            }

        } finally {
            closeFtpClient(ftp);
        }

    }

    private void closeFtpClient(FTPClient ftp) {
        if (ftp.isConnected()) {
            try {
                ftp.logout();
                ftp.disconnect();
            } catch (IOException ioe) {
                System.out.println("Fail to close.");
            }
        }
    }

    private void configFTPClient(FTPClient ftp) throws IOException {
        final int _1MB=1024;
        ////如果缺省该句 传输txt正常 但图片和其他格式的文件传输可能会出现未知异常
        ftp.setFileType(FTP.BINARY_FILE_TYPE);
        ftp.enterLocalPassiveMode();
        System.out.println("ftp.getBufferSize():"+ftp.getBufferSize());
        ftp.setBufferSize(_1MB);
    }

    private void connectServer(FTPClient ftp) throws SocketException,
            IOException {
        int reply;
        ftp.connect(_config.getHostName(), _config.getPort());
        ftp.login(_config.getUsername(), _config.getPassword());
        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        // 以2开头的返回值就会为真
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            throw new RuntimeException("FTP server refused connection:"
                    + ftp.getReplyString());
        }

    }

}
package switchplat.entity;

import java.util.List;
import java.util.Map;

public class Config {
    public String getHostName() {
        return this._hostName;
    }
    public void setHostName(String hostName) {
        this._hostName = hostName;
    }
    public int getPort() {
        return this._port;
    }
    public void setPort(int port) {
        this._port = port;
    }
    public String getUsername() {
        return this._username;
    }
    public void setUsername(String username) {
        this._username = username;
    }
    public String getPassword() {
        return this._password;
    }
    public void setPassword(String password) {
        this._password = password;
    }
    public Map<String, List<String>> getFilesToDownload() {
        return this._filesToDownload;
    }
    public void setFilesToDownload(Map<String, List<String>> filesToDownload) {
        this._filesToDownload = filesToDownload;
    }
    public Map<String, List<String>> getFilesToUpload() {
        return this._filesToUpload;
    }
    public void setFilesToUpload(Map<String, List<String>> filesToUpload) {
        this._filesToUpload = filesToUpload;
    }

    private String _hostName;
    private int _port=21;
    private String _username;
    private String _password;
    private Map<String,List<String>> _filesToDownload;
    private Map<String,List<String>> _filesToUpload;

}

Extension Part:

private String userName = "anonymous";//匿名登录，空字符串不行
private String password = "";//随便一个地址，我胡乱写一个也可以运行的
默认情况下，FtpClient使用的是UTF_8字符集作为服务器通讯的编码集。而FTP服务器SERV-U在windowsXP上，使用GBK字符集作为服务器通讯。

// 下面三行代码必须要，而且不能改变编码格式，否则不能正确下载中文文件
ftp.setControlEncoding("GBK");
FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
conf.setServerLanguageCode("zh");

http://yijingjia.blog.sohu.com/170731845.html

http://www.open-open.com/lib/view/open1329922375281.html

         /**
         * 重命名文件
         *
         * @param oldFileName --原文件名
         * @param newFileName --新文件名
         */
         public static void renameFile(String oldFileName, String newFileName) {
                 try {
                        connectServer();
                        ftpClient.rename(oldFileName, newFileName);
                } catch (IOException ioe) {
                        ioe.printStackTrace();
                }
        } 
         /**
         * 设置FTP客服端的配置--一般可以不设置
         *
         * @return ftpConfig
         */
         private static FTPClientConfig getFtpConfig() {
                FTPClientConfig ftpConfig = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
                ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);
                 return ftpConfig;
        } 
         /**
         * 在服务器上创建一个文件夹
         *
         * @param dir 文件夹名称，不能含有特殊字符，如 \ 、/ 、: 、* 、?、 "、 <、>...
         */
         public static boolean makeDirectory(String dir) {
                connectServer();
                 boolean flag = true;
                 try {
                         // System.out.println("dir=======" dir);
                        flag = ftpClient.makeDirectory(dir);
                         if (flag) {
                                System.out.println( "make Directory " + dir + " succeed"); 

                        } else { 

                                System.out.println( "make Directory " + dir + " false");
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
                 return flag;
        } 
         /**
         * 连接到服务器
         *
         * @return true 连接服务器成功，false 连接服务器失败
         */
         public static boolean connectServer() {
                 boolean flag = true;
                 if (ftpClient == null) {
                         int reply;
                         try {
                                setArg(configFile);
                                ftpClient = new FTPClient();
                                ftpClient.setControlEncoding( "GBK");
                                ftpClient.setDefaultPort(port);
                                ftpClient.configure(getFtpConfig());
                                ftpClient.connect(ip);
                                ftpClient.login(userName, password);
                                ftpClient.setDefaultPort(port);
                                 //System.out.print(ftpClient.getReplyString());
                                reply = ftpClient.getReplyCode();
                                ftpClient.setDataTimeout(120000); 

                                 if (!FTPReply.isPositiveCompletion(reply)) {
                                        ftpClient.disconnect();
                                        System.err.println( "FTP server refused connection.");
                                         // logger.debug("FTP 服务拒绝连接！");
                                        flag = false;
                                }
//                                System.out.println(i);
                                i++;
                        } catch (SocketException e) {
                                flag = false;
                                e.printStackTrace();
                                System.err.println( "登录ftp服务器 " + ip + " 失败,连接超时！");
                        } catch (IOException e) {
                                flag = false;
                                e.printStackTrace();
                                System.err.println( "登录ftp服务器 " + ip + " 失败，FTP服务器无法打开！");
                        }
                }
                 return flag;
        } 
    /**
         * 删除一个文件
         */
         public static boolean deleteFile(String filename) {
                 boolean flag = true;
                 try {
                        connectServer();
                        flag = ftpClient.deleteFile(filename);
                         if (flag) {
                                System.out.println( "删除文件成功！");
                        } else {
                                System.out.println( "删除文件失败！");
                        }
                } catch (IOException ioe) {
                        ioe.printStackTrace();
                }
                 return flag;
        } 

         /**
         * 删除目录
         */
         public static void deleteDirectory(String pathname) {
                 try {
                        connectServer();
                        File file = new File(pathname);
                         if (file.isDirectory()) {
                                File file2[] = file.listFiles();
                        } else {
                                deleteFile(pathname);
                        }
                        ftpClient.removeDirectory(pathname);
                } catch (IOException ioe) {
                        ioe.printStackTrace();
                }
        } 

         /**
         * 删除空目录
         */
         public static void deleteEmptyDirectory(String pathname) {
                 try {
                        connectServer();
                        ftpClient.removeDirectory(pathname);
                } catch (IOException ioe) {
                        ioe.printStackTrace();
                }
        } 

         /**
         * 列出服务器上文件和目录
         *
         * @param regStr --匹配的正则表达式
         */
         public static void listRemoteFiles(String regStr) {
                connectServer();
                 try {
                        String files[] = ftpClient.listNames(regStr);
                         if (files == null || files.length == 0)
                                System.out.println( "没有任何文件!");
                         else {
                                 for ( int i = 0; i < files.length; i++) {
                                        System.out.println(files[i]);
                                }
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        } 

         /**
         * 列出Ftp服务器上的所有文件和目录
         */
         public static void listRemoteAllFiles() {
                connectServer();
                 try {
                        String[] names = ftpClient.listNames();
                         for ( int i = 0; i < names.length; i++) {
                                System.out.println(names[i]);
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }

http://www.open-open.com/lib/view/open1325816800031.html

1.支持上传下载。支持断点续传
2.支持进度汇报
3.支持对于中文目录及中文文件创建的支持。

Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;   

import open.mis.data.DownloadStatus;
import open.mis.data.UploadStatus;   

import org.apache.commons.net.PrintCommandListener;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;   

/** *//**
 * 支持断点续传的FTP实用类
 * @author BenZhou  http://www.bt285.cn
 * @version 0.1 实现基本断点上传下载
 * @version 0.2 实现上传下载进度汇报
 * @version 0.3 实现中文目录创建及中文文件创建，添加对于中文的支持
 */
public class ContinueFTP {
    public FTPClient ftpClient = new FTPClient();   

    public ContinueFTP(){
        //设置将过程中使用到的命令输出到控制台
        this.ftpClient.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out)));
    }   

    /** *//**
     * 连接到FTP服务器
     * @param hostname 主机名
     * @param port 端口
     * @param username 用户名
     * @param password 密码
     * @return 是否连接成功
     * @throws IOException
     */
    public boolean connect(String hostname,int port,String username,String password) throws IOException{
        ftpClient.connect(hostname, port);
        ftpClient.setControlEncoding("GBK");
        if(FTPReply.isPositiveCompletion(ftpClient.getReplyCode())){
            if(ftpClient.login(username, password)){
                return true;
            }
        }
        disconnect();
        return false;
    }   

    /** *//**
     * 从FTP服务器上下载文件,支持断点续传，上传百分比汇报
     * @param remote 远程文件路径
     * @param local 本地文件路径
     * @return 上传的状态
     * @throws IOException
     */
    public DownloadStatus download(String remote,String local) throws IOException{
        //设置被动模式
        ftpClient.enterLocalPassiveMode();
        //设置以二进制方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        DownloadStatus result;   

        //检查远程文件是否存在
        FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("GBK"),"iso-8859-1"));
        if(files.length != 1){
            System.out.println("远程文件不存在");
            return DownloadStatus.Remote_File_Noexist;
        }   

        long lRemoteSize = files[0].getSize();
        File f = new File(local);
        //本地存在文件，进行断点下载
        if(f.exists()){
            long localSize = f.length();
            //判断本地文件大小是否大于远程文件大小
            if(localSize >= lRemoteSize){
                System.out.println("本地文件大于远程文件，下载中止");
                return DownloadStatus.Local_Bigger_Remote;
            }   

            //进行断点续传，并记录状态
            FileOutputStream out = new FileOutputStream(f,true);
            ftpClient.setRestartOffset(localSize);
            InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"),"iso-8859-1"));
            byte[] bytes = new byte[1024];
            long step = lRemoteSize /100;
            long process=localSize /step;
            int c;
            while((c = in.read(bytes))!= -1){
                out.write(bytes,0,c);
                localSize+=c;
                long nowProcess = localSize /step;
                if(nowProcess > process){
                    process = nowProcess;
                    if(process % 10 == 0)
                        System.out.println("下载进度："+process);
                    //TODO 更新文件下载进度,值存放在process变量中
                }
            }
            in.close();
            out.close();
            boolean isDo = ftpClient.completePendingCommand();
            if(isDo){
                result = DownloadStatus.Download_From_Break_Success;
            }else {
                result = DownloadStatus.Download_From_Break_Failed;
            }
        }else {
            OutputStream out = new FileOutputStream(f);
            InputStream in= ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"),"iso-8859-1"));
            byte[] bytes = new byte[1024];
            long step = lRemoteSize /100;
            long process=0;
            long localSize = 0L;
            int c;
            while((c = in.read(bytes))!= -1){
                out.write(bytes, 0, c);
                localSize+=c;
                long nowProcess = localSize /step;
                if(nowProcess > process){
                    process = nowProcess;
                    if(process % 10 == 0)
                        System.out.println("下载进度："+process);
                    //TODO 更新文件下载进度,值存放在process变量中
                }
            }
            in.close();
            out.close();
            boolean upNewStatus = ftpClient.completePendingCommand();
            if(upNewStatus){
                result = DownloadStatus.Download_New_Success;
            }else {
                result = DownloadStatus.Download_New_Failed;
            }
        }
        return result;
    }   

    /** *//**
     * 上传文件到FTP服务器，支持断点续传
     * @param local 本地文件名称，绝对路径
     * @param remote 远程文件路径，使用/home/directory1/subdirectory/file.ext或是 http://www.guihua.org /subdirectory/file.ext 按照Linux上的路径指定方式，支持多级目录嵌套，支持递归创建不存在的目录结构
     * @return 上传结果
     * @throws IOException
     */
    public UploadStatus upload(String local,String remote) throws IOException{
        //设置PassiveMode传输
        ftpClient.enterLocalPassiveMode();
        //设置以二进制流的方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.setControlEncoding("GBK");
        UploadStatus result;
        //对远程目录的处理
        String remoteFileName = remote;
        if(remote.contains("/")){
            remoteFileName = remote.substring(remote.lastIndexOf("/")+1);
            //创建服务器远程目录结构，创建失败直接返回
            if(CreateDirecroty(remote, ftpClient)==UploadStatus.Create_Directory_Fail){
                return UploadStatus.Create_Directory_Fail;
            }
        }   

        //检查远程是否存在文件
        FTPFile[] files = ftpClient.listFiles(new String(remoteFileName.getBytes("GBK"),"iso-8859-1"));
        if(files.length == 1){
            long remoteSize = files[0].getSize();
            File f = new File(local);
            long localSize = f.length();
            if(remoteSize==localSize){
                return UploadStatus.File_Exits;
            }else if(remoteSize > localSize){
                return UploadStatus.Remote_Bigger_Local;
            }   

            //尝试移动文件内读取指针,实现断点续传
            result = uploadFile(remoteFileName, f, ftpClient, remoteSize);   

            //如果断点续传没有成功，则删除服务器上文件，重新上传
            if(result == UploadStatus.Upload_From_Break_Failed){
                if(!ftpClient.deleteFile(remoteFileName)){
                    return UploadStatus.Delete_Remote_Faild;
                }
                result = uploadFile(remoteFileName, f, ftpClient, 0);
            }
        }else {
            result = uploadFile(remoteFileName, new File(local), ftpClient, 0);
        }
        return result;
    }
    /** *//**
     * 断开与远程服务器的连接
     * @throws IOException
     */
    public void disconnect() throws IOException{
        if(ftpClient.isConnected()){
            ftpClient.disconnect();
        }
    }   

    /** *//**
     * 递归创建远程服务器目录
     * @param remote 远程服务器文件绝对路径
     * @param ftpClient FTPClient对象
     * @return 目录创建是否成功
     * @throws IOException
     */
    public UploadStatus CreateDirecroty(String remote,FTPClient ftpClient) throws IOException{
        UploadStatus status = UploadStatus.Create_Directory_Success;
        String directory = remote.substring(0,remote.lastIndexOf("/")+1);
        if(!directory.equalsIgnoreCase("/")&&!ftpClient.changeWorkingDirectory(new String(directory.getBytes("GBK"),"iso-8859-1"))){
            //如果远程目录不存在，则递归创建远程服务器目录
            int start=0;
            int end = 0;
            if(directory.startsWith("/")){
                start = 1;
            }else{
                start = 0;
            }
            end = directory.indexOf("/",start);
            while(true){
                String subDirectory = new String(remote.substring(start,end).getBytes("GBK"),"iso-8859-1");
                if(!ftpClient.changeWorkingDirectory(subDirectory)){
                    if(ftpClient.makeDirectory(subDirectory)){
                        ftpClient.changeWorkingDirectory(subDirectory);
                    }else {
                        System.out.println("创建目录失败");
                        return UploadStatus.Create_Directory_Fail;
                    }
                }   

                start = end + 1;
                end = directory.indexOf("/",start);   

                //检查所有目录是否创建完毕
                if(end <= start){
                    break;
                }
            }
        }
        return status;
    }   

    /** *//**
     * 上传文件到服务器,新上传和断点续传
     * @param remoteFile 远程文件名，在上传之前已经将服务器工作目录做了改变
     * @param localFile 本地文件File句柄，绝对路径
     * @param processStep 需要显示的处理进度步进值
     * @param ftpClient FTPClient引用
     * @return
     * @throws IOException
     */
    public UploadStatus uploadFile(String remoteFile,File localFile,FTPClient ftpClient,long remoteSize) throws IOException{
        UploadStatus status;
        //显示进度的上传
        long step = localFile.length() / 100;
        long process = 0;
        long localreadbytes = 0L;
        RandomAccessFile raf = new RandomAccessFile(localFile,"r");
        OutputStream out = ftpClient.appendFileStream(new String(remoteFile.getBytes("GBK"),"iso-8859-1"));
        //断点续传
        if(remoteSize>0){
            ftpClient.setRestartOffset(remoteSize);
            process = remoteSize /step;
            raf.seek(remoteSize);
            localreadbytes = remoteSize;
        }
        byte[] bytes = new byte[1024];
        int c;
        while((c = raf.read(bytes))!= -1){
            out.write(bytes,0,c);
            localreadbytes+=c;
            if(localreadbytes / step != process){
                process = localreadbytes / step;
                System.out.println("上传进度:" + process);
                //TODO 汇报上传状态
            }
        }
        out.flush();
        raf.close();
        out.close();
        boolean result =ftpClient.completePendingCommand();
        if(remoteSize > 0){
            status = result?UploadStatus.Upload_From_Break_Success:UploadStatus.Upload_From_Break_Failed;
        }else {
            status = result?UploadStatus.Upload_New_File_Success:UploadStatus.Upload_New_File_Failed;
        }
        return status;
    }   

    public static void main(String[] args) {
        ContinueFTP myFtp = new ContinueFTP();
        try {
            myFtp.connect("192.168.21.181", 21, "nid", "123");
//          myFtp.ftpClient.makeDirectory(new String("电视剧".getBytes("GBK"),"iso-8859-1"));
//          myFtp.ftpClient.changeWorkingDirectory(new String("电视剧".getBytes("GBK"),"iso-8859-1"));
//          myFtp.ftpClient.makeDirectory(new String("走西口".getBytes("GBK"),"iso-8859-1"));
//          System.out.println(myFtp.upload("http://www.5a520.cn /yw.flv", "/yw.flv",5));
//          System.out.println(myFtp.upload("http://www.5a520.cn /走西口24.mp4","/央视走西口/新浪网/走西口24.mp4"));
            System.out.println(myFtp.download("/央视走西口/新浪网/走西口24.mp4", "E:\\走西口242.mp4"));
            myFtp.disconnect();
        } catch (IOException e) {
            System.out.println("连接FTP出错："+e.getMessage());
        }
    }
}

http://www.cnblogs.com/tt_mc/archive/2010/03/22/1691708.html

时间： 2024-10-04 09:06:09

Apache commons-net用法的一个示例的相关文章

Apache commons VFS之Shell源代码示例

这个示例主要是模拟一个Shell程序,通过输入一些命令,执行操作.源代码来自官网. 这个示例的特点: 1.       接收用户的输入: 2.       通过字符解析和判断: 3.       利用VFS自带的一些功能进行功能实现: package test.ffm83.commons.VFS; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import

Apache commons VFS 文件操作 源代码示例

通过VFS对文件进行一些操作,包括写入.读取文件,判断文件是否可读可写等示例.Apache commons VFS包和apache commons的其他基础性类有非常密切的关系. 整理了一些常用的方法,源代码如下: package test.ffm83.commons.VFS; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.O

Apache Commons CLI 开发命令行工具示例

概念说明Apache Commons CLI 简介 虽然各种人机交互技术飞速发展,但最传统的命令行模式依然被广泛应用于各个领域:从编译代码到系统管理,命令行因其简洁高效而备受宠爱.各种工具和系统都 提供了详尽的使用手册,有些还提供示例说明如何二次开发.然而关于如何开发一个易用.强壮的命令行工具的文章却很少.本文将结合 Apache Commons CLI,通过一个完整的例子展示如何准备.开发.测试一个命令行工具.希望本文对有相关需求的读者能有所帮助.      Apache Commons CL

apache commons 之 transcation 简介和文件事务系统的实现

Apache Commons Transaction 旨在提供一个轻量级.标准化.高效的 Java 事务多线程编程的工具包,实现了多级锁.事务集合和事务级文件访问. 事务处理系统对数据库使用者来说,是非常熟悉的事情:但是如果将事务处理系统从数据库转移到文件系统上,估计很多同学都要一筹莫展了.实际上,无论库/框架.语言,或者文件系统级别,对文件系统操作事务的支持一直都很薄弱. 单独看一些文件系统操作(比如文件重命名.删除等),它们是原子的,但是从目前的情况看,很少有解决办法能够形成一组综合的API

ysoserial分析【一】 之 Apache Commons Collections

目录 0x00 前言 0x01 基础知识 Transformer 利用InvokerTransformer造成命令执行 Map TransformedMap LazyMap AnnotationInvocationHandler 动态代理 0x02 Commons Collections Gadget 分析 CommonsCollections1 CommonsCollections2 疑问 CommonsCollections3 CommonsCollections4 CommonsColle

Apache commons VFS简介和ShowProperties源代码示例

Apache commons VFS又叫做 Apache Commons Virtual FileSystem.是一组功能强大的对各类资源的访问接口,目前这个JAR包得到了全新的重构,目前最新的版本是2.2. 如果我们在平常的工作中,需要得到一些不同格式文件的信息,比如文件大小.所在路径.文件最后更改时间等,或者我们需要对文件进行一些常规的操作,比如删除文件,拷贝文件等等,那么Apache Commons中的VFS(Virtual File System)就是我们可以考虑的一个开源系统. 据VF

使用 Apache Commons CLI 开发命令行工具示例

概念说明 Apache Commons CLI 简介 Apache Commons CLI 是 Apache 下面的一个解析命令行输入的工具包,该工具包还提供了自动生成输出帮助文档的功能. Apache Commons CLI 支持多种输入参数格式,主要支持的格式有以下几种: POSIX(Portable Operating System Interface of Unix)中的参数形式,例如 tar -zxvf foo.tar.gz GNU 中的长参数形式,例如 du --human-read

org.apache.commons.lang.time用法实例

<table style="color:rgb(68, 68, 68);"><tbody><tr><td><div><div><p>org.apache.commons.lang.time.这个包里面包含了如下5个类:</p><p> </p><p><span style="color:navy;">DateFormatUti

【转】用JSON报的一个错误java.lang.ClassNotFoundException: org.apache.commons.lang.exception.NestableRuntimeExcept

来源:http://blog.csdn.net/eilent/article/details/6927700 出现错误的原因是因为jar包导入不全. 今天自己写了一个JSON的例子,可以一调用就出了问题,报下面这个异常: java.lang.ClassNotFoundException: org.apache.commons.lang.exception.NestableRuntimeException 上网上搜了一下才知道原来在使用JSON的使用的时候,不光要导入JSON这个包,同时还要导入另