1. JSCH应用办法
jsch应用办法
2. JSCH工具类
JSCH工具类
3. 创立连接池
ConnectionPool.java
@Slf4jpublic 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
@Configurationpublic 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); }