博客

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_tomcat_deployment.htm

    使用 Spring Boot 应用,我们可以创建一个 war 文件部署到 web 服务器中。本文讲解如何创建 war 文件并将 Spring Boot 应用部署到 Tomcat web 服务器中。

Spring Boot Servlet 初始化器

    传统的部署方式是将 Spring Boot 应用中 @SpringBootApplication 注解的类扩展自 SpringBootServletInitializer 类。Spring Boot Servlet Initializer 类文件允许你在使用 Servlet 窗口启动时配置应用。    用于 JAR 文件部署的 Spring Boot 应用类文件示例如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

    我们需要扩展类 SpringBootServletInitializer 以支持 WAR 文件部署。对应的 Spring Boot 应用类文件如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

设置主类

    在 Spring Boot 中,我们需要在构件文件中指定主类。可使用下面的代码片段:

    对于 Maven,在 pom.xml 中增加启动类属性,如下所示:

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

    对于Gradle,在 build.gradle 中加入主类名,如下所示:

mainClassName="com.tutorialspoint.demo.DemoApplication"

更新 JAR 包到 WAR 中

    我们还要用下面的代码片段更新 JAR 包到 WAR 中:

    对于 Maven,pom.xml 中打包 WAR 的插件如下:

<packaging>war</packaging>

    对于 Gradle,在 build.gradle 中加上 应用和 war 插件,如下所示:

apply plugin: ‘war’
apply plugin: ‘application’

   现在,让我们编写一个简单的 Rest 端点,返回 “Hello World from Tomcat” 字符串。要编写 Rest Endpoint,我们要在构建文件中加上 Spring Boot web starter 依赖。

   对于 Maven,在 pom.xml 中加上 Spring Boot starter 依赖,如下所示:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

   对于 Gradle,在 build.gradle 中加上 Spring Boot starter 依赖,如下所示:

dependencies {
  compile('org.springframework.boot:spring-boot-starter-web')
}

   现在,在 Spring Boot 应用类文件中编写 Rest 端点,示例代码如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

打包应用

   如下所示,使用Maven 或 Gradle 命令将应用打包成 WAR 文件以部署到 Tomcat 服务器:

   对于 Maven,用 mvn package 来打包应用。之后,会创建一个 WAR 文件,可以在 target 目录下找到它,如下图:

   对于 Gradle,用 gradle clean build 来打包应用。之后,会创建一个 WAR 文件,可以在 build/libs 目录下找到它,如下图:

部署到 Tomcat

   现在,运行 Tomcat 服务器,在 webapps 目录下部署 WAR 文件,如下图所示:

   部署成功之后,在web 浏览器中敲入 http://localhost:8080/demo-0.0.1-SNAPSHOT/,屏幕截图如下:

全部代码如下:

pom.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

    build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

    主 Spring Boot 应用类文件如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_build_systems.htm

    对于 Spring Boot,选择构建系统是一项重要任务。我们推荐使用 Maven 或 Gradle,因为它们对于依赖管理有良好的支持。Spring对于其他构建系统支持得不是很好。

依赖管理

    Spring Boot 团队在每次发布时都提供一支持 Spring Boot 版本的依赖列表。你不需要在构建配置文件中提供依赖的版本。Spring Boot 根据发布自动配置依赖版本。记住你更新 Spring Boot 版本时,会自动更新相关依赖。注意:如果你想指定依赖的版本,可以在配置文件中指定。然而,Spring Boot 团队强烈推荐没必要指定依赖版本。

Maven 依赖

    对于 Maven 配置,我们应当继承 Spring Boot 启动器父项目管理 Spring Boot 启动器依赖。我们的 pom.xml 如下所示:

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.8.RELEASE</version>
</parent>

    我们应用指定 Spring Boot 父启动器依赖的版本号。之后对于其他启动器依赖,我们就没必要再指定 Spring Boot 版本号了。示例如下:

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Gradle 依赖

    我们可以在 build.gradle 文件中直接引入 Spring Boot 启动器依赖。没必要象Maven 一样指定Spring Boot 父启动器依赖,如下所示:

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

    同样,在 Gradle 中,我们也没必要指定所依赖的 Spring Boot 版本号。Spring Boot 自动配置依赖版本。

dependencies {
  compile('org.springframework.boot:spring-boot-starter-web')
}

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_code_structure.htm

Spring Boot 不要求任何代码布局就能工作。然而,却有一些最佳实践能够帮到我们,且待本文为你详解。

缺省包

    没有包含任何包声明的类被视为缺省包。请注意:一般来说缺省包声明是不推荐的。如果使用缺省包,那么 Spring Boot 会出现类似自动配置和组件扫描不起作用的问题。注意:Java 推荐的包声明命名规范是翻转的域名。例如:com.tutorialspoint.myproject

典型结构

    Spring Boot 应用的典型结构如下图所示:

package com.tutorialspoint.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
   public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

【注】本文译自: https://www.tutorialspoint.com/spring_boot/spring_boot_beans_and_dependency_injection.htm

    在Spring Boot 中,我们可以利用 Spring Framework 定义 bean 及其依赖注入。@ComponentScan 及其对应的@Autowired 注解被用于发现和注入 bean。

    如果你遵循典型的 Spring Boot 代码结构,那么就不需要使用 @ComponentScan 注解的任何参数。所有的组件类文件都被注册为 Spring Beans。

    下面的示例说明如何自动注入 Rest Template 对象并创建一个相同的:

@Bean
public RestTemplate getRestTemplate() {
   return new RestTemplate();
}

    以下代码展示如何在主Spring Boot 应用类文件中自动注入 Rest Template 对象及其 Bean 对象:

package com.tutorialspoint.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
@Autowired
   RestTemplate restTemplate;
   
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();   
   }
}

【注】本文译自:https://www.tutorialspoint.com/spring_boot/spring_boot_runners.htm

    应用运行器和命令行运行器接口可以让你的代码在 Spring Boot 应该启动之后执行,你可以使用这些接口让应用启动之后立即执行任何行为。本文为你细说详情。

应用运行器

    应用运行器是一个接口,用于在 Spring Boot 应用启动之后执行代码。下面的代码展示了如何在主类文件中实现应用运行器接口:

package com.tutorialspoint.demo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements ApplicationRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      System.out.println("Hello World from Application Runner");
   }
}

    如下所示,在控制台窗口中运行,可以看到在 Tomcat 启动之后打印出了 Hello World from Application Runner

package com.tutorialspoint.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(String... arg0) throws Exception {
      System.out.println("Hello world from Command Line Runner");
   }
}

    如下所示,在控制台窗口运行后,可以看到在 Tomcat 启动之后打印出了 ”Hello world from Command Line Runner“ 。