java使用jsch连接linux
由于项目需要使用java来linux进行管理，近一番查找，发现第三方jar包 jsch 可以轻松实现对linux的管理，（相关文档及例子请访问官网www.jcraft.com），故引进。
在网上搜索了一些资料参考并修改（资料来源地址一下子找不到了，有发现的请提醒加上），创建一个工具类，可以实现对linux上的基本操作及系统上文件的上传和下载。
代码如下：
/**
* @description 用来创建与 linux 交互的会话，操作文件和执行 操作 命令
* @date: 2016/7/25
* @author: gongtao
*/
public class LinuxConnetionHelper {
private static final org.slf4j.Logger log = LoggerFactory.getLogger(LinuxConnetionHelper.class);
private static final int TIME_OUT = 5*60*1000; //设置超时为5分钟
private static final Map<String,Session> cache = new HashMap<>(); //session缓存
public static SessionMonitor sessionMonitor;
/**
* 创建 连接，需手动关闭
* @param host
* @param userName
* @param password
* @param port
* @throws JSchException
*/
public static Session connect(String host,String userName,String password,int port) throws JSchException {
//创建对象
JSch jsch = new JSch();
//创建会话
Session session = jsch.getSession(userName,host, port);
//输入密码
session.setPassword(password);
//配置信息
Properties config = new Properties();
//设置不用检查hostKey
//如果设置成“yes”，ssh就不会自动把计算机的密匙加入“$HOME/.ssh/known_hosts”文件，
//并且一旦计算机的密匙发生了变化，就拒绝连接。
config.setProperty("StrictHostKeyChecking", "no");
// //默认值是 “yes” 此处是由于我们SFTP服务器的DNS解析有问题，则把UseDNS设置为“no”
// config.put("UseDNS", "no");
session.setConfig(config);
//过期时间
session.setTimeout(TIME_OUT);
//建立连接
session.connect();
return session;
}
/**
* 创建 连接，无需手动关闭
* @param host
* @param userName
* @param password
* @param port
* @throws JSchException
*/
public static Session longConnect(String host,String userName,String password,int port) throws JSchException {
String key = host + userName + password + port;
Session session = cache.get(key);
if (session == null){
//创建对象
JSch jsch = new JSch();
//创建会话
session = jsch.getSession(userName,host, port);
//输入密码
session.setPassword(password);
//配置信息
Properties config = new Properties();
//设置不用检查hostKey
//如果设置成“yes”，ssh就不会自动把计算机的密匙加入“$HOME/.ssh/known_hosts”文件，
//并且一旦计算机的密匙发生了变化，就拒绝连接。
config.setProperty("StrictHostKeyChecking", "no");
// //默认值是 “yes” 此处是由于我们SFTP服务器的DNS解析有问题，则把UseDNS设置为“no”
// config.put("UseDNS", "no");
session.setConfig(config);
//过期时间
//session.setTimeout(TIME_OUT);
//建立连接，此时会在linux上新建一个进程，timeout 并不会结束进程，只有调用disconnect()才会结束此进程
session.connect();
cache.put(key,session);
}else{
//判断session是否失效
if (testSessionIsDown(key)){
//session is down
//session 失去连接则清除
closeLongSessionByKey(key);
//重新生成session
session = longConnect(host, userName, password, port);
}
}
//创建定时器
createSessionMonitor();
return session;
}
/**
* 销毁 session
* @param session
*/
public static void close(Session session){
if (session != null){
session.disconnect();
}
}
/**
* 测试session是否失效
* @param key
* @return
*/
public static boolean testSessionIsDown(String key){
Session session = cache.get(key);
if (session == null){
return true;
}
ChannelExec channelExec = null;
try {
channelExec = openChannelExec(session);
channelExec.setCommand("true");
channelExec.connect();
return false;
}catch (Throwable e){
//session is down
return true;
}finally {
if (channelExec != null){
channelExec.disconnect();
}
}
}
/**
* 销毁 session
* @param key
*/
public static synchronized void closeLongSessionByKey(String key){
Session session = cache.get(key);
if (session != null){
session.disconnect();
cache.remove(key);
}
}
/**
* 销毁 session
* @param session
*/
public static void closeLongSessionBySession(Session session){
Iterator iterator = cache.keySet().iterator();
while (iterator.hasNext()){
String key = (String)iterator.next();
Session oldSession = cache.get(key);
if (session == oldSession){
session.disconnect();
cache.remove(key);
return;
}
}
}
/**
* 创建一个 sftp 通道并建立连接
* @param session
* @return
* @throws Exception
*/
public static ChannelSftp openChannelSftp(Session session) throws Exception
{
ChannelSftp channelSftp = (ChannelSftp)session.openChannel("sftp");
channelSftp.connect();
return channelSftp;
}
/**
* 关闭 sftp 通道
* @param channelSftp
* @throws Exception
*/
public static void closeChannelSftp(ChannelSftp channelSftp)
{
if (channelSftp != null){
channelSftp.disconnect();
}
}
/**
* 下载文件
* @param remoteFile
* 远程服务器的文件路径
* @param localPath
* 需要保存文件的本地路径
* @throws IOException
* @throws SftpException
*/
public static void downloadFile(Session session , String remoteFile, String localPath) throws Exception {
ChannelSftp channelSftp = openChannelSftp(session);
try {
String remoteFilePath = remoteFile.substring(0, remoteFile.lastIndexOf("/"));
String remoteFileName = remoteFile.substring(remoteFile.lastIndexOf("/") + 1,remoteFile.length());
if(localPath.charAt(localPath.length() - 1) != '/'){
localPath += '/';
}
File file = new File(localPath + remoteFileName);
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
file.createNewFile();
}
OutputStream output = new FileOutputStream(file);
try {
channelSftp.cd(remoteFilePath);
log.info("远程服务器路径：" + remoteFilePath);
log.info("本地下载路径：" + localPath + remoteFileName);
SftpATTRS attrs = channelSftp.lstat(remoteFile);
channelSftp.get(remoteFile, output, new FileSftpProgressMonitor(attrs.getSize()));
}catch (Exception e){
throw e;
}finally {
output.flush();
output.close();
}
}catch (Exception e){
throw e;
}finally {
closeChannelSftp(channelSftp);
}
}
/**
* 上传文件
* @param localFile
* 本地文件路径
* @param remotePath
* 远程服务器路径
* @throws IOException
* @throws SftpException
*/
public static void uploadFile(Session session,String localFile,String remotePath) throws Exception {
ChannelSftp channelSftp = openChannelSftp(session);
String remoteFileName = localFile.substring(localFile.lastIndexOf("/") + 1, localFile.length());
File file = new File(localFile);
final InputStream input = new FileInputStream(file);
try {
channelSftp.cd(remotePath);
}catch (SftpException e){
String tempPath = null;
try {
tempPath = remotePath.substring(0, remotePath.lastIndexOf("/"));
channelSftp.cd(tempPath);
}catch (SftpException e1){
channelSftp.mkdir(tempPath);
}
channelSftp.mkdir(remotePath);
channelSftp.cd(remotePath);
}
log.info("远程服务器路径：" + remotePath);
log.info("本地上传路径：" + localFile);
try {
channelSftp.put(input, remoteFileName, new FileSftpProgressMonitor(file.length()));
}catch (Exception e){
throw e;
}finally {
input.close();
closeChannelSftp(channelSftp);
}
}
/**
* 文件上传
* @param session
* @param inputStream
* @param fileName
* @param remotePath
* @throws Exception
*/
public static void uploadFile(Session session,InputStream inputStream,String fileName,String remotePath) throws Exception {
ChannelSftp channelSftp = openChannelSftp(session);
channelSftp.cd(remotePath);
log.info("远程服务器路径：" + remotePath);
try {
channelSftp.put(inputStream, fileName,new FileSftpProgressMonitor(inputStream.available()));
}catch (Exception e){
throw e;
}finally {
inputStream.close();
closeChannelSftp(channelSftp);
}
}
/**
* 获取远程服务器文件列表
* @param session
* @param remotePath
* 远程服务器路径
* @return
* @throws SftpException
*/
public static Vector listFiles(Session session,String remotePath) throws Exception {
ChannelSftp channelSftp = openChannelSftp(session);
try {
Vector vector = channelSftp.ls(remotePath);
return vector;
}catch (Exception e){
throw e;
}finally {
closeChannelSftp(channelSftp);
}
}
/**
* 删除文件
* @param session
* @param remotePath
* @param fileName
* @throws Exception
*/
public static void removeFile(Session session,String remotePath,String fileName) throws Exception{
ChannelSftp channelSftp = openChannelSftp(session);
try {
channelSftp.cd(remotePath);
channelSftp.rm(fileName);
}catch (Exception e){
throw e;
}finally {
closeChannelSftp(channelSftp);
}
}
/**
* 删除文件夹
* @param session
* @param remotePath
* @throws Exception
*/
public static void removeDir(Session session,String remotePath) throws Exception{
ChannelSftp channelSftp = openChannelSftp(session);
try {
if (remotePath.lastIndexOf("/") == remotePath.length() - 1){
remotePath = remotePath.substring(0,remotePath.length() - 1);
}
String parentDir = remotePath.substring(0,remotePath.lastIndexOf("/") + 1);
String rmDir = remotePath.substring(remotePath.lastIndexOf("/") + 1,remotePath.length());
channelSftp.cd(parentDir);
channelSftp.rmdir(rmDir);
}catch (Exception e){
throw e;
}finally {
closeChannelSftp(channelSftp);
}
}
/**
* 新建一个 exec 通道
* @param session
* @return
* @throws JSchException
*/
public static ChannelExec openChannelExec(Session session) throws JSchException {
ChannelExec channelExec = (ChannelExec)session.openChannel("exec");
return channelExec;
}
/**
* 关闭 exec 通道
* @param channelExec
*/
public static void closeChannelExec(ChannelExec channelExec){
if (channelExec != null){
channelExec.disconnect();
}
}
/**
* 执行 脚本
* @param session
* @param cmd
* 执行 .sh 脚本
* @param charset
* 字符格式
* @return
* @throws IOException
* @throws JSchException
*/
public static String[] execCmd(Session session,String cmd,String charset) throws Exception{
//打开通道
ChannelExec channelExec = openChannelExec(session);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ByteArrayOutputStream error = new ByteArrayOutputStream();
channelExec.setCommand(cmd);
channelExec.setOutputStream(out);
channelExec.setErrStream(error);
channelExec.connect();
//确保能够执行完成及响应所有数据
Thread.sleep(10000);
String[] msg = new String[2];
msg[0] = new String(out.toByteArray(),charset);
msg[1] = new String(error.toByteArray(),charset);
out.close();
error.close();
//关闭通道
closeChannelExec(channelExec);
return msg;
}
/**
* 创建一个交互式的 shell 通道
* @param session
* @return
* @throws JSchException
*/
public static ChannelShell openChannelShell(Session session) throws JSchException{
ChannelShell channelShell = (ChannelShell)session.openChannel("shell");
return channelShell;
}
/**
* 关闭 shell 通道
* @param channelShell
*/
public static void closeChannelShell(ChannelShell channelShell){
if (channelShell != null){
channelShell.disconnect();
}
}
/**
* 执行命令
* @param cmds
* 命令参数
* @param session
* @param timeout
* 连接超时时间
* @param sleepTimeout
* 线程等待时间
* @return
* @throws Exception
*/
public static String execShellCmd(String[] cmds,Session session,int timeout,int sleepTimeout) throws Exception {
//打开通道
ChannelShell channelShell = openChannelShell(session);
//设置输入输出流
PipedOutputStream pipedOut = new PipedOutputStream();
ByteArrayOutputStream errorOut = new ByteArrayOutputStream();
channelShell.setInputStream(new PipedInputStream(pipedOut));
channelShell.setOutputStream(errorOut);
channelShell.connect(timeout);
for (String cmd : cmds){
pipedOut.write(cmd.getBytes("UTF-8"));
//线程休眠，保证执行命令后能够及时返回响应数据
Thread.sleep(sleepTimeout);
}
String msg = new String(errorOut.toByteArray(),"UTF-8");
log.info(msg);
pipedOut.close();
errorOut.close();
//关闭通道
closeChannelShell(channelShell);
return msg;
}
/**
* 创建定时器，清除timeout 的 session 连接
*/
public static void createSessionMonitor(){
if (sessionMonitor == null){
synchronized (SessionMonitor.class){
if (sessionMonitor == null){
//定时器，定时清除失效的session
sessionMonitor = new SessionMonitor();
sessionMonitor.start();
}
}
}
}
/**
* 监控文件传输
*/
static class FileSftpProgressMonitor extends TimerTask implements SftpProgressMonitor{
private long progressInterval = 5 * 1000; // 默认间隔时候为5秒
private boolean isEnd = false; // 记录传输是否停止
private long transfered; // 记录已传输的数据总大小
private long fileSize; // 记录文件总大小
private Timer timer; // 定时器对象
private boolean isScheduled = false; // 记录是否已启动timer定时器
private NumberFormat df = NumberFormat.getInstance(); //格式化
public FileSftpProgressMonitor(long fileSize){
this.fileSize = fileSize;
}
@Override
public void run() {
if (!isEnd()){
long transfered = getTransfered();
if (transfered != fileSize){
log.info("Current transfered: " + transfered + " bytes");
sendProgressMessage(transfered);
}else{
log.info("transfered end.");
setIsEnd(true);
}
}else {
log.info("Transfering done. Cancel timer.");
stop(); // 若是传输停止，停止timer记时器
}
}
/**
* 定时器关闭
*/
public void stop() {
log.info("Try to stop progress monitor.");
if (timer != null) {
timer.cancel();
timer.purge();
timer = null;
isScheduled = false;
}
log.info("Progress monitor stoped.");
}
/**
* 定时器启动
*/
public void start() {
log.info("Try to start progress monitor.");
if (timer == null) {
timer = new Timer();
}
timer.schedule(this, 1000, progressInterval);
isScheduled = true;
log.info("Progress monitor started.");
}
/**
* 传输进度
* @param transfered
*/
private void sendProgressMessage(long transfered) {
if (fileSize != 0) {
double d = ((double)transfered * 100)/(double)fileSize;
log.info("Sending progress message: " + df.format(d) + "%");
} else {
log.info("Sending progress message: " + transfered);
}
}
@Override
public void init(int i, String s, String s1, long l) {
log.info("transfering start.");
}
@Override
public boolean count(long l) {
if (isEnd()){
return false;
}
if (!getIsScheduled()){
start();
}
add(l);
return true;
}
@Override
public void end() {
setIsEnd(false);
log.info("transfering end.");
}
private synchronized void add(long count) {
transfered = transfered + count;
}
public synchronized boolean isEnd() {
return isEnd;
}
public synchronized void setIsEnd(boolean isEnd) {
this.isEnd = isEnd;
}
public synchronized long getTransfered() {
return transfered;
}
public synchronized void setTransfered(long transfered) {
this.transfered = transfered;
}
public synchronized boolean getIsScheduled() {
return isScheduled;
}
public synchronized void setIsScheduled(boolean isScheduled) {
this.isScheduled = isScheduled;
}
}
/**
* 定时器，定时清除失效的session
*/
static class SessionMonitor extends TimerTask{
private Timer timer; // 定时器对象
private long progressInterval = 30 * 1000; // 默认间隔时候为30秒
@Override
public void run() {
if (!cache.isEmpty()){
Iterator iterator = cache.keySet().iterator();
while (iterator.hasNext()){
String key = (String)iterator.next();
//清除失效session
if (testSessionIsDown(key)){
closeLongSessionByKey(key);
}
}
}
}
public void start(){
if (timer == null){
timer = new Timer();
}
timer.schedule(this,1000,progressInterval);
}
public void stop(){
if (timer != null) {
timer.cancel();
timer.purge();
timer = null;
}
}
}
}
