使用 Eureka 注册服务

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

  本文将带你深入学习如何将 Spring Boot 微服务应用注册到 Eureka 服务器中。在注册应用前,请确保 Eureka Server 已经运行在 8761 端口或者先构建 Eureka 服务器并运行起来。有关搭建 Eureka 服务器的信息,可以参考本系列教程的相关部分。
  首先,你需要在构建配置文件中加入以下依赖,以注册微服务到 Eureka 服务器。
  Maven 用户可以加上下面的依赖到 pom.xml 文件:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

  Gradle 用户可以加上下面的依赖到 build.gradle 文件:

compile('org.springframework.cloud:spring-cloud-starter-eureka')

  现在,我们需要在 Spring Boot 应用类文件中加上 @EnableEurekaClient 注解。@EnableEurekaClient 注解可以使你的 Spring Boot 应用作为 Eureka 客户端。
  主 Spring Boot 就用如下所示:

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

  要注册 Spring Boot 应用到 Eureka 服务器中,我们要加上以下配置到 application.properties 或 application.yml 文件,并指定 Eureka 服务器的 URL。
  application.yml 文件的代码如下:

eureka:
  client:
     serviceUrl:
        defaultZone: http://localhost:8761/eureka
     instance:
     preferIpAddress: true
spring:
  application:
     name: eurekaclient

  application.properties 文件的代码如下:
eureka.client.serviceUrl.defaultZone = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient
  现在,在主 Spring Boot 应用中加上 Rest 端点以返回字符串,在构建配置文件中要加上相应的应用描述。示例代码如下:

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String home() {
      return "Eureka Client application";
   }
}

  整个配置文件如下:
  Maven – 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>eurekaclient</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>eurekaclient</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.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>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</artifactId>
      </dependency>
      <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>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

</project>

  Gradle – build.gradle

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

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

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile('org.springframework.boot:spring-boot-starter-web')   
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

  你可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  现在,应用已经在 Tomcat 8080 端口启动,且 Eureka 客户端应用已经被注册到 Eureka 服务器,如下所示:

  在 Web 浏览器中输入 URL http://localhost:8761/,可以看到 Eureka 客户端应用已经被注册到 Eureka 服务器。

  在 Web 浏览器中输入 URL http://localhost:8080/,可以看到 Rest 端点输出。

Spring Boot 教程:Eureka 服务器

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

  Eureka 服务器是一个应用,它包含所有客户端服务应用的信息。每个微服务都会注册到 Eureka 服务器并且 Eureka 服务器知道所有客户端应用的端口和 IP 地址。Eureka 服务器也被称为发现服务器。
  本文将带你学习如何搭建 Eureka 服务器。搭建 Eureka 服务器
  Eureka 服务器与 Spring Cloud 打包发布。基于此,我们需要开发 Eureka 服务器并将它运行于缺省的 8761 端口上。
  访问 Spring 初始化器主页 https://start.spring.io/ 并下载 Spring Boot 工程的 Eureka 服务器依赖。如下图所示:

  工程下载之后,在主 Spring Boot 应用类文件中,我们要加上 @EnableEurekaServer 注解。@EnableEurekaServer 注解可使你的 Spring Boot 应用用作 Eureka 服务器。
  主 Spring Boot 应用类文件如下所示:

package com.tutorialspoint.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

  确保你的构建配置文件中已经加入了 Spring cloud Eureka 服务器依赖。
  Maven 用户的依赖代码如下:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

  Gradle 用户的依赖代码如下:

compile('org.springframework.cloud:spring-cloud-starter-eureka-server')

  完整的构建配置代码文件如下所示:
Maven 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>eurekaserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>eurekaserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.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>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka-server</artifactId>
      </dependency>

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

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

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

</project>

Gradle – build.gradle

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

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

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

  缺省情况下,Eureka 服务器会将自身注册到发现中。你应当加入以下配置到 application.properties 或 application.yml 文件中:
application.properties 文件如下所示:

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

application.yml 文件如下所示:

eureka:
  client:
     registerWithEureka: false
     fetchRegistry: false
server:
  port: 8761

  现在可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  应用已在 Tomcat 8761 端口启动,如下图所示:

  接下来,在 web 浏览器中单击 URL http://localhost:8761/,可以发现 Eureka 服务器已经运行在 8761 端口,如下所示:

Spring Boot 教程:启用 HTTPS

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

  Spring Boot 应用默认以 HTTP 8080 端口启动。

  你要在 Spring Boot 应用中执行以下步骤来配置 HTTPS 和端口 443:

  • 获取 SSL 证书:创建自签名证书或者从一个证书认证机构申请一个。
  • 启用 HTTPS 和 443 端口

    自签名证书

      Java 运行时环境已经内置了证书管理实用工具,可用于创建自签名证书。示例代码如下:

keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650
Enter keystore password:
   Re-enter new password:
   What is your first and last name?
   [Unknown]:
   What is the name of your organizational unit?
   [Unknown]:
   What is the name of your organization?
   [Unknown]:
   What is the name of your City or Locality?
   [Unknown]:
   What is the name of your State or Province?
   [Unknown]:
   What is the two-letter country code for this unit?
   [Unknown]:
   Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct?
   [no]: yes

  这段代码将产生一个名为 keystore.p12 的PKCS12 keystore 文件,证书别名为 tomcat。

配置 HTTPS

  我们要在 application.properties 文件中写入:服务端口为 443、key-store 文件路径、key-store-password、key-store-type 和 密钥别名。如下所示:

server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat

  如果你使用 YAML 属性的话,你也可以使用下面的 application.yml 的代码:

server:
  port: 443
  ssl:
     key-store: keystore.p12
     key-store-password: springboot
     keyStoreType: PKCS12
     keyAlias: tomcat

  现在可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  应用已在 Tomcat 443 端口启动,如下图所示:

Spring Boot 教程:调度

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

  调度用来处理特定时间周期的任务。Spring Boot 为 Spring 应用编写调度器提供了良好的支持。

Java Cron 表达式

  Java Cron 表达式用于配置 CronTrigger 实例,是 org.quartz.Trigger 的子类。关于 Java cron 表达式的更多信息可参考:https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm
  @EnableScheduling 注解用于使你的应用能够使用调度器。这个注解应当被加在主 Spring Boot 应用类文件中。

@SpringBootApplication
@EnableScheduling

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

  @Scheduled 注解用于触发一个特定时间周期的调度器。

@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}

  以下代码展示了如何在每天的早上 9:00 到 9:59 之间每分钟执行任务:

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(cron = "0 * 9 * * ?")
   public void cronJobSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Java cron job expression:: " + strDate);
   }
}

  以下截图展示了应用在 09:03:23 启动之后如何每隔一分钟执行一次:

固定频度

  固定频度调度器被用于在特定时间执行任务。它不等待前一个任务完成,时间单位为毫秒。示例代码如下:

@Scheduled(fixedRate = 1000)
public void fixedRateSch() { 
}

  以下代码示例是应用启动后的每秒钟执行一个任务:

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedRate = 1000)
   public void fixedRateSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Rate scheduler:: " + strDate);
   }
}

  观看以下截屏,可以看出应用在 09:12:00 启动后以每隔一秒钟的固定频度执行任务:

固定延迟

  固定延迟调度器用于在指定时间执行任务。它应当等待上一个任务完成,单位为毫秒。示例代码如下:

@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}

  这里,initialDelay 是在初始化之后到首次执行间的延迟值。
  下面的例子中,是从应用启动完成后 3 秒后执行每秒一次的任务:

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
   public void fixedDelaySch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Delay scheduler:: " + strDate);
   }
}

  下面看到的截屏显示的是应用在 09:18:39 启动完成 3 秒后,固定延迟调度器任务每秒执行一次的情况。

Spring Boot 教程:国际化

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

  国际化是一种处理机制,使得你的应用可以适配不同的语言和区域而无需更改源代码。换言之,国际化是为本地化而准备。
  本文将带你学习在 Spring Boot 中如何实现国际化的细节。

依赖

  在 Spring Boot 中开发 web 应用,我们需要依赖 Spring Boot Starter Web 和 Spring Boot Starter Thymeleaf 依赖项。

Maven

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

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

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

  要确定你的应用的缺省本地化,需要在 Spring Boot 应用中 增加 LocaleResolver bean。

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

  LocaleChangeInterceptor 用于根据请求所带的语言参数来切换新的本地化。

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

  要把 LocaleChangeInterceptor 加到应用注册拦截器中才能生效。这个配置类应当继承 WebMvcConfigurerAdapter 类且重载 addInterceptors() 方法。

消息资源

  Spring Boot 应用默认从 classpath 路径下的 src/main/resources 文件夹获取消息源。缺省本地化消息文件名应当是 message.properties,每个本地化文件名应当类似 messages_XX.properties。“XX” 代表本地化代号。
  所有的消息属性应当以键值方式表达。如果任意属性没有在本地化中找到,应用就从 messages.properties 文件中获取缺省值。
  缺省 messages.properties 如下所示:

welcome.text=Hi Welcome to Everyone

  法语 messages_cn.properties 如下所示:

welcome.text=Salut Bienvenue à tous

注意:消息源文件应当以 “UTF-8” 格式存储。

HTML 文件

  在 HTML 文件中,使用 #{key} 语法来显示属性文件中获取的消息。

<h1 th:text = "#{welcome.text}"></h1>

  完整的代码如下:

Maven – 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>jar</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 />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </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>

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

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

Gradle – 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'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   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;

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

  控制类文件如下:

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

  支持国际化的配置类:

package com.tutorialspoint.demo;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

  消息源 – messages.properties 如下:

welcome.text = Hi Welcome to Everyone

  消息源 – message_fr.properties 文件如下:

welcome.text = Salut Bienvenue à tous
  HTML 文件 locale.html 应当放在 classpath 路径下的 templates 目录,如下所示:
```html


   
      
      Internationalization
   
   
      

  使用 Maven 或 Gradle 命令创建可执行 JAR 文件并运行 Spring Boot 应用:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:
  应用已在 Tomcat 8080 端口启动,如下图所示:

  在浏览器输入 URL http://localhost:8080/locale 可以看到如下输出:

URL http://localhost:8080/locale?language=fr 输出如下:

Spring Boot 教程:CORS 支持

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

  跨域资源共享 (CORS) 是一个安全概念,它允许在 web 浏览器中实现对资源访问的限制。它可避免 JavaScript 代码产生或消费别跨越不同域的请求。
  例如,你的运行在 8080 端口的 web 应用试图使用 JavaScript 消费来自 9090 端口的 RESTful web 服务。在这样的情形下,你将面对 web 浏览器上跨域资源共享的安全问题。
  这个问题有两个需求要处理:

  • RESTful web 服务应当支持跨域资源共享。
  • RESTful web 服务应用应当允许来自 8080 端口访问 API(s)。
      在本文中,我们将详细学习如何让一个 RESTful Web 服务应用能够进行跨域请求。

    在控制器方法中启用 CORS

      我们需要在控制器方法上对一个 RESTful web 服务使用 @CrossOrigin 设置源。@CrossOrigin 注解支持指定 REST API,而不是对整个应用。

    @RequestMapping(value = "/products")
    @CrossOrigin(origins = "http://localhost:8080")
    public ResponseEntity<Object> getProduct() {
    return null;
    }

    全局 CORS 配置

      要定义 @Bean 以对 Spring Boot 应用全局配置 CORS。

    @Bean
    public WebMvcConfigurer corsConfigurer() {
    return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/products").allowedOrigins("http://localhost:9000");
      }    
    };
    }

      在主 Spring Boot 应用中全局配置 CORS 的代码如下:

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurerAdapter() {
         @Override
         public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/products").allowedOrigins("http://localhost:8080");
         }
      };
   }
}

  现在,你创建了一个 Spring Boot web 应用,运行在 8080 端口上,RESTful web 服务应用运行在 9090 端口上。关于如何实现 RESTful Web 服务,你可以参考本系列教程的另外一部分:消费 RESTful Web 服务

Spring Boot 教程:消费 Rest Web 服务

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

  本文将讨论如何使用 jQuery AJAX 来消费 RESTful Web 服务。
  创建一个简单的 Spring Boot web 应用并编写一个控制器类文件用于重定向到 HTML 文件中,以消费 RESTful web 服务。
  我们要在构件配置文件中加上 Spring Boot starter Thymeleaf 和 Web 依赖。
  对于 Maven 用户,在 pom.xml 文件中加上以下依赖:

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

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

  对于 Gradle 用户,在 build.gradle 中加上如下依赖:

compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)

  @Controller 类文件如下:

@Controller
public class ViewController {
}

  可以定义请求 URI 方法来重定向到 HTML 文件中,如下所示:

@RequestMapping(“/view-products”)
public String viewProducts() {
   return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
   return “add-products”;
}

  API http://localhost:9090/products 应当返回以下所示的 JSON 响应:

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

  现在,在 classpath 下的 templates 目录中创建 view-products.html 文件:
  在这个 HTML 文件中,我们加上了 jQuery 类,且编写代码在页面加载时消费 RESTful web 服务。

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<script>
$(document).ready(function(){
   $.getJSON("http://localhost:9090/products", function(result){
      $.each(result, function(key,value) {
         $("#productsJson").append(value.id+" "+value.name+" ");
      }); 
   });
});
</script>

  POST 方法和 URL http://localhost:9090/products 应当包含以下请求体和响应体:
  请求体代码如下:

{
   "id":"3",
   "name":"Ginger"
}

  响应体代码如下:

Product is created successfully

  现在,在 classpath 下的 templates 目录中创建 add-products.html 文件。
  在 HTML 文件中,我们加上 jQuery 库并编写,在单击按钮时提交表单以消费 RESTful web 服务。

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
   $(document).ready(function() {
      $("button").click(function() {
         var productmodel = {
            id : "3",
            name : "Ginger"
         };
         var requestJSON = JSON.stringify(productmodel);
         $.ajax({
            type : "POST",
            url : "http://localhost:9090/products",
            headers : {
               "Content-Type" : "application/json"
            },
            data : requestJSON,
            success : function(data) {
               alert(data);
            },
            error : function(data) {
            }
         });
      });
   });
</script>

  完整的代码如下:
  Maven – 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>jar</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 />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </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>

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

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

</project>

  Gradle – 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’

group = ‘com.tutorialspoint’
version = ‘0.0.1-SNAPSHOT’
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile(‘org.springframework.boot:spring-boot-starter-web’)
   compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
   testCompile(‘org.springframework.boot:spring-boot-starter-test’)
}

  控制类代码如下:
  ViewController.java 如下:

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping(“/view-products”)
   public String viewProducts() {
      return “view-products”;
   }
   @RequestMapping(“/add-products”)
   public String addProducts() {
      return “add-products”;   
   }   
}

  view-products.html 文件如下:

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>View Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

      <script>
         $(document).ready(function(){
            $.getJSON("http://localhost:9090/products", function(result){
               $.each(result, function(key,value) {
                  $("#productsJson").append(value.id+" "+value.name+" ");
               }); 
            });
         });
      </script>
   </head>

   <body>
      <div id = "productsJson"> </div>
   </body>
</html>

  add-products.html 文件如下:

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <title>Add Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

      <script>
         $(document).ready(function() {
            $("button").click(function() {
               var productmodel = {
                  id : "3",
                  name : "Ginger"
               };
               var requestJSON = JSON.stringify(productmodel);
               $.ajax({
                  type : "POST",
                  url : "http://localhost:9090/products",
                  headers : {
                     "Content-Type" : "application/json"
                  },
                  data : requestJSON,
                  success : function(data) {
                     alert(data);
                  },
                  error : function(data) {
                  }
               });
            });
         });
      </script>
   </head>

   <body>
      <button>Click here to submit the form</button>
   </body>
</html>

  主 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);
   }
}

  现在可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  应用已在 Tomcat 8080 端口启动,如下图所示:

  在浏览器中输入下面的 URL 你会看到如下图所示的输出:
  http://localhost:8080/view-products

http://localhost:8080/add-products

  现在,单击按钮 Click here to submit the form 你可以看到如下图所示的结果:

  现在,单击如下查看产品 URL 查看所创建的产品。
  http://localhost:8080/view-products

Angular JS

  要使用 Angular JS 消费 APIs,如下所示:
  使用下面的代码创建 Angular JS 控制来消费 GET API – http://localhost:9090/products

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.get('http://localhost:9090/products').
   then(function(response) {
      $scope.products = response.data;
   });
});

  使用下面的代码创建 Angular JS 控制来消费 POST API – http://localhost:9090/products

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.post('http://localhost:9090/products',data).
   then(function(response) {
      console.log("Product created successfully");
   });
});

注意: Post 方法数据表示用于创建产品的 JSON 格式的请求体

Spring Boot 教程:Thymeleaf

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

  Thymeleaf 是一个基于 Java 的库【译注:模板引擎】,可用于创建 web 应用。它对于 web 应用中的 XHTML/HTML5 提供了良好的支持。在本文中,你将学会有关 Thymeleaf 细节。

Thymeleaf 模板

  Thymeleaf 将你的文件转换成格式良好的 XML 文件。它包含以下 6 种类型的模板:

  • XML
  • 有效 XML
  • XHTML
  • 有效 XHTML
  • HTML5
  • 遗留 HTML5
      除了遗留 HTML5 以外的所有模板都可参阅有效的 XML 文件。遗留 HTML5 允许我们在 web 页中渲染 HTML5 标签,包括没闭合的标签。

    Web 应用

      你可以使用 Thymeleaf 模板在 Spring Boot 中创建 web 应用,需要以下几个步骤。
      使用以下代码创建一个 @Controller 类文件以重定向请求 URI 到 HTML 文件:

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {
   @RequestMapping(value = "/index")
   public String index() {
      return "index";
   }
}

  在上述例子中,请求 URI 为 /index,控制重定向到 index.html 文件。注意,index.html 文件应当放到 templates 目录下面,所有的 JS 和 CSS 文件应当放到 classpath 路径下的 static 目录。在示例中,我们使用 CSS 文件改变文本颜色。
  你可以使用以下代码在一个独立的目录中创建 CSS 文件,文件名为 styles.css:

h4 {
   color: red;
}

  index.html 文件的代码如下:

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <link href = "css/styles.css" rel = "stylesheet"/>
      <title>Spring Boot Application</title>
   </head>
   <body>
      <h4>Welcome to Thymeleaf Spring Boot web application</h4>
   </body>
</html>

  项目浏览器的截屏如下所示:

  现在,我们需要在我们的构建配置文件中加上 Spring Boot Starter Thymeleaf 依赖。
  Maven 用户可以将下面的依赖加入 pom.xml 文件:

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

  Gradle 用户可以在 build.gradle 文件中加入以下依赖:

compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

  主 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);
   }
}

  Maven – 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>jar</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 />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </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>

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

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

</project>

  Gradle – 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'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

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

  现在你可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  现在应用已在 Tomcat 8080 端口启动,如下图所示:

  在浏览器中输入以下 URL,你将会看到下图所示的输出:
http://localhost:8080/index

Spring Boot 教程:服务组件

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

  服务组件是包含 @Service 注解的类文件。这些类文件可用在与 @RestController 类文件所不同的层来编写业务逻辑。创建服务组件类文件如下所示:

public interface ProductService {
}

  以 @Service 注解实现接口的类如下所示:

@Service
public class ProductServiceImpl implements ProductService {
}

  回顾以前的教程中,我们使用产品服务 API(s) 来存储、获取、更新和删除产品。我们在 @RestController 类文件自身中编写业务逻辑。现在我们要把业务逻辑代码从控制器移到服务组件。
  你可以创建一个接口,包含增加、编辑、获取和删除方法,示例代码如下:

package com.tutorialspoint.demo.service;

import java.util.Collection;
import com.tutorialspoint.demo.model.Product;

public interface ProductService {
   public abstract void createProduct(Product product);
   public abstract void updateProduct(String id, Product product);
   public abstract void deleteProduct(String id);
   public abstract Collection<Product> getProducts();
}

  以下代码将让你创建一个以 @Service 注解来实现 ProductService 接口的类,用以编写存储、获取、删除和更新产品。

package com.tutorialspoint.demo.service;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.tutorialspoint.demo.model.Product;

@Service
public class ProductServiceImpl implements ProductService {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);

      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @Override
   public void createProduct(Product product) {
      productRepo.put(product.getId(), product);
   }
   @Override
   public void updateProduct(String id, Product product) {
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
   }
   @Override
   public void deleteProduct(String id) {
      productRepo.remove(id);

   }
   @Override
   public Collection<Product> getProducts() {
      return productRepo.values();
   }
}

  以里的代码展示了 Rest Controller 类文件,我们用 @Autowired 来自动注入 ProductService 接口并调用其方法。

package com.tutorialspoint.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;
import com.tutorialspoint.demo.service.ProductService;

@RestController
public class ProductServiceController {
   @Autowired
   ProductService productService;

   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productService.getProducts(), HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> 
      updateProduct(@PathVariable("id") String id, @RequestBody Product product) {

      productService.updateProduct(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) {
      productService.deleteProduct(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productService.createProduct(product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

  POJO class – Product.java 代码在此:

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

  主 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);
   }
}

  Maven build – 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>jar</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/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </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>

  Gradle Build – 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'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

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

  现在你可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:
  Maven 命令如下:

mvn clean install

  在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。
  Gradle 可以使用以下命令:

gradle clean build

  在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。
  现在,使用以下命令运行 JAR 文件:

java –jar <JARFILE>

  应用将在 Tomcat 8080 端口启动,如下图所示:

  现在在 POSTMAN 应用中输入以下 URL,可以看到下图所示的输出:
GET API URL 为: http://localhost:8080/products

POST API URL 为: http://localhost:8080/products

PUT API URL 为: http://localhost:8080/products/3

DELETE API URL 为: http://localhost:8080/products/3

Spring Boot 教程:文件处理

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

    本文学习如何使用 web 服务进行文件上传和下载。

文件上传

   上传一个文件,可以使用 MultipartFile 作为请求参数,并且这个 API 应当消费 Multi-Part 表单数据值。示例代码如下:

@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

public String fileUpload(@RequestParam("file") MultipartFile file) {
   return null;
}

   完整代码如下:

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
   @RequestMapping(value = "/upload", method = RequestMethod.POST, 
      consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
   
   public String fileUpload(@RequestParam("file") MultipartFile file) throws IOException {
      File convertFile = new File("/var/tmp/"+file.getOriginalFilename());
      convertFile.createNewFile();
      FileOutputStream fout = new FileOutputStream(convertFile);
      fout.write(file.getBytes());
      fout.close();
      return "File is upload successfully";
   }
}

文件下载

   文件下载应当使用 InputStreamResource。我们要在响应中设置 HttpHeader Content-Disposition,并且要指定应用的响应媒体类型(Media Type)。注意: 以下面的例子中,在应用运行时指定路径上的文件应当是可用的。

@RequestMapping(value = "/download", method = RequestMethod.GET) 
public ResponseEntity<Object> downloadFile() throws IOException  {
   String filename = "/var/tmp/mysql.png";
   File file = new File(filename);
   InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
   HttpHeaders headers = new HttpHeaders();
      
   headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
   headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
   headers.add("Pragma", "no-cache");
   headers.add("Expires", "0");
      
   ResponseEntity<Object> 
   responseEntity = ResponseEntity.ok().headers(headers).contentLength(file.length()).contentType(
      MediaType.parseMediaType("application/txt")).body(resource);
      
   return responseEntity;
}

   完整代码如下:

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FileDownloadController {
   @RequestMapping(value = "/download", method = RequestMethod.GET) 
   public ResponseEntity<Object> downloadFile() throws IOException  {
      String filename = "/var/tmp/mysql.png";
      File file = new File(filename);
      InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
      HttpHeaders headers = new HttpHeaders();
      
      headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
      headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
      headers.add("Pragma", "no-cache");
      headers.add("Expires", "0");
      
      ResponseEntity<Object> 
      responseEntity = ResponseEntity.ok().headers(headers).contentLength(
         file.length()).contentType(MediaType.parseMediaType("application/txt")).body(resource);
      
      return responseEntity;
   }
}

   主 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);
   }
}

   Maven build – 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>jar</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/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </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>

   Gradle Build – 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'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

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

   现在你可以使用 Maven 或 Gradle 命令创建可执行 executable JAR 文件并运行 Spring Boot 应用了:   Maven 命令如下:

mvn clean install

   在 “BUILD SUCCESS” 之后,你可以在 target 目录下找到 JAR 文件。   Gradle 可以使用以下命令:

sgradle clean build

   在 “BUILD SUCCESSFUL” 之后,你可以在 build/libs 目录下找到 JAR 文件。   现在,使用以下命令运行 JAR 文件:

java –jar <JARFILE>

   应用将在 Tomcat 8080 端口启动,如下 所示:

   应用将在 Tomcat 8080 端口启动,如下 所示: