1. JSCH 应用办法
jsch 应用办法
2. JSCH 工具类
JSCH 工具类
3. 创立连接池
ConnectionPool.java
@Slf4j
public class ConnectionPool {
private String strictHostKeyChecking;
private Integer timeout;
/**
* ip 地址
*/
private String ip = "";
/**
* 端口号
*/
private Integer port = 22;
/**
* 用户名
*/
private String username = "";
/**
* 明码
*/
private String password = "";
/**
* 每次扩容减少几个连贯
*/
private int incrementalConnections = 2;
/**
* 最大连接数
*/
private int maxConnections = 10;
/**
* 最大闲暇连贯
*/
private int maxIdle = 4;
/**
* 最小闲暇连贯
*/
private int minIdel = 2;
private Vector<PooledConnection> connections = null;
@PostConstruct
private void init() {createPool();
}
/**
* 构造方法
*
* @param strictHostKeyChecking 连贯模式
* @param timeout 超时工夫
*/
public ConnectionPool(String strictHostKeyChecking, Integer timeout) {
this.strictHostKeyChecking = strictHostKeyChecking;
this.timeout = timeout;
}
/**
* 构造方法
*
* @param strictHostKeyChecking 连贯模式
* @param timeout 超时工夫
* @param incrementalConnections 增量大小
*/
public ConnectionPool(String strictHostKeyChecking,
Integer timeout,
int incrementalConnections) {
this.strictHostKeyChecking = strictHostKeyChecking;
this.timeout = timeout;
this.incrementalConnections = incrementalConnections;
}
/**
* 构造方法
*
* @param strictHostKeyChecking 连贯模式
* @param timeout 超时工夫
* @param incrementalConnections 增量大小
* @param maxConnections 连接池最大连接数
*/
public ConnectionPool(String strictHostKeyChecking,
Integer timeout,
int incrementalConnections,
int maxConnections) {
this.strictHostKeyChecking = strictHostKeyChecking;
this.timeout = timeout;
this.incrementalConnections = incrementalConnections;
this.maxConnections = maxConnections;
}
/**
* 创立连接池，判断连接池是否创立，如果连接池没有创立则创立连接池
*/
public synchronized void createPool() {if (Objects.nonNull(connections)) {return;}
connections = new Vector<>();
log.info("create shell connectionPool success!");
}
/**
* 创立指定数量的连贯放入连接池中
*
* @param numConnections 创立数量
* @throws JSchException 建设近程连贯异样
*/
private void createConnections(int numConnections) throws JSchException {for (int x = 0; x < numConnections; x++) {
// 判断是否已达连接池最大连贯，如果达到最大连贯数据则不再创立连贯
if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {break;}
// 在连接池中新增一个连贯
try {connections.addElement(new PooledConnection(newConnection(), ip));
} catch (JSchException e) {log.error("create shell connection failed {}", e.getMessage());
throw new JSchException();}
log.info("Session connected!");
}
}
/**
* 新一个连贯 session
*
* @return 创立的 session
* @throws JSchException 近程连贯异样
*/
private Session newConnection() throws JSchException {
// 创立一个 session
JSch jsch = new JSch();
Session session = jsch.getSession(username, ip, port);
session.setPassword(password);
Properties sshConfig = new Properties();
sshConfig.put("StrictHostKeyChecking", strictHostKeyChecking);
session.setConfig(sshConfig);
session.connect(timeout);
session.setServerAliveInterval(1800);
return session;
}
/**
* 获取一个可用 session
*
* @param ip ip 地址
* @param port 端口号
* @param username 用户名
* @param password 明码
* @return 可用的 session
* @throws JSchException 近程连贯异样
*/
public synchronized Session getConnection(String ip, Integer port, String username, String password) throws JSchException {
this.ip = ip;
this.port = port;
this.username = username;
this.password = password;
// 连接池还没创立，则返回 null
if (Objects.isNull(connections)) {return null;}
// 取得一个可用的数据库连贯
Session session = getFreeConnection();
// 如果目前没有能够应用的连贯，即所有的连贯都在应用中，等一会重试
while (Objects.isNull(session)) {wait(250);
session = getFreeConnection();}
return session;
}
/**
* 获取一个可用 session
*
* @return 返回可用 session
* @throws JSchException 近程连贯异样
*/
private Session getFreeConnection() throws JSchException {Session session = findFreeConnection();
// 如果没有可用连贯，则创立连贯，if (Objects.isNull(session)) {createConnections(incrementalConnections);
session = findFreeConnection();
if (Objects.isNull(session)) {return null;}
}
return session;
}
/**
* 查找可用连贯
*
* @return 返回可用连贯
*/
private Session findFreeConnection() {
Session session = null;
PooledConnection conn;
Enumeration<PooledConnection> enumerate = connections.elements();
// 遍历所有的对象，看是否有可用的连贯
while (enumerate.hasMoreElements()) {conn = enumerate.nextElement();
if (!ip.equals(conn.getTag())) {continue;}
if (!conn.isBusy()) {session = conn.getSession();
conn.setBusy(true);
if (!testConnection(session)) {
try {session = newConnection();
} catch (JSchException e) {log.error("create shell connection failed {}", e.getMessage());
return null;
}
conn.setSession(session);
}
break;
}
}
return session;
}
/**
* 测试连贯是否可用
*
* @param session 须要测试的 session
* @return 是否可用
*/
private boolean testConnection(Session session) {boolean connected = session.isConnected();
if (!connected) {closeConnection(session);
return false;
}
return true;
}
/**
* 将 session 放回连接池中
*
* @param session 须要放回连接池中的 session
*/
public synchronized void returnConnection(Session session) {
// 确保连接池存在，如果连贯没有创立（不存在），间接返回
if (Objects.isNull(connections)) {log.error("ConnectionPool does not exist");
return;
}
PooledConnection conn;
Enumeration<PooledConnection> enumerate = connections.elements();
// 遍历连接池中的所有连贯，找到这个要返回的连贯对象，将状态设置为闲暇
while (enumerate.hasMoreElements()) {conn = enumerate.nextElement();
if (session.equals(conn.getSession())) {conn.setBusy(false);
}
}
}
/**
* 刷新连接池
*
* @throws JSchException 近程连贯异样
*/
public synchronized void refreshConnections() throws JSchException {
// 确保连接池己翻新存在
if (Objects.isNull(connections)) {log.error("ConnectionPool does not exist");
return;
}
PooledConnection conn;
Enumeration<PooledConnection> enumerate = connections.elements();
while (enumerate.hasMoreElements()) {conn = enumerate.nextElement();
if (conn.isBusy()) {wait(5000);
}
closeConnection(conn.getSession());
conn.setSession(newConnection());
conn.setBusy(false);
}
}
/**
* 敞开连接池
*/
public synchronized void closeConnectionPool() {
// 确保连接池存在，如果不存在，返回
if (Objects.isNull(connections)) {log.info("Connection pool does not exist");
return;
}
PooledConnection conn;
Enumeration<PooledConnection> enumerate = connections.elements();
while (enumerate.hasMoreElements()) {conn = enumerate.nextElement();
if (conn.isBusy()) {wait(5000);
}
closeConnection(conn.getSession());
connections.removeElement(conn);
}
connections = null;
}
/**
* 敞开 session 会话
*
* @param session 须要敞开的 session
*/
private void closeConnection(Session session) {session.disconnect();
}
/**
* 线程暂停
*
* @param mSeconds 暂停工夫
*/
private void wait(int mSeconds) {
try {Thread.sleep(mSeconds);
} catch (InterruptedException e) {log.error("{} 线程暂停失败 -> {}", Thread.currentThread().getName(), e.getMessage());
}
}
/**
* 对象连接状态
*/
class PooledConnection {
/**
* 近程连贯
*/
Session session;
/**
* 此连贯是否正在应用的标记，默认没有正在应用
*/
boolean busy = false;
/**
* 连贯标记
*/
String tag;
/**
* 构造函数，依据一个 Session 结构一个 PooledConnection 对象
*
* @param session 连贯
* @param tag 连贯标记
*/
public PooledConnection(Session session, String tag) {
this.session = session;
this.tag = tag;
}
public Session getSession() {return session;}
public void setSession(Session session) {this.session = session;}
public boolean isBusy() {return busy;}
public void setBusy(boolean busy) {this.busy = busy;}
public String getTag() {return tag;}
public void setTag(String tag) {this.tag = tag;}
}
public int getIncrementalConnections() {return this.incrementalConnections;}
public void setIncrementalConnections(int incrementalConnections) {this.incrementalConnections = incrementalConnections;}
public int getMaxConnections() {return this.maxConnections;}
public void setMaxConnections(int maxConnections) {this.maxConnections = maxConnections;}
}
4. 革新 shellUtil
ShellUtil.java
@Slf4j
@Component
@Scope(value = "prototype")
public class ShellUtil {
/**
* ip 地址
*/
private String ip = "";
/**
* 端口号
*/
private Integer port = 22;
/**
* 用户名
*/
private String username = "";
/**
* 明码
*/
private String password = "";
private Session session;
private Channel channel;
private ChannelExec channelExec;
private ChannelSftp channelSftp;
private ChannelShell channelShell;
private ConnectionPool connectionPool;
public ShellUtil(ConnectionPool connectionPool) {this.connectionPool = connectionPool;}
/**
* 初始化
*
* @param ip 近程主机 IP 地址
* @param port 近程主机端口
* @param username 近程主机登陆用户名
* @param password 近程主机登陆密码
* @throws JSchException JSch 异样
*/
public void init(String ip, Integer port, String username, String password) throws JSchException {
this.ip = ip;
this.port = port;
this.username = username;
this.password = password;
}
public void init(String ip, String username, String password) throws JSchException {
this.ip = ip;
this.username = username;
this.password = password;
}
private void getSession() throws JSchException {session = connectionPool.getConnection(ip, port, username, password);
if (Objects.isNull(session)) {connectionPool.refreshConnections();
session = connectionPool.getConnection(ip, port, username, password);
if (Objects.isNull(session)){throw new RuntimeException("无可用连贯");
}
}
}
/**
* 连贯屡次执行命令，执行命令结束后须要执行 close()办法
*
* @param command 须要执行的指令
* @return 执行后果
* @throws Exception 没有执行初始化
*/
public String execCmd(String command) throws Exception {initChannelExec();
log.info("execCmd command - > {}", command);
channelExec.setCommand(command);
channel.setInputStream(null);
channelExec.setErrStream(System.err);
channel.connect();
StringBuilder sb = new StringBuilder(16);
try (InputStream in = channelExec.getInputStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader reader = new BufferedReader(isr)) {
String buffer;
while ((buffer = reader.readLine()) != null) {sb.append("\n").append(buffer);
}
log.info("execCmd result - > {}", sb);
return sb.toString();}
}
/**
* 执行命令敞开连贯
*
* @param command 须要执行的指令
* @return 执行后果
* @throws Exception 没有执行初始化
*/
public String execCmdAndClose(String command) throws Exception {String result = execCmd(command);
close();
return result;
}
/**
* 执行简单 shell 命令
*
* @param cmds 多条命令
* @return 执行后果
* @throws Exception 连贯异样
*/
public String execCmdByShell(String... cmds) throws Exception {return execCmdByShell(Arrays.asList(cmds));
}
/**
* 执行简单 shell 命令
*
* @param cmds 多条命令
* @return 执行后果
* @throws Exception 连贯异样
*/
public String execCmdByShell(List<String> cmds) throws Exception {
String result = "";
initChannelShell();
InputStream inputStream = channelShell.getInputStream();
channelShell.setPty(true);
channelShell.connect();
OutputStream outputStream = channelShell.getOutputStream();
PrintWriter printWriter = new PrintWriter(outputStream);
for (String cmd : cmds) {printWriter.println(cmd);
}
printWriter.flush();
byte[] tmp = new byte[1024];
while (true) {while (inputStream.available() > 0) {int i = inputStream.read(tmp, 0, 1024);
if (i < 0) {break;}
String s = new String(tmp, 0, i);
if (s.contains("--More--")) {outputStream.write((" ").getBytes());
outputStream.flush();}
System.out.println(s);
}
if (channelShell.isClosed()) {System.out.println("exit-status:" + channelShell.getExitStatus());
break;
}
try {Thread.sleep(1000);
} catch (Exception e) {e.printStackTrace();
}
}
outputStream.close();
inputStream.close();
close();
return result;
}
/**
* SFTP 文件上传
*
* @param src 源地址
* @param dst 目标地址
* @throws Exception 上传文件失败
*/
public void put(String src, String dst) throws Exception {put(src, dst, ChannelSftp.OVERWRITE);
}
/**
* SFTP 文件上传
*
* @param src 源地址
* @param dst 目标地址
* @param mode 上传模式 默认为 ChannelSftp.OVERWRITE
* @throws Exception 上传文件失败
*/
public void put(String src, String dst, int mode) throws Exception {initChannelSftp();
log.info("Upload File {} -> {}", src, dst);
channelSftp.put(src, dst, mode);
log.info("Upload File Success!");
close();}
/**
* SFTP 文件上传并监控上传进度
*
* @param src 源地址
* @param dst 目标地址
* @throws Exception 上传文件失败
*/
public void putMonitorAndClose(String src, String dst) throws Exception {putMonitorAndClose(src, dst, ChannelSftp.OVERWRITE);
}
/**
* SFTP 文件上传并监控上传进度
*
* @param src 源地址
* @param dst 目标地址
* @param mode 上传模式 默认为 ChannelSftp.OVERWRITE
* @throws Exception 上传文件失败
*/
public void putMonitorAndClose(String src, String dst, int mode) throws Exception {initChannelSftp();
FileProgressMonitor monitor = new FileProgressMonitor(new File(src).length());
log.info("Upload File {} -> {}", src, dst);
channelSftp.put(src, dst, monitor, mode);
log.info("Upload File Success!");
close();}
/**
* SFTP 文件下载
*
* @param src 源文件地址
* @param dst 目标地址
* @throws Exception 下载文件失败
*/
public void get(String src, String dst) throws Exception {initChannelSftp();
log.info("Download File {} -> {}", src, dst);
channelSftp.get(src, dst);
log.info("Download File Success!");
close();}
/**
* SFTP 文件下载并监控下载进度
*
* @param src 源文件地址
* @param dst 目标地址
* @throws Exception 下载文件失败
*/
public void getMonitorAndClose(String src, String dst) throws Exception {initChannelSftp();
FileProgressMonitor monitor = new FileProgressMonitor(new File(src).length());
log.info("Download File {} -> {}", src, dst);
channelSftp.get(src, dst, monitor);
log.info("Download File Success!");
close();}
/**
* 删除指定目录文件
*
* @param path 删除门路
* @throws Exception 近程主机连贯异样
*/
public void deleteFile(String path) throws Exception {initChannelSftp();
channelSftp.rm(path);
log.info("Delete File {}", path);
close();}
/**
* 删除指定目录
*
* @param path 删除门路
* @throws Exception 近程主机连贯异样
*/
public void deleteDir(String path) throws Exception {initChannelSftp();
channelSftp.rmdir(path);
log.info("Delete Dir {}", path);
close();}
/**
* 开释资源
*/
public void close() {connectionPool.returnConnection(session);
}
private void initChannelSftp() throws Exception {getSession();
channel = session.openChannel("sftp");
channel.connect(); // 建设 SFTP 通道的连贯
channelSftp = (ChannelSftp) channel;
if (session == null || channel == null || channelSftp == null) {log.error("请先执行 init()");
throw new Exception("请先执行 init()");
}
}
private void initChannelExec() throws Exception {getSession();
// 关上执行 shell 指令的通道
channel = session.openChannel("exec");
channelExec = (ChannelExec) channel;
if (session == null || channel == null || channelExec == null) {log.error("请先执行 init()");
throw new Exception("请先执行 init()");
}
}
private void initChannelShell() throws Exception {getSession();
// 关上执行 shell 指令的通道
channel = session.openChannel("shell");
channelShell = (ChannelShell) channel;
if (session == null || channel == null || channelShell == null) {log.error("请先执行 init()");
throw new Exception("请先执行 init()");
}
}
}
5. 增加配置
ConnectionPoolConfig.java
@Configuration
public class PoolConfiguration {@Value("${ssh.strictHostKeyChecking:no}")
private String strictHostKeyChecking;
@Value("${ssh.timeout:30000}")
private Integer timeout;
@Value("${ssh.incrementalConnections:2}")
private Integer incrementalConnections;
@Value("${ssh.maxConnections:10}")
private Integer maxConnections;
@Bean
public ConnectionPool connectionPool(){return new ConnectionPool(strictHostKeyChecking, timeout,incrementalConnections,maxConnections);
}
}
6. 线程平安问题解决
6.1
public class SessionThreadLocal {private static ThreadLocal<Session> threadLocal = new ThreadLocal<>();
public static synchronized void set(Session session) {threadLocal.set(session);
}
public static synchronized Session get( ) {return threadLocal.get();
}
public static synchronized void remove( ) {threadLocal.remove();
}
}
6.2 应用 springboot 中 bean 的作用域 prototype
应用 @Lookup 注入形式
@Lookup
public ShellUtil getshellUtil(){return null;};
@GetMapping("/test")
public void Test() throws Exception {int i = getshellUtil().hashCode();
System.out.println(i);
}