devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot集成JSch快速入门demo

作者：不正经 | 2024-03-30 19:54:52

赞

踩

Spring Boot集成JSch快速入门demo

1.JSch介绍

JSch是SSH2的纯Java实现。JSch允许您连接到sshd服务器并使用端口转发，X11转发，文件传输等，并且可以将其功能集成到您自己的Java程序中。

2.实现原理

  • 根据远程主机的IP地址，用户名和端口，建立会话（Session）

  • 设置用户信息（包括密码和Userinfo），然后连接session，getSession()只是创建一个session，需要设置必要的认证信息之后，调用connect()才能建立连接。

  • 设置channel上需要远程执行的Shell脚本，连接channel，就可以远程执行该Shell脚本，调用openChannel(String type) 可以在session上打开指定类型的channel。该channel只是被初始化，使用前需要先调用connect()进行连接。

  • 可以读取远程执行Shell脚本的输出，然后依次断开channel和session的连接

3.代码工程

实验目标：实现文件上传到服务，服务器下载文件以及执行服务器命令 

pom.xml

 
 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>springboot-demo</artifactId>
  7.         <groupId>com.et</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.  
  13.     <artifactId>JSch</artifactId>
  14.  
  15.  
  16.     <properties>
  17.         <maven.compiler.source>8</maven.compiler.source>
  18.         <maven.compiler.target>8</maven.compiler.target>
  19.     </properties>
  20.     <dependencies>
  21.  
  22.  
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.  
  28.  
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-autoconfigure</artifactId>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-test</artifactId>
  36.             <scope>test</scope>
  37.         </dependency>
  38.         <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
  39.         <dependency>
  40.             <groupId>com.jcraft</groupId>
  41.             <artifactId>jsch</artifactId>
  42.             <version>0.1.55</version>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>org.projectlombok</groupId>
  46.             <artifactId>lombok</artifactId>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>com.alibaba</groupId>
  50.             <artifactId>fastjson</artifactId>
  51.             <version>1.2.78</version>
  52.         </dependency>
  53.     </dependencies>
  54. </project>
 
 
remote.java
 
 
 
 
  1. package com.et.jsch.model;
  2.  
  3.  
  4. import lombok.Data;
  5.  
  6.  
  7. @Data
  8. public class Remote {
  9.   private String host;
  10.   private final int port = 22;
  11.   private String user;
  12.   private String password;
  13.   private final String identity = "~/.ssh/id_rsa";
  14.   private String passphrase;
  15. }
 
 
JSchUtil.java
 
 
 
 
  1. package com.et.jsch.util;
  2.  
  3.  
  4. import com.et.jsch.model.Remote;
  5. import com.jcraft.jsch.*;
  6. import lombok.extern.slf4j.Slf4j;
  7.  
  8.  
  9. import java.io.*;
  10. import java.nio.file.Files;
  11. import java.nio.file.Paths;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.function.Function;
  15.  
  16.  
  17. /**
  18.  * ssh tools
  19.  */
  20. @Slf4j
  21. public class JSchUtil {
  22.  
  23.  
  24.     public static final int SESSION_TIMEOUT = 30000;
  25.     public static final int CONNECT_TIMEOUT = 3000;
  26.  
  27.  
  28.     /**
  29.      * get session
  30.      *
  31.      * @param remote ssh server info
  32.      * @return session
  33.      * @throws JSchException /
  34.      */
  35.     public static Session getSession(Remote remote) throws JSchException {
  36.         JSch jSch = new JSch();
  37.         if (Files.exists(Paths.get(remote.getIdentity()))) {
  38.             jSch.addIdentity(remote.getIdentity(), remote.getPassphrase());
  39.         }
  40.         Session session = jSch.getSession(remote.getUser(), remote.getHost(), remote.getPort());
  41.         session.setPassword(remote.getPassword());
  42.         session.setConfig("StrictHostKeyChecking", "no");
  43.         return session;
  44.     }
  45.  
  46.  
  47.     /**
  48.      * excute remote command
  49.      *
  50.      * @param session session
  51.      * @param command command
  52.      * @return /
  53.      * @throws JSchException /
  54.      */
  55.     public static List<String> remoteExecute(Session session, String command) throws JSchException {
  56.         log.debug(">> {}", command);
  57.         List<String> resultLines = new ArrayList<>();
  58.         ChannelExec channel = null;
  59.         try {
  60.             channel = openExecChannel(session);
  61.             channel.setCommand(command);
  62.             InputStream input = channel.getInputStream();
  63.             channel.connect(CONNECT_TIMEOUT);
  64.             try {
  65.                 BufferedReader inputReader = new BufferedReader(new InputStreamReader(input));
  66.                 String inputLine;
  67.                 while ((inputLine = inputReader.readLine()) != null) {
  68.                     log.debug("   {}", inputLine);
  69.                     resultLines.add(inputLine);
  70.                 }
  71.             } finally {
  72.                 if (input != null) {
  73.                     try {
  74.                         input.close();
  75.                     } catch (Exception e) {
  76.                         log.error("JSch inputStream close error:", e);
  77.                     }
  78.                 }
  79.             }
  80.         } catch (IOException e) {
  81.             log.error("IOException:", e);
  82.         } finally {
  83.             disconnect(channel);
  84.         }
  85.         return resultLines;
  86.     }
  87.  
  88.  
  89.     /**
  90.      * scp file to remote server
  91.      *
  92.      * @param session     session
  93.      * @param source      local file
  94.      * @param destination remote target file
  95.      * @return file size
  96.      */
  97.     public static long scpTo(Session session, String source, String destination) {
  98.         FileInputStream fileInputStream = null;
  99.         ChannelExec channel = null;
  100.         try {
  101.             channel = openExecChannel(session);
  102.             OutputStream out = channel.getOutputStream();
  103.             InputStream in = channel.getInputStream();
  104.             boolean ptimestamp = false;
  105.             String command = "scp";
  106.             if (ptimestamp) {
  107.                 command += " -p";
  108.             }
  109.             command += " -t " + destination;
  110.             channel.setCommand(command);
  111.             channel.connect(CONNECT_TIMEOUT);
  112.             if (checkAck(in) != 0) {
  113.                 return -1;
  114.             }
  115.             File _lfile = new File(source);
  116.             if (ptimestamp) {
  117.                 command = "T " + (_lfile.lastModified() / 1000) + " 0";
  118.                 // The access time should be sent here,
  119.                 // but it is not accessible with JavaAPI ;-<
  120.                 command += (" " + (_lfile.lastModified() / 1000) + " 0\n");
  121.                 out.write(command.getBytes());
  122.                 out.flush();
  123.                 if (checkAck(in) != 0) {
  124.                     return -1;
  125.                 }
  126.             }
  127.             //send "C0644 filesize filename", where filename should not include '/'
  128.             long fileSize = _lfile.length();
  129.             command = "C0644 " + fileSize + " ";
  130.             if (source.lastIndexOf('/') > 0) {
  131.                 command += source.substring(source.lastIndexOf('/') + 1);
  132.             } else {
  133.                 command += source;
  134.             }
  135.             command += "\n";
  136.             out.write(command.getBytes());
  137.             out.flush();
  138.             if (checkAck(in) != 0) {
  139.                 return -1;
  140.             }
  141.             //send content of file
  142.             fileInputStream = new FileInputStream(source);
  143.             byte[] buf = new byte[1024];
  144.             long sum = 0;
  145.             while (true) {
  146.                 int len = fileInputStream.read(buf, 0, buf.length);
  147.                 if (len <= 0) {
  148.                     break;
  149.                 }
  150.                 out.write(buf, 0, len);
  151.                 sum += len;
  152.             }
  153.             //send '\0'
  154.             buf[0] = 0;
  155.             out.write(buf, 0, 1);
  156.             out.flush();
  157.             if (checkAck(in) != 0) {
  158.                 return -1;
  159.             }
  160.             return sum;
  161.         } catch (JSchException e) {
  162.             log.error("scp to caught jsch exception, ", e);
  163.         } catch (IOException e) {
  164.             log.error("scp to caught io exception, ", e);
  165.         } catch (Exception e) {
  166.             log.error("scp to error, ", e);
  167.         } finally {
  168.             closeInputStream(fileInputStream);
  169.             disconnect(channel);
  170.         }
  171.         return -1;
  172.     }
  173.  
  174.  
  175.     /**
  176.      * scp remote file to local
  177.      *
  178.      * @param session     session
  179.      * @param source      remote file
  180.      * @param destination local file
  181.      * @return file size
  182.      */
  183.     public static long scpFrom(Session session, String source, String destination) {
  184.         FileOutputStream fileOutputStream = null;
  185.         ChannelExec channel = null;
  186.         try {
  187.             channel = openExecChannel(session);
  188.             channel.setCommand("scp -f " + source);
  189.             OutputStream out = channel.getOutputStream();
  190.             InputStream in = channel.getInputStream();
  191.             channel.connect();
  192.             byte[] buf = new byte[1024];
  193.             //send '\0'
  194.             buf[0] = 0;
  195.             out.write(buf, 0, 1);
  196.             out.flush();
  197.             while (true) {
  198.                 if (checkAck(in) != 'C') {
  199.                     break;
  200.                 }
  201.             }
  202.             //read '644 '
  203.             in.read(buf, 0, 4);
  204.             long fileSize = 0;
  205.             while (true) {
  206.                 if (in.read(buf, 0, 1) < 0) {
  207.                     break;
  208.                 }
  209.                 if (buf[0] == ' ') {
  210.                     break;
  211.                 }
  212.                 fileSize = fileSize * 10L + (long) (buf[0] - '0');
  213.             }
  214.             String file = null;
  215.             for (int i = 0; ; i++) {
  216.                 in.read(buf, i, 1);
  217.                 if (buf[i] == (byte) 0x0a) {
  218.                     file = new String(buf, 0, i);
  219.                     break;
  220.                 }
  221.             }
  222.             // send '\0'
  223.             buf[0] = 0;
  224.             out.write(buf, 0, 1);
  225.             out.flush();
  226.             // read a content of lfile
  227.             if (Files.isDirectory(Paths.get(destination))) {
  228.                 fileOutputStream = new FileOutputStream(destination + File.separator + file);
  229.             } else {
  230.                 fileOutputStream = new FileOutputStream(destination);
  231.             }
  232.             long sum = 0;
  233.             while (true) {
  234.                 int len = in.read(buf, 0, buf.length);
  235.                 if (len <= 0) {
  236.                     break;
  237.                 }
  238.                 sum += len;
  239.                 if (len >= fileSize) {
  240.                     fileOutputStream.write(buf, 0, (int) fileSize);
  241.                     break;
  242.                 }
  243.                 fileOutputStream.write(buf, 0, len);
  244.                 fileSize -= len;
  245.             }
  246.             return sum;
  247.         } catch (JSchException e) {
  248.             log.error("scp to caught jsch exception, ", e);
  249.         } catch (IOException e) {
  250.             log.error("scp to caught io exception, ", e);
  251.         } catch (Exception e) {
  252.             log.error("scp to error, ", e);
  253.         } finally {
  254.             closeOutputStream(fileOutputStream);
  255.             disconnect(channel);
  256.         }
  257.         return -1;
  258.     }
  259.  
  260.  
  261.     /**
  262.      * remote edit
  263.      *
  264.      * @param session session
  265.      * @param source  target file
  266.      * @param process edit command collect
  267.      * @return isSuccess
  268.      */
  269.     private static boolean remoteEdit(Session session, String source, Function<List<String>, List<String>> process) {
  270.         InputStream in = null;
  271.         OutputStream out = null;
  272.         try {
  273.             String fileName = source;
  274.             int index = source.lastIndexOf('/');
  275.             if (index >= 0) {
  276.                 fileName = source.substring(index + 1);
  277.             }
  278.             //backup source
  279.             remoteExecute(session, String.format("cp %s %s", source, source + ".bak." + System.currentTimeMillis()));
  280.             //scp from remote
  281.             String tmpSource = System.getProperty("java.io.tmpdir") + session.getHost() + "-" + fileName;
  282.             scpFrom(session, source, tmpSource);
  283.             in = new FileInputStream(tmpSource);
  284.             //edit file according function process
  285.             String tmpDestination = tmpSource + ".des";
  286.             out = new FileOutputStream(tmpDestination);
  287.             List<String> inputLines = new ArrayList<>();
  288.             BufferedReader reader = new BufferedReader(new InputStreamReader(in));
  289.             String inputLine = null;
  290.             while ((inputLine = reader.readLine()) != null) {
  291.                 inputLines.add(inputLine);
  292.             }
  293.             List<String> outputLines = process.apply(inputLines);
  294.             for (String outputLine : outputLines) {
  295.                 out.write((outputLine + "\n").getBytes());
  296.                 out.flush();
  297.             }
  298.             //scp to remote
  299.             scpTo(session, tmpDestination, source);
  300.             return true;
  301.         } catch (Exception e) {
  302.             log.error("remote edit error, ", e);
  303.             return false;
  304.         } finally {
  305.             closeInputStream(in);
  306.             closeOutputStream(out);
  307.         }
  308.     }
  309.  
  310.  
  311.     /**
  312.      * update file
  313.      *
  314.      * @param session   session
  315.      * @param in        file stream
  316.      * @param directory local dir
  317.      * @param fileName  FTP server file name：xxx.txt ||xxx.txt.zip
  318.      */
  319.     public static boolean uploadFile(Session session, InputStream in, String directory, String fileName) {
  320.         log.info(">>>>>>>>uploadFile--ftp start>>>>>>>>>>>>>");
  321.         ChannelSftp channel = null;
  322.         try {
  323.             channel = openSftpChannel(session);
  324.             channel.connect(CONNECT_TIMEOUT);
  325.             String[] folders = directory.split("/");
  326.             try {
  327.                 for (int i = 0; i < folders.length; i++) {
  328.                     if (i == 0 && folders[i].length() == 0) {
  329.                         channel.cd("/");
  330.                     } else if (folders[i].length() > 0) {
  331.                         try {
  332.                             channel.cd(folders[i]);
  333.                         } catch (SftpException e) {
  334.                             channel.mkdir(folders[i]);
  335.                             channel.cd(folders[i]);
  336.                         }
  337.                     }
  338.                 }
  339.             } catch (SftpException e) {
  340.                 log.error("ftp create file fail" + directory, e);
  341.                 return false;
  342.             }
  343.  
  344.  
  345.             try {
  346.                 channel.put(in, fileName);
  347.             } catch (SftpException e) {
  348.                 log.error("sftp error-->" + e.getMessage(), e);
  349.                 return false;
  350.             }
  351.  
  352.  
  353.             log.info(">>>>>>>>uploadFile--ftp upload end>>>>>>>>>>>>>");
  354.             log.info(">>>>>>>>ftp upload dir：{}，filename：{}>>>>>>>>>>>>>", directory, fileName);
  355.  
  356.  
  357.             return true;
  358.         } catch (JSchException e) {
  359.             log.error("JSch error-->" + e.getMessage(), e);
  360.             return false;
  361.         } finally {
  362.             closeInputStream(in);
  363.             disconnect(channel);
  364.         }
  365.     }
  366.  
  367.  
  368.  
  369.  
  370.     /**
  371.      *
  372.      *
  373.      * @param channel   sftp connect
  374.      * @param directory
  375.      * @param fileName
  376.      * @return
  377.      */
  378.     public static InputStream stream(ChannelSftp channel, String directory, String fileName) {
  379.         try {
  380.             channel.connect(CONNECT_TIMEOUT);
  381.             InputStream inputStream = channel.get(directory + "/" + fileName);
  382.             log.info(">>>>>>>>ftp file directory：{}，filename：{}>>>>>>>>>>>>>", directory, fileName);
  383.             return inputStream;
  384.         } catch (SftpException e) {
  385.             log.error("sftp error-->" + e.getMessage());
  386.             return null;
  387.         } catch (JSchException e) {
  388.             log.error("JSch error-->" + e.getMessage());
  389.             return null;
  390.         }
  391.     }
  392.  
  393.  
  394.  
  395.  
  396.     /**
  397.      * ftp delete remote file
  398.      *
  399.      * @param session   session
  400.      * @param directory directory
  401.      * @param fileName  filename
  402.      * @return is Success
  403.      */
  404.     public static boolean deleteFile(Session session, String directory, String fileName) {
  405.         log.info(">>>>>>>>deleteFile--ftp delete file end>>>>>>>>>>>>>");
  406.         ChannelSftp channel = null;
  407.         try {
  408.             channel = openSftpChannel(session);
  409.             channel.connect(CONNECT_TIMEOUT);
  410.             channel.rm(directory + "/" + fileName);
  411.  
  412.  
  413.             log.info(">>>>>>>>deleteFile--deletefile end>>>>>>>>>>>>>");
  414.             log.info(">>>>>>>>ftp delete file directory：{}，filename：{}>>>>>>>>>>>>>", directory, fileName);
  415.         } catch (SftpException e) {
  416.             log.error("ftp create directory fail" + directory);
  417.             return false;
  418.         } catch (JSchException e) {
  419.             log.error("JSch error-->" + e.getMessage());
  420.             return false;
  421.         } finally {
  422.             disconnect(channel);
  423.         }
  424.  
  425.  
  426.         return true;
  427.     }
  428.  
  429.  
  430.     public static Channel openChannel(Session session, String type) throws JSchException {
  431.         if (!session.isConnected()) {
  432.             session.connect(SESSION_TIMEOUT);
  433.         }
  434.         return session.openChannel(type);
  435.     }
  436.  
  437.  
  438.     public static ChannelSftp openSftpChannel(Session session) throws JSchException {
  439.         return (ChannelSftp) openChannel(session, "sftp");
  440.     }
  441.  
  442.  
  443.     public static ChannelExec openExecChannel(Session session) throws JSchException {
  444.         return (ChannelExec) openChannel(session, "exec");
  445.     }
  446.  
  447.  
  448.     /**
  449.      * disconnect
  450.      *
  451.      * @param session
  452.      */
  453.     public static void disconnect(Session session) {
  454.         if (session != null) {
  455.             if (session.isConnected()) {
  456.                 try {
  457.                     session.disconnect();
  458.                     log.info("session disconnect successfully");
  459.                 } catch (Exception e) {
  460.                     log.error("JSch session disconnect error:", e);
  461.                 }
  462.             }
  463.         }
  464.     }
  465.  
  466.  
  467.     /**
  468.      * close connection
  469.      *
  470.      * @param channel channel connection
  471.      */
  472.     public static void disconnect(Channel channel) {
  473.         if (channel != null) {
  474.             if (channel.isConnected()) {
  475.                 try {
  476.                     channel.disconnect();
  477.                     log.info("channel is closed already");
  478.                 } catch (Exception e) {
  479.                     log.error("JSch channel disconnect error:", e);
  480.                 }
  481.             }
  482.         }
  483.     }
  484.  
  485.  
  486.     public static int checkAck(InputStream in) throws IOException {
  487.         int b = in.read();
  488.         // b may be 0 for success,
  489.         //          1 for error,
  490.         //          2 for fatal error,
  491.         //          -1
  492.         if (b == 0) {
  493.             return b;
  494.         }
  495.         if (b == -1) {
  496.             return b;
  497.         }
  498.         if (b == 1 || b == 2) {
  499.             StringBuilder sb = new StringBuilder();
  500.             int c;
  501.             do {
  502.                 c = in.read();
  503.                 sb.append((char) c);
  504.             }
  505.             while (c != '\n');
  506.             if (b == 1) { // error
  507.                 log.debug(sb.toString());
  508.             }
  509.             if (b == 2) { // fatal error
  510.                 log.debug(sb.toString());
  511.             }
  512.         }
  513.         return b;
  514.     }
  515.  
  516.  
  517.     public static void closeInputStream(InputStream in) {
  518.         if (in != null) {
  519.             try {
  520.                 in.close();
  521.             } catch (IOException e) {
  522.                 log.error("Close input stream error." + e.getMessage());
  523.             }
  524.         }
  525.     }
  526.  
  527.  
  528.     public static void closeOutputStream(OutputStream out) {
  529.         if (out != null) {
  530.             try {
  531.                 out.close();
  532.             } catch (IOException e) {
  533.                 log.error("Close output stream error." + e.getMessage());
  534.             }
  535.         }
  536.     }
  537.  
  538.  
  539. }
 
 
DemoApplication.java
 
 
 
 
  1. package com.et.jsch;
  2.  
  3.  
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6.  
  7.  
  8. @SpringBootApplication
  9. public class DemoApplication {
  10.  
  11.  
  12.    public static void main(String[] args) {
  13.       SpringApplication.run(DemoApplication.class, args);
  14.    }
  15. }
 
 
代码仓库
 
 
  • https://github.com/Harries/springboot-demo
 
 
4.测试
 
 
  1. import com.alibaba.fastjson.JSONObject;
  2. import com.et.jsch.DemoApplication;
  3. import com.et.jsch.model.Remote;
  4. import com.et.jsch.util.JSchUtil;
  5. import com.jcraft.jsch.JSchException;
  6. import com.jcraft.jsch.Session;
  7. import org.junit.After;
  8. import org.junit.Before;
  9. import org.junit.Test;
  10. import org.junit.runner.RunWith;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  13. import org.springframework.boot.test.context.SpringBootTest;
  14. import org.springframework.test.context.junit4.SpringRunner;
  15.  
  16.  
  17. import java.io.File;
  18. import java.io.FileInputStream;
  19. import java.io.FileNotFoundException;
  20. import java.io.InputStream;
  21. import java.util.List;
  22.  
  23.  
  24.  
  25.  
  26. @RunWith(SpringRunner.class)
  27. @SpringBootTest(classes = DemoApplication.class)
  28. public class JSchUtilTests {
  29.     private Logger log = LoggerFactory.getLogger(getClass());
  30.  
  31.  
  32.     Session session;
  33.     @Before
  34.     public void before() throws JSchException {
  35.         Remote remote= new Remote();
  36.         remote.setHost("xxx.xxx.xxx.xxx");
  37.         remote.setUser("root");
  38.         remote.setPassword("xxxx");
  39.         session= JSchUtil.getSession(remote);
  40.     }
  41.     @After
  42.     public void after(){
  43.         JSchUtil.disconnect(session);
  44.     }
  45.     @Test
  46.     public void remoteExecute() throws JSchException {
  47.         List<String>  list= JSchUtil.remoteExecute(session,"ls");
  48.         System.out.println(JSONObject.toJSON(list));
  49.     }
  50.     @Test
  51.     public void uploadFile() throws JSchException, FileNotFoundException {
  52.         String filestr ="D:\\tmp\\test\\file_utils\\file1.txt";
  53.         File file = new File(filestr);
  54.         InputStream in = new FileInputStream(file);
  55.  
  56.  
  57.         String directory="/root/test";
  58.         String fileName="test.txt";
  59.        boolean flag= JSchUtil.uploadFile(session,in,directory,fileName);
  60.         System.out.println(flag);
  61.     }
  62.     @Test
  63.     public void deleteFile() throws JSchException, FileNotFoundException {
  64.         String directory="/root/test";
  65.         String fileName="test.txt";
  66.         boolean flag= JSchUtil.deleteFile(session,directory,fileName);
  67.         System.out.println(flag);
  68.     }
  69.     @Test
  70.     public void scpFrom() throws JSchException, FileNotFoundException {
  71.  
  72.  
  73.         String source="/root/test/file1.txt";
  74.         String destination ="D:\\tmp\\scfFrom.txt";
  75.         long  filesize= JSchUtil.scpFrom(session,source,destination);
  76.         System.out.println(filesize);
  77.     }
  78.     @Test
  79.     public void scpTo() throws JSchException, FileNotFoundException {
  80.  
  81.  
  82.         String filestr ="D:\\tmp\\test\\file_utils\\file1.txt";
  83.         String destination="/root/test/file1.txt";
  84.         long  filesize= JSchUtil.scpTo(session,filestr,destination);
  85.         System.out.println(filesize);
  86.     }
  87.  
  88.  
  89. }
 
 
自己尝试一下吧，非常好的一个工具，更多功能可以去官网看例子
 
 
5.引用
 
 
  • http://www.jcraft.com/jsch/examples/
  • http://www.liuhaihua.cn/archives/710346.html
 


                

               本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/341293
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号