行war包,命令行启动war包

如果你用过hudson,肯定对它的启动方式印象深刻,它既可以用 java -jar *.war来启动,也可以放到web容器中启动。

这次在项目中也用到了这种方式,在这里总结一下,

内置了jetty作为启动容器,

启动类:

Java代码 

 收藏代码

  1. import java.io.File;  
  2. import java.net.URL;  
  3. import java.security.ProtectionDomain;  
  4.   
  5. import org.eclipse.jetty.server.Server;  
  6. import org.eclipse.jetty.webapp.WebAppContext;  
  7.   
  8. public class CompareLuncher {  
  9.     public static void main(String[] args) throws Exception {  
  10.         String currentPath=new File("").getAbsolutePath();  
  11.         //如果没有work目录,则创建,jetty默认解压路径  
  12.         File work=new File(currentPath+"\\work");  
  13.         if(!work.exists()){  
  14.             work.mkdir();  
  15.         }  
  16.         Server server =null;  
  17.         Integer port=8090;  
  18.         server=new Server(port);  
  19.         ProtectionDomain domain = CompareLuncher.class.getProtectionDomain();  
  20.         URL location = domain.getCodeSource().getLocation();  
  21.         WebAppContext webapp = new WebAppContext();  
  22.         webapp.setContextPath("/");  
  23.         webapp.setWar(location.toExternalForm());  
  24.         server.setHandler(webapp);  
  25.         server.start();  
  26.         server.join();  
  27.           
  28.         //启动部署包的时候可以用这个  
  29.         // // Server server = new Server(8080);  
  30.         // // WebAppContext context = new WebAppContext();  
  31.         // // context.setContextPath("/compare");  
  32.         // // context.setWar("F:/compare.war");  
  33.         // // server.setHandler(context);  
  34.         // // server.start();  
  35.         // // server.join();  
  36.   
  37.         //eclipse 测试的时候启用如下代码,debug模式下可以直接看到修改效果  
  38. //       Server server = new Server(8090);  
  39.            
  40. //       ResourceHandler resourceHandler = new ResourceHandler();    
  41. //       resourceHandler.setDirectoriesListed(true);    
  42. //            
  43. //       server.setSendServerVersion(true);  
  44. //       server.setStopAtShutdown(true);  
  45. //       server.setHandler(getWebAppContext());  
  46. //       server.start();  
  47. //       server.join();  
  48.   
  49.     }  
  50.   
  51.     private static WebAppContext getWebAppContext() {  
  52.   
  53.         String path = CompareLuncher.class.getResource("/").getFile()  
  54.                 .replaceAll("/target/(.*)", "")  
  55.                 + "/src/main/webapp";  
  56. //      System.out.println(path);  
  57.         String path2 = new File("").getAbsolutePath() + "\\src\\main\\webapp";  
  58.         // System.out.println();  
  59.   
  60.         return new WebAppContext(path2, "/");  
  61.     }  
  62. }  

 

pom:

Xml代码 

 收藏代码

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.     <groupId>ssss</groupId>  
  5.     <artifactId>pdfcompare</artifactId>  
  6.     <packaging>war</packaging>  
  7.     <version>0.0.1-SNAPSHOT</version>  
  8.     <name>pdfcompare Maven Webapp</name>  
  9.     <url>http://maven.apache.org</url>  
  10.     <dependencies>  
  11.         <dependency>  
  12.             <groupId>junit</groupId>  
  13.             <artifactId>junit</artifactId>  
  14.             <version>4.8.1</version>  
  15.             <scope>test</scope>  
  16.         </dependency>  
  17.         <dependency>  
  18.             <groupId>org.apache.pdfbox</groupId>  
  19.             <artifactId>pdfbox</artifactId>  
  20.             <version>1.8.2</version>  
  21.         </dependency>  
  22.         <!-- <dependency> <groupId>org.apache.axis2</groupId> <artifactId>axis2-kernel</artifactId>   
  23.             <version>1.6.2</version> </dependency> -->  
  24.   
  25.         <dependency>  
  26.             <groupId>commons-fileupload</groupId>  
  27.             <artifactId>commons-fileupload</artifactId>  
  28.             <version>1.3</version>  
  29.         </dependency>  
  30.         <!-- Jetty -->  
  31.   
  32.         <dependency>  
  33.             <groupId>org.eclipse.jetty</groupId>  
  34.             <artifactId>jetty-server</artifactId>  
  35.             <version>${jettyVersion}</version>  
  36.             <scope>provided</scope>  
  37.         </dependency>  
  38.         <dependency>  
  39.             <groupId>org.eclipse.jetty</groupId>  
  40.             <artifactId>jetty-webapp</artifactId>  
  41.             <version>${jettyVersion}</version>  
  42.             <scope>provided</scope>  
  43.         </dependency>  
  44.         <!-- the dependency can be commented if no jsp -->  
  45.         <dependency>  
  46.             <groupId>org.eclipse.jetty.orbit</groupId>  
  47.             <artifactId>org.apache.jasper.glassfish</artifactId>  
  48.             <version>2.2.2.v201112011158</version>  
  49.             <scope>provided</scope>  
  50.         </dependency>  
  51.   
  52.         <dependency>  
  53.             <groupId>org.eclipse.jetty.orbit</groupId>  
  54.             <artifactId>javax.el</artifactId>  
  55.             <version>2.2.0.v201108011116</version>  
  56.             <scope>provided</scope>  
  57.         </dependency>  
  58.     </dependencies>  
  59.     <build>  
  60.         <plugins>  
  61.             <plugin>  
  62.                 <groupId>org.apache.maven.plugins</groupId>  
  63.                 <artifactId>maven-war-plugin</artifactId>  
  64.                 <version>2.3</version>  
  65.                 <configuration>  
  66.                     <archive>  
  67.                         <manifest>  
  68.                             <mainClass><span style="color: #ff0000;">CompareLuncher</span></mainClass>  
  69.                         </manifest>  
  70.                     </archive>  
  71.                 </configuration>  
  72.             </plugin>  
  73.             <plugin>  
  74.                 <groupId>org.apache.maven.plugins</groupId>  
  75.                 <artifactId>maven-antrun-plugin</artifactId>  
  76.                 <version>1.7</version>  
  77.                 <executions>  
  78.                     <execution>  
  79.                         <id>main-class-placement</id>  
  80.                         <phase>prepare-package</phase>  
  81.                         <configuration>  
  82.                             <target>  
  83.                                 <move todir="${project.build.directory}/${project.artifactId}/">  
  84.                                     <fileset dir="${project.build.directory}/classes/">  
  85.                                         <include name="CompareLuncher.class" />  
  86.                                     </fileset>  
  87.                                 </move>  
  88.                             </target>  
  89.                         </configuration>  
  90.                         <goals>  
  91.                             <goal>run</goal>  
  92.                         </goals>  
  93.                     </execution>  
  94.                 </executions>  
  95.             </plugin>  
  96.             <plugin>  
  97.                 <groupId>org.apache.maven.plugins</groupId>  
  98.                 <artifactId>maven-dependency-plugin</artifactId>  
  99.                 <version>2.5.1</version>  
  100.                 <executions>  
  101.                     <execution>  
  102.                         <id>jetty-classpath</id>  
  103.                         <phase>prepare-package</phase>  
  104.                         <goals>  
  105.                             <goal>unpack-dependencies</goal>  
  106.                         </goals>  
  107.                         <configuration>  
  108.                             <includeGroupIds>org.eclipse.jetty, org.eclipse.jetty.orbit</includeGroupIds>  
  109.                             <includeScope>provided</includeScope>  
  110.                             <!-- remove some files in order to decrease size -->  
  111.                             <excludes>*, about_files/*, META-INF/*</excludes>  
  112.                             <outputDirectory>  
  113.                                 ${project.build.directory}/${project.artifactId}  
  114.                             </outputDirectory>  
  115.                         </configuration>  
  116.                     </execution>  
  117.                 </executions>  
  118.             </plugin>  
  119.         </plugins>  
  120.         <finalName>pdfcompare</finalName>  
  121.     </build>  
  122.     <properties>  
  123.         <!-- <jettyVersion>7.3.0.v20110203</jettyVersion> -->  
  124.         <jettyVersion>8.1.7.v20120910</jettyVersion>  
  125.     </properties>  
  126. </project>  

 最后 在 workspace/项目名的根文件夹下执行:mvn clean install,再到target文件夹下找到 项目名称.war

用 java -jar  名字.war 即可启动

转载于:https://my.oschina.net/u/4000302/blog/3051128

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 在Linux系统上启动WAR,一般需要以下步骤: 1. 确保已经安装了Java环境(JRE或JDK),可以通过在命令行输入"java -version"命令来检查。 2. 在命令行中使用"cd"命令进入WAR所在的目录。 3. 使用"java -jar"命令启动WAR,例如:"java -jar yourwarfile.war"。如果需要指定端口号,可以在命令后面添加"--server.port=8080"之类的参数。 4. 启动后,可以在浏览器中输入"http://localhost:8080"(或者指定的端口号)来访问应用程序。要在Linux上启动war,需要遵循以下步骤: 1. 确保你已经安装了Java环境(JRE)或者Java开发工具(JDK)。 2. 将war放到合适的目录下,比如/opt/tomcat/webapps/目录下(如果你使用的是Tomcat服务器)。 3. 打开终端窗口,并进入到war所在的目录。 4. 输入以下命令启动war: ``` java -jar yourapp.war ``` 其中,"yourapp.war"代表你的war文件名。如果你使用的是Tomcat服务器,可以使用以下命令代替: ``` /opt/tomcat/bin/startup.sh ``` 这将启动Tomcat服务器,并自动部署war。 5. 等待一段时间,直到应用程序完全启动。你可以在浏览器中输入http://localhost:8080/yourapp来访问应用程序。其中,“yourapp”是你的应用程序名称。要在Linux系统上启动WAR文件,您需要遵循以下步骤: 1. 确保您已经安装了Java Runtime Environment (JRE)。 2. 打开终端并导航到WAR文件的目录。 3. 使用以下命令启动WAR文件: `java -jar your_war_file_name.war` 请将“your_war_file_name.war”替换为您的WAR文件名。 4. 等待应用程序启动,直到看到类似于“Tomcat started on port(s): 8080 (http) with context path”之类的消息。 5. 现在,您可以通过浏览器访问应用程序,方法是在地址栏中输入服务器的IP地址或域名,后跟端口号和上下文路径。例如: `http://your_server_ip_address:8080/your_application_context_path/` 请将“your_server_ip_address”替换为服务器的IP地址,将“8080”替换为应用程序使用的端口号,将“your_application_context_path”替换为应用程序的上下文路径。要在Linux上启动一个WAR文件,您需要先确保已经安装了Java环境(JRE或JDK)。如果没有安装,您可以通过以下命令安装OpenJDK 8: ``` sudo apt-get update sudo apt-get install openjdk-8-jdk ``` 安装完成后,您可以使用以下命令启动WAR文件: ``` java -jar your-war-file.war ``` 其中,"your-war-file.war"是您要启动WAR文件的名称。确保在运命令之前,您已经进入了WAR文件的目录。 如果您需要将WAR文件作为服务来运,您可以考虑使用系统服务管理器(例如systemd)来创建一个服务单元。这样,您可以随时启动和停止服务,并使其在系统启动时自动启动。在Linux上启动一个WAR,可以使用以下命令: ``` java -jar yourwarfile.war ``` 其中,`yourwarfile.war`是你想要启动WAR文件名。使用该命令时,需要确保已经安装了Java环境。要在Linux上启动一个WAR,您需要安装一个Java Web服务器,例如Tomcat或Jetty。 安装完成后,您可以使用以下命令启动WAR: ``` sudo systemctl start tomcat ``` 其中“tomcat”是您安装的Web服务器的名称。如果您使用的是Jetty,命令将类似于: ``` sudo systemctl start jetty ``` 一旦您的Web服务器正在运,您可以在浏览器中输入服务器的IP地址和端口号来访问您的应用程序。例如,如果您的服务器IP地址为192.168.1.100,您的应用程序使用8080端口,则可以在浏览器中输入以下地址: ``` http://192.168.1.100:8080/ ``` 这将打开您的应用程序主页。在Linux上启动WAR通常需要安装Java环境,然后使用Java命令来启动。具体步骤如下: 1. 确保已经安装了Java环境。可以在终端输入"java -version"命令来检查是否已经安装。 2. 将WAR上传到Linux服务器上。 3. 在终端中使用以下命令来启动WARjava -jar your-war-file-name.war 其中,"your-war-file-name.war"是你上传的WAR文件名。在执该命令之前,请确保你的终端工作目录位于WAR文件的目录中。 4. 程序启动后,你可以在浏览器中输入"http://your-server-address:port/your-application-context-path"来访问应用程序。 其中,"your-server-address"是你的Linux服务器的IP地址或域名,"port"是应用程序使用的端口号,"your-application-context-path"是应用程序的上下文路径。在Linux系统上启动war可以通过以下命令: 1. 首先确保已经安装了Java环境变量。 2. 在命令行终端中使用以下命令启动war: ``` java -jar /path/to/war/file.war ``` 其中,`/path/to/war/file.war` 是war文件的绝对路径。 3. 如果war需要指定端口号,可以使用以下命令: ``` java -Dserver.port=8080 -jar /path/to/war/file.war ``` 其中,`8080` 是指定的端口号,可以根据需要进修改。 4. 如果需要在后台运war,可以使用以下命令: ``` nohup java -jar /path/to/war/file.war > /dev/null 2>&1 & ``` 这个命令会将进程放到后台运,并将所有输出重定向到`/dev/null`,从而避免输出到终端。 在Linux上启动war的命令是:java -jar <war路径>。在Linux上启动WAR需要使用Java虚拟机,具体的命令如下: ``` java -jar your-war-file-name.war ``` 其中,`your-war-file-name.war`应替换为你要启动WAR文件名。在执该命令前,请确保已经安装了Java环境,并且当前目录下含了要启动WAR文件启动war需要在安装了Tomcat服务器的Linux系统中进,具体命令如下: 1. 进入Tomcat的bin目录:cd /usr/local/tomcat/bin/ 2. 启动Tomcat服务器:./startup.sh 3. 将war复制到Tomcat的webapps目录下:cp /path/to/your/war /usr/local/tomcat/webapps/ 4. 等待Tomcat自动解压war并部署应用程序。 5. 在浏览器中访问应用程序:http://yourdomain.com:8080/yourapp/ (其中yourdomain和yourapp应替换为实际的域名和应用程序名称)在Linux上启动war,需要安装Java环境(JRE)或Java开发工具(JDK)。 假设您已经安装了Java并设置了环境变量,可以使用以下命令启动war: ``` java -jar your_war_file.war ``` 其中,`your_war_file.war`是您要启动war文件名。 执此命令后,Java启动嵌入式Web服务器,并将war部署到服务器上。您可以在Web浏览器中访问服务器的IP地址和端口号来查看应用程序。要在Linux系统上启动一个WAR,您需要安装Java并使用Java应用服务器,如Tomcat、Jetty或GlassFish等。这些服务器会自动处理WAR的部署和启动。 以下是在Tomcat服务器上启动WAR的基本步骤: 1. 将WAR复制到Tomcat服务器的webapps目录中。 2. 使用终端进入Tomcat服务器的bin目录。 3. 运startup.sh脚本以启动Tomcat服务器。 4. 在Web浏览器中输入http://localhost:8080/,您将看到Tomcat的默认欢迎页面。 5. 如果WAR已正确部署,您可以通过输入http://localhost:8080/<your-war-file-name> 来访问您的应用程序。 请注意,WAR的具体部署和启动步骤可能因您所使用的应用服务器而异。启动war的命令取决于你使用的应用服务器。下面是几个常用的应用服务器的启动命令: 1. Tomcat:假设你已经将war放置在Tomcat的webapps目录下,使用以下命令启动Tomcat服务器: ``` $CATALINA_HOME/bin/startup.sh ``` 2. JBoss:假设你已经将war放置在JBoss的deploy目录下,使用以下命令启动JBoss服务器: ``` $JBOSS_HOME/bin/run.sh ``` 3. WebLogic:假设你已经将war放置在WebLogic的自动部署目录下,使用以下命令启动WebLogic服务器: ``` $DOMAIN_HOME/startWebLogic.sh ``` 请注意,以上命令中的路径和变量名称需要根据你的实际情况进修改。要在Linux上启动一个WAR文件,你需要安装Java并使用Java命令来启动它。 以下是启动WAR的命令: ``` java -jar your_war_file_name.war ``` 确保在执此命令之前,你已经将WAR文件放置在合适的目录下,并且已经安装了Java时环境。启动一个WAR,需要用到Java Web应用服务器,比如Tomcat、Jetty等。以下是在Linux环境下启动一个WAR的步骤: 1. 首先确保已经安装了Java和对应的Web应用服务器。如果没有安装,可以通过管理器安装或者从官网下载并手动安装。 2. 将WAR上传到Web应用服务器的webapps目录下。可以使用命令行或者FTP等方式上传。 3. 在终端中切换到Web应用服务器的bin目录下,比如对于Tomcat,可以执以下命令:cd /usr/local/tomcat/bin 4. 启动Web应用服务器,比如对于Tomcat,可以执以下命令:./startup.sh 5. 等待一段时间后,可以在浏览器中访问应用程序,比如http://localhost:8080/应用程序名称。 如果想停止Web应用服务器,可以执以下命令:./shutdown.sh。在Linux系统中,启动一个war通常需要使用Java应用服务器,例如Tomcat或Jetty。 以下是启动war的基本步骤: 1. 安装Java应用服务器。可以使用管理器(例如yum或apt-get)安装Tomcat或Jetty。 2. 将war复制到应用服务器的webapps目录下。 3. 启动应用服务器。可以使用启动脚本(例如/bin/startup.sh)启动Tomcat或Jetty。 4. 在浏览器中输入服务器地址和端口号,访问应用程序。 具体命令可能会因不同的应用服务器而异,可以参考应用服务器的文档进操作。如果您要在Linux上启动一个war,可以使用Java命令来执。具体命令如下: ``` java -jar your_war_file.war ``` 在命令中,将“your_war_file.war”替换为您要启动war文件名。您需要确保已经安装了Java环境。要在Linux上启动一个WAR,您可以使用以下命令: ``` java -jar yourAppName.war ``` 请确保您已经安装了Java环境,并将"yourAppName.war"替换为您的应用程序名称。您需要在WAR文件的目录中运此命令。在Linux上启动WAR,您需要安装Java环境,并使用Java命令来启动WAR。以下是启动WAR的命令: ``` java -jar yourWarFile.war ``` 其中,`yourWarFile.war`应替换为您要启动WAR文件名。在运此命令之前,请确保您的当前目录中WAR文件,并且您已经安装了Java环境。启动Linux上的WAR需要使用Java应用程序服务器,如Tomcat或Jetty等。下面是使用Tomcat启动WAR的命令: 1. 解压WAR到Tomcat的webapps目录下: ``` sudo unzip yourapp.war -d /path/to/tomcat/webapps/yourapp/ ``` 2. 启动Tomcat服务器: ``` sudo /path/to/tomcat/bin/startup.sh ``` 3. 在Web浏览器中访问应用程序: ``` http://localhost:8080/yourapp/ ``` 其中,`yourapp`是你的应用程序的名称。在Linux上启动一个war,你需要先安装一个Java应用程序服务器,例如Tomcat或Jetty。然后,你可以按照以下步骤启动war: 1.将war放到Tomcat或Jetty服务器的webapps目录下。 2.启动Tomcat或Jetty服务器。这通常需要运一个启动脚本,例如catalina.sh或jetty.sh。 3.一旦服务器启动完成,你就可以通过浏览器访问你的应用程序。假设你的war名为myapp.war,则你可以在浏览器中输入http://localhost:8080/myapp访问它。 请注意,具体的命令可能因为服务器版本和配置而有所不同,建议查阅相关的服务器文档以获得更详细的指导。 在Linux系统中,可以使用java -jar命令来启动WARjava -jar war名.war启动war需要在安装了Java环境的Linux系统中执以下命令: 1. 首先进入war所在的目录,使用cd命令切换目录。 2. 然后使用以下命令启动war: ``` java -jar yourAppName.war ``` 其中,yourAppName.warwar的名称,需要根据实际情况进替换。 执完上述命令后,就会启动应用程序并在Linux系统上运。如果想让应用程序在后台运,可以在命令后面加上“&”符号,例如: ``` java -jar yourAppName.war & ``` 这样就可以让应用程序在后台运了。在Linux上启动WAR,您可以使用以下命令: 1. 首先确保您已经安装了Java时环境(JRE)或Java开发工具(JDK)。 2. 打开终端或命令行窗口,并切换到WAR所在的目录。 3. 运以下命令: ``` java -jar yourfile.war ``` 将 "yourfile" 替换为您的WAR文件名。 4. 等待应用程序启动并监听来自指定端口的请求。 如果您需要将应用程序作为后台进程运,可以在命令后面添加一个 “&” 符号: ``` java -jar yourfile.war & ``` 这样,应用程序将在后台运,并将命令行控制台释放回您。要在Linux上启动war,您可以使用以下命令: ``` java -jar yourwarfile.war ``` 其中,`yourwarfile.war` 是您要启动war文件的名称。此命令将使用Java虚拟机来启动您的应用程序,并将war文件作为一个可执的JAR文件。请确保您已经安装了Java,并且您在war文件的目录中运此命令。要在Linux上启动一个WAR,您需要安装Java并使用Java命令来启动该应用程序。以下是在Linux上启动WAR的基本命令: 1. 首先,在Linux系统中安装Java时环境(JRE)或Java开发工具(JDK)。 2. 打开终端或命令行界面,并进入WAR所在的目录。 3. 输入以下命令来启动WAR: ``` java -jar your_war_file_name.war ``` 其中,your_war_file_name是您的WAR文件名。确保在命令中使用正确的文件名。 4. 按下“Enter”键来启动应用程序。 5. 等待一段时间,直到应用程序成功启动并显示出相关信息。如果出现错误,请检查JavaWAR的安装和配置是否正确。 请注意,在启动WAR之前,您需要确保您的Linux系统已正确配置Java环境变量。在Linux系统中启动WAR,需要使用Java应用服务器(如Tomcat、Jetty等)来运。以下是一些通用的启动WAR的命令: 1. 使用Tomcat启动WAR: 首先,确保Tomcat服务器已经安装并正确配置。然后,使用以下命令启动WAR: ``` $CATALINA_HOME/bin/startup.sh ``` 该命令将启动Tomcat服务器,并部署WAR到Tomcat的webapps目录下。 2. 使用Jetty启动WAR: 类似于Tomcat,首先需要确保Jetty服务器已经安装并正确配置。然后,使用以下命令启动WAR: ``` java -jar jetty-runner.jar yourapp.war ``` 该命令将使用Jetty运WAR。 请注意,上述命令中的“$CATALINA_HOME”和“jetty-runner.jar”需要根据实际情况进替换。在Linux系统上启动一个war,需要先安装Java环境。接着,使用以下命令启动: ``` java -jar your_application.war ``` 其中,`your_application.war`为你想要启动war文件名。执该命令后,应用程序将被部署并在后台运。如果需要终止该应用程序的运,可以使用 `Ctrl + C` 组合键来中断程序的执。在Linux中启动war的命令通常是使用Java虚拟机(JVM)运war文件。具体的命令如下: 1. 首先,安装Java并确保它已经添加到环境变量中。 2. 在命令行中使用cd命令进入war所在的目录。 3. 使用以下命令来运war文件java -jar your-war-file-name.war 其中,your-war-file-name是你的war文件名。 4. 执命令后,你的应用程序就会在后台运,并可以通过浏览器访问它。 注意:有些应用程序需要配置一些参数,例如端口号等。在这种情况下,你需要查看应用程序的文档来了解如何配置这些参数。在Linux上启动WAR需要使用Java虚拟机来运,具体命令如下: ``` java -jar your_war_file_name.war ``` 其中,`your_war_file_name.war` 是你的WAR文件名。需要在终端中进入该WAR所在的目录,然后执上述命令即可启动应用程序。在Linux系统中启动war可以使用以下命令: ``` java -jar your_application.war ``` 其中,"your_application.war"是你要启动war文件名。此命令会使用Java虚拟机(JVM)运你的应用程序。在运之前,请确保已经安装了Java并配置了环境变量。在Linux上启动WAR需要使用Java应用服务器,如Tomcat或Jetty等。以下是启动WAR的基本步骤: 1. 安装Java应用服务器,例如Tomcat或Jetty。 2. 将WAR放置在Java应用服务器的webapps目录下。 3. 启动Java应用服务器。可以使用以下命令: - 对于Tomcat服务器:进入Tomcat的bin目录,执./startup.sh命令启动Tomcat服务器。 - 对于Jetty服务器:进入Jetty的bin目录,执./jetty.sh start命令启动Jetty服务器。 4. 启动后,在Web浏览器中输入服务器的IP地址和端口号,即可访问启动的应用程序。例如,如果Tomcat服务器在本地计算机上运,并监听8080端口,则可以在浏览器中输入http://localhost:8080/访问应用程序。要在Linux上启动WAR,您可以使用以下命令: ``` java -jar yourwarfile.war ``` 其中,"yourwarfile.war"应替换为您要启动WAR文件的实际文件名。此命令会使用Java时环境(JRE)来启动WAR文件,并在指定端口上启动应用程序。您可以使用浏览器访问应用程序的URL来验证是否已成功启动。要在Linux上启动WAR,您需要使用Java应用程序服务器。以下是一些可能有用的命令: 1. 解压WAR文件: `jar xvf yourapp.war` 2. 安装Java应用程序服务器(这里以Tomcat为例): `sudo apt-get install tomcat` 3. 将WAR文件复制到Tomcat webapps目录下: `sudo cp yourapp.war /var/lib/tomcat/webapps/` 4. 启动Tomcat服务器: `sudo systemctl start tomcat` 5. 检查Tomcat服务器状态: `sudo systemctl status tomcat` 6. 在Web浏览器中打开应用程序: `http://localhost:8080/yourapp` 请注意,上述命令可能需要根据您的特定环境进修改。在Linux系统中,启动WAR可以通过以下命令: 1. 确保已经安装了Java并且已经配置了环境变量。 2. 打开终端并进入WAR所在的目录。 3. 使用以下命令启动WAR: ``` java -jar yourwarfile.war ``` 其中,"yourwarfile.war"是你的WAR的名称。 4. 等待应用程序启动,这可能需要一些时间。 如果你想在后台运WAR,可以使用以下命令: ``` nohup java -jar yourwarfile.war > log.file 2>&1 & ``` 这将在后台启动WAR,并将所有输出重定向到"log.file"文件中。你可以检查"log.file"文件以查看应用程序的输出信息。 ### 回答2: 对于Linux系统,启动war的常用方法是通过Java web容器(如Tomcat、Jetty等)来实现。下面以Tomcat容器为例,介绍如何启动war。 首先,需要安装好Java和Tomcat,并将war放到Tomcat的webapps目录中。假设Tomcat安装目录为/opt/tomcat,war名为myapp.war,则可通过以下命令将war拷贝到webapps目录: ``` cp myapp.war /opt/tomcat/webapps/ ``` 然后,切换到Tomcat的bin目录,执startup.sh脚本启动Tomcat: ``` cd /opt/tomcat/bin ./startup.sh ``` 启动后,可通过访问localhost:8080/myapp(其中8080为Tomcat默认端口)来访问应用。 如果需要停止Tomcat,可以执shutdown.sh脚本: ``` cd /opt/tomcat/bin ./shutdown.sh ``` 需要注意的是,启动和停止Tomcat时需要使用超级管理员权限或Tomcat所属用户的权限。如果启动时出现权限不足的错误,可以使用sudo或su命令切换用户来操作。 另外,如果需要在Tomcat启动时自动部署war,可以将war直接放在webapps目录中,或者在Tomcat的conf/server.xml文件中添加Context元素,设置docBase属性为war所在路径。 总之,通过Java web容器启动war是Linux系统中常用的部署Web应用的方式,掌握相关操作技能能够更好地管理和运维Web应用。 ### 回答3: 首先,需要安装Tomcat服务器,Tomcat是一个流的开源JSP/Servlet容器,可以在Linux系统上运。安装完Tomcat后,需要将WAR文件拷贝到Tomcat的webapps目录下。 接着,在Linux系统中,在终端输入以下命令,启动Tomcat服务器: ``` sudo /usr/local/apache-tomcat-9.0.37/bin/startup.sh ``` 上述命令中,`/usr/local/apache-tomcat-9.0.37/`是Tomcat的安装路径,可根据实际安装情况修改。执该命令后,会启动Tomcat服务器,并在终端输出一些启动信息。 接下来,在浏览器中访问以下URL: ``` http://localhost:8080/webappname ``` 上述URL中,`webappname`为WAR文件的名称,可根据实际情况修改。如果一切顺利,应该能看到WEB应用程序已经成功启动的界面了。 注意,如果启动WAR文件时已经存在同名的Web应用程序,Tomcat会先将该应用程序停止,然后在重新启动时重新部署WAR文件。如果需要重启Tomcat服务器,可以使用以下命令: ``` sudo /usr/local/apache-tomcat-9.0.37/bin/shutdown.sh sudo /usr/local/apache-tomcat-9.0.37/bin/startup.sh ``` 上述命令中,第一条命令将停止Tomcat服务器,第二条命令将启动Tomcat服务器。在执重启命令前,应确保Tomcat服务器已经成功停止了。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值