java 连接SSH工具操作服务器 (构建者模式+Util类) 分享

需求

因为需要以java 远程操作服务器, 比如进行文件下载/上传操作, 或者执行一些服务器常用命令ls cat grep 等等. 调研发现比较好用的SSH 工具有:

• ganymed-ssh2
• jsch
• sshj 等.
  这些工具最主要的区别在于SSH加密算法的丰富性
  ganymed-ssh2 < jsch< sshj

因为目前服务器的安全性上 ganymed-ssh2 可以满足,所以本工具基于ganymed-ssh2 封装

        <dependency>
            <groupId>ch.ethz.ganymed</groupId>
            <artifactId>ganymed-ssh2</artifactId>
            <version>build210</version>
        </dependency>
1
2
3
4
5

静态方法工具类

优点:
直接使用SSHUtil.xxx方法完成部分操作,简洁无脑
缺点:
方法为单独调用, 操作不方便 (因为有时候需要使用多个步骤)

使用方式 : 基本顺序式调用

Connection connection= SSHUtil.getConnect(“”,“”,“”)
SFTPv3Client sftpClient = new SFTPv3Client(connection);
// 查看删除等操作
sftpClient.rm(“”);
sftpClient.ls(“”);
sftpClient.mv(“”);
// 或者执行命令行
Session sess = connection.openSession();
sess.execCommand("mv a b);
sess.close();
connection.close();

import ch.ethz.ssh2.*;
import cn.hutool.core.util.StrUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;

/**
 * @author jee
 * @version 1.0
 */
public class SSHUtil {

    private static final Logger logger = LoggerFactory.getLogger(SSHUtil.class);


    /**
     * 使用默认的22端口
     * 获取ssh服务连接
     *
     * @param serverIp 服务器IP
     * @param username 用户名
     * @param password 密码
     * @return ssh连接对象
     * @throws SSHException ssh连接异常
     */
    public static Connection getConnect(String serverIp, String username, String password) throws SSHException {
        return getConnect(serverIp, 22, username, password);
    }

    /**
     * 获取ssh服务连接
     *
     * @param serverIp 服务器IP
     * @param port     端口
     * @param username 用户名
     * @param password 密码
     * @return ssh连接对象
     * @throws SSHException ssh连接异常
     */
    public static Connection getConnect(String serverIp, int port, String username, String password) throws SSHException {
        Connection connection = new Connection(serverIp, port);
        try {
            connection.connect();
            connection.authenticateWithPassword(username, password);
            return connection;
        } catch (IOException e) {
            throw new SSHException("服务连接异常", e);
        }
    }

    /**
     * 远程拷贝文件
     *
     * @param remoteFile           远程源文件路径
     * @param localTargetDirectory 本地存放文件路径
     */
    public void downloadFile(Connection connection, String remoteFile, String localTargetDirectory) throws SSHException {
        try {
            SCPClient client = new SCPClient(connection);
            client.get(remoteFile, localTargetDirectory);
            connection.close();
        } catch (IOException e) {
            throw new SSHException("拷贝文件异常!", e);
        }
    }


    /**
     * 远程上传文件
     *
     * @param localFile             本地文件路径
     * @param remoteTargetDirectory 远程存放文件路径
     */
    public void uploadFile(Connection connection, String localFile, String remoteTargetDirectory) throws SSHException {
        try {
            SCPClient client = new SCPClient(connection);
            client.put(localFile, remoteTargetDirectory);
            connection.close();
        } catch (IOException e) {
            throw new SSHException("上传文件异常!", e);
        }
    }

    /**
     * 远程上传文件 并指定上传文件名称
     *
     * @param localFile             本地文件路径
     * @param remoteFileName        远程文件名
     * @param remoteTargetDirectory 远程存放文件路径
     * @param mode                  默认"0600"，length=4
     */
    public static void uploadFile(Connection connection, String localFile, String remoteFileName, String remoteTargetDirectory, String mode) throws SSHException {
        try {
            SCPClient client = new SCPClient(connection);
            if (StrUtil.isBlank(mode)) {
                mode = "0600";
            }
            client.put(localFile, remoteFileName, remoteTargetDirectory, mode);
            //重命名
            String tmpPathName = remoteTargetDirectory + File.separator + remoteFileName;
            String newPathName = tmpPathName.substring(0, tmpPathName.lastIndexOf("."));
            String cmd = StrUtil.format("mv {} {}", remoteFileName, newPathName);
            execShell(connection, cmd);
            connection.close();
        } catch (IOException e) {
            throw new SSHException("上传文件异常!", e);
        }
    }


    /**
     * 执行shell命令
     *
     * @param connection 服务器连接对象
     * @param cmd        shell命令
     * @throws SSHException 执行shell异常
     */
    public static void execShell(Connection connection, String cmd) throws SSHException {
        //重命名
        try {
            Session session = connection.openSession();
            session.execCommand(cmd);
            session.close();
        } catch (IOException e) {
            throw new SSHException("执行shell异常!", e);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

使用构造者模式升级工具

基于Consumer 加builder模式进行构建

import ch.ethz.ssh2.*;
import cn.hutool.core.io.IoUtil;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * SSH 构建者模式
 *
 * @author jee
 * @version 1.0
 */
public class SSHBuilder {
    /**
     * 连接对象
     */
    private Connection connection;
    /**
     * session会话
     */
    private Session session;


    public SSHBuilder conn(String ip, int port, String username, String password) throws SSHException {
        if (connection == null) {
            connection = SSHUtil.getConnect(ip, port, username, password);
        }
        return this;
    }
    public SSHBuilder conn(String ip, String username, String password) throws SSHException {
        conn(ip, 22, username, password);
        return this;
    }

    /**
     * scp 操作
     *
     * @param consumer 提供SCPClient对象
     * @return ssh对象
     * @throws SSHException ssh操作异常
     */
    public SSHBuilder scp(Consumer<SCPClient> consumer) throws SSHException {
        if (connection == null) {
            throw new IllegalArgumentException("未建立连接");
        }
        consumer.accept(new SCPClient(connection));
        return this;
    }

    /**
     * sftp操作
     *
     * @param consumer 提供SFTPv3Client 操作对象
     * @return ssh对象
     * @throws SSHException ssh操作异常
     */
    public SSHBuilder sftp(Consumer<SFTPv3Client> consumer) throws SSHException {
        if (connection == null) {
            throw new IllegalArgumentException("未建立连接");
        }
        try {
            consumer.accept(new SFTPv3Client(connection));
        } catch (IOException e) {
            throw new SSHException("构建sftp异常", e);
        }
        return this;
    }


    /**
     * 无返回结果的命令行操作
     *
     * @param cmd shell命令
     * @return ssh对象
     * @throws SSHException ssh操作异常
     */
    public SSHBuilder exec(String cmd) throws SSHException {
        return exec(cmd, null);
    }


    /**
     * 命令行操作
     *
     * @param cmd      shell命令
     * @param consumer 提供执行结果行集合文本
     * @return ssh对象
     * @throws SSHException ssh操作异常
     */
    public SSHBuilder exec(String cmd, Consumer<List<String>> consumer) throws SSHException {
        if (connection == null) {
            throw new IllegalArgumentException("未建立连接");
        }

        try {
            session = connection.openSession();
            session.execCommand(cmd);
            if (consumer != null) {
                List<String> lines = IoUtil.readUtf8Lines(session.getStdout(), new ArrayList<>());
                //读取错误信息
                if (lines.size() == 0) {
                    lines = IoUtil.readUtf8Lines(session.getStderr(), new ArrayList<>());
                }
                consumer.accept(lines);
            }
        } catch (IOException e) {
            throw new SSHException("构建exec异常", e);
        }
        return this;
    }

    public void close() {
        if (session != null) {
            session.close();
        }

        if (connection != null) {
            connection.close();
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

使用方式

1. scp操作

   // 上传文件
        new SSHBuilder().conn("xxx.xxx.xxx.xxx", "root", "xxxx").scp(scp -> {
            try {
                scp.get("", "");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).close();
1
2
3
4
5
6
7
8

2.sftp操作

 // 删除文件
        new SSHBuilder().conn("xxx.xxx.xxx.xxx", "root", "xxxx").sftp(sftp -> {
            try {
                sftp.rm("");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).close();
1
2
3
4
5
6
7
8

3. 链式多操作

    // sftp+ 命令 操作
        new SSHBuilder().conn("xxx.xxx.xxx.xxx", "root", "xxxx")
                .sftp(sftp -> {
                    try {
                        sftp.mkdir("/test-ssh", 0777);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                })
                .exec("cd /&&ls", lines -> {
                    lines.forEach(s -> {
                        System.out.println(s);
                    });
                }).close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试结果如图: