`

使用纯java ssh方式连接linux服务器,并用此方式部署war到linux的tomcat下

阅读更多
纯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() {
 super();
 }



 public SchUnitJsch(String username, String password, String host) {
 super(username, password, host);
 }
 /**
 * 开启session
 * @return
 * @throws JSchException
 */
 private  Session openSession() throws JSchException{
    JSch jsch=new JSch();
 Session session=null;    
 session=jsch.getSession(username, host);
     Properties sshConfig = new Properties();  
    sshConfig.put("StrictHostKeyChecking", "no");  
    session.setConfig(sshConfig); 
    session.setPassword(password);
    session.connect(3000);
 return session;
 }
 /**
 * 上传本地文件到远程linux上
 * 使用sftp上传
 */
 @Override
 public boolean uploadLocalFileToRemote(String localFile, String remoteDir) {
   Session session=null;
 try {
 session = openSession();
 } catch (JSchException e) {
 logger.error(e.getMessage());
 if(session!=null) session.disconnect();
 return false;
 }
 ChannelSftp channel=null;
 try {
 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();
 }
    return  false;
 } catch (SftpException e) {
 logger.error(e.getMessage());
 }
 return false;
 }
 /**
 * 上传镜像映射检测
 * @author liuxy
 *
 */
   static class  SftpProgressMonitorImpl implements SftpProgressMonitor{
 private  long size;
 private  long currentSize=0;
 private  boolean endFlag=false;
 @Override
 public void init(int op, String srcFile, String dstDir, long size) {
 logger.debug("文件开始上传:【"+srcFile+"】-->【"+dstDir+"】"+",文件大小:"+size+",参数"+op);
 this.size=size; 
 }
 
 @Override
 public void end() {
 logger.debug("文件上传结束");
 endFlag=true;
 }
 
 @Override
 public boolean count(long count){
 currentSize+=count;
 logger.debug("上传数量:"+currentSize); 
 return true;
 }
 public boolean isSuccess(){
 return endFlag&&currentSize==size;
 }
 }
 
 /**
 * 执行指令
 * @param commands
 */
 public StringBuffer executeCommands(String commands){
 return executeCmd(commands).getOutRes();
 }
 /**
 * 执行shell指令并且返回结果对象ResInfo
 * @param commands
 * @return
 */
 public ResInfo executeCmd(String commands){
     ResInfo resInfo=new ResInfo();
     Session session=null;
 try {
 session = openSession();
 } catch (JSchException e) {
 logger.debug(e.getMessage());
 if(session!=null) session.disconnect();
 return null;
 }
 ChannelExec channel=null;
 StringBuffer result=new StringBuffer();
 StringBuffer errResult=new StringBuffer();
 try {
     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);
       if(i0){
       int i=err.read(bytesErr, 0, 1024);
       if(i0||err.available()>0) continue;
       logger.debug("exit-status: "+channel.getExitStatus());
       resInfo.setExitStuts(channel.getExitStatus());
       resInfo.setOutRes(result);
       resInfo.setErrRes(errResult);
               break;
       }
       Thread.sleep(1000);
       }
     return resInfo;
 } catch (JSchException e) {
 logger.error(e.getMessage());
     return null;
 } catch (Exception e) {
 logger.error(e.getMessage());
 return null;
 }finally{
 channel.disconnect();
 session.disconnect();
 }
 } 
 
 //exec command 结果返回对象
     public static class ResInfo{
   int exitStuts;//返回状态码 (在linux中可以通过 echo $? 可知每步执行令执行的状态码)
    StringBuffer outRes;//标准正确输出流内容
    StringBuffer errRes;//标准错误输出流内容
    public int getExitStuts() {
     return exitStuts;
     }
 public void setExitStuts(int exitStuts) {
 this.exitStuts = exitStuts;
 }
 public StringBuffer getOutRes() {
 return outRes;
 }
 public void setOutRes(StringBuffer outRes) {
 this.outRes = outRes;
 }
 public StringBuffer getErrRes() {
 return errRes;
 }
 public void setErrRes(StringBuffer errRes) {
 this.errRes = errRes;
 }
   
 public void clear(){
 exitStuts=0;
 outRes=errRes=null;
 }
 }
 
 
 
 public static abstract class MyUserInfo
     implements UserInfo, UIKeyboardInteractive{
 @Override
 public String getPassword(){ return null; }
 @Override
 public boolean promptYesNo(String str){ return false; }
 @Override
 public String getPassphrase(){ return null; }
 @Override
 public boolean promptPassphrase(String message){ return false; }
 @Override
 public boolean promptPassword(String message){ return false; }
 @Override
 public void showMessage(String message){ }
 @Override
 public String[] promptKeyboardInteractive(String destination,
 String name, String instruction, String[] prompt, boolean[] echo) {
 return null;
 }
 } 
    /**
     * 删除远程linux下的文件
     */
 @Override
 public boolean deleteRemoteFileorDir(String remoteFile) {
   Session session=null;
 try {
 session = openSession();
 } catch (JSchException e) {
 logger.info(e.getMessage());
 if(session!=null) session.disconnect();
 return false;
 }
 ChannelSftp channel=null;
 try {
 channel=(ChannelSftp) session.openChannel("sftp");
 channel.connect();
 SftpATTRS sftpATTRS= channel.lstat(remoteFile);
 if(sftpATTRS.isDir()){
 //目录
 logger.debug("remote File:dir");
 channel.rmdir(remoteFile);
 return true;
 }else if(sftpATTRS.isReg()){
 //文件
 logger.debug("remote File:file");
 channel.rm(remoteFile);
 return true;
 }else{
 logger.debug("remote File:unkown");
 return false;
 }
 }catch (JSchException e) {
 if(channel!=null){
 channel.disconnect();
             session.disconnect();
 }
    return  false;
 } catch (SftpException e) {
 logger.error(e.getMessage());
 }
 return false;
 }
    /**
     * 判断linux下 某文件是否存在
     */
 @Override
 public boolean detectedFileExist(String remoteFile) {
   Session session=null;
 try {
 session = openSession();
 } catch (JSchException e) {
 logger.info(e.getMessage());
 if(session!=null) session.disconnect();
 return false;
 }
 ChannelSftp channel=null;
 try {
 channel=(ChannelSftp) session.openChannel("sftp");
 channel.connect();
 SftpATTRS sftpATTRS= channel.lstat(remoteFile);
 if(sftpATTRS.isDir()||sftpATTRS.isReg()){
 //目录 和文件
 logger.info("remote File:dir");
 return true;
 }else{
 logger.info("remote File:unkown");
 return false;
 }
 }catch (JSchException e) {
 if(channel!=null){
 channel.disconnect();
             session.disconnect();
 }
    return  false;
 } catch (SftpException e) {
 logger.error(e.getMessage());
 }
 return false;
 }


}



将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 baseTomcatHome;
	public DetectedTomcatService(String username, String pwd, String host) {
		super(username, pwd, host);
	}
	/**
	 * 检测tomcat是否启动
	 */
	public  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
	 */
	public  boolean  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];
		        		break;
		        	}
		        	continue;
		        }
		         logger.info("baseTomcatHome:"+baseTomcatHome);
		         if(baseTomcatHome!=null) commandShutdownTomcat="sh  "+baseTomcatHome+"/bin/shutdown.sh";
			}
            //关闭tomcat
      		sshUnit.executeCommands(commandShutdownTomcat);
				//等待几秒钟
			   try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				 logger.equals(e.getMessage());
			}
			   boolean  success=isStartingTomcat(command);
			    if(success){
			     	StringBuffer res=sshUnit.executeCommands(command);
			        String[] fragments=res.toString().split("\\s+");
			    	sshUnit.executeCommands("kill -9 "+fragments[1]);
			    }
	    	return true;
	    }
		return true;
	}
	/**
	 * 开启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包
	 * @return
	 */
	public boolean deleteWar(){
		String regex=baseTomcatHome+"/webapps/ROOT*";
		String deleteCommand="rm -rf "+ regex;
		String  detectFileCommand="ls "+baseTomcatHome+"/webapps | grep ROOT";
		String commands=deleteCommand+" ; "+detectFileCommand;
		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+"/webapps;mv ROOT.war ROOT.zip;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 = baseTomcatHome;
	}
	

}


测试war包上传例子
/**
 * 将演示主程序
 * @author liuxy
 *
 */
public class TomcatPublish{
	private static final Log logger =LogFactory.getLog(TomcatPublish.class);
    private DetectedTomcatService tomcatService;
    private String baseTomcatHome="/opt/server/Tomcat";//设置默认tomcat根目录
    private String localFileWarPath;//本地war包路径
    public  TomcatPublish(String username,String pwd,String host){
    	tomcatService=new DetectedTomcatService(username, pwd, host);
    	tomcatService.setBaseTomcatHome(baseTomcatHome);
    }
    public  void publish(){
    	//关闭tomcat 
    	boolean success=tomcatService.shutdownTomcat(null);
    	
    	if(!success){
    		logger.debug("Tomcat shutdown failed"); return ;
    	}
    	//删除原有文件
        success=tomcatService.deleteWar();
        if(!success){
        	logger.debug("ROOT 残留war包已经文件没有删除干净");
        	return  ;
        }
    		//上传文件
 	    if(tomcatService.uploadWar(localFileWarPath)){
 	    	//解压
 	        logger.debug("=============================================解压缩====================");
 	        if(tomcatService.warDealwith()){
 	       	logger.debug("........start Tomcat......");
 	    	tomcatService.startupTomcat(null);
 	    	try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
				   
			}
 	    	System.exit(0);
 	        }
 	    
 	    }
 	    else
 	    	logger.debug("上传失败war");
   
    }
	public DetectedTomcatService getTomcatService() {
		return tomcatService;
	}
	public void setTomcatService(DetectedTomcatService tomcatService) {
		this.tomcatService = tomcatService;
	}
	public String getBaseTomcatHome() {
		return baseTomcatHome;
	}
	public void setBaseTomcatHome(String baseTomcatHome) {
		this.baseTomcatHome = baseTomcatHome;
	}
	public String getLocalFileWarPath() {
		return localFileWarPath;
	}
	public void setLocalFileWarPath(String localFileWarPath) {
		this.localFileWarPath = localFileWarPath;
	}
    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();	
	}
}



分享到:
评论
1 楼 yukang1 2018-05-09  
大哥 好想要源码.  你的代码不全啊  我的亲哥啊

相关推荐

    SSH远程连接linux服务器工具

    标题中的"SSH远程连接linux服务器工具"指的是使用SSH协议来远程访问Linux服务器的软件工具。SSH协议提供了身份验证和加密功能,确保了用户与服务器之间的通信不会被窃听或篡改。这对于管理和维护远程服务器尤其重要...

    java实现ssh方式连接linux(包含ganymed-ssh2-build210.jar包)

    java实现ssh方式连接linux(包含ganymed-ssh2-build210.jar包) ---------Java语言+绚丽的界面+仿ssh实现调用Linux的Terminal,实现远程连接linux进行命令行的操作!

    连接Linux服务器工具SSH

    连接Linux服务器工具SSH 3.2.9 方便快捷!

    java上传文件到linux服务器,操作linux服务器上文件,下载linux服务器文件,删除linux服务器文件

    总之,Java结合ganymed-ssh2库,为开发者提供了强大的工具,使他们能够在安全的环境下与Linux服务器进行交互,实现文件的上传、下载、操作和删除,极大地提升了远程管理服务器的效率。在开发过程中,理解这些基本...

    Mac下使用SSH连接远程Linux服务器

    本文主要介绍三种方法,在Mac下使用SSH连接远程Linux服务器。 方法一:使用终端 1.打开终端,点击新建远程连接 2.点击加号,然后添加自己服务器的IP地址 3.点击右侧的服务器,然后在下方输入用户名,选择最下方的 ...

    Java运用ganymed-ssh2-build210.jar包远程连接操作linux服务器

    Java 远程连接 Linux 服务器使用 Ganymed-SSH2 库 标题解释 本文档的标题是"Java 运用 Ganymed-SSH2 库远程连接操作 Linux 服务器",这意味着我们将使用 Java 语言来远程连接 Linux 服务器,并使用 Ganymed-SSH2...

    Java(通过ganymed-ssh2-build210.jar)实现SSH远程连接linux终端

    Java通过ganymed-ssh2-build210.jar库实现SSH远程连接Linux终端是一个常见的应用场景,主要用于自动化运维、系统管理或者开发过程中需要与Linux服务器交互的场景。ganymed-ssh2-build210.jar是Java的一个开源SSH库,...

    tomcat部署war项目操作文档

    Tomcat是一个广泛使用的开源Java Servlet容器,它允许开发者部署Web应用程序,包括WAR(Web Application Archive)格式的文件。以下是一份详细的步骤指南,涵盖了从打包WAR文件到在Linux服务器上部署和管理的全过程...

    ssh 远程连接Linux工具

    ssh工具 用于连接远程服务器 linux 系统 解压 安装即可使用

    ssh Tomcat自动部署无需手动重启服务器设置

    首先,在server.xml文件中添加Context元素,然后使用ssh连接到Tomcat服务器,并重启Tomcat服务。 四、JVM内存分配机制 JVM将内存分为不同的区,包括Heap space、PermGen space等。Heap space用于存放对象,GC会...

    SSH协议连接远程服务器的java实现

    ### SSH协议连接远程服务器的Java实现 #### 一、引言 在计算机网络领域中,SSH(Secure Shell)协议是一种广泛使用的网络安全协议,用于在不安全的网络上提供安全的远程登录服务。本文将深入探讨如何使用Java语言来...

    Windows远程SSH连接Linux服务器(xmanager说明书)

    3. 远程连接后,可以在 Windows 平台下使用 Linux 命令行方式来操作 RHEL 服务器。 四、Xftp 的 SFTP 连接 Xftp 是 Xmanager 的一个组件,提供了文件传输协议(SFTP)的连接方式。使用 Xftp,可以在 Windows 平台...

    linux java web SSH 工具 远程

    例如,开发者可以使用SSH连接到服务器进行代码部署、调试或故障排查,而运维人员可以通过SSH进行系统维护和监控。此外,工具如PuTTY(Windows平台)和iTerm2(MacOS平台)提供了友好的SSH客户端界面,简化了远程操作...

    Xshell通过SSH密钥、SSH代理连接Linux服务器详解

    在IT行业中,安全高效地远程访问Linux服务器是日常工作的重要部分,Xshell作为一款强大的终端模拟器,提供了多种连接方式,包括使用SSH(Secure Shell)协议。本文将详细讲解如何通过SSH密钥对和SSH代理来连接Linux...

    asp.net实现SSH连接远程Linux服务器

    在这个场景下,"asp.net实现SSH连接远程Linux服务器"涉及的主要知识点包括ASP.NET编程、SSH协议、远程命令执行以及可能的跨平台交互。 首先,我们需要理解ASP.NET如何与SSH结合。ASP.NET程序通常运行在Windows...

    SSH登陆LINUX服务器命令.doc

    通过 SSH 连接到 Linux 服务器,可以像控制自己的机器一样控制远程服务器。下面是 SSH 登陆 LINUX 服务器命令的详细知识点: 一、基本命令 * ssh [hostname] -u user:连接到远程 Linux 服务器,输入用户名和密码...

    java linux ssh登陆

    标题“Java Linux SSH登录”指的是使用Java编程语言与Linux操作系统进行安全外壳(SSH)通信的过程。在描述中提到,这个过程通常涉及建立一个通道并执行单个命令。这里,我们将会详细探讨Java如何通过SSH连接到Linux...

    C#版SSH、SCP,可作为客户端连结LINUX源码

    标题中的"C#版SSH、SCP,可作为客户端连结LINUX源码"表明这是一个使用C#编程语言实现的SSH(Secure Shell)和SCP(Secure Copy)客户端库,用于连接Linux服务器。SSH是一种网络协议,用于安全地远程登录到服务器,...

    详解Java使用Jsch与sftp服务器实现ssh免密登录

    1. 在服务器端生成一对公私钥,并将公钥复制到目标服务器的指定用户.ssh目录下。 2. 进入到.ssh目录,将公钥导入到授权列表(authorized_keys)中,以完成对远程服务器的公钥认证。 3. 配置文件权限,一般设置为600...

    java连接linux,执行shell命令的工具类 sshxcute.jar

    在Java开发中,有时我们需要远程连接到Linux服务器执行shell命令,比如进行系统管理、自动化运维或者数据处理等任务。在这种情况下,使用SSH(Secure Shell)协议是常见的解决方案,因为它提供了安全的网络通信。...

Global site tag (gtag.js) - Google Analytics