纯java代码使用ssh方式登录linux服务
纯java代码使用ssh方式登录linux服务。
实际应用中，可以使用这种方式上传部署web工程war包 并且部署启动tomcat 一个自动化完成所有工作 起到节省时间作用。
1.去下载最新的jar包
jsch-0.1.51.jar 下面是我的java code 例子 /**
* java ssh登录linux以后的一些操作方式
* @author liuxy
public class SchUnitJsch extends SchUnit{
private final static Log logger =LogFactory.getLog(SchUnitJsch.class);
public SchUnitJsch() {
public SchUnitJsch(String username, String password, String host) {
super(username, password, host);
* 开启session
* @throws JSchException
Session openSession() throws JSchException{
JSch jsch=new JSch();
Session session=
session=jsch.getSession(username, host);
Properties sshConfig = new Properties();
sshConfig.put(&StrictHostKeyChecking&, &no&);
session.setConfig(sshConfig);
session.setPassword(password);
session.connect(3000);
* 上传本地文件到远程linux上
* 使用sftp上传
public boolean uploadLocalFileToRemote(String localFile, String remoteDir) {
Session session=
session = openSession();
} catch (JSchException e) {
logger.error(e.getMessage());
if(session!=null) session.disconnect();
ChannelSftp channel=
channel=(ChannelSftp) session.openChannel(&sftp&);
channel.connect();
SftpProgressMonitorImpl sftpProgressMonitorImpl=new SftpProgressMonitorImpl();
channel.put(localFile, remoteDir,sftpProgressMonitorImpl);
return sftpProgressMonitorImpl.isSuccess();
}catch (JSchException e) {
if(channel!=null){
channel.disconnect();
session.disconnect();
} catch (SftpException e) {
logger.error(e.getMessage());
* 上传镜像映射检测
* @author liuxy
static class
SftpProgressMonitorImpl implements SftpProgressMonitor{
long currentSize=0;
boolean endFlag=
public void init(int op, String srcFile, String dstDir, long size) {
logger.debug(&文件开始上传：【&+srcFile+&】--&【&+dstDir+&】&+&，文件大小:&+size+&,参数&+op);
this.size=
public void end() {
logger.debug(&文件上传结束&);
public boolean count(long count){
currentSize+=
logger.debug(&上传数量:&+currentSize);
public boolean isSuccess(){
return endFlag&&currentSize==
* 执行指令
* @param commands
public StringBuffer executeCommands(String commands){
return executeCmd(commands).getOutRes();
* 执行shell指令并且返回结果对象ResInfo
* @param commands
public ResInfo executeCmd(String commands){
ResInfo resInfo=new ResInfo();
Session session=
session = openSession();
} catch (JSchException e) {
logger.debug(e.getMessage());
if(session!=null) session.disconnect();
ChannelExec channel=
StringBuffer result=new StringBuffer();
StringBuffer errResult=new StringBuffer();
channel=(ChannelExec) session.openChannel(&exec&);
channel.setCommand(commands);
channel.setInputStream(null);
((ChannelExec)channel).setErrStream(null);
InputStream in=channel.getInputStream();
InputStream err=channel.getErrStream();
channel.connect();
byte[] bytes=new byte[1024];
byte[] bytesErr=new byte[1024];
while(true){
while(in.available()&0){
int i=in.read(bytes, 0, 1024);
int i=err.read(bytesErr, 0, 1024);
if(i0||err.available()&0)
logger.debug(&exit-status: &+channel.getExitStatus());
resInfo.setExitStuts(channel.getExitStatus());
resInfo.setOutRes(result);
resInfo.setErrRes(errResult);
Thread.sleep(1000);
return resI
} catch (JSchException e) {
logger.error(e.getMessage());
} catch (Exception e) {
logger.error(e.getMessage());
channel.disconnect();
session.disconnect();
//exec command 结果返回对象
public static class ResInfo{
int exitS//返回状态码 （在linux中可以通过 echo $? 可知每步执行令执行的状态码）
StringBuffer outR//标准正确输出流内容
StringBuffer errR//标准错误输出流内容
public int getExitStuts() {
return exitS
public void setExitStuts(int exitStuts) {
this.exitStuts = exitS
public StringBuffer getOutRes() {
return outR
public void setOutRes(StringBuffer outRes) {
this.outRes = outR
public StringBuffer getErrRes() {
return errR
public void setErrRes(StringBuffer errRes) {
this.errRes = errR
public void clear(){
exitStuts=0;
outRes=errRes=
public static abstract class MyUserInfo
implements UserInfo, UIKeyboardInteractive{
public String getPassword(){ }
public boolean promptYesNo(String str){ }
public String getPassphrase(){ }
public boolean promptPassphrase(String message){ }
public boolean promptPassword(String message){ }
public void showMessage(String message){ }
public String[] promptKeyboardInteractive(String destination,
String name, String instruction, String[] prompt, boolean[] echo) {
* 删除远程linux下的文件
public boolean deleteRemoteFileorDir(String remoteFile) {
Session session=
session = openSession();
} catch (JSchException e) {
logger.info(e.getMessage());
if(session!=null) session.disconnect();
ChannelSftp channel=
channel=(ChannelSftp) session.openChannel(&sftp&);
channel.connect();
SftpATTRS sftpATTRS= channel.lstat(remoteFile);
if(sftpATTRS.isDir()){
logger.debug(&remote File:dir&);
channel.rmdir(remoteFile);
}else if(sftpATTRS.isReg()){
logger.debug(&remote File:file&);
channel.rm(remoteFile);
logger.debug(&remote File:unkown&);
}catch (JSchException e) {
if(channel!=null){
channel.disconnect();
session.disconnect();
} catch (SftpException e) {
logger.error(e.getMessage());
* 判断linux下 某文件是否存在
public boolean detectedFileExist(String remoteFile) {
Session session=
session = openSession();
} catch (JSchException e) {
logger.info(e.getMessage());
if(session!=null) session.disconnect();
ChannelSftp channel=
channel=(ChannelSftp) session.openChannel(&sftp&);
channel.connect();
SftpATTRS sftpATTRS= channel.lstat(remoteFile);
if(sftpATTRS.isDir()||sftpATTRS.isReg()){
//目录 和文件
logger.info(&remote File:dir&);
logger.info(&remote File:unkown&);
}catch (JSchException e) {
if(channel!=null){
channel.disconnect();
session.disconnect();
} catch (SftpException e) {
logger.error(e.getMessage());
将web工程的war部署到tomcat下的 /**
* 将war包部署到linux的tomcat下一些操作方法
* @author liuxy
public class DetectedTomcatService extends BaseService{
private final static Log logger=LogFactory.getLog(DetectedTomcatService.class);
//tomcat所在的linux下的根目录
public String baseTomcatH
public DetectedTomcatService(String username, String pwd, String host) {
super(username, pwd, host);
* 检测tomcat是否启动
boolean isStartingTomcat(String command){
if(command==null)command="ps -ef | grep Tomcat | grep -v grep";
StringBuffer res=sshUnit.executeCommands(command);
logger.debug(res);
return !StringUtils.isBlank(res);
* 关闭tomcat
shutdownTomcat(String commandShutdownTomcat){
String command="ps -ef | grep Tomcat | grep -v grep";
if(isStartingTomcat(command)){
if(StringUtils.isBlank(commandShutdownTomcat)){
StringBuffer res=sshUnit.executeCommands(command);
String[] fragments=res.toString().split("\\s+");
for(String fragment:fragments){
logger.debug(fragment);
if(fragment.indexOf("catalina.base")&-1||fragment.indexOf("catalina.base")&-1)
baseTomcatHome=fragment.split("=")[1];
logger.info("baseTomcatHome:"+baseTomcatHome);
if(baseTomcatHome!=null) commandShutdownTomcat="sh
"+baseTomcatHome+"/bin/shutdown.sh";
//关闭tomcat
sshUnit.executeCommands(commandShutdownTomcat);
//等待几秒钟
Thread.sleep(2000);
} catch (InterruptedException e) {
logger.equals(e.getMessage());
success=isStartingTomcat(command);
if(success){
StringBuffer res=sshUnit.executeCommands(command);
String[] fragments=res.toString().split("\\s+");
sshUnit.executeCommands("kill -9 "+fragments[1]);
* 开启tomcat
public void startupTomcat(String commandStartupTomcat){
String command="ps -ef | grep Tomcat | grep -v grep";
if(isStartingTomcat(command)){
shutdownTomcat(null);
//开启tomcat
if(StringUtils.isBlank(commandStartupTomcat))
commandStartupTomcat="sh "+baseTomcatHome+"/bin/startup.sh";
sshUnit.executeCommands(commandStartupTomcat);
* 删除war包
public boolean deleteWar(){
String regex=baseTomcatHome+"/webapps/ROOT*";
String deleteCommand="rm -rf "+
detectFileCommand="ls "+baseTomcatHome+"/webapps | grep ROOT";
String commands=deleteCommand+" ; "+detectFileC
StringBuffer res=sshUnit.executeCommands(commands);
return StringUtils.isBlank(res);
* 上传war包
* @param baseTomcatHome
public boolean uploadWar(String localFile){
String remoteDir=baseTomcatHome+"/webapps";
sshUnit.uploadLocalFileToRemote(localFile,remoteDir);
return sshUnit.uploadLocalFileToRemote(localFile,remoteDir);
public boolean warDealwith(){
String commands="cd "+baseTomcatHome+"/mv ROOT.war ROOT.unzip ROOT.zip -d ROOT;rm -rf ROOT.zip";
StringBuffer res=sshUnit.executeCommands(commands);
logger.info(res);
return !StringUtils.isBlank(res);
public void setBaseTomcatHome(String baseTomcatHome) {
this.baseTomcatHome = baseTomcatH
测试war包上传例子 /**
* 将演示主程序
* @author liuxy
public class TomcatPublish{
private static final Log logger =LogFactory.getLog(TomcatPublish.class);
private DetectedTomcatService tomcatS
private String baseTomcatHome="/opt/server/Tomcat";//设置默认tomcat根目录
private String localFileWarP//本地war包路径
TomcatPublish(String username,String pwd,String host){
tomcatService=new DetectedTomcatService(username, pwd, host);
tomcatService.setBaseTomcatHome(baseTomcatHome);
void publish(){
//关闭tomcat
boolean success=tomcatService.shutdownTomcat(null);
if(!success){
logger.debug("Tomcat shutdown failed");
//删除原有文件
success=tomcatService.deleteWar();
if(!success){
logger.debug("ROOT 残留war包已经文件没有删除干净");
//上传文件
if(tomcatService.uploadWar(localFileWarPath)){
logger.debug("=============================================解压缩====================");
if(tomcatService.warDealwith()){
logger.debug("........start Tomcat......");
tomcatService.startupTomcat(null);
Thread.sleep(3000);
} catch (InterruptedException e) {
System.exit(0);
logger.debug("上传失败war");
public DetectedTomcatService getTomcatService() {
return tomcatS
public void setTomcatService(DetectedTomcatService tomcatService) {
this.tomcatService = tomcatS
public String getBaseTomcatHome() {
return baseTomcatH
public void setBaseTomcatHome(String baseTomcatHome) {
this.baseTomcatHome = baseTomcatH
public String getLocalFileWarPath() {
return localFileWarP
public void setLocalFileWarPath(String localFileWarPath) {
this.localFileWarPath = localFileWarP
public static void main(String[] args) {
TomcatPublish tomcatPublish=new TomcatPublish("登录用户名(如root)","密码","主机域名（如:192.168.0.123）");
tomcatPublish.setLocalFileWarPath("E:\\WarFiles\\ROOT.war");
TomcatPublish tomcatPublish=new
tomcatPublish.publish();
java 通过SSH方式连接远程主机并上传和下载文件
使用java登录远程LINUX并对服务实现各种操作
linux 使用java编写ssh登陆主机 输入密码登陆并执行命令（jsch）
JAVA使用JSch进行SSH连接Linux并执行命令
java通过ssh操作linux服务器
java使用ssh连接Linux并执行命令
JAVA利用SSH2登录LINUX并执行命令
Java实现ssh连接linux并执行shell命令
java代码通过ssh免密操作远程服务器shell
没有更多推荐了，远程命令执行工具 mssh
mssh 是一个用来同时高效的执行多个远程主机命令的工具。mssh 使用 SSH 连接来执行命令。基于 开发，IO处理非常高效。
原文链接:http://www.oschina.net/p/mssh
阅读: 1449 |我在mac上终端使用ssh远程连接到linux服务器，命令是什么？_百度知道
我在mac上终端使用ssh远程连接到linux服务器，命令是什么？
比如服务器用户名为damin端口为8080，我应该怎么输入命令。还有mac上有没有类似win下的ssh工具啊。linux比较不熟，如果mac上想使用ssh需要下载吗？...
比如服务器用户名为damin 端口为8080，我应该怎么输入命令。还有mac上有没有类似win下的ssh工具啊。linux比较不熟，如果mac上想使用ssh需要下载吗？
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
哗然之后知道合伙人
采纳数：1670
获赞数：6969
ssh -p 8080 damin@服务器ip地址mac可以直接使用ssh
你对象叫宇哥吗知道合伙人
你对象叫宇哥吗
ppkingpping知道合伙人
来自电脑网络类芝麻团
ppkingpping
采纳数：368
获赞数：707
参与团队：
mac 就是unix,在终端输入：ssh 用户名@服务器地址 即可如：$ ssh user@192.168.1.100
lionheart1988知道合伙人
来自电脑网络类芝麻团
lionheart1988
采纳数：2000
获赞数：2908
擅长：暂未定制
参与团队：
$&ssh&damin@服务器ip&8080ssh工具的话可以用ShellCraft,不过是收费的
<span class="wgt-replyer-all-uname
" data-href="https://zhidao.baidu.com/usercenter?uid=ff2b05e知道合伙人
<span class="wgt-replyer-all-card-name3 wgt-replyer-all-card-names" data-href="https://zhidao.baidu.com/usercenter?uid=ff2b05e
擅长：暂未定制
ssh root @ip地址
3条折叠回答
为你推荐：
其他类似问题
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。Linux-ssh证书登录(实例详解) - John_ABC - 博客园
随笔 - 416, 文章 - 0, 评论 - 17, 引用 - 0
本文基于实际Linux管理工作，实例讲解工作中使用ssh证书登录的实际流程，讲解ssh证书登录的配置原理，基于配置原理，解决实际工作中，windows下使用SecureCRT证书登录的各种问题，以及实现hadoop集群部署要求的无密码跳转问题。
ssh有密码登录和证书登录，初学者都喜欢用密码登录，甚至是root账户登录，密码是123456。但是在实际工作中，尤其是互联网公司，基本都 是证书登录的。内网的机器有可能是通过密码登录的，但在外网的机器，如果是密码登录，很容易受到攻击，真正的生产环境中，ssh登录都是证书登录。
证书登录的步骤
1.客户端生成证书:私钥和公钥，然后私钥放在客户端，妥当保存，一般为了安全，访问有黑客拷贝客户端的私钥，客户端在生成私钥时，会设置一个密 码，以后每次登录ssh服务器时，客户端都要输入密码解开私钥(如果工作中，你使用了一个没有密码的私钥，有一天服务器被黑了，你是跳到黄河都洗不清)。
2.服务器添加信用公钥：把客户端生成的公钥，上传到ssh服务器，添加到指定的文件中，这样，就完成ssh证书登录的配置了。
假设客户端想通过私钥要登录其他ssh服务器，同理，可以把公钥上传到其他ssh服务器。
真实的工作中:员工生成好私钥和公钥(千万要记得设置私钥密码)，然后把公钥发给运维人员，运维人员会登记你的公钥，为你开通一台或者多台服务器的 权限，然后员工就可以通过一个私钥，登录他有权限的服务器做系统维护等工作，所以，员工是有责任保护他的私钥的，如果被别人恶意拷贝，你又没有设置私钥密 码，那么，服务器就全完了，员工也可以放长假了。
客户端建立私钥和公钥
在客户端终端运行命令
ssh-keygen -t rsa
rsa是一种密码算法，还有一种是dsa，证书登录常用的是rsa。
假设用户是blue,执行 ssh-keygen 时，才会在我的home目录底下的 .ssh/ 这个目录里面产生所需要的两把 Keys ，分别是私钥 (id_rsa) 与公钥 (id_rsa.pub)。
另外就是私钥的密码了，如果不是测试，不是要求无密码ssh，那么对于passphrase，不能输入空(直接回车),要妥当想一个有特殊字符的密码。
ssh服务端配置
ssh服务器配置如下:
vim /etc/ssh/sshd_config
#禁用root账户登录，非必要，但为了安全性，请配置
PermitRootLogin no
# 是否让 sshd 去检查用户家目录或相关档案的权限数据，
# 这是为了担心使用者将某些重要档案的权限设错，可能会导致一些问题所致。
# 例如使用者的 ~.ssh/ 权限设错时，某些特殊情况下会不许用户登入
StrictModes no
# 是否允许用户自行使用成对的密钥系统进行登入行为，仅针对 version 2。
# 至于自制的公钥数据就放置于用户家目录下的 .ssh/authorized_keys 内
RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile
%h/.ssh/authorized_keys
#有了证书登录了，就禁用密码登录吧，安全要紧
PasswordAuthentication no
配置好ssh服务器的配置了，那么我们就要把客户端的公钥上传到服务器端，然后把客户端的公钥添加到authorized_keys
在客户端执行命令
scp ~/.ssh/id_rsa.pub blue@&ssh_server_ip&:~
在服务端执行命令
id_rsa.pub && ～/.ssh/authorized_keys
如果有修改配置/etc/ssh/sshd_config，需要重启ssh服务器
/etc/init.d/ssh restart
客户端通过私钥登录ssh服务器
ssh -i /blue/.ssh/id_rsa blue@&ssh_server_ip&
scp -i /blue/.ssh/id_rsa filename blue@&ssh_server_ip&:/blue
每次敲命令，都要指定私钥，是一个很繁琐的事情，所以我们可以把私钥的路径加入ssh客户端的默认配置里
修改/etc/ssh/ssh_config
#其实默认id_rsa就已经加入私钥的路径了,这里只是示例而已
IdentityFile ~/.ssh/id_rsa
#如果有其他的私钥，还要再加入其他私钥的路径
IdentityFile ~/.ssh/blue_rsa
其他应用场景
SecureCRT密钥key远连接程ssh证书登录Linux
& 国内大部分人用的系统是windows，而windows下有很多ssh客户端图形工作，最流行，功能最强大的就是SecureCRT了，所以我会单独针对SecureCRT简单讲下实现ssh证书登录Linux的要点,步骤如下:
& 1:在SecureCRT创建私钥和公钥:主菜单-&工具-&创建公钥-&选择RSA-&填写私钥的密码-&密钥长度填为1024-&点击完成，生成两个文件,默认名为identity和identity.pub
& 2.把私钥和公钥转换为OpenSSH格式:主菜单-&工具-&转换私钥到OpenSSH格式-&选择刚生成私钥文件identity-&输入私钥的密码-&生成两个文件，指定为id_rsa,id_rsa.pub&
& 3.把公钥id_rsa.pub上传到ssh服务器，按照之前配置服务器端的证书，再配置一次。
& 另外，如果你之前用windows的&SecureCRT的证书登录linux的，有一天你换成了linux，并希望通过原来的私钥登录公司的服务器，那么可以把id_rsa拷贝倒~/.ssh/目录下，配置ssh客户端参考上文。
& 备注:ssh对证书的文件和目录权限比较敏感，要么根据出错提示设置好文件和目录权限，要么是把StrictModes选项设置为no
hadoop部署的无密码ssh登录
hadoop要求master要无密码跳转到每个slave,那么master就是上文中的ssh客户端了，步骤如下
& &在hadoop master上，生成公钥私钥，这个场景下，私钥不能设置密码。
& &把公钥上传到每个slave上指定的目录，这样就完成了ssh的无密码跳转了。
ssh证书登录，在实际工作才是最常用的登录方式，本人结合了真正工作的场景普及了ssh证书登录的知识，并根据流行的hadoop部署和windows下最常用的SecureCRT实例讲解了证书登录。
以上转自:http://www.cnblogs.com/ggjucheng/archive//2646346.html
以下为本人实际操作
测试环境客户端为Windows(Git Bash或cygwin),&服务端为Linux(虚拟机)
"公私钥"认证方式简单的解释:首先在客户端上创建一对公私钥 （公钥文件：~/.ssh/id_rsa.pub； 私钥文件：~/.ssh/id_rsa）然后把公钥放到服务器上（~/.ssh/authorized_keys）, 自己保留好私钥, 在使用ssh登录时, ssh程序会发送私钥去和服务器上的公钥做匹配, 如果匹配成功就可以登录了
1.在本地生成一对密钥(即公钥和私钥)
ssh-keygen -t rsa
执行完如下命令会在用户目录(本人的是C:/用户/John_ABC/)的.ssh目录下看到两个文件id_rsa(私钥,&放在这儿即可), id_rsa.pub(公钥,&放在要登录的服务器的使用的用户的家目录的.ssh目录下)
2.将公钥复制到要使用Public&Key登录的服务端(此处就先复制到用户suiyongjie的家目录下),&此时(如果是首次访问服务端)还会在客户端用户家目录的.ssh文件夹下生成known_hosts文件,&来保存各个认证过的主机信息(即再次连接的时候不再提示The authenticity of host 'xxx.xxx.xxx.xxx' can not be established)
scp ~/.ssh/id_rsa.pub suiyongjie@192.168.126.128:~/
3.此时会提示输入这个用户的登录密码
4.输入密码后,&拷贝成功
5.使用ssh登录到服务端,&此时在suiyongjie的家目录可以看到id_rsa.pub文件
6.如果在suiyongjie的家目录没有.ssh文件夹则新建
mkdir ~/.ssh
chmod 700 ~/.ssh
7.将刚才上传到服务端的id_rsa.pub文件中的内容添加到suiyongjie家目录/.ssh/authorized_keys中,&删除刚才上传到服务端的的id_rsa.pub
~/id_rsa.pub && ~/.ssh/authorized_keys
rm ~/id_rsa.pub
8.修改~/.ssh文件夹内文件的访问权限 权限的设置非常重要, 因为不安全的设置, 会让你不能使用RSA功能。
chmod 600 ~/.ssh/*
9.使用SSH私钥登录服务器
ssh -i ~/.ssh/id_rsa suiyongjie@192.168.126.128
如果以上步骤不能实现不输密码登陆的话,需要检查sshd服务的Pubkey认证功能是否默认打开修改/etc/ssh/sshd_config,&改以下条目PubkeyAuthentication yes