通过jsch和linux服务器进行文件的上传下载删除

jsch 是ssh2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的程序中。同时该项目也提供一个J2ME版本用来在手机上直连SSHD服务器。

一般连接到服务器有两种方式：

１、通过用户名和密码连接，缺点（出于安全需要，一般服务器的密码会定期修改，程序部署后将不得不经常更新配置文件中的密码。）

2、通过用户名和ssh private key file连接，缺点(因为Java程序必须和private key file在同一台机器上，将服务器的private key file复制到本地后，本地机器的安全措施可能会使private key file被窃取，威胁服务器安全。)

　　jsch官网地址为http://www.jcraft.com/jsch/,实现jsch功能需要添加一个jsch-0.1.51.jar包，官网有一些例子可直接下载参考。

maven的配置为:

[html]view plain copy
<dependency>  
            <groupId>com.jcraft</groupId>  
            <artifactId>jsch</artifactId>  
            <version>0.1.51</version>  
</dependency>  

１、jsch连接到linux的基本原理和用ssh一样，需要ip地址，端口（一般为22），用户名，密码，为了方便配置，可以把静态变量初始化在配置文件中:

[html]view plain copy
#jsch配置  
host.ip=192.168.1.1  
host.user=root  
host.port=22  
host.password=123456  
host.connect.timeout=5000     

获取配置文件变量的工具类：

[java]view plain copy
package com.personal.core.constant;  
  
  
import com.personal.core.utils.PropertiesLoader;  
import org.apache.commons.lang.StringUtils;  
import org.springframework.core.io.DefaultResourceLoader;  
  
import java.io.File;  
import java.io.IOException;  
import java.util.HashMap;  
import java.util.Map;  
  
/** 
 * 注释:全局配置类 
 * 
 * @Author： coding99 
 * @Date： 16-9-2 
 * @Time： 下午7:33 
 */  
public class Global {  
  
  
    /** 
     * 当前对象实例 
     */  
    private static Global global = new Global();  
      
    /** 
     * 保存全局属性值 
     */  
    private static Map<String, String> map = new HashMap<String, String>();  
      
    /** 
     * 属性文件加载对象 
     */  
    private static PropertiesLoader loader = new PropertiesLoader("sysConfig.properties");  
  
  
      
    /** 
     * 获取当前对象实例 
     */  
    public static Global getInstance() {  
        return global;  
    }  
      
    /** 
     * 获取配置 
     * @see {fns:getConfig('adminPath')} 
     */  
    public static String getConfig(String key) {  
        String value = map.get(key);  
        if (value == null){  
            value = loader.getProperty(key);  
            map.put(key, value != null ? value : StringUtils.EMPTY);  
        }  
        return value;  
    }/**     * 获取工程路径     * @return     */    public static String getProjectPath(){        // 如果配置了工程路径，则直接返回，否则自动获取。String projectPath = Global.getConfig("projectPath");if (StringUtils.isNotBlank(projectPath)){return projectPath;}try {File file = new DefaultResourceLoader().getResource("").getFile();if (file != null){while(true){File f = new File(file.getPath() + File.separator + "src" + File.separator + "main");if (f == null || f.exists()){break;}if (file.getParentFile() != null){file = file.getParentFile();}else{break;}}projectPath = file.toString();}} catch (IOException e) {e.printStackTrace();}return projectPath;    }}  
      
    /** 
     * 获取工程路径 
     * @return 
     */  
    public static String getProjectPath(){  
        // 如果配置了工程路径，则直接返回，否则自动获取。  
        String projectPath = Global.getConfig("projectPath");  
        if (StringUtils.isNotBlank(projectPath)){  
            return projectPath;  
        }  
        try {  
            File file = new DefaultResourceLoader().getResource("").getFile();  
            if (file != null){  
                while(true){  
                    File f = new File(file.getPath() + File.separator + "src" + File.separator + "main");  
                    if (f == null || f.exists()){  
                        break;  
                    }  
                    if (file.getParentFile() != null){  
                        file = file.getParentFile();  
                    }else{  
                        break;  
                    }  
                }  
                projectPath = file.toString();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return projectPath;  
    }  
  
  
}  

2、为了方便脚本配置，统一管理，修改，我们可以把脚本放在一个xml里面，例如：

[html]view plain copy
<?xml version="1.0" encoding="UTF-8"?>  
<configuration>  
  
  
    <!--开发环境-->  
    <shell name="ls" env="dev">  
        <description>查看opt文件夹内容</description>  
        <step>ls -ltr /opt</step>  
    </shell>  
  
    <!--开发环境-->  
    <shell name="ls" env="uat">  
        <description>查看opt文件夹内容</description>  
        <step>ls -ltr /opt</step>  
    </shell>  
  
    <!--生产环境-->  
    <shell name="ls" env="pro">  
        <description>查看opt文件夹内容</description>  
        <step>ls -ltr /opt</step>  
    </shell>  
  
  
</configuration>  

3、获取脚本的方法通过一个工具类读取这个配置文件，用dom4j进行解析，获取相应指定shell name的脚本,例如

[java]view plain copy
package com.personal.core.utils;  
  
import com.personal.core.constant.Global;  
import org.dom4j.Document;  
import org.dom4j.Element;  
import org.dom4j.io.SAXReader;  
  
import java.io.File;  
import java.util.List;  
  
/** 
 * 注释 
 * 
 * @Author： coding99 
 * @Date： 16-9-2 
 * @Time： 下午9:31 
 */  
public class ShellConfigUtil {  
  
    private static final String SHELL_ENV = Global.getConfig("environment");  
    private static final String DEFAULT_SHELL_CONFIG = ShellConfigUtil.class.getResource("/").getPath()+"shell.xml";  
  
    private ShellConfigUtil() {  
  
    }  
  
  
    /** 
     * 取得脚本 
     * @param shellName 
     * @return 
     * @throws Exception 
     */  
    public static String getShell(String shellName)throws Exception{  
        String shellContent = "";  
  
        List<Element> shells = getShellEelements();  
  
        for(Element shell : shells) {  
            String name = shell.attributeValue("name");  
            String env = shell.attributeValue("env");  
            //把shell数组遍历  
            if(shellName.equals(name) && SHELL_ENV.equals(env)) {  
                shellContent = getShellResult(shell);  
            }  
  
        }  
        return shellContent;  
    }  
  
    /** 
     * 解析xml 
     * @return 
     * @throws Exception 
     */  
    public static List<Element> getShellEelements() throws Exception{  
        SAXReader saxReader = new SAXReader();//创建读取配置文件的对象  
        Document document = saxReader.read(new File(DEFAULT_SHELL_CONFIG));//开始读取配置文件  
        Element element = document.getRootElement();  
        List<Element> shellElements = element.elements("shell");  
        return shellElements;  
    }  
  
    /** 
     * 获取脚本内容 
     * @param shell 
     * @return 
     */  
    public static String getShellResult(Element shell) {  
        String result = "";  
        List<Element> steps = shell.elements("step");  
        for (Element step : steps) {  
            result = step.getText();  
        }  
        return result;  
    }  
  
  
  
    public static void main(String[] args) throws Exception{  
        ShellConfigUtil.getShell("ls");  
    }  
  
}  

4、JSCH实现原理：

jsch进行连接服务器连接时可以看做时java的jdbc连接，首先我们需要实例化一个jsch对象，再利用这个对象根据用户名，主机ip，端口获取一个Session对象，设置好相应的参数后，就进行连接，创建连接后这个session是一直可用的，所以不需要关闭。之后我们需要在session上建立channel通道

Channel的类型可以为如下类型：

shell - ChannelShell exec - ChannelExec 　

direct-tcpip - ChannelDirectTCPIP sftp - ChannelSftp subsystem - ChannelSubsystem

其中，ChannelShell和ChannelExec比较类似，都可以作为执行Shell脚本的Channel类型。它们有一个比较重要的区别：ChannelShell可以看作是执行一个交互式的Shell，而ChannelExec是执行一个Shell脚本。

实现远程命令操作我们需要创建ChannelExec对象。

实现文件上传下载我们需要实现ChannelSftp对象。

ChannelSftp类是JSch实现SFTP核心类，它包含了所有SFTP的方法，如：

put()：文件上传

get()：文件下载

cd()：进入指定目录

ls()：得到指定目录下的文件列表

rename()：重命名指定文件或目录

rm()：删除指定文件

mkdir()：创建目录

rmdir()：删除目录下面有个工具类展示

应用实例：

JschUtil.java

[java]view plain copy
package com.personal.core.utils;  
import com.jcraft.jsch.*;  
import com.personal.core.constant.Global;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
import java.io.*;  
import java.nio.charset.Charset;  
import java.util.*;  
/** 
 * 注释 
 * 
 * @Author： coding99 
 * @Date： 16-9-2 
 * @Time： 下午7:33 
 */  
public class JschUtil {  
  
    private static final Logger logger = LoggerFactory.getLogger(JschUtil.class);  
  
    private String charset = "UTF-8"; // 设置编码格式,可以根据服务器的编码设置相应的编码格式  
    private JSch jsch;  
    private Session session;  
    Channel channel = null;  
    ChannelSftp chSftp = null;  
  
  
    //初始化配置参数  
    private String jschHost = Global.getConfig("host.ip");  
    private int jschPort = Integer.parseInt(Global.getConfig("host.port"));  
    private String jschUserName = Global.getConfig("host.user");  
    private String jschPassWord = Global.getConfig("host.password");  
    private int jschTimeOut = Integer.parseInt(Global.getConfig("host.connect.timeout"));  
  
  
  
    /** 
     * 静态内部类实现单例模式 
     */  
    private static class LazyHolder {  
        private static final JschUtil INSTANCE = new JschUtil();  
    }  
  
    private JschUtil() {  
  
    }  
  
    /** 
     * 获取实例 
     * @return 
     */  
    public static final JschUtil getInstance() {  
        return LazyHolder.INSTANCE;  
    }  
  
  
    /** 
     * 连接到指定的服务器 
     * @return 
     * @throws JSchException 
     */  
    public boolean connect() throws JSchException {  
  
        jsch = new JSch();// 创建JSch对象  
  
        boolean result = false;  
  
        try{  
  
            long begin = System.currentTimeMillis();//连接前时间  
            logger.debug("Try to connect to jschHost = " + jschHost + ",as jschUserName = " + jschUserName + ",as jschPort =  " + jschPort);  
  
            session = jsch.getSession(jschUserName, jschHost, jschPort);// // 根据用户名，主机ip，端口获取一个Session对象  
            session.setPassword(jschPassWord); // 设置密码  
            Properties config = new Properties();  
            config.put("StrictHostKeyChecking", "no");  
            session.setConfig(config);// 为Session对象设置properties  
            session.setTimeout(jschTimeOut);//设置连接超时时间  
            session.connect();  
  
            logger.debug("Connected successfully to jschHost = " + jschHost + ",as jschUserName = " + jschUserName + ",as jschPort =  " + jschPort);  
  
            long end = System.currentTimeMillis();//连接后时间  
  
            logger.debug("Connected To SA Successful in {} ms", (end-begin));  
  
            result = session.isConnected();  
  
        }catch(Exception e){  
            logger.error(e.getMessage(), e);  
        }finally{  
            if(result){  
                logger.debug("connect success");  
            }else{  
                logger.debug("connect failure");  
            }  
        }  
  
        if(!session.isConnected()) {  
            logger.error("获取连接失败");  
        }  
  
        return  session.isConnected();  
  
    }  
  
    /** 
     * 关闭连接 
     */  
    public void close() {  
  
        if(channel != null && channel.isConnected()){  
            channel.disconnect();  
            channel=null;  
        }  
  
        if(session!=null && session.isConnected()){  
            session.disconnect();  
            session=null;  
        }  
  
    }  
  
    /** 
     * 脚本是同步执行的方式 
     * 执行脚本命令 
     * @param command 
     * @return 
     */  
    public Map<String,Object> execCmmmand(String command) throws Exception{  
  
  
        Map<String,Object> mapResult = new HashMap<String,Object>();  
  
        logger.debug(command);  
  
        StringBuffer result = new StringBuffer();//脚本返回结果  
  
        BufferedReader reader = null;  
        int returnCode = -2;//脚本执行退出状态码  
  
  
        try {  
  
            channel = session.openChannel("exec");  
            ((ChannelExec) channel).setCommand(command);  
            channel.setInputStream(null);  
            ((ChannelExec) channel).setErrStream(System.err);  
  
            channel.connect();//执行命令 等待执行结束  
  
            InputStream in = channel.getInputStream();  
            reader = new BufferedReader(new InputStreamReader(in, Charset.forName(charset)));  
  
            String res="";  
            while((res=reader.readLine()) != null){  
                result.append(res+"\n");  
                logger.debug(res);  
            }  
  
            returnCode = channel.getExitStatus();  
  
            mapResult.put("returnCode",returnCode);  
            mapResult.put("result",result.toString());  
  
        } catch (IOException e) {  
  
            logger.error(e.getMessage(),e);  
  
        } catch (JSchException e) {  
  
            logger.error(e.getMessage(), e);  
  
        } finally {  
            try {  
                reader.close();  
            } catch (IOException e) {  
                logger.error(e.getMessage(), e);  
            }  
        }  
  
        return mapResult;  
  
    }  
  
    /** 
     * 上传文件 
     * 
     * @param directory 上传的目录,有两种写法 
     *                  １、如/opt，拿到则是默认文件名 
     *                  ２、/opt/文件名，则是另起一个名字 
     * @param uploadFile 要上传的文件 如/opt/xxx.txt 
     */  
    public void upload(String directory, String uploadFile) {  
  
        try {  
  
            logger.debug("Opening Channel.");  
            channel = session.openChannel("sftp"); // 打开SFTP通道  
            channel.connect(); // 建立SFTP通道的连接  
            chSftp = (ChannelSftp) channel;  
            File file = new File(uploadFile);  
            long fileSize = file.length();  
  
            /*方法一*/  
             OutputStream out = chSftp.put(directory, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); // 使用OVERWRITE模式  
             byte[] buff = new byte[1024 * 256]; // 设定每次传输的数据块大小为256KB  
             int read;  
             if (out != null) {  
                 logger.debug("Start to read input stream");  
                InputStream is = new FileInputStream(uploadFile);  
                do {  
                    read = is.read(buff, 0, buff.length);  
                     if (read > 0) {  
                            out.write(buff, 0, read);  
                     }  
                     out.flush();  
                 } while (read >= 0);  
                 logger.debug("input stream read done.");  
             }  
  
            // chSftp.put(uploadFile, directory, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); //方法二  
            // chSftp.put(new FileInputStream(src), dst, new FileProgressMonitor(fileSize), ChannelSftp.OVERWRITE); //方法三  
            logger.debug("成功上传文件至"+directory);  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        }finally {  
            chSftp.quit();  
  
            if (channel != null) {  
                channel.disconnect();  
                logger.debug("channel disconnect");  
            }  
  
        }  
    }  
  
  
    /** 
     * 下载文件 
     * 
     * @param directory 下载的目录,有两种写法 
     *                  １、如/opt，拿到则是默认文件名 
     *                  ２、/opt/文件名，则是另起一个名字 
     * @param downloadFile 要下载的文件 如/opt/xxx.txt 
     * 
     */  
  
    public void download(String directory, String downloadFile) {  
        try {  
  
            logger.debug("Opening Channel.");  
            channel = session.openChannel("sftp"); // 打开SFTP通道  
            channel.connect(); // 建立SFTP通道的连接  
            chSftp = (ChannelSftp) channel;  
            SftpATTRS attr = chSftp.stat(downloadFile);  
            long fileSize = attr.getSize();  
  
  
            OutputStream out = new FileOutputStream(directory);  
  
            InputStream is = chSftp.get(downloadFile, new MyProgressMonitor());  
            byte[] buff = new byte[1024 * 2];  
            int read;  
            if (is != null) {  
                logger.debug("Start to read input stream");  
                do {  
                    read = is.read(buff, 0, buff.length);  
                    if (read > 0) {  
                        out.write(buff, 0, read);  
                    }  
                    out.flush();  
                } while (read >= 0);  
                logger.debug("input stream read done.");  
            }  
  
            //chSftp.get(downloadFile, directory, new FileProgressMonitor(fileSize)); // 代码段1  
            //chSftp.get(downloadFile, out, new FileProgressMonitor(fileSize)); // 代码段2  
  
            logger.debug("成功下载文件至"+directory);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            chSftp.quit();  
            if (channel != null) {  
                channel.disconnect();  
                logger.debug("channel disconnect");  
            }  
        }  
    }  
  
  
    /** 
     * 删除文件 
     * @param deleteFile 要删除的文件 
     */  
    public void delete(String deleteFile) {  
  
        try {  
            connect();//建立服务器连接  
            logger.debug("Opening Channel.");  
            channel = session.openChannel("sftp"); // 打开SFTP通道  
            channel.connect(); // 建立SFTP通道的连接  
            chSftp = (ChannelSftp) channel;  
            chSftp.rm(deleteFile);  
            logger.debug("成功删除文件"+deleteFile);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
  
    }  
  
  
    public String getCharset() {  
        return charset;  
    }  
  
    public void setCharset(String charset) {  
        this.charset = charset;  
    }  
  
  
  
    public static void main(String[] args) throws Exception{  
  
        JschUtil jschUtil = JschUtil.getInstance();  
  
        boolean isConnected = false;  
        isConnected  = jschUtil.connect();  
  
        if(isConnected == true){  
  
  
            /*上传文件*/  
            jschUtil.upload("/opt/123456.png","/home/sky/Desktop/resizeApi.png");  
  
             /*执行命令*/  
            String command = "ls -ltr /opt";  
           // String command = ShellConfigUtil.getShell("ls");  
            Map<String,Object> result = jschUtil.execCmmmand(command);  
            System.out.println(result.get("result").toString());  
  
            /*下载文件*/  
            jschUtil.download("/opt/123456.png","/opt/123456.png");  
  
            jschUtil.close();  
  
        }  
  
  
    }  
}  

[java]view plain copy
package com.personal.core.utils;  
import java.text.DecimalFormat;  
import java.util.Timer;  
import java.util.TimerTask;  
  
import com.jcraft.jsch.SftpProgressMonitor;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
/** 
 * 注释 
 * 
 * @Author： coding99 
 * @Date： 16-9-2 
 * @Time： 下午8:29 
 */  
public class FileProgressMonitor extends TimerTask implements SftpProgressMonitor {  
  
    private static final Logger logger = LoggerFactory.getLogger(FileProgressMonitor.class);  
      
  
    private long progressInterval = 5 * 1000; // 默认间隔时间为5秒  
  
    private boolean isEnd = false; // 记录传输是否结束  
  
    private long transfered; // 记录已传输的数据总大小  
  
    private long fileSize; // 记录文件总大小  
  
    private Timer timer; // 定时器对象  
  
    private boolean isScheduled = false; // 记录是否已启动timer记时器  
  
    public FileProgressMonitor(long fileSize) {  
        this.fileSize = fileSize;  
    }  
    
    @Override  
    public void run() {  
  
        if (!isEnd()) { // 判断传输是否已结束  
  
            logger.debug("Transfering is in progress.");  
  
            long transfered = getTransfered();  
  
            if (transfered != fileSize) { // 判断当前已传输数据大小是否等于文件总大小  
                logger.debug("Current transfered: " + transfered + " bytes");  
                sendProgressMessage(transfered);  
            } else {  
                logger.debug("File transfering is done.");  
                setEnd(true); // 如果当前已传输数据大小等于文件总大小，说明已完成，设置end  
            }  
        } else {  
            logger.debug("Transfering done. Cancel timer.");  
            stop(); // 如果传输结束，停止timer记时器  
            return;  
        }  
    }  
  
    public void stop() {  
        logger.debug("Try to stop progress monitor.");  
        if (timer != null) {  
            timer.cancel();  
            timer.purge();  
            timer = null;  
            isScheduled = false;  
        }  
        logger.debug("Progress monitor stoped.");  
    }  
  
    public void start() {  
        logger.debug("Try to start progress monitor.");  
        if (timer == null) {  
            timer = new Timer();  
        }  
        timer.schedule(this, 1000, progressInterval);  
        isScheduled = true;  
        logger.debug("Progress monitor started.");  
    }  
  
    /** 
     * 打印progress信息 
     * @param transfered 
     */  
    private void sendProgressMessage(long transfered) {  
        if (fileSize != 0) {  
            double d = ((double)transfered * 100)/(double)fileSize;  
            DecimalFormat df = new DecimalFormat( "#.##");  
            logger.debug("Sending progress message: " + df.format(d) + "%");  
        } else {  
            logger.debug("Sending progress message: " + transfered);  
        }  
    }  
  
    /** 
     * 实现了SftpProgressMonitor接口的count方法 
     */  
    public boolean count(long count) {  
        if (isEnd()) return false;  
        if (!isScheduled) {  
            start();  
        }  
        add(count);  
        return true;  
    }  
  
    /** 
     * 实现了SftpProgressMonitor接口的end方法 
     */  
    public void end() {  
        setEnd(true);  
        logger.debug("transfering end.");  
    }  
  
    private synchronized void add(long count) {  
        transfered = transfered + count;  
    }  
  
    private synchronized long getTransfered() {  
        return transfered;  
    }  
  
    public synchronized void setTransfered(long transfered) {  
        this.transfered = transfered;  
    }  
  
    private synchronized void setEnd(boolean isEnd) {  
        this.isEnd = isEnd;  
    }  
  
    private synchronized boolean isEnd() {  
        return isEnd;  
    }  
  
    public void init(int op, String src, String dest, long max) {  
        // Not used for putting InputStream  
    }  
}  

[java]view plain copy
package com.personal.core.utils;  
  
  
import com.jcraft.jsch.SftpProgressMonitor;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
  
  
  
/** 
 * 注释 
 * 
 * @Author： coding99 
 * @Date： 16-9-2 
 * @Time： 下午8:36 
 */  
  
  
public class MyProgressMonitor implements SftpProgressMonitor {  
  
  
    private static final Logger logger = LoggerFactory.getLogger(MyProgressMonitor.class);  
  
  
    private long transfered;  
  
  
    @Override  
    public boolean count(long count) {  
        transfered = transfered + count;  
        logger.debug("Currently transferred total size: " + transfered + " bytes");  
        return true;  
    }  
  
  
    @Override  
    public void end() {  
        logger.debug("Transferring done.");  
    }  
  
  
    @Override  
    public void init(int op, String src, String dest, long max) {  
        logger.debug("Transferring begin.");  
    }  
  
  
}  

注：工具类主要封装了三个方法

1、执行脚本命令

2、文件上传(为了做进度监控，需要用到监控类FileProgressMonitor.java)

3、文件下载 (为了做进度监控，需要用到监控类MyProgressMonitor.java)

JschUtil.java工具类的几个使用步骤如下

1、初始化连接参数

2、调用connect()方法进行连接

3、执行相应的方法，如果是脚本命令，先用ShellConfigUtil.java获取相应的脚本，再执行（jsch执行脚本的方式是同步，就是要等到脚本执行结束才返回结果，如果没有返回就一直等着，应该不支持交互式命令，比如连接到某个数据库，然后执行相应的操作）

4、最后关闭连接

通过jsch和linux服务器进行文件的上传下载删除

猜你喜欢