스프링 부트-퀵 가이드
Spring Boot는 마이크로 서비스를 생성하는 데 사용되는 오픈 소스 Java 기반 프레임 워크입니다. Pivotal Team에서 개발했으며 독립 실행 형 및 프로덕션 준비 스프링 애플리케이션을 빌드하는 데 사용됩니다. 이 장에서는 Spring Boot에 대한 소개를 제공하고 기본 개념에 익숙해집니다.
마이크로 서비스 란?
Micro Service는 개발자가 독립적으로 서비스를 개발하고 배포 할 수있는 아키텍처입니다. 실행되는 각 서비스에는 자체 프로세스가 있으며 이는 비즈니스 응용 프로그램을 지원하는 경량 모델을 달성합니다.
장점
마이크로 서비스는 개발자에게 다음과 같은 이점을 제공합니다.
- 간편한 배포
- 간단한 확장 성
- 컨테이너와 호환
- 최소 구성
- 생산 시간 단축
스프링 부트 란?
Spring Boot는 Java 개발자가 독립 실행 형 및 프로덕션 등급의 스프링 애플리케이션을 개발할 수있는 좋은 플랫폼을 제공합니다. just run. 전체 Spring 구성 설정없이 최소 구성으로 시작할 수 있습니다.
장점
Spring Boot는 개발자에게 다음과 같은 이점을 제공합니다.
- 이해하기 쉽고 스프링 애플리케이션 개발
- 생산성 향상
- 개발 시간 단축
목표
Spring Boot는 다음 목표로 설계되었습니다.
- Spring에서 복잡한 XML 구성을 피하려면
- 더 쉬운 방법으로 생산 준비가 된 Spring 애플리케이션을 개발하려면
- 개발 시간을 줄이고 애플리케이션을 독립적으로 실행하려면
- 애플리케이션을 시작하는 더 쉬운 방법 제공
왜 스프링 부트인가?
여기에 제공된 기능과 이점으로 인해 Spring Boot를 선택할 수 있습니다.
Java Bean, XML 구성 및 데이터베이스 트랜잭션을 구성하는 유연한 방법을 제공합니다.
강력한 일괄 처리를 제공하고 REST 끝점을 관리합니다.
Spring Boot에서는 모든 것이 자동으로 구성됩니다. 수동 구성이 필요하지 않습니다.
주석 기반 스프링 애플리케이션을 제공합니다.
의존성 관리 용이
포함 된 서블릿 컨테이너
어떻게 작동합니까?
Spring Boot는 다음을 사용하여 프로젝트에 추가 한 종속성을 기반으로 애플리케이션을 자동으로 구성합니다. @EnableAutoConfiguration주석. 예를 들어 MySQL 데이터베이스가 클래스 경로에 있지만 데이터베이스 연결을 구성하지 않은 경우 Spring Boot는 메모리 내 데이터베이스를 자동 구성합니다.
스프링 부트 애플리케이션의 진입 점은 다음을 포함하는 클래스입니다. @SpringBootApplication 주석 및 주요 방법.
Spring Boot는 다음을 사용하여 프로젝트에 포함 된 모든 구성 요소를 자동으로 스캔합니다. @ComponentScan 주석.
스프링 부트 스타터
종속성 관리를 처리하는 것은 큰 프로젝트에서 어려운 작업입니다. Spring Boot는 개발자의 편의를 위해 일련의 종속성을 제공하여이 문제를 해결합니다.
예를 들어 데이터베이스 접근을 위해 Spring과 JPA를 사용하고 싶다면 다음을 포함하면 충분하다. spring-boot-starter-data-jpa 프로젝트의 종속성.
모든 Spring Boot 스타터는 동일한 이름 지정 패턴을 따릅니다. spring-boot-starter- *, 여기서 *는 애플리케이션의 유형임을 나타냅니다.
예
더 나은 이해를 위해 아래에 설명 된 다음 Spring Boot 스타터를 살펴보십시오.
Spring Boot Starter Actuator dependency애플리케이션을 모니터링하고 관리하는 데 사용됩니다. 그 코드는 다음과 같습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Spring Boot Starter Security dependencySpring Security에 사용됩니다. 그 코드는 다음과 같습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>Spring Boot Starter web dependency나머지 끝점을 작성하는 데 사용됩니다. 그 코드는 다음과 같습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Spring Boot Starter Thyme Leaf dependency웹 애플리케이션을 만드는 데 사용됩니다. 그 코드는 다음과 같습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>Spring Boot Starter Test dependency테스트 케이스 작성에 사용됩니다. 그 코드는 다음과 같습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>자동 구성
Spring Boot Auto Configuration은 프로젝트에 추가 한 JAR 종속성을 기반으로 Spring 애플리케이션을 자동으로 구성합니다. 예를 들어 MySQL 데이터베이스가 클래스 경로에 있지만 데이터베이스 연결을 구성하지 않은 경우 Spring Boot는 자동으로 메모리 내 데이터베이스를 구성합니다.
이를 위해 다음을 추가해야합니다. @EnableAutoConfiguration 주석 또는 @SpringBootApplication주 클래스 파일에 주석을 추가합니다. 그러면 Spring Boot 애플리케이션이 자동으로 구성됩니다.
더 나은 이해를 위해 다음 코드를 관찰하십시오.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@EnableAutoConfiguration
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}Spring Boot 애플리케이션
Spring Boot Application의 진입 점은 다음을 포함하는 클래스입니다. @SpringBootApplication주석. 이 클래스에는 Spring Boot 애플리케이션을 실행하기위한 주요 메소드가 있어야합니다.@SpringBootApplication 주석에는 자동 구성, 구성 요소 스캔 및 스프링 부트 구성이 포함됩니다.
추가 한 경우 @SpringBootApplication 주석을 클래스에 추가 할 필요가 없습니다. @EnableAutoConfiguration, @ComponentScan 과 @SpringBootConfiguration주석. 그만큼@SpringBootApplication 주석에는 다른 모든 주석이 포함됩니다.
더 나은 이해를 위해 다음 코드를 관찰하십시오.
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);
}
}구성 요소 스캔
Spring Boot 애플리케이션은 애플리케이션이 초기화 될 때 모든 빈과 패키지 선언을 스캔합니다. 추가해야합니다@ComponentScan 프로젝트에 추가 된 구성 요소를 스캔하기위한 클래스 파일의 주석.
더 나은 이해를 위해 다음 코드를 관찰하십시오.
import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}이 장에서는 Maven과 Gradle을 사용하여 Spring Boot 애플리케이션을 만드는 방법을 설명합니다.
전제 조건
Spring Boot 애플리케이션을 생성하려면 시스템에 다음과 같은 최소 요구 사항이 있어야합니다.
- 자바 7
- 메이븐 3.2
- Gradle 2.5
스프링 부트 CLI
Spring Boot CLI는 명령 줄 도구이며 Groovy 스크립트를 실행할 수 있습니다. 이것은 Spring Boot 명령 줄 인터페이스를 사용하여 Spring Boot 애플리케이션을 만드는 가장 쉬운 방법입니다. 명령 프롬프트 자체에서 애플리케이션을 생성, 실행 및 테스트 할 수 있습니다.
이 섹션에서는 Spring Boot CLI의 수동 설치와 관련된 단계를 설명합니다. 추가 도움이 필요하면 다음 링크를 사용할 수 있습니다.https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot
다음 위치의 Spring Software 저장소에서 Spring CLI 배포를 다운로드 할 수도 있습니다. https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation
수동 설치의 경우 다음 두 폴더를 사용해야합니다.
spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip
spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz
다운로드 후 아카이브 파일의 압축을 풀고 install.txt 파일에 제공된 단계를 따르십시오. 환경 설정이 필요하지 않습니다.
Windows에서 Spring Boot CLI로 이동합니다. bin 명령 프롬프트에 디렉토리를 입력하고 명령을 실행하십시오. spring –-version스프링 CLI가 올바르게 설치되었는지 확인하십시오. 명령을 실행하면 아래와 같이 spring CLI 버전을 볼 수 있습니다.
Groovy로 Hello World 실행
Rest Endpoint 스크립트를 포함하는 간단한 groovy 파일을 만들고 spring boot CLI로 groovy 파일을 실행하십시오. 이 목적을 위해 여기에 표시된 코드를 관찰하십시오.
@Controller
class Example {
@RequestMapping("/")
@ResponseBody
public String hello() {
"Hello Spring Boot"
}
}이제 그루비 파일을 이름으로 저장하십시오. hello.groovy. 이 예에서는 Spring Boot CLI 내에 groovy 파일을 저장했습니다.bin예배 규칙서. 이제 명령을 사용하여 응용 프로그램을 실행하십시오.spring run hello.groovy 아래 주어진 스크린 샷에서 볼 수 있듯이-
groovy 파일을 실행하면 필요한 종속성이 자동으로 다운로드되고 아래 스크린 샷과 같이 Tomcat 8080 포트에서 응용 프로그램이 시작됩니다.
Tomcat이 시작되면 웹 브라우저로 이동하여 URL을 누르십시오. http://localhost:8080/ 그림과 같이 출력을 볼 수 있습니다.
이 장에서는 Spring Boot 애플리케이션에서 부트 스트랩을 수행하는 방법을 설명합니다.
스프링 이니셜 라이저
Spring Boot 애플리케이션을 부트 스트랩하는 방법 중 하나는 Spring Initializer를 사용하는 것입니다. 이렇게하려면 Spring Initializer 웹 페이지 www.start.spring.io 를 방문 하여 빌드, Spring Boot 버전 및 플랫폼을 선택해야합니다. 또한 애플리케이션을 실행하려면 그룹, 아티팩트 및 필수 종속성을 제공해야합니다.
우리가 추가 한 예를 보여주는 다음 스크린 샷을 관찰하십시오. spring-boot-starter-web REST 끝점 작성에 대한 종속성.
그룹, 아티팩트, 종속성, 빌드 프로젝트, 플랫폼 및 버전을 제공했으면 Generate Project단추. zip 파일이 다운로드되고 파일이 추출됩니다.
이 섹션에서는 Maven과 Gradle을 모두 사용하여 예제를 설명합니다.
메이븐
프로젝트를 다운로드 한 후 파일의 압축을 풉니 다. 자, 당신의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/> <!-- 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>
</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.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')
}클래스 경로 종속성
Spring Boot는 Starters클래스 경로에 항아리를 추가합니다. 예를 들어 Rest Endpoint를 작성하려면 다음을 추가해야합니다.spring-boot-starter-web클래스 경로의 종속성. 더 나은 이해를 위해 아래 표시된 코드를 관찰하십시오.
Maven 종속성
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>Gradle 종속성
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
}주요 방법
주요 방법은 Spring Boot Application 클래스를 작성하는 것입니다. 이 클래스는 다음과 같이 주석을 달아야합니다.@SpringBootApplication. 시작할 스프링 부트 애플리케이션의 진입 점입니다. 아래에서 기본 클래스 파일을 찾을 수 있습니다.src/java/main 기본 패키지가있는 디렉토리.
이 예에서 기본 클래스 파일은 src/java/main 기본 패키지가있는 디렉토리 com.tutorialspoint.demo. 더 나은 이해를 위해 여기에 표시된 코드를 관찰하십시오.
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);
}
}나머지 끝점 작성
Spring Boot Application 메인 클래스 파일 자체에 간단한 Hello World Rest Endpoint를 작성하려면 다음 단계를 따르십시오.
먼저 @RestController 수업 상단의 주석.
이제 다음을 사용하여 Request URI 메서드를 작성합니다. @RequestMapping 주석.
그런 다음 요청 URI 메서드는 Hello World 끈.
이제 메인 Spring Boot Application 클래스 파일은 아래에 주어진 코드와 같이 보일 것입니다.
package com.tutorialspoint.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RequestMapping(value = "/")
public String hello() {
return "Hello World";
}
}실행 가능한 JAR 생성
아래와 같이 명령 프롬프트에서 Maven 및 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행하기위한 실행 가능한 JAR 파일을 생성 해 보겠습니다.
아래와 같이 Maven 명령 mvn clean install을 사용하십시오.
명령을 실행 한 후 BUILD SUCCESS 아래와 같이 명령 프롬프트에서 메시지-
Gradle 명령 사용 gradle clean build 아래와 같이-
명령을 실행 한 후 BUILD SUCCESSFUL 아래와 같이 명령 프롬프트에 메시지-
Java로 Hello World 실행
실행 가능한 JAR 파일을 생성하면 다음 디렉토리에서 찾을 수 있습니다.
Maven의 경우 아래와 같이 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래에서 JAR 파일을 찾을 수 있습니다. build/libs 아래에 표시된 디렉토리-
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오. java –jar <JARFILE>. 위의 예에서 JAR 파일의 이름이demo-0.0.1-SNAPSHOT.jar
jar 파일을 실행하면 아래와 같이 콘솔 창에서 출력을 볼 수 있습니다.
이제 콘솔을 보면 Tomcat이 포트 8080 (http)에서 시작되었습니다. 이제 웹 브라우저로 이동하여 URL을 누르십시오.http://localhost:8080/ 다음과 같이 출력을 볼 수 있습니다.
Spring Boot 애플리케이션을 사용하여 웹 서버에 배포 할 war 파일을 만들 수 있습니다. 이 장에서는 Tomcat 웹 서버에서 WAR 파일을 만들고 Spring Boot 애플리케이션을 배포하는 방법을 배우게됩니다.
스프링 부트 서블릿 이니셜 라이저
전통적인 배포 방법은 Spring Boot 애플리케이션을 만드는 것입니다. @SpringBootApplication 클래스 확장 SpringBootServletInitializer수업. Spring Boot Servlet Initializer 클래스 파일을 사용하면 Servlet Container를 사용하여 애플리케이션을 시작할 때 애플리케이션을 구성 할 수 있습니다.
JAR 파일 배포를위한 Spring Boot Application 클래스 파일의 코드는 다음과 같습니다.
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);
}
}클래스를 확장해야합니다. SpringBootServletInitializerWAR 파일 배포를 지원합니다. Spring Boot Application 클래스 파일의 코드는 다음과 같습니다.
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의 경우 패키지를 WAR로 추가합니다. pom.xml 아래와 같이-
<packaging>war</packaging>Gradle의 경우 애플리케이션 플러그인과 war 플러그인을 build.gradle 아래와 같이-
apply plugin: ‘war’
apply plugin: ‘application’이제“Hello World from Tomcat”문자열을 반환하는 간단한 Rest Endpoint를 작성하겠습니다. Rest Endpoint를 작성하려면 빌드 파일에 Spring Boot 웹 스타터 종속성을 추가해야합니다.
Maven의 경우 아래와 같이 코드를 사용하여 pom.xml에 Spring Boot 스타터 종속성을 추가하십시오.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Gradle의 경우 Spring Boot 스타터 종속성을 build.gradle 아래와 같이 코드를 사용하여-
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
}이제 아래와 같이 코드를 사용하여 Spring Boot Application 클래스 파일에 간단한 Rest Endpoint를 작성하십시오.
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 명령을 사용하여 Tomcat 서버에 배포 할 WAR 파일을 만듭니다.
Maven의 경우 다음 명령을 사용하십시오. mvn package애플리케이션 패키징. 그런 다음 WAR 파일이 생성되고 아래 스크린 샷과 같이 대상 디렉토리에서 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용하십시오. gradle clean build애플리케이션 패키징. 그런 다음 WAR 파일이 생성되고 아래에서 찾을 수 있습니다.build/libs예배 규칙서. 더 나은 이해를 위해 여기에 제공된 스크린 샷을 관찰하십시오.
Tomcat에 배포
이제 Tomcat 서버를 실행하고 아래에 WAR 파일을 배포합니다. webapps예배 규칙서. 더 나은 이해를 위해 여기에 표시된 스크린 샷을 참조하십시오.
성공적으로 배포 한 후 웹 브라우저에서 URL을 누르십시오. 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";
}
}Spring Boot에서 빌드 시스템을 선택하는 것은 중요한 작업입니다. Maven 또는 Gradle은 종속성 관리에 대한 좋은 지원을 제공하므로 권장합니다. Spring은 다른 빌드 시스템을 잘 지원하지 않습니다.
종속성 관리
Spring Boot 팀은 모든 릴리스에 대해 Spring Boot 버전을 지원하는 종속성 목록을 제공합니다. 빌드 구성 파일에서 종속성 버전을 제공 할 필요가 없습니다. Spring Boot는 릴리스에 따라 종속성 버전을 자동으로 구성합니다. Spring Boot 버전을 업그레이드하면 종속성도 자동으로 업그레이드됩니다.
Note− 종속성 버전을 지정하려면 구성 파일에서 지정할 수 있습니다. 그러나 Spring Boot 팀은 종속성 버전을 지정할 필요가 없다고 강력히 권장합니다.
Maven 종속성
Maven 구성의 경우 Spring Boot Starter 종속성을 관리하기 위해 Spring Boot Starter 상위 프로젝트를 상속해야합니다. 이를 위해 간단하게 시작 부모를 상속 할 수 있습니다.pom.xml 아래와 같이 파일.
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.8.RELEASE</version>
</parent>Spring Boot Parent Starter 종속성에 대한 버전 번호를 지정해야합니다. 그런 다음 다른 스타터 종속성의 경우 Spring Boot 버전 번호를 지정할 필요가 없습니다. 아래 주어진 코드를 관찰하십시오-
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>Gradle 종속성
Spring Boot Starters 종속성을 직접 가져올 수 있습니다. build.gradle파일. Maven for Gradle과 같은 Spring Boot start Parent 종속성이 필요하지 않습니다. 아래 주어진 코드를 관찰하십시오-
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')
}Spring Boot에는 작업 할 코드 레이아웃이 없습니다. 그러나 우리에게 도움이 될 몇 가지 모범 사례가 있습니다. 이 장에서는 이에 대해 자세히 설명합니다.
기본 패키지
패키지 선언이없는 클래스는 default package. 일반적으로 기본 패키지 선언은 권장되지 않습니다. Spring Boot는 기본 패키지를 사용할 때 Auto Configuration 또는 Component Scan의 오작동과 같은 문제를 유발합니다.
Note− 패키지 선언에 대한 Java의 권장 명명 규칙은 역 도메인 이름입니다. 예를 들면-com.tutorialspoint.myproject
일반적인 레이아웃
Spring Boot 애플리케이션의 일반적인 레이아웃은 아래 이미지에 나와 있습니다.
Application.java 파일은 @SpringBootApplication과 함께 기본 메소드를 선언해야합니다. 더 나은 이해를 위해 아래 주어진 코드를 관찰하십시오-
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);}
}Spring Boot에서는 Spring Framework를 사용하여 Bean과 종속성 주입을 정의 할 수 있습니다. 그만큼@ComponentScan 주석은 빈을 찾는 데 사용되며 해당하는 @Autowired 주석.
Spring Boot 일반 레이아웃을 따랐다면 인수를 지정할 필요가 없습니다. @ComponentScan주석. 모든 컴포넌트 클래스 파일은 Spring Beans에 자동으로 등록됩니다.
다음 예제는 Rest Template 객체를 자동으로 연결하고 동일한 Bean을 만드는 방법에 대한 아이디어를 제공합니다.
@Bean
public RestTemplate getRestTemplate() {
return new RestTemplate();
}다음 코드는 메인 Spring Boot Application 클래스 파일에서 자동 유선 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();
}
}Application Runner 및 Command Line Runner 인터페이스를 사용하면 Spring Boot 애플리케이션이 시작된 후 코드를 실행할 수 있습니다. 이러한 인터페이스를 사용하여 응용 프로그램이 시작된 직후 모든 작업을 수행 할 수 있습니다. 이 장에서는 이에 대해 자세히 설명합니다.
애플리케이션 러너
Application Runner는 Spring Boot 애플리케이션이 시작된 후 코드를 실행하는 데 사용되는 인터페이스입니다. 아래의 예제는 메인 클래스 파일에서 Application Runner 인터페이스를 구현하는 방법을 보여줍니다.
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");
}
}이제 아래 콘솔 창을 보면 Hello World from Application Runner, println 문은 Tomcat이 시작된 후 실행됩니다. 다음 스크린 샷이 관련이 있습니까?
커맨드 라인 러너
Command Line Runner는 인터페이스입니다. Spring Boot 애플리케이션이 시작된 후 코드를 실행하는 데 사용됩니다. 아래의 예제는 메인 클래스 파일에서 Command Line 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");
}
}“Hello world from Command Line Runner”아래의 콘솔 창을보십시오. Tomcat이 시작된 후 println 문이 실행됩니다.
응용 프로그램 속성은 다른 환경에서 작업 할 수 있도록 지원합니다. 이 장에서는 Spring Boot 애플리케이션에 속성을 구성하고 지정하는 방법을 배우게됩니다.
명령 줄 속성
Spring Boot 애플리케이션은 명령 줄 속성을 Spring Boot Environment 속성으로 변환합니다. 명령 줄 속성은 다른 속성 소스보다 우선합니다. 기본적으로 Spring Boot는 8080 포트 번호를 사용하여 Tomcat을 시작합니다. 명령 줄 속성을 사용하여 포트 번호를 변경하는 방법을 알아 보겠습니다.
Step 1 − 실행 가능한 JAR 파일을 생성 한 후 다음 명령을 사용하여 실행합니다. java –jar <JARFILE>.
Step 2 − 명령 줄 속성을 사용하여 Spring Boot 애플리케이션의 포트 번호를 변경하려면 아래 스크린 샷에 제공된 명령을 사용합니다.
Note − 구분 기호 −를 사용하여 하나 이상의 응용 프로그램 속성을 제공 할 수 있습니다.
속성 파일
속성 파일은 단일 파일에 'N'개의 속성을 유지하여 다른 환경에서 응용 프로그램을 실행하는 데 사용됩니다. Spring Boot에서 속성은application.properties 클래스 경로 아래의 파일.
application.properties 파일은 src/main/resources예배 규칙서. 샘플 코드application.properties 파일은 다음과 같습니다-
server.port = 9090
spring.application.name = demoservice위에 표시된 코드에서 Spring Boot 애플리케이션 데모 서비스는 포트 9090에서 시작됩니다.
YAML 파일
Spring Boot는 애플리케이션을 실행하기 위해 YAML 기반 속성 구성을 지원합니다. 대신에application.properties, 우리는 사용할 수 있습니다 application.yml파일. 이 YAML 파일도 클래스 경로 내에 보관되어야합니다. 샘플application.yml 파일은 다음과 같습니다-
spring:
application:
name: demoservice
server:
port: 9090외부화 된 속성
클래스 경로 아래에 속성 파일을 유지하는 대신 속성을 다른 위치 또는 경로에 유지할 수 있습니다. JAR 파일을 실행하는 동안 속성 파일 경로를 지정할 수 있습니다. 다음 명령을 사용하여 JAR을 실행하는 동안 속성 파일의 위치를 지정할 수 있습니다.
-Dspring.config.location = C:\application.properties
@Value 주석 사용
@Value 주석은 Java 코드에서 환경 또는 애플리케이션 특성 값을 읽는 데 사용됩니다. 속성 값을 읽는 구문은 다음과 같습니다.
@Value("${property_key_name}")읽기 구문을 보여주는 다음 예제를보십시오. spring.application.name @Value 주석을 사용하여 Java 변수의 속성 값.
@Value("${spring.application.name}")더 나은 이해를 위해 아래 주어진 코드를 관찰하십시오-
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class DemoApplication {
@Value("${spring.application.name}")
private String name;
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RequestMapping(value = "/")
public String name() {
return name;
}
}Note − 애플리케이션을 실행하는 동안 속성이 발견되지 않으면 Spring Boot는 다음과 같이 Illegal Argument 예외를 발생시킵니다. Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".
자리 표시 자 문제를 해결하기 위해 아래에 주어진 thr 구문을 사용하여 속성의 기본값을 설정할 수 있습니다.
@Value("${property_key_name:default_value}")
@Value("${spring.application.name:demoservice}")스프링 부트 액티브 프로필
Spring Boot는 Spring 활성 프로필을 기반으로 다른 속성을 지원합니다. 예를 들어 Spring Boot 애플리케이션을 실행하기 위해 개발 및 프로덕션 용으로 두 개의 개별 파일을 유지할 수 있습니다.
application.properties의 스프링 활성 프로필
application.properties에서 Spring 활성 프로파일을 갖는 방법을 이해합시다. 기본적으로 application. 속성은 Spring Boot 애플리케이션을 실행하는 데 사용됩니다. 프로필 기반 속성을 사용하려면 아래와 같이 각 프로필에 대해 별도의 속성 파일을 보관할 수 있습니다.
application.properties
server.port = 8080
spring.application.name = demoserviceapplication-dev.properties
server.port = 9090
spring.application.name = demoserviceapplication-prod.properties
server.port = 4431
spring.application.name = demoserviceJAR 파일을 실행하는 동안 각 속성 파일을 기반으로 스프링 활성 프로필을 지정해야합니다. 기본적으로 Spring Boot 애플리케이션은 application.properties 파일을 사용합니다. 스프링 활성 프로파일을 설정하는 명령은 다음과 같습니다.
아래와 같이 콘솔 로그에서 활성 프로필 이름을 볼 수 있습니다.
2017-11-26 08:13:16.322 INFO 14028 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: dev이제 Tomcat은 아래와 같이 포트 9090 (http)에서 시작되었습니다.
2017-11-26 08:13:20.185 INFO 14028 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 9090 (http)다음과 같이 프로덕션 활성 프로필을 설정할 수 있습니다.
아래와 같이 콘솔 로그에서 활성 프로필 이름을 볼 수 있습니다.
2017-11-26 08:13:16.322 INFO 14028 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: prod이제 Tomcat은 아래와 같이 포트 4431 (http)에서 시작되었습니다.
2017-11-26 08:13:20.185 INFO 14028 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 4431 (http)application.yml에 대한 Spring 활성 프로파일
application.yml에 대한 Spring 활성 프로파일을 유지하는 방법을 이해합시다. Spring 활성 프로필 속성을 단일application.yml파일. application.properties와 같은 별도의 파일을 사용할 필요가 없습니다.
다음은 application.yml 파일에서 Spring 활성 프로파일을 유지하는 예제 코드입니다. 구분 기호 (---)는 application.yml 파일에서 각 프로필을 구분하는 데 사용됩니다.
spring:
application:
name: demoservice
server:
port: 8080
---
spring:
profiles: dev
application:
name: demoservice
server:
port: 9090
---
spring:
profiles: prod
application:
name: demoservice
server:
port: 4431개발 활성 프로필을 설정하는 명령은 다음과 같습니다.
아래와 같이 콘솔 로그에서 활성 프로필 이름을 볼 수 있습니다.
2017-11-26 08:41:37.202 INFO 14104 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: dev이제 Tomcat은 아래와 같이 포트 9090 (http)에서 시작되었습니다.
2017-11-26 08:41:46.650 INFO 14104 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 9090 (http)생산 활성 프로필을 설정하는 명령은 다음과 같습니다.
아래와 같이 콘솔 로그에서 활성 프로필 이름을 볼 수 있습니다.
2017-11-26 08:43:10.743 INFO 13400 --- [
main] com.tutorialspoint.demo.DemoApplication :
The following profiles are active: prod그러면 아래와 같이 포트 4431 (http)에서 Tomcat이 시작됩니다.
2017-11-26 08:43:14.473 INFO 13400 --- [
main] s.b.c.e.t.TomcatEmbeddedServletContainer :
Tomcat started on port(s): 4431 (http)Spring Boot는 모든 내부 로깅에 Apache Commons 로깅을 사용합니다. Spring Boot의 기본 구성은 Java Util Logging, Log4j2 및 Logback 사용을 지원합니다. 이를 사용하여 콘솔 로깅과 파일 로깅을 구성 할 수 있습니다.
Spring Boot Starters를 사용하는 경우 Logback은 로깅에 대한 좋은 지원을 제공합니다. 또한 Logback은 Common Logging, Util Logging, Log4J 및 SLF4J에 대한 좋은 지원을 제공합니다.
로그 형식
기본 Spring Boot Log 형식은 아래 스크린 샷에 나와 있습니다.
다음 정보를 제공합니다.
Date 과 Time 로그의 날짜와 시간을 제공합니다.
Log level INFO, ERROR 또는 WARN 표시
Process ID
구분 기호 인 ---
Thread name 대괄호 []로 묶여 있습니다.
Logger Name 소스 클래스 이름을 표시합니다.
로그 메시지
콘솔 로그 출력
기본 로그 메시지가 콘솔 창에 인쇄됩니다. 기본적으로 "INFO", "ERROR"및 "WARN"로그 메시지는 로그 파일에 인쇄됩니다.
디버그 수준 로그를 활성화해야하는 경우 아래 표시된 명령을 사용하여 응용 프로그램을 시작할 때 디버그 플래그를 추가합니다.
java –jar demo.jar --debug여기에 표시된대로 application.properties 파일에 디버그 모드를 추가 할 수도 있습니다.
debug = true파일 로그 출력
기본적으로 모든 로그는 파일이 아닌 콘솔 창에 인쇄됩니다. 로그를 파일로 인쇄하려면 속성을 설정해야합니다.logging.file 또는 logging.path application.properties 파일에서.
아래에 표시된 속성을 사용하여 로그 파일 경로를 지정할 수 있습니다. 로그 파일 이름은 spring.log입니다.
logging.path = /var/tmp/아래에 표시된 속성을 사용하여 자신의 로그 파일 이름을 지정할 수 있습니다.
logging.file = /var/tmp/mylog.logNote − 파일 크기가 10MB에 도달하면 자동으로 회전합니다.
로그 수준
Spring Boot는 "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF"와 같은 모든 로거 레벨을 지원합니다. 아래와 같이 application.properties 파일에서 루트 로거를 정의 할 수 있습니다.
logging.level.root = WARNNote− Logback은 "FATAL"수준의 로그를 지원하지 않습니다. "ERROR"수준 로그에 매핑됩니다.
Logback 구성
Logback은 Spring Boot Log 구성을 처리하기 위해 XML 기반 구성을 지원합니다. 로깅 구성 세부 정보는logback.xml파일. logback.xml 파일은 클래스 경로 아래에 있어야합니다.
아래에 주어진 코드를 사용하여 Logback.xml 파일에서 ROOT 레벨 로그를 구성 할 수 있습니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
<root level = "INFO">
</root>
</configuration>아래 제공된 Logback.xml 파일에서 콘솔 어 펜더를 구성 할 수 있습니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
<appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender"></appender>
<root level = "INFO">
<appender-ref ref = "STDOUT"/>
</root>
</configuration>아래의 코드를 사용하여 Logback.xml 파일에서 파일 어 펜더를 구성 할 수 있습니다. 파일 어 펜더 내부의 로그 파일 경로를 지정해야합니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
<appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
<File>/var/tmp/mylog.log</File>
</appender>
<root level = "INFO">
<appender-ref ref = "FILE"/>
</root>
</configuration>다음에서 로그 패턴을 정의 할 수 있습니다. logback.xml아래 주어진 코드를 사용하여 파일. 아래 주어진 코드를 사용하여 콘솔 또는 파일 로그 어 펜더 내부에서 지원되는 로그 패턴 세트를 정의 할 수도 있습니다.
<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>완전한 logback.xml 파일의 코드는 다음과 같습니다. 이것을 클래스 경로에 배치해야합니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
<appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
</encoder>
</appender>
<appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
<File>/var/tmp/mylog.log</File>
<encoder>
<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
</encoder>
</appender>
<root level = "INFO">
<appender-ref ref = "FILE"/>
<appender-ref ref = "STDOUT"/>
</root>
</configuration>아래 코드는 Spring Boot 메인 클래스 파일에 slf4j 로거를 추가하는 방법을 보여줍니다.
package com.tutorialspoint.demo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
public static void main(String[] args) {
logger.info("this is a info message");
logger.warn("this is a warn message");
logger.error("this is a error message");
SpringApplication.run(DemoApplication.class, args);
}
}콘솔 창에서 볼 수있는 출력은 다음과 같습니다.
로그 파일에서 볼 수있는 출력은 다음과 같습니다.
Spring Boot는 엔터프라이즈 애플리케이션을위한 RESTful 웹 서비스 구축을 매우 잘 지원합니다. 이 장에서는 Spring Boot를 사용하여 RESTful 웹 서비스를 구축하는 방법에 대해 자세히 설명합니다.
Note − RESTful 웹 서비스를 구축하려면 빌드 구성 파일에 Spring Boot Starter 웹 종속성을 추가해야합니다.
Maven 사용자 인 경우 다음 코드를 사용하여 아래 종속성을 pom.xml 파일-
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Gradle 사용자 인 경우 다음 코드를 사용하여 아래 종속성을 build.gradle 파일.
compile('org.springframework.boot:spring-boot-starter-web')전체 빌드 구성 파일의 코드 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')
}RESTful 웹 서비스를 구축하기 전에 다음 주석에 대한 지식이있는 것이 좋습니다.
나머지 컨트롤러
@RestController 어노테이션은 RESTful 웹 서비스를 정의하는 데 사용됩니다. JSON, XML 및 사용자 지정 응답을 제공합니다. 구문은 다음과 같습니다.
@RestController
public class ProductServiceController {
}매핑 요청
@RequestMapping 주석은 REST 엔드 포인트에 액세스하기위한 요청 URI를 정의하는 데 사용됩니다. 객체를 소비하고 생성하는 Request 메소드를 정의 할 수 있습니다. 기본 요청 방법은 GET입니다.
@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }요청 본문
@RequestBody 어노테이션은 요청 본문 컨텐츠 유형을 정의하는 데 사용됩니다.
public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}경로 변수
@PathVariable 주석은 사용자 지정 또는 동적 요청 URI를 정의하는 데 사용됩니다. 요청 URI의 Path 변수는 아래와 같이 중괄호 {}로 정의됩니다.
public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}요청 매개 변수
@RequestParam 주석은 요청 URL에서 요청 매개 변수를 읽는 데 사용됩니다. 기본적으로 필수 매개 변수입니다. 여기에 표시된대로 요청 매개 변수에 대한 기본값을 설정할 수도 있습니다.
public ResponseEntity<Object> getProduct(
@RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}GET API
기본 HTTP 요청 방법은 GET입니다. 이 방법에는 요청 본문이 필요하지 않습니다. 요청 매개 변수 및 경로 변수를 보내 사용자 지정 또는 동적 URL을 정의 할 수 있습니다.
HTTP GET 요청 메소드를 정의하는 샘플 코드는 다음과 같습니다. 이 예에서는 HashMap을 사용하여 제품을 저장했습니다. 저장할 제품으로 POJO 클래스를 사용했습니다.
여기서 요청 URI는 /productsHashMap 저장소에서 제품 목록을 반환합니다. GET 메소드 REST Endpoint를 포함하는 컨트롤러 클래스 파일은 아래에 제공됩니다.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.model.Product;
@RestController
public class ProductServiceController {
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);
}
@RequestMapping(value = "/products")
public ResponseEntity<Object> getProduct() {
return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
}
}POST API
HTTP POST 요청은 리소스를 만드는 데 사용됩니다. 이 메소드는 요청 본문을 포함합니다. 요청 매개 변수와 경로 변수를 보내 사용자 지정 또는 동적 URL을 정의 할 수 있습니다.
다음 예제는 HTTP POST 요청 메소드를 정의하는 샘플 코드를 보여줍니다. 이 예에서는 HashMap을 사용하여 제품을 저장했습니다. 여기서 제품은 POJO 클래스입니다.
여기서 요청 URI는 /products, 제품을 HashMap 저장소에 저장 한 후 문자열을 반환합니다.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
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;
@RestController
public class ProductServiceController {
private static Map<String, Product> productRepo = new HashMap<>();
@RequestMapping(value = "/products", method = RequestMethod.POST)
public ResponseEntity<Object> createProduct(@RequestBody Product product) {
productRepo.put(product.getId(), product);
return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
}
}PUT API
HTTP PUT 요청은 기존 리소스를 업데이트하는 데 사용됩니다. 이 메소드는 요청 본문을 포함합니다. 요청 매개 변수와 경로 변수를 보내 사용자 지정 또는 동적 URL을 정의 할 수 있습니다.
아래의 예제는 HTTP PUT 요청 방법을 정의하는 방법을 보여줍니다. 이 예에서는 HashMap을 사용하여 제품이 POJO 클래스 인 기존 제품을 업데이트했습니다.
여기서 요청 URI는 /products/{id}제품 뒤에있는 문자열을 HashMap 저장소로 반환합니다. Path 변수를 사용했습니다.{id} 업데이트해야하는 제품 ID를 정의합니다.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
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;
@RestController
public class ProductServiceController {
private static Map<String, Product> productRepo = new HashMap<>();
@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
productRepo.remove(id);
product.setId(id);
productRepo.put(id, product);
return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
}
}API 삭제
HTTP 삭제 요청은 기존 리소스를 삭제하는 데 사용됩니다. 이 메소드에는 요청 본문이 없습니다. 요청 매개 변수와 경로 변수를 보내 사용자 지정 또는 동적 URL을 정의 할 수 있습니다.
아래의 예제는 HTTP DELETE 요청 메소드를 정의하는 방법을 보여줍니다. 이 예에서는 HashMap을 사용하여 POJO 클래스 인 기존 제품을 제거했습니다.
요청 URI는 /products/{id}HashMap 저장소에서 제품을 삭제 한 후 문자열을 반환합니다. Path 변수를 사용했습니다.{id} 삭제해야하는 제품 ID를 정의합니다.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
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;
@RestController
public class ProductServiceController {
private static Map<String, Product> productRepo = new HashMap<>();
@RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
public ResponseEntity<Object> delete(@PathVariable("id") String id) {
productRepo.remove(id);
return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
}
}이 섹션에서는 완전한 소스 코드 세트를 제공합니다. 각각의 기능에 대해 다음 코드를 준수하십시오.
The Spring Boot main application class – DemoApplication.java
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);
}
}The 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;
}
}The Rest Controller class – ProductServiceController.java
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
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;
@RestController
public class ProductServiceController {
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);
}
@RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
public ResponseEntity<Object> delete(@PathVariable("id") String id) {
productRepo.remove(id);
return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
}
@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
productRepo.remove(id);
product.setId(id);
productRepo.put(id, product);
return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
}
@RequestMapping(value = "/products", method = RequestMethod.POST)
public ResponseEntity<Object> createProduct(@RequestBody Product product) {
productRepo.put(product.getId(), product);
return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
}
@RequestMapping(value = "/products")
public ResponseEntity<Object> getProduct() {
return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
}
}실행 가능한 JAR 파일을 생성하고 아래와 같이 Maven 또는 Gradle 명령을 사용하여 스프링 부트 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 표시된 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 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
API에서 예외 및 오류를 처리하고 클라이언트에 적절한 응답을 보내는 것은 엔터프라이즈 애플리케이션에 좋습니다. 이 장에서는 Spring Boot에서 예외를 처리하는 방법을 배웁니다.
예외 처리를 진행하기 전에 다음 주석에 대해 이해해 보겠습니다.
컨트롤러 조언
@ControllerAdvice는 예외를 전역 적으로 처리하기위한 주석입니다.
예외 처리기
@ExceptionHandler는 특정 예외를 처리하고 사용자 지정 응답을 클라이언트에 보내는 데 사용되는 주석입니다.
다음 코드를 사용하여 @ControllerAdvice 클래스를 생성하여 예외를 전역 적으로 처리 할 수 있습니다.
package com.tutorialspoint.demo.exception;
import org.springframework.web.bind.annotation.ControllerAdvice;
@ControllerAdvice
public class ProductExceptionController {
}RuntimeException 클래스를 확장하는 클래스를 정의하십시오.
package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
private static final long serialVersionUID = 1L;
}표시된대로 예외를 처리하도록 @ExceptionHandler 메서드를 정의 할 수 있습니다. 이 메서드는 Controller Advice 클래스 파일을 작성하는 데 사용해야합니다.
@ExceptionHandler(value = ProductNotfoundException.class)
public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}이제 아래 제공된 코드를 사용하여 API에서 예외를 발생시킵니다.
@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() {
throw new ProductNotfoundException();
}예외를 처리하는 전체 코드는 다음과 같습니다. 이 예에서는 PUT API를 사용하여 제품을 업데이트했습니다. 여기에서 제품을 업데이트하는 동안 제품을 찾을 수없는 경우 "제품을 찾을 수 없음"으로 응답 오류 메시지를 반환합니다. 참고ProductNotFoundException 예외 클래스는 RuntimeException.
package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
private static final long serialVersionUID = 1L;
}예외를 전역 적으로 처리하기위한 Controller Advice 클래스는 다음과 같습니다. 이 클래스 파일에서 모든 Exception Handler 메서드를 정의 할 수 있습니다.
package com.tutorialspoint.demo.exception;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
@ControllerAdvice
public class ProductExceptionController {
@ExceptionHandler(value = ProductNotfoundException.class)
public ResponseEntity<Object> exception(ProductNotfoundException exception) {
return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
}
}제품을 업데이트하기 위해 제품 서비스 API 컨트롤러 파일이 아래에 제공됩니다. 제품을 찾을 수없는 경우ProductNotFoundException 수업.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
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.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;
@RestController
public class ProductServiceController {
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);
}
@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
if(!productRepo.containsKey(id))throw new ProductNotfoundException();
productRepo.remove(id);
product.setId(id);
productRepo.put(id, product);
return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
}
}주요 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);
}
}코드 POJO class 제품은 다음과 같습니다-
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;
}
}코드 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')
}실행 가능한 JAR 파일을 만들고 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
다음 명령을 사용하여 JAR 파일을 실행할 수 있습니다.
java –jar <JARFILE>그러면 아래와 같이 Tomcat 포트 8080에서 응용 프로그램이 시작됩니다.
이제 POSTMAN 응용 프로그램에서 아래 URL을 누르면 아래와 같이 출력을 볼 수 있습니다.
업데이트 URL : http : // localhost : 8080 / products / 3
Spring Boot에서 Interceptor를 사용하여 다음 상황에서 작업을 수행 할 수 있습니다.
컨트롤러에 요청을 보내기 전에
클라이언트에 응답을 보내기 전에
예를 들어, 컨트롤러에 요청을 보내기 전에 인터셉터를 사용하여 요청 헤더를 추가하고 클라이언트에 응답을 보내기 전에 응답 헤더를 추가 할 수 있습니다.
인터셉터로 작업하려면 @Component 지원하는 클래스이며 HandlerInterceptor 상호 작용.
다음은 인터셉터에서 작업하는 동안 알아야 할 세 가지 방법입니다.
preHandle()방법-이것은 컨트롤러에 요청을 보내기 전에 작업을 수행하는 데 사용됩니다. 이 메서드는 클라이언트에 응답을 반환하려면 true를 반환해야합니다.
postHandle() 방법-이것은 클라이언트에 응답을 보내기 전에 작업을 수행하는 데 사용됩니다.
afterCompletion() 방법-요청 및 응답을 완료 한 후 작업을 수행하는 데 사용됩니다.
더 나은 이해를 위해 다음 코드를 관찰하십시오.
@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(
HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
@Override
public void postHandle(
HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception exception) throws Exception {}
}이 인터셉터를 다음과 같이 등록해야합니다. InterceptorRegistry 사용하여 WebMvcConfigurerAdapter 아래와 같이-
@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
@Autowired
ProductServiceInterceptor productServiceInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(productServiceInterceptor);
}
}아래 주어진 예에서, 우리는 아래에 주어진 출력을 제공하는 GET 제품 API를 칠 것입니다.
인터셉터 클래스 ProductServiceInterceptor.java의 코드는 다음과 같습니다.
package com.tutorialspoint.demo.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle
(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.out.println("Pre Handle method is Calling");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("Post Handle method is Calling");
}
@Override
public void afterCompletion
(HttpServletRequest request, HttpServletResponse response, Object
handler, Exception exception) throws Exception {
System.out.println("Request and Response is completed");
}
}인터셉터를 인터셉터 레지스트리에 등록하기위한 애플리케이션 구성 클래스 파일의 코드 – ProductServiceInterceptorAppConfig.java는 다음과 같습니다.
package com.tutorialspoint.demo.interceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
@Autowired
ProductServiceInterceptor productServiceInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(productServiceInterceptor);
}
}컨트롤러 클래스 파일 ProductServiceController.java의 코드는 다음과 같습니다.
package com.tutorialspoint.demo.controller;
import java.util.HashMap;
import java.util.Map;
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.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;
@RestController
public class ProductServiceController {
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);
}
@RequestMapping(value = "/products")
public ResponseEntity<Object> getProduct() {
return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
}
}Product.java에 대한 POJO 클래스의 코드는 다음과 같습니다.
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 애플리케이션 클래스 파일의 코드 DemoApplication.java 아래에 주어진다-
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>
</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')
testCompile('org.springframework.boot:spring-boot-starter-test')
}아래 Maven 또는 Gradle 명령어를 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래와 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
다음 명령을 사용하여 JAR 파일을 실행할 수 있습니다.
java –jar <JARFILE>이제 응용 프로그램은 아래와 같이 Tomcat 포트 8080에서 시작되었습니다.
이제 POSTMAN 응용 프로그램에서 아래 URL을 누르면 아래와 같이 출력을 볼 수 있습니다.
GET API : http://localhost:8080/products
콘솔 창에서 아래 스크린 샷과 같이 인터셉터에 추가 된 System.out.println 문을 볼 수 있습니다.
필터는 애플리케이션의 HTTP 요청 및 응답을 가로채는 데 사용되는 개체입니다. 필터를 사용하여 두 인스턴스에서 두 가지 작업을 수행 할 수 있습니다.
- 컨트롤러에 요청을 보내기 전에
- 클라이언트에 응답을 보내기 전에.
다음 코드는 @Component 어노테이션이있는 서블릿 필터 구현 클래스의 샘플 코드를 보여줍니다.
@Component
public class SimpleFilter implements Filter {
@Override
public void destroy() {}
@Override
public void doFilter
(ServletRequest request, ServletResponse response, FilterChain filterchain)
throws IOException, ServletException {}
@Override
public void init(FilterConfig filterconfig) throws ServletException {}
}다음 예제는 컨트롤러에 요청을 보내기 전에 ServletRequest 객체에서 원격 호스트 및 원격 주소를 읽는 코드를 보여줍니다.
doFilter () 메서드에서 원격 호스트 및 원격 주소를 인쇄하기 위해 System.out.println 문을 추가했습니다.
package com.tutorialspoint.demo;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.springframework.stereotype.Component;
@Component
public class SimpleFilter implements Filter {
@Override
public void destroy() {}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain)
throws IOException, ServletException {
System.out.println("Remote Host:"+request.getRemoteHost());
System.out.println("Remote Address:"+request.getRemoteAddr());
filterchain.doFilter(request, response);
}
@Override
public void init(FilterConfig filterconfig) throws ServletException {}
}Spring Boot 메인 애플리케이션 클래스 파일에서 "Hello World"문자열을 반환하는 간단한 REST 엔드 포인트를 추가했습니다.
package com.tutorialspoint.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RequestMapping(value = "/")
public String hello() {
return "Hello World";
}
}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>
</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')
testCompile('org.springframework.boot:spring-boot-starter-test')
}실행 가능한 JAR 파일을 만들고 아래 표시된 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean installBUILD SUCCESS 후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래와 같이 명령을 사용하십시오.
gradle clean buildBUILD SUCCESSFUL 후 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>응용 프로그램이 Tomcat 포트 8080에서 시작되었음을 알 수 있습니다.
이제 URL을 누르십시오. http://localhost:8080/출력 Hello World를 봅니다. 아래와 같이 보일 것입니다-
그러면 아래와 같이 콘솔 로그에서 원격 호스트와 원격 주소를 볼 수 있습니다.
Spring Boot를 사용하면 다른 포트 번호에서 동일한 애플리케이션을 두 번 이상 실행할 수 있습니다. 이 장에서는 이에 대해 자세히 알아 봅니다. 기본 포트 번호는 8080입니다.
커스텀 포트
에서 application.properties 파일에서 server.port 속성에 대한 사용자 지정 포트 번호를 설정할 수 있습니다.
server.port = 9090에서 application.yml 파일, 다음과 같이 찾을 수 있습니다-
server:
port: 9090랜덤 포트
에서 application.properties 파일에서 server.port 속성에 대해 임의의 포트 번호를 설정할 수 있습니다.
server.port = 0에서 application.yml 파일, 다음과 같이 찾을 수 있습니다-
server:
port: 0Note − 만약 server.port Spring Boot 애플리케이션을 시작하는 동안 번호는 0이고 Tomcat은 임의의 포트 번호를 사용합니다.
Rest Template은 RESTful 웹 서비스를 사용하는 애플리케이션을 만드는 데 사용됩니다. 사용할 수 있습니다exchange()모든 HTTP 메서드에 대해 웹 서비스를 사용하는 메서드입니다. 아래의 코드는 Rest Template 객체를 자동 연결하기 위해 Bean for Rest Template을 생성하는 방법을 보여줍니다.
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.client.RestTemplate;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Bean
public RestTemplate getRestTemplate() {
return new RestTemplate();
}
}가져 오기
Consuming the GET API by using RestTemplate - exchange() method
이 URL 가정 http://localhost:8080/products 다음 JSON을 반환하고 다음 코드를 사용하여 Rest Template을 사용하여이 API 응답을 사용합니다.
[
{
"id": "1",
"name": "Honey"
},
{
"id": "2",
"name": "Almond"
}
]API를 사용하려면 주어진 포인트를 따라야합니다.
- 나머지 템플릿 개체를 자동 연결했습니다.
- HttpHeaders를 사용하여 요청 헤더를 설정합니다.
- HttpEntity를 사용하여 요청 개체를 래핑합니다.
- Exchange () 메서드에 대한 URL, HttpMethod 및 반환 유형을 제공합니다.
@RestController
public class ConsumeWebService {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/template/products")
public String getProductList() {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity <String> entity = new HttpEntity<String>(headers);
return restTemplate.exchange("
http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
}
}우편
Consuming POST API by using RestTemplate - exchange() method
이 URL 가정 http://localhost:8080/products 아래 표시된 응답을 반환하면 나머지 템플릿을 사용하여이 API 응답을 사용합니다.
아래에 주어진 코드는 요청 본문입니다-
{
"id":"3",
"name":"Ginger"
}아래에 주어진 코드는 응답 본문입니다.
Product is created successfullyAPI를 사용하려면 아래에 주어진 사항을 따라야합니다.
나머지 템플릿 개체를 자동 연결했습니다.
HttpHeaders를 사용하여 요청 헤더를 설정합니다.
HttpEntity를 사용하여 요청 개체를 래핑합니다. 여기서는 Product 객체를 래핑하여 요청 본문으로 보냅니다.
exchange () 메서드에 대한 URL, HttpMethod 및 반환 유형을 제공합니다.
@RestController
public class ConsumeWebService {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/template/products", method = RequestMethod.POST)
public String createProducts(@RequestBody Product product) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
return restTemplate.exchange(
"http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
}
}놓다
Consuming PUT API by using RestTemplate - exchange() method
이 URL 가정 http://localhost:8080/products/3 아래 응답을 반환하고 나머지 템플릿을 사용하여이 API 응답을 사용할 것입니다.
아래에 주어진 코드는 요청 본문입니다-
{
"name":"Indian Ginger"
}아래에 주어진 코드는 응답 본문입니다.
Product is updated successfullyAPI를 사용하려면 아래에 주어진 사항을 따라야합니다.
나머지 템플릿 개체를 자동 연결했습니다.
HttpHeaders를 사용하여 요청 헤더를 설정합니다.
HttpEntity를 사용하여 요청 개체를 래핑합니다. 여기서는 Product 객체를 래핑하여 요청 본문으로 보냅니다.
exchange () 메서드에 대한 URL, HttpMethod 및 반환 유형을 제공합니다.
@RestController
public class ConsumeWebService {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
return restTemplate.exchange(
"http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
}
}지우다
Consuming DELETE API by using RestTemplate - exchange() method
이 URL 가정 http://localhost:8080/products/3 아래에 주어진 응답을 반환하고 나머지 템플릿을 사용하여이 API 응답을 사용할 것입니다.
아래에 표시된 코드 줄은 응답 본문입니다.
Product is deleted successfullyAPI를 사용하려면 아래 표시된 사항을 따라야합니다.
나머지 템플릿 개체를 자동 연결했습니다.
HttpHeaders를 사용하여 요청 헤더를 설정합니다.
HttpEntity를 사용하여 요청 개체를 래핑합니다.
exchange () 메서드에 대한 URL, HttpMethod 및 반환 유형을 제공합니다.
@RestController
public class ConsumeWebService {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
public String deleteProduct(@PathVariable("id") String id) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(headers);
return restTemplate.exchange(
"http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
}
}완전한 Rest Template Controller 클래스 파일은 다음과 같습니다.
package com.tutorialspoint.demo.controller;
import java.util.Arrays;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
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 org.springframework.web.client.RestTemplate;
import com.tutorialspoint.demo.model.Product;
@RestController
public class ConsumeWebService {
@Autowired
RestTemplate restTemplate;
@RequestMapping(value = "/template/products")
public String getProductList() {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<String> entity = new HttpEntity<String>(headers);
return restTemplate.exchange(
"http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
}
@RequestMapping(value = "/template/products", method = RequestMethod.POST)
public String createProducts(@RequestBody Product product) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
return restTemplate.exchange(
"http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
}
@RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
return restTemplate.exchange(
"http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
}
@RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
public String deleteProduct(@PathVariable("id") String id) {
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<Product> entity = new HttpEntity<Product>(headers);
return restTemplate.exchange(
"http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
}
}Spring Boot Application Class – DemoApplication.java의 코드는 다음과 같습니다.
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>
</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')
testCompile('org.springframework.boot:spring-boot-starter-test')
}실행 가능한 JAR 파일을 생성하고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래에 표시된 명령을 사용할 수 있습니다.
gradle clean build“BUILD SUCCESSFUL”후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램이 Tomcat 포트 8080에서 시작되었습니다.
이제 POSTMAN 응용 프로그램에서 아래 URL을 누르면 출력을 볼 수 있습니다.
나머지 템플릿으로 제품 받기 − http://localhost:8080/template/products
제품 POST − http://localhost:8080/template/products
제품 PUT 업데이트 − http://localhost:8080/template/products/3
제품 삭제 − http://localhost:8080/template/products/3
이 장에서는 웹 서비스를 사용하여 파일을 업로드하고 다운로드하는 방법에 대해 설명합니다.
파일 업로드
파일을 업로드하려면 다음을 사용할 수 있습니다. MultipartFile요청 매개 변수로 사용되며이 API는 다중 파트 양식 데이터 값을 사용해야합니다. 아래 주어진 코드를 관찰하십시오-
@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 응답에서 응용 프로그램의 응답 미디어 유형을 지정해야합니다.
Note − 다음 예에서 파일은 응용 프로그램이 실행중인 지정된 경로에서 사용할 수 있어야합니다.
@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 빌드의 코드 – 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.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')
}이제 실행 가능한 JAR 파일을 만들고 아래에 주어진 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래에 표시된 명령을 사용합니다.
sgradle clean build“BUILD SUCCESSFUL”후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>그러면 아래와 같이 Tomcat 포트 8080에서 응용 프로그램이 시작됩니다.
이제 POSTMAN 응용 프로그램에서 아래 URL을 누르면 아래와 같이 출력을 볼 수 있습니다.
파일 업로드- http://localhost:8080/upload
파일 다운로드- http://localhost:8080/upload
서비스 컴포넌트는 @Service 주석을 포함하는 클래스 파일입니다. 이러한 클래스 파일은 @RestController 클래스 파일과 분리 된 다른 계층에서 비즈니스 논리를 작성하는 데 사용됩니다. 서비스 컴포넌트 클래스 파일을 생성하는 로직은 다음과 같습니다.
public interface ProductService {
}@Service 주석으로 인터페이스를 구현하는 클래스는 다음과 같습니다.
@Service
public class ProductServiceImpl implements ProductService {
}이 튜토리얼에서 우리는 Product Service 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 클래스 파일을 보여줍니다. 여기서는 ProductService 인터페이스를 @Autowired하고 메서드를 호출했습니다.
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 클래스의 코드 – 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 빌드의 코드 – 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')
}실행 가능한 JAR 파일을 만들고 아래에 주어진 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 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
Thymeleaf는 웹 애플리케이션을 만드는 데 사용되는 Java 기반 라이브러리입니다. 웹 애플리케이션에서 XHTML / HTML5를 제공하기위한 좋은 지원을 제공합니다. 이 장에서는 Thymeleaf에 대해 자세히 알아 봅니다.
Thymeleaf 템플릿
Thymeleaf는 파일을 올바른 형식의 XML 파일로 변환합니다. 다음과 같이 6 가지 유형의 템플릿이 포함되어 있습니다.
- XML
- 유효한 XML
- XHTML
- 유효한 XHTML
- HTML5
- 기존 HTML5
레거시 HTML5를 제외한 모든 템플릿은 올바른 형식의 유효한 XML 파일을 참조합니다. 레거시 HTML5를 사용하면 닫히지 않은 태그를 포함하여 웹 페이지에서 HTML5 태그를 렌더링 할 수 있습니다.
웹 애플리케이션
Thymeleaf 템플릿을 사용하여 Spring Boot에서 웹 애플리케이션을 만들 수 있습니다. Thymeleaf를 사용하여 Spring Boot에서 웹 애플리케이션을 생성하려면 아래 단계를 따라야합니다.
다음 코드를 사용하여 요청 URI를 HTML 파일로 리디렉션하는 @Controller 클래스 파일을 만듭니다.
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의 정적 디렉토리 아래에 배치해야합니다. 표시된 예에서는 CSS 파일을 사용하여 텍스트 색상을 변경했습니다.
다음 코드를 사용하여 별도의 폴더에 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')
}실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 스프링 부트 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래와 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
여기에 주어진 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>이제 응용 프로그램은 아래와 같이 Tomcat 포트 8080에서 시작되었습니다.
이제 웹 브라우저에서 URL을 누르면 다음과 같이 출력을 볼 수 있습니다.
http://localhost:8080/index
이 장에서는 jQuery AJAX를 사용하여 RESTful 웹 서비스를 사용하는 방법에 대해 자세히 설명합니다.
간단한 Spring Boot 웹 애플리케이션을 만들고 RESTful 웹 서비스를 사용하기 위해 HTML 파일로 리디렉션하는 데 사용되는 컨트롤러 클래스 파일을 작성합니다.
빌드 구성 파일에 Spring Boot 스타터 Thymeleaf 및 웹 종속성을 추가해야합니다.
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 {
}아래와 같이 HTML 파일로 리디렉션 할 요청 URI 메서드를 정의 할 수 있습니다.
@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"
}
]이제 클래스 경로의 templates 디렉토리 아래에 view-products.html 파일을 만듭니다.
HTML 파일에서 jQuery 라이브러리를 추가하고 페이지로드시 RESTful 웹 서비스를 사용하는 코드를 작성했습니다.
<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이제 클래스 경로의 templates 디렉토리 아래에 add-products.html 파일을 만듭니다.
HTML 파일에 jQuery 라이브러리를 추가하고 버튼을 클릭하면 RESTful 웹 서비스에 양식을 제출하는 코드를 작성했습니다.
<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 Application 클래스 파일은 다음과 같습니다.
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);
}
}이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 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를 사용하여 API를 사용하려면 아래에 제공된 예제를 사용할 수 있습니다.
다음 코드를 사용하여 GET API를 사용하는 Angular JS 컨트롤러를 만듭니다. 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;
});
});다음 코드를 사용하여 POST API를 사용하는 Angular JS 컨트롤러를 만듭니다. 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");
});
});Note − Post 메소드 데이터는 상품 생성을위한 요청 본문을 JSON 형식으로 나타냅니다.
CORS (Cross-Origin Resource Sharing)는 웹 브라우저에 구현 된 리소스를 제한 할 수있는 보안 개념입니다. 다른 출처에 대한 요청을 생성하거나 소비하는 JavaScript 코드를 방지합니다.
예를 들어 웹 애플리케이션이 8080 포트에서 실행 중이고 JavaScript를 사용하여 9090 포트에서 RESTful 웹 서비스를 사용하려고합니다. 이러한 상황에서는 웹 브라우저에서 Cross-Origin Resource Sharing 보안 문제에 직면하게됩니다.
이 문제를 처리하려면 두 가지 요구 사항이 필요합니다.
RESTful 웹 서비스는 Cross-Origin 리소스 공유를 지원해야합니다.
RESTful 웹 서비스 애플리케이션은 8080 포트에서 API에 액세스 할 수 있어야합니다.
이 장에서는 RESTful 웹 서비스 응용 프로그램에 대해 원본 간 요청을 활성화하는 방법에 대해 자세히 알아 봅니다.
컨트롤러 방법에서 CORS 활성화
RESTful 웹 서비스의 출처를 설정해야합니다. @CrossOrigin컨트롤러 메서드에 대한 주석. 이 @CrossOrigin 주석은 전체 애플리케이션이 아닌 특정 REST API를 지원합니다.
@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")
public ResponseEntity<Object> getProduct() {
return null;
}글로벌 CORS 구성
CORS 구성 지원을 Spring Boot 애플리케이션에 전역 적으로 설정하려면 표시된 @Bean 구성을 정의해야합니다.
@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");
}
};
}
}이제 8080 포트에서 실행되는 Spring Boot 웹 애플리케이션과 9090 포트에서 실행할 수있는 RESTful 웹 서비스 애플리케이션을 만들 수 있습니다. RESTful 웹 서비스 구현에 대한 자세한 내용은 제목이 붙은 장을 참조하십시오.Consuming RESTful Web Services 이 튜토리얼의.
국제화는 소스 코드에 대한 엔지니어링 변경없이 애플리케이션을 다양한 언어 및 지역에 적용 할 수 있도록하는 프로세스입니다. 즉, 국제화는 현지화의 준비 상태입니다.
이 장에서는 Spring Boot에서 국제화를 구현하는 방법에 대해 자세히 배울 것입니다.
의존성
Spring Boot에서 웹 애플리케이션을 개발하려면 Spring Boot Starter Web 및 Spring Boot Starter Thymeleaf 종속성이 필요합니다.
메이븐
<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
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 () 메서드를 재정의해야합니다.
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(localeChangeInterceptor());
}메시지 소스
기본적으로 Spring Boot 애플리케이션은 다음에서 메시지 소스를 가져옵니다. src/main/resources클래스 경로 아래의 폴더. 기본 로케일 메시지 파일 이름은 다음과 같아야합니다.message.properties 각 로케일의 파일 이름은 messages_XX.properties. "XX"는 로케일 코드를 나타냅니다.
모든 메시지 속성은 키 쌍 값으로 사용되어야합니다. 로케일에 특성이없는 경우 애플리케이션은 messages.properties 파일의 기본 특성을 사용합니다.
기본 messages.properties는 다음과 같습니다.
welcome.text=Hi Welcome to Everyone프랑스어 messages_fr.properties는 다음과 같습니다.
welcome.text=Salut Bienvenue à tousNote − 메시지 소스 파일은“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 à tousHTML 파일 locale.html은 다음과 같이 클래스 경로의 템플릿 디렉토리 아래에 있어야합니다.
<!DOCTYPE html>
<html>
<head>
<meta charset = "ISO-8859-1"/>
<title>Internationalization</title>
</head>
<body>
<h1 th:text = "#{welcome.text}"></h1>
</body>
</html>실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring 부팅 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음과 같이 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>응용 프로그램이 Tomcat 포트 8080에서 시작되었음을 알 수 있습니다.
이제 URL을 누르십시오. http://localhost:8080/locale 웹 브라우저에서 다음 출력을 볼 수 있습니다.
URL http://localhost:8080/locale?language=fr 다음과 같이 출력을 제공합니다.
스케줄링은 특정 기간 동안 작업을 실행하는 프로세스입니다. Spring Boot는 Spring 애플리케이션에서 스케줄러를 작성하는 데 좋은 지원을 제공합니다.
Java Cron 표현식
Java Cron 표현식은 org.quartz.Trigger의 하위 클래스 인 CronTrigger의 인스턴스를 구성하는 데 사용됩니다. 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 시부 터 오전 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에 시작된 방법과 그 시간으로부터 1 분마다 크론 작업 스케줄러 작업이 실행 된 방법을 보여줍니다.
고정 비율
고정 속도 스케줄러는 특정 시간에 작업을 실행하는 데 사용됩니다. 이전 작업이 완료 될 때까지 기다리지 않습니다. 값은 밀리 초 단위 여야합니다. 샘플 코드는 다음과 같습니다.
@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 초마다 고정 지연 스케줄러 작업이 1 초마다 실행됩니다.
기본적으로 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 키 저장소 파일을 생성하고 인증서 별명은 tomcat입니다.
HTTPS 구성
application.properties 파일에 서버 포트를 443, 키 저장소 파일 경로, 키 저장소 암호, 키 저장소 유형 및 키 별칭 이름으로 제공해야합니다. 여기에 주어진 코드를 관찰하십시오-
server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcatYAML 속성을 사용하는 경우 다음 코드를 사용할 수 있습니다 application.yml-
server:
port: 443
ssl:
key-store: keystore.p12
key-store-password: springboot
keyStoreType: PKCS12
keyAlias: tomcat다음 Maven 또는 Gradle 명령을 사용하여 실행 가능한 JAR 파일을 만들고 스프링 부트 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 다음과 같이 https로 Tomcat 포트 443에서 시작되었습니다.
Eureka Server는 모든 클라이언트 서비스 애플리케이션에 대한 정보를 보유하는 애플리케이션입니다. 모든 Micro 서비스는 Eureka 서버에 등록되고 Eureka 서버는 각 포트 및 IP 주소에서 실행되는 모든 클라이언트 애플리케이션을 알고 있습니다. Eureka Server는 Discovery Server라고도합니다.
이 장에서는 유레카 서버 구축 방법에 대해 자세히 알아 봅니다.
유레카 서버 구축
Eureka Server는 Spring Cloud 번들과 함께 제공됩니다. 이를 위해 Eureka 서버를 개발하고 기본 포트 8761에서 실행해야합니다.
Spring Initializer 홈페이지 방문 https://start.spring.io/Eureka 서버 종속성으로 Spring Boot 프로젝트를 다운로드하십시오. 아래 스크린 샷에 나와 있습니다.
메인 Spring Boot Application 클래스 파일에서 프로젝트를 다운로드 한 후 @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 = 8761application.yml 파일은 다음과 같습니다.
eureka:
client:
registerWithEureka: false
fetchRegistry: false
server:
port: 8761이제 실행 가능한 JAR 파일을 만들고 아래 표시된 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래와 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래에 표시된 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>응용 프로그램이 아래와 같이 Tomcat 포트 8761에서 시작되었음을 알 수 있습니다.
이제 URL을 누르십시오. http://localhost:8761/ 웹 브라우저에서 아래와 같이 포트 8761에서 실행되는 Eureka 서버를 찾을 수 있습니다.
이 장에서는 Spring Boot Micro 서비스 애플리케이션을 Eureka Server에 등록하는 방법에 대해 자세히 알아 봅니다. 응용 프로그램을 등록하기 전에 Eureka Server가 포트 8761에서 실행 중인지 확인하거나 먼저 Eureka Server를 빌드하고 실행하십시오. 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 Server에 등록하려면 application.properties 파일 또는 application.yml 파일에 다음 구성을 추가하고 구성에 Eureka Server URL을 지정해야합니다.
application.yml 파일의 코드는 다음과 같습니다.
eureka:
client:
serviceUrl:
defaultZone: http://localhost:8761/eureka
instance:
preferIpAddress: true
spring:
application:
name: eurekaclientapplication.properties 파일의 코드는 다음과 같습니다.
eureka.client.serviceUrl.defaultZone = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient이제 Rest Endpoint를 추가하여 메인 Spring Boot 애플리케이션에서 String을 반환하고 빌드 구성 파일에서 Spring Boot Starter 웹 종속성을 반환합니다. 아래 주어진 코드를 관찰하십시오-
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";
}
}전체 구성 파일은 다음과 같습니다.
For Maven user - 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>
</projecta>For Gradle user – 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}"
}
}실행 가능한 JAR 파일을 생성하고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음과 같이 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 Tomcat 포트 8080에서 시작되고 Eureka Client 응용 프로그램은 아래와 같이 Eureka Server에 등록됩니다.
웹 브라우저에서 URL http : // localhost : 8761 /을 누르면 Eureka Client 애플리케이션이 Eureka Server에 등록되어있는 것을 볼 수 있습니다.
이제 URL을 누르십시오. http://localhost:8080/ 웹 브라우저에서 Rest Endpoint 출력을 확인하십시오.
Zuul Server는 모든 요청을 처리하고 마이크로 서비스 애플리케이션의 동적 라우팅을 수행하는 게이트웨이 애플리케이션입니다. Zuul Server는 Edge Server라고도합니다.
예를 들어 /api/user 사용자 서비스에 매핑되고 / api / products는 제품 서비스에 매핑되고 Zuul 서버는 요청을 각 백엔드 애플리케이션으로 동적으로 라우팅합니다.
이 장에서는 Spring Boot에서 Zuul Server 애플리케이션을 생성하는 방법을 자세히 살펴 보겠습니다.
Zuul 서버 애플리케이션 생성
Zuul Server는 Spring Cloud 종속성과 함께 번들로 제공됩니다. Spring Initializer 페이지에서 Spring Boot 프로젝트를 다운로드 할 수 있습니다.https://start.spring.io/ Zuul 서버 종속성을 선택하십시오.
기본 Spring Boot 애플리케이션에 @EnableZuulProxy 주석을 추가하십시오. @EnableZuulProxy 주석은 Spring Boot 애플리케이션이 Zuul 프록시 서버로 작동하도록 만드는 데 사용됩니다.
package com.tutorialspoint.zuulserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
@SpringBootApplication
@EnableZuulProxy
public class ZuulserverApplication {
public static void main(String[] args) {
SpringApplication.run(ZuulserverApplication.class, args);
}
}빌드 구성 파일에 Spring Cloud Starter Zuul 종속성을 추가해야합니다.
Maven 사용자는 다음 종속성을 추가해야합니다. pom.xml 파일-
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>Gradle 사용자의 경우 build.gradle 파일에 아래 종속성을 추가하십시오.
compile('org.springframework.cloud:spring-cloud-starter-zuul')Zuul 라우팅의 경우 application.properties 파일 또는 application.yml 파일에 아래 속성을 추가합니다.
spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111이것은 http가 /api/demo/제품 서비스로 전달됩니다. 예를 들면/api/demo/products 전달됩니다 /products.
yaml 파일 사용자는 아래 표시된 application.yml 파일을 사용할 수 있습니다.
server:
port: 8111
spring:
application:
name: zuulserver
zuul:
routes:
products:
path: /api/demo/**
url: http://localhost:8080/Note − http://localhost:8080/ Zuul 프록시를 통해 라우팅하기 전에 응용 프로그램이 이미 실행 중이어야합니다.
전체 빌드 구성 파일은 다음과 같습니다.
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>zuulserver</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>zuulserver</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-zuul</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-zuul')
testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
imports {
mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}실행 가능한 JAR 파일을 만들고 아래에 주어진 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 아래에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>여기에 표시된대로 Tomcat 포트 8111에서 애플리케이션이 시작된 것을 찾을 수 있습니다.
이제 URL을 누르십시오. http://localhost:8111/api/demo/products 웹 브라우저에서 다음의 출력을 볼 수 있습니다. /products 아래와 같이 REST 끝점-
Spring Cloud Configuration Server는 모든 애플리케이션 관련 구성 속성을 관리하는 중앙 집중식 애플리케이션입니다. 이 장에서는 Spring Cloud Configuration 서버를 만드는 방법에 대해 자세히 알아 봅니다.
Spring Cloud 구성 서버 생성
먼저 Spring Initializer 페이지에서 Spring Boot 프로젝트를 다운로드하고 Spring Cloud Config Server 종속성을 선택합니다. 아래 주어진 스크린 샷을 관찰하십시오-
이제 아래에 설명 된대로 빌드 구성 파일에 Spring Cloud Config 서버 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 아래 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 아래 종속성을 추가 할 수 있습니다.
compile('org.springframework.cloud:spring-cloud-config-server')이제 기본 Spring Boot 애플리케이션 클래스 파일에 @EnableConfigServer 주석을 추가하십시오. @EnableConfigServer 어노테이션은 Spring Boot 애플리케이션이 구성 서버로 작동하도록합니다.
주요 Spring Boot 애플리케이션 클래스 파일은 다음과 같습니다.
package com.tutorialspoint.configserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigserverApplication.class, args);
}
}이제 아래 구성을 속성 파일에 추가하고 application.properties 파일을 bootstrap.properties 파일로 바꿉니다. 아래 주어진 코드를 관찰하십시오-
server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=nativeConfiguration Server는 Tomcat 포트 8888에서 실행되며 응용 프로그램 구성 속성은 기본 검색 위치에서로드됩니다.
지금에 file:///C:/configprop/, 클라이언트 애플리케이션-application.properties 파일을 배치하십시오. 예를 들어 클라이언트 애플리케이션 이름은config-client을 클릭 한 다음 application.properties 파일의 이름을 config-client.properties 경로에 속성 파일을 배치하십시오. file:///C:/configprop/.
config-client 속성 파일의 코드는 다음과 같습니다.
welcome.message = Welcome to Spring cloud config 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>configserver</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>configserver</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-config-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 파일을 사용할 수 있습니다.
<scope>import</scope>
</dependency>
</dependencies>
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-config-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행합니다.
Maven의 경우 아래 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
다음 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>이제 응용 프로그램은 여기에 표시된대로 Tomcat 포트 8888에서 시작되었습니다.
이제 URL을 누르십시오. http://localhost:8888/config-client/default/master 웹 브라우저에서 여기에 표시된대로 config-client 애플리케이션 구성 속성을 볼 수 있습니다.
일부 응용 프로그램은 변경이 필요한 구성 속성이 필요할 수 있으며 개발자는이를 수행하기 위해 응용 프로그램을 종료하거나 다시 시작해야 할 수 있습니다. 그러나 이로 인해 프로덕션 중단 시간이 발생하고 애플리케이션을 다시 시작해야 할 수 있습니다. Spring Cloud Configuration Server를 사용하면 개발자가 애플리케이션을 다시 시작하지 않고 다운 타임없이 새 구성 속성을로드 할 수 있습니다.
Spring Cloud 구성 서버 작업
먼저 Spring Boot 프로젝트를 https://start.spring.io/Spring Cloud Config Client 종속성을 선택하십시오. 이제 빌드 구성 파일에 Spring Cloud Starter Config 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>Gradle 사용자는 다음 종속성을 build.gradle 파일.
compile('org.springframework.cloud:spring-cloud-starter-config')이제 기본 Spring Boot 애플리케이션에 @RefreshScope 주석을 추가해야합니다. @RefreshScope 주석은 구성 서버에서 구성 속성 값을로드하는 데 사용됩니다.
package com.example.configclient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
@SpringBootApplication
@RefreshScope
public class ConfigclientApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigclientApplication.class, args);
}
}이제 application.properties 파일에 구성 서버 URL을 추가하고 애플리케이션 이름을 제공하십시오.
Note − http : // localhost : 8888 설정 서버는 설정 클라이언트 응용 프로그램을 시작하기 전에 실행되어야합니다.
spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888구성 서버에서 환영 메시지를 읽기 위해 간단한 REST 엔드 포인트를 작성하는 코드는 다음과 같습니다.
package com.example.configclient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RefreshScope
@RestController
public class ConfigclientApplication {
@Value("${welcome.message}")
String welcomeText;
public static void main(String[] args) {
SpringApplication.run(ConfigclientApplication.class, args);
}
@RequestMapping(value = "/")
public String welcomeText() {
return welcomeText;
}
}실행 가능한 JAR 파일을 생성하고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래에 표시된 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래에 표시된 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 여기에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 다음과 같이 Tomcat 포트 8080에서 시작되었습니다.
로그인 콘솔 창을 볼 수 있습니다. config-client 애플리케이션이https://localhost:8888
2017-12-08 12:41:57.682 INFO 1104 --- [
main] c.c.c.ConfigServicePropertySourceLocator :
Fetching config from server at: http://localhost:8888이제 URL을 누르십시오. http://localhost:8080/ 환영 메시지는 구성 서버에서로드됩니다.
이제 구성 서버에서 속성 값을 변경하고 액추에이터 Endpoint POST URL을 누르십시오. http://localhost:8080/refresh URL에서 새 구성 속성 값을 확인합니다. http://localhost:8080/
Spring Boot Actuator는 Spring Boot 애플리케이션을 모니터링하고 관리하기위한 보안 엔드 포인트를 제공합니다. 기본적으로 모든 액추에이터 끝점은 보호됩니다. 이 장에서는 애플리케이션에서 Spring Boot 액추에이터를 활성화하는 방법에 대해 자세히 알아 봅니다.
스프링 부트 액추에이터 활성화
Spring Boot 애플리케이션에 Spring Boot 액추에이터 엔드 포인트를 활성화하려면 빌드 구성 파일에 Spring Boot Starter Actuator 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 아래 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 아래 종속성을 추가 할 수 있습니다.
compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'application.properties 파일에서 액추에이터 엔드 포인트에 대한 보안을 비활성화해야합니다.
management.security.enabled = falseYAML 파일 사용자는 application.yml 파일에 다음 속성을 추가 할 수 있습니다.
management:
security:
enabled: falseSpring Boot Actutator 엔드 포인트에 액세스하기 위해 별도의 포트 번호를 사용하려면 application.properties 파일에 관리 포트 번호를 추가하십시오.
management.port = 9000YAML 파일 사용자는 application.yml 파일에 다음 속성을 추가 할 수 있습니다.
management:
port: 9000이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행할 수 있습니다.
java –jar <JARFILE>이제 응용 프로그램이 Tomcat 포트 8080에서 시작되었습니다. 관리 포트 번호를 지정한 경우 동일한 응용 프로그램이 두 개의 다른 포트 번호에서 실행됩니다.
몇 가지 중요한 Spring Boot Actuator 끝점은 다음과 같습니다. 웹 브라우저에 입력하고 애플리케이션 동작을 모니터링 할 수 있습니다.
| 종점 | 용법 |
|---|---|
| / metrics | 사용 된 메모리, 사용 가능한 메모리, 스레드, 클래스, 시스템 가동 시간 등과 같은 애플리케이션 메트릭을 보려면 |
| / env | 응용 프로그램에서 사용되는 환경 변수 목록을 보려면. |
| /콩 | Spring Bean과 해당 유형, 범위 및 종속성을 보려면. |
| /건강 | 응용 프로그램 상태를 보려면 |
| / info | Spring Boot 애플리케이션에 대한 정보를 보려면. |
| /자취 | Rest 엔드 포인트의 Trace 목록을 보려면. |
Spring Boot Actuator Endpoint를 사용하여 애플리케이션을 모니터링하는 것은 약간 어렵습니다. 애플리케이션 수가 'n'개인 경우 모든 애플리케이션에는 별도의 액추에이터 엔드 포인트가있어 모니터링이 어렵 기 때문입니다. Spring Boot Admin Server는 마이크로 서비스 애플리케이션을 관리하고 모니터링하는 데 사용되는 애플리케이션입니다.
이러한 상황을 처리하기 위해 CodeCentric Team은 모든 Spring Boot 애플리케이션 Actuator 엔드 포인트를 한 곳에서 관리하고 모니터링 할 수있는 Spring Boot Admin UI를 제공합니다.
Spring Boot Admin Server를 빌드하려면 빌드 구성 파일에 아래 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 아래 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server</artifactId>
<version>1.5.5</version>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server-ui</artifactId>
<version>1.5.5</version>
</dependency>Gradle 사용자는 build.gradle 파일에 아래 종속성을 추가 할 수 있습니다.
compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'기본 Spring Boot 애플리케이션 클래스 파일에 @EnableAdminServer 주석을 추가하십시오. @EnableAdminServer 주석은 다른 모든 마이크로 서비스를 모니터링하기 위해 Admin Server로 만드는 데 사용됩니다.
package com.tutorialspoint.adminserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import de.codecentric.boot.admin.config.EnableAdminServer;
@SpringBootApplication
@EnableAdminServer
public class AdminserverApplication {
public static void main(String[] args) {
SpringApplication.run(AdminserverApplication.class, args);
}
}이제 표시된 application.properties 파일에서 server.port 및 응용 프로그램 이름을 정의하십시오-
server.port = 9090
spring.application.name = adminserverYAML 사용자의 경우 다음 속성을 사용하여 application.yml 파일에서 포트 번호와 애플리케이션 이름을 정의합니다.
server:
port: 9090
spring:
application:
name: adminserver빌드 구성 파일은 다음과 같습니다.
For Maven users – 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>adminserver</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>adminserver</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server</artifactId>
<version>1.5.5</version>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-server-ui</artifactId>
<version>1.5.5</version>
</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>For Gradle users – build.gradle file
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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'
testCompile('org.springframework.boot:spring-boot-starter-test')
}실행 가능한 JAR 파일을 생성하고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 여기에 표시된 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 여기에 표시된 명령을 사용하십시오.
gradle clean build“BUILD SUCCESSFUL”후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 아래 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 다음과 같이 Tomcat 포트 9090에서 시작되었습니다.
이제 웹 브라우저에서 아래 URL을 누르고 관리 서버 UI를 확인하십시오.
http://localhost:9090/
Spring Boot Admin Server를 통해 마이크로 서비스 애플리케이션을 모니터링하고 관리하려면 Spring Boot Admin 스타터 클라이언트 종속성을 추가하고 애플리케이션 속성 파일에 Admin Server URI를 지정해야합니다.
Note − 애플리케이션을 모니터링하려면 마이크로 서비스 애플리케이션에 대해 Spring Boot Actuator Endpoints를 활성화해야합니다.
먼저 빌드 구성 파일에 다음 Spring Boot Admin 스타터 클라이언트 종속성 및 Spring Boot 스타터 액추에이터 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>1.5.5</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')이제 애플리케이션 속성 파일에 Spring Boot Admin Server URL을 추가합니다.
속성 파일 사용자의 경우 application.properties 파일에 다음 속성을 추가합니다.
spring.boot.admin.url = http://localhost:9090/YAML 사용자의 경우 application.yml 파일에 다음 속성을 추가합니다.
spring:
boot:
admin:
url: http://localhost:9000/이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행합니다.
Maven의 경우 다음과 같이 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 다음과 같이 Tomcat 포트 9090에서 시작되었습니다.
이제 웹 브라우저에서 다음 URL을 클릭하고 Spring Boot 애플리케이션이 Spring Boot Admin Server에 등록되었는지 확인하십시오.
http://localhost:9090/
이제 Details 버튼을 클릭하고 Admin Server UI에서 액추에이터 끝점을 확인합니다.
Swagger2는 RESTful 웹 서비스 용 REST API 문서를 생성하는 데 사용되는 오픈 소스 프로젝트입니다. 웹 브라우저를 통해 RESTful 웹 서비스에 액세스 할 수있는 사용자 인터페이스를 제공합니다.
Spring Boot 애플리케이션에서 Swagger2를 활성화하려면 빌드 구성 파일에 다음 종속성을 추가해야합니다.
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>Gradle 사용자의 경우 build.gradle 파일에 다음 종속성을 추가하십시오.
compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'이제 기본 Spring Boot 애플리케이션에 @ EnableSwagger2 주석을 추가하십시오. @ EnableSwagger2 주석은 Spring Boot 애플리케이션에 Swagger2를 활성화하는 데 사용됩니다.
주요 Spring Boot 애플리케이션의 코드는 다음과 같습니다.
package com.tutorialspoint.swaggerdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SwaggerDemoApplication.class, args);
}
}다음으로 Docket Bean을 생성하여 Spring Boot 애플리케이션에 대해 Swagger2를 구성합니다. Swagger2 용 REST API를 구성하려면 기본 패키지를 정의해야합니다.
@Bean
public Docket productApi() {
return new Docket(DocumentationType.SWAGGER_2).select()
.apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
}이제이 빈을 메인 Spring Boot 애플리케이션 클래스 파일 자체에 추가하면 메인 Spring Boot 애플리케이션 클래스가 아래와 같이 보일 것입니다.
package com.tutorialspoint.swaggerdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SwaggerDemoApplication.class, args);
}
@Bean
public Docket productApi() {
return new Docket(DocumentationType.SWAGGER_2).select()
.apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
}
}이제 빌드 구성 파일에 아래 Spring Boot Starter 웹 종속성을 추가하여 아래와 같이 REST 엔드 포인트를 작성하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.boot:spring-boot-starter-web')이제 Rest Controller 파일에서 두 개의 간단한 RESTful 웹 서비스 GET 및 POST를 빌드하는 코드가 여기에 표시됩니다.
package com.tutorialspoint.swaggerdemo;
import java.util.ArrayList;
import java.util.List;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class SwaggerAPIController {
@RequestMapping(value = "/products", method = RequestMethod.GET)
public List<String> getProducts() {
List<String> productsList = new ArrayList<>();
productsList.add("Honey");
productsList.add("Almond");
return productsList;
}
@RequestMapping(value = "/products", method = RequestMethod.POST)
public String createProduct() {
return "Product is saved successfully";
}
}전체 빌드 구성 파일은 다음과 같습니다.
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>swagger-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>swagger-demo</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>
</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>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</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.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()
} dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'
}다음 Maven 또는 Gradle 명령을 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 여기에 표시된 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 여기에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램은 다음과 같이 Tomcat 포트 8080에서 시작됩니다.
이제 웹 브라우저에서 URL을 누르고 Swagger API 기능을 확인하십시오.
http://localhost:8080/swagger-ui.html
Docker는 구축 및 배포를 용이하게하는 컨테이너 관리 서비스입니다. Docker 초보자 인 경우이 링크에서 자세히 알아볼 수 있습니다.https://www.tutorialspoint.com/docker/index.htm
이 장에서는 Spring Boot 애플리케이션에 Maven 및 Gradle 종속성을 사용하여 Docker 이미지를 만드는 방법을 살펴 봅니다.
Dockerfile 생성
먼저 이름을 가진 파일을 만듭니다. Dockerfile 디렉토리 아래 src/main/docker아래 표시된 내용으로. 이 파일은 Docker 이미지를 만드는 데 중요합니다.
FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]메이븐
Maven의 경우 Docker Maven 플러그인을 빌드 구성 파일에 추가합니다. pom.xml
<properties>
<docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</properties>
<build>
<plugins>
<plugin>
<groupId>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>1.0.0</version>
<configuration>
<imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
<include>${project.build.finalName}.jar</include>
</resource>
</resources>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</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>dockerapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>dockerapp</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>
<docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</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>com.spotify</groupId>
<artifactId>docker-maven-plugin</artifactId>
<version>1.0.0</version>
<configuration>
<imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
<include>${project.build.finalName}.jar</include>
</resource>
</resources>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>이제 Maven 명령을 사용하여 애플리케이션을 실행할 수 있습니다. mvn package docker:build
Note − Expose 데몬 활성화 tcp://localhost:2375 TLS없이.
빌드 성공 후 아래와 같이 콘솔에서 출력을 볼 수 있습니다.
이제 docker 이미지를 사용하는 명령으로 Docker 이미지를보고 콘솔에서 이미지 정보를 확인합니다.
Gradle
Gradle 빌드 구성을 사용하여 Docker 이미지를 빌드하려면 다음을 추가해야합니다. docker 플러그인과 작업 작성 필요 buildDocker Docker 이미지를 만듭니다.
Gradle Docker 구성 코드는 다음과 같습니다.
buildscript {
.....
dependencies {
.....
classpath('se.transmode.gradle:gradle-docker:1.2')
}
}
group = 'spring-boot-tutorialspoint'
.....
apply plugin: 'docker'
task buildDocker(type: Docker, dependsOn: build) {
applicationName = jar.baseName
dockerfile = file('src/main/docker/Dockerfile')
doFirst {
copy {
from jar
into stageDir
}
}
}완전한 build.gradle 파일은 다음과 같습니다.
buildscript {
ext {
springBootVersion = '1.5.9.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
classpath('se.transmode.gradle:gradle-docker:1.2')
}
}
group = 'spring-boot-tutorialspoint'
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'docker'
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')
}
task buildDocker(type: Docker, dependsOn: build) {
applicationName = jar.baseName
dockerfile = file('src/main/docker/Dockerfile')
doFirst {
copy {
from jar
into stageDir
}
}
}이제 아래 표시된 명령을 사용하여 Docker 이미지를 만듭니다.
gradle build buildDocker
명령을 실행 한 후 콘솔 창에서 BUILD SUCCESSFUL 로그를 볼 수 있습니다.
이제 다음 명령을 사용하여 Docker 이미지를 확인하십시오. docker images 콘솔에서 이미지 정보를 확인하세요.
대부분의 개발자는 문제가 발생하면 로그를 추적하는 데 어려움을 겪습니다. 이는 Spring Boot 애플리케이션을위한 Spring Cloud Sleuth 및 ZipKin 서버로 해결할 수 있습니다.
봄 구름 탐정
Spring Cloud Sleuth 로그는 다음 형식으로 인쇄됩니다.
[application-name,traceid,spanid,zipkin-export]어디,
Application-name = 애플리케이션 이름
Traceid = 동일한 서비스 또는 한 서비스를 다른 서비스에 호출 할 때 각 요청 및 응답 traceid가 동일합니다.
Spanid = Span Id는 Trace Id와 함께 인쇄됩니다. 스팬 ID는 한 서비스를 다른 서비스로 호출하는 모든 요청 및 응답이 다릅니다.
Zipkin-export = 기본적으로 false입니다. 참이면 로그가 Zipkin 서버로 내보내집니다.
이제 다음과 같이 빌드 구성 파일에 Spring Cloud Starter Sleuth 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.cloud:spring-cloud-starter-sleuth')이제 여기에 표시된대로 Spring Boot 애플리케이션 Rest Controller 클래스 파일에 로그를 추가하십시오.
package com.tutorialspoint.sleuthapp;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class SleuthappApplication {
private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
public static void main(String[] args) {
SpringApplication.run(SleuthappApplication.class, args);
}
@RequestMapping("/")
public String index() {
LOG.log(Level.INFO, "Index API is calling");
return "Welcome Sleuth!";
}
}이제 다음과 같이 application.properties 파일에 응용 프로그램 이름을 추가하십시오.
spring.application.name = tracinglogs빌드 구성 파일의 전체 코드는 다음과 같습니다.
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>sleuthapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>sleuthapp</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-sleuth</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-sleuth')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
imports {
mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}다음 Maven 또는 Gradle 명령을 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 여기에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 응용 프로그램이 Tomcat 포트 8080에서 시작되었습니다.
이제 웹 브라우저에서 URL을 누르고 콘솔 로그에서 출력을 확인하십시오.
http://localhost:8080/
콘솔 창에서 다음 로그를 볼 수 있습니다. 로그가 [application-name, traceid, spanid, zipkin-export] 형식으로 인쇄되는지 확인합니다.
Zipkin 서버
Zipkin은 Spring Boot 애플리케이션의 Spring Cloud Sleuth 로그를 모니터링하고 관리하는 애플리케이션입니다. Zipkin 서버를 빌드하려면 빌드 구성 파일에 Zipkin UI 및 Zipkin Server 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>io.zipkin.java</groupId>
<artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
<groupId>io.zipkin.java</groupId>
<artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 아래 종속성을 추가 할 수 있습니다.
compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')이제 응용 프로그램 속성 파일에서 server.port = 9411을 구성합니다.
속성 파일 사용자의 경우 application.properties 파일에 아래 속성을 추가하십시오.
server.port = 9411YAML 사용자의 경우 application.yml 파일에 아래 속성을 추가하십시오.
server:
port: 9411기본 Spring Boot 애플리케이션 클래스 파일에 @EnableZipkinServer 주석을 추가하십시오. @EnableZipkinServer 주석은 애플리케이션이 Zipkin 서버로 작동 할 수 있도록하는 데 사용됩니다.
package com.tutorialspoint.zipkinapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;
@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
public static void main(String[] args) {
SpringApplication.run(ZipkinappApplication.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>zipkinapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>zipkinapp</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>io.zipkin.java</groupId>
<artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
<groupId>io.zipkin.java</groupId>
<artifactId>zipkin-autoconfigure-ui</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('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}실행 가능한 JAR 파일을 생성하고 아래 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 아래 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
표시된 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>이제 응용 프로그램은 아래와 같이 Tomcat 포트 9411에서 시작되었습니다.
이제 아래 URL을 누르고 Zipkin 서버 UI를 확인하십시오.
http://localhost:9411/zipkin/
그런 다음 클라이언트 서비스 애플리케이션에 다음 종속성을 추가하고 Zipkin 서버 URL을 지정하여 Zipkin UI를 통해 마이크로 서비스 로그를 추적합니다.
이제 다음과 같이 빌드 구성 파일에 Spring Cloud Starter Zipkin 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 아래 종속성을 추가 할 수 있습니다.
compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')이제 Always Sampler Bean Spring Boot 애플리케이션에서 로그를 Zipkin 서버로 내보내십시오.
@Bean
public AlwaysSampler defaultSampler() {
return new AlwaysSampler();
}AlwaysSampler Bean을 추가하면 Spring Sleuth Zipkin Export 옵션이 false에서 true로 자동 변경됩니다.
다음으로 클라이언트 서비스 application.properties 파일에서 Zipkin 서버 기본 URL을 구성합니다.
spring.zipkin.baseUrl = http://localhost:9411/zipkin/그런 다음 추적 ID를 제공하고 Zipkin UI에서 추적을 찾습니다.
http://localhost:9411/zipkin/traces/{traceid}/
Flyway는 모든 인스턴스에서 데이터베이스 스키마를 쉽고 안정적으로 발전시키는 버전 제어 애플리케이션입니다. Flyway에 대한 자세한 내용은 www.flywaydb.org 링크를 사용할 수 있습니다.
많은 소프트웨어 프로젝트는 관계형 데이터베이스를 사용합니다. 이를 위해서는 종종 스키마 마이그레이션이라고도하는 데이터베이스 마이그레이션을 처리해야합니다.
이 장에서는 Spring Boot 애플리케이션에서 Flyway 데이터베이스를 구성하는 방법에 대해 자세히 알아 봅니다.
Flyway 데이터베이스 구성
먼저 Spring Initializer 페이지 www.start.spring.io 에서 Spring Boot 프로젝트를 다운로드 하고 다음 종속성을 선택하십시오.
- 스프링 부트 스타터 웹
- Flyway
- MySQL
- JDBC
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')응용 프로그램 속성에서 DataSource를 만들기위한 데이터베이스 속성과 응용 프로그램 속성에서 구성해야하는 플라이 웨이 속성을 구성해야합니다.
속성 파일 사용자의 경우 application.properties 파일에 아래 속성을 추가합니다.
spring.application.name = flywayapp
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000
flyway.url = jdbc:mysql://localhost:3306/mysql
flyway.schemas = USERSERVICE
flyway.user = root
flyway.password = rootYAML 사용자는 application.yml 파일에 다음 속성을 추가 할 수 있습니다.
spring:
application:
name: flywayapp
datasource:
driverClassName: com.mysql.jdbc.Driver
url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
password: "root"
username: "root"
testOnBorrow: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 30000
validationQuery: SELECT 1
max-active: 15
max-idle: 10
max-wait: 8000
flyway:
url: jdbc:mysql://localhost:3306/mysql
schemas: USERSERVICE
user: "root"
password: "root"이제 아래에 SQL 파일을 만듭니다. src/main/resources/db/migration예배 규칙서. SQL 파일의 이름을 "V1__Initial.sql"로 지정합니다.
CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');주요 Spring Boot 애플리케이션 클래스 파일 코드는 다음과 같습니다.
package com.tutorialspoint.flywayapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class FlywayappApplication {
public static void main(String[] args) {
SpringApplication.run(FlywayappApplication.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>flywayapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>flywayapp</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>
</properties>
<dependencies>
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</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.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()
}
dependencies {
compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')
testCompile('org.springframework.boot:spring-boot-starter-test')
}실행 가능한 JAR 파일을 만들고 아래에 주어진 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 여기에 표시된 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 여기에 표시된 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 다음 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 Tomcat은 포트 8080에서 시작되었으며 콘솔 창에서 여기에 표시된대로 플라이 웨이 데이터베이스 로그를 볼 수 있습니다.
이제 데이터베이스로 이동하여 선택 쿼리를 수행 할 수 있습니다.
Spring Boot RESTful 웹 서비스를 사용하면 Gmail Transport Layer Security로 이메일을 보낼 수 있습니다. 이 장에서는이 기능을 사용하는 방법을 자세히 이해하겠습니다.
먼저 빌드 구성 파일에 Spring Boot Starter Mail 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.boot:spring-boot-starter-mail')주요 Spring Boot 애플리케이션 클래스 파일의 코드는 다음과 같습니다.
package com.tutorialspoint.emailapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class EmailappApplication {
public static void main(String[] args) {
SpringApplication.run(EmailappApplication.class, args);
}
}그림과 같이 Rest Controller 클래스 파일에서 이메일로 보낼 간단한 Rest API를 작성할 수 있습니다.
package com.tutorialspoint.emailapp;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class EmailController {
@RequestMapping(value = "/sendemail")
public String sendEmail() {
return "Email sent successfully";
}
}첨부 파일로 이메일을 보내는 방법을 작성할 수 있습니다. mail.smtp 속성을 정의하고 PasswordAuthentication을 사용했습니다.
private void sendmail() throws AddressException, MessagingException, IOException {
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", "smtp.gmail.com");
props.put("mail.smtp.port", "587");
Session session = Session.getInstance(props, new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("[email protected]", "<your password>");
}
});
Message msg = new MimeMessage(session);
msg.setFrom(new InternetAddress("[email protected]", false));
msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("[email protected]"));
msg.setSubject("Tutorials point email");
msg.setContent("Tutorials point email", "text/html");
msg.setSentDate(new Date());
MimeBodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setContent("Tutorials point email", "text/html");
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
MimeBodyPart attachPart = new MimeBodyPart();
attachPart.attachFile("/var/tmp/image19.png");
multipart.addBodyPart(attachPart);
msg.setContent(multipart);
Transport.send(msg);
}이제 다음과 같이 Rest API에서 위의 sendmail () 메서드를 호출합니다.
@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
sendmail();
return "Email sent successfully";
}Note − 이메일을 보내기 전에 Gmail 계정 설정에서 보안 수준이 낮은 앱 허용을 켜십시오.
전체 빌드 구성 파일은 다음과 같습니다.
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>emailapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>emailapp</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>
</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-mail</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter-web')
compile('org.springframework.boot:spring-boot-starter-mail')
testCompile('org.springframework.boot:spring-boot-starter-test')
}이제 실행 가능한 JAR 파일을 만들고 아래 표시된 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음과 같이 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 아래 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>응용 프로그램이 Tomcat 포트 8080에서 시작되었음을 알 수 있습니다.
이제 웹 브라우저에서 다음 URL을 누르면 이메일을 받게됩니다.
http://localhost:8080/sendemail
Hystrix는 Netflix의 라이브러리입니다. Hystrix는 서비스 간의 액세스 지점을 격리하고 서비스 간의 계단식 장애를 중지하며 대체 옵션을 제공합니다.
당신이 3 호출 할 때 예를 들어, RD의 파티 응용 프로그램을, 그것은 응답을 보낼 수있는 시간이 더 걸립니다. 따라서 그 때 컨트롤은 fallback 메서드로 이동하여 사용자 지정 응답을 애플리케이션에 반환합니다.
이 장에서는 Spring Boot 애플리케이션에서 Hystrix를 구현하는 방법을 살펴볼 것입니다.
먼저 빌드 구성 파일에 Spring Cloud Starter Hystrix 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.cloud:spring-cloud-starter-hystrix')이제 기본 Spring Boot 애플리케이션 클래스 파일에 @EnableHystrix 주석을 추가합니다. @EnableHystrix 주석은 Spring Boot 애플리케이션에서 Hystrix 기능을 활성화하는 데 사용됩니다.
주요 Spring Boot 애플리케이션 클래스 파일 코드는 다음과 같습니다.
package com.tutorialspoint.hystrixapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
@SpringBootApplication
@EnableHystrix
public class HystrixappApplication {
public static void main(String[] args) {
SpringApplication.run(HystrixappApplication.class, args);
}
}이제 요청 된 시간으로부터 3 초 후에 문자열을 반환하도록 간단한 Rest Controller를 작성합니다.
@RequestMapping(value = "/")
public String hello() throws InterruptedException {
Thread.sleep(3000);
return "Welcome Hystrix";
}이제 Rest API에 @Hystrix 명령과 @HystrixProperty를 추가하고 시간 제한 (밀리 초) 값을 정의합니다.
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})다음으로, 요청이 응답하는 데 오랜 시간이 걸리는 경우 fallback 메서드 fallback_hello ()를 정의하십시오.
private String fallback_hello() {
return "Request fails. It takes long time to response";
}REST API 및 Hystrix 속성을 포함하는 전체 Rest Controller 클래스 파일은 다음과 같습니다.
@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
Thread.sleep(3000);
return "Welcome Hystrix";
}
private String fallback_hello() {
return "Request fails. It takes long time to response";
}이 예제에서는 메인 Spring Boot 애플리케이션 클래스 파일 자체에 작성된 REST API입니다.
package com.tutorialspoint.hystrixapp;
import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
public static void main(String[] args) {
SpringApplication.run(HystrixappApplication.class, args);
}
@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
Thread.sleep(3000);
return "Welcome Hystrix";
}
private String fallback_hello() {
return "Request fails. It takes long time to response";
}
}전체 빌드 구성 파일은 다음과 같습니다.
Maven – pom.xml file
<?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>hystrixapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>hystrixapp</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-hystrix</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-hystrix')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
imports {
mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}실행 가능한 JAR 파일을 생성하고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음과 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 아래 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>그러면 아래와 같이 Tomcat 포트 8080에서 응용 프로그램이 시작됩니다.
이제 URL을 누르십시오. http://localhost:8080/웹 브라우저에서 Hystrix 응답을 확인하십시오. API가 응답하는 데 3 초가 걸리지 만 Hystrix 시간 제한은 1 초입니다.
이 장에서는 웹 소켓과 함께 Spring Boot를 사용하여 대화 형 웹 애플리케이션을 구축하는 방법을 이해해 보겠습니다.
웹 소켓을 사용하여 Spring Boot에서 대화 형 웹 애플리케이션을 빌드하려면 다음 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가해야합니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>sockjs-client</artifactId>
<version>1.0.2</version>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>stomp-websocket</artifactId>
<version>2.3.3</version>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>bootstrap</artifactId>
<version>3.3.7</version> </dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>jquery</artifactId>
<version>3.1.0</version>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")STOMP 메시징과 함께 작동하는 메시지 처리 컨트롤러를 만들어 보겠습니다. STOMP 메시지는 @Controller 클래스 파일로 라우팅 될 수 있습니다. 예를 들어, GreetingController는 "/ hello"대상에 대한 메시지를 처리하도록 매핑됩니다.
package com.tutorialspoint.websocketapp;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;
@Controller
public class GreetingController {
@MessageMapping("/hello")
@SendTo("/topic/greetings")
public Greeting greeting(HelloMessage message) throws Exception {
Thread.sleep(1000); // simulated delay
return new Greeting("Hello, " + message.getName() + "!");
}
}이제 STOMP 메시징을 위해 Spring을 구성하십시오. 아래와 같이 AbstractWebSocketMessageBrokerConfigurer 클래스를 확장하는 WebSocketConfig 클래스 파일을 작성하십시오.
package com.tutorialspoint.websocketapp;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/tutorialspoint-websocket").withSockJS();
}
}@EnableWebSocketMessageBroker 주석은 STOMP 엔드 포인트를 생성하도록 웹 소켓 메시지 브로커를 구성하는 데 사용됩니다.
다음과 같이 src / main / resources / static / index.html 아래에 브라우저 클라이언트 파일을 만들 수 있습니다.
<!DOCTYPE html>
<html>
<head>
<title>Hello WebSocket</title>
<link href = "/webjars/bootstrap/css/bootstrap.min.css" rel = "stylesheet">
<link href = "/main.css" rel = "stylesheet">
<script src = "/webjars/jquery/jquery.min.js"></script>
<script src = "/webjars/sockjs-client/sockjs.min.js"></script>
<script src = "/webjars/stomp-websocket/stomp.min.js"></script>
<script src = "/app.js"></script>
</head>
<body>
<noscript>
<h2 style = "color: #ff0000">
Seems your browser doesn't support Javascript! Websocket relies on Javascript being
enabled. Please enable Javascript and reload this page!
</h2>
</noscript>
<div id = "main-content" class = "container">
<div class = "row">
<div class = "col-md-6">
<form class = "form-inline">
<div class = "form-group">
<label for = "connect">WebSocket connection:</label>
<button id = "connect" class = "btn btn-default" type = "submit">Connect</button>
<button id = "disconnect" class = "btn btn-default" type = "submit" disabled = "disabled">Disconnect
</button>
</div>
</form>
</div>
<div class = "col-md-6">
<form class = "form-inline">
<div class = "form-group">
<label for = "name">What is your name?</label>
<input type = "text" id = "name" class = "form-control" placeholder = "Your name here...">
</div>
<button id = "send" class = "btn btn-default" type = "submit">Send</button>
</form>
</div>
</div>
<div class = "row">
<div class = "col-md-12">
<table id = "conversation" class = "table table-striped">
<thead>
<tr>
<th>Greetings</th>
</tr>
</thead>
<tbody id = "greetings"></tbody>
</table>
</div>
</div>
</div>
</body>
</html>STOMP를 사용하여 메시지를 소비하고 생성하는 app.js 파일을 만들어 보겠습니다.
var stompClient = null;
function setConnected(connected) {
$("#connect").prop("disabled", connected);
$("#disconnect").prop("disabled", !connected); if (connected) { $("#conversation").show();
} else {
$("#conversation").hide(); } $("#greetings").html("");
}
function connect() {
var socket = new SockJS('/tutorialspoint-websocket');
stompClient = Stomp.over(socket);
stompClient.connect({}, function (frame) {
setConnected(true);
console.log('Connected: ' + frame);
stompClient.subscribe('/topic/greetings', function (greeting) {
showGreeting(JSON.parse(greeting.body).content);
});
});
}
function disconnect() {
if (stompClient !== null) {
stompClient.disconnect();
}
setConnected(false);
console.log("Disconnected");
}
function sendName() {
stompClient.send("/app/hello", {}, JSON.stringify({'name': $("#name").val()})); } function showGreeting(message) { $("#greetings").append("<tr><td>" + message + "</td></tr>");
}
$(function () { $( "form" ).on('submit', function (e) {e.preventDefault();});
$( "#connect" ).click(function() { connect(); }); $( "#disconnect" ).click(function() { disconnect(); });
$( "#send" ).click(function() { sendName(); });
});주요 Spring Boot 애플리케이션의 코드는 다음과 같습니다.
package com.tutorialspoint.websocketapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class WebsocketappApplication {
public static void main(String[] args) {
SpringApplication.run(WebsocketappApplication.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>websocketapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>websocketapp</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>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>sockjs-client</artifactId>
<version>1.0.2</version>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>stomp-websocket</artifactId>
<version>2.3.3</version>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>bootstrap</artifactId>
<version>3.3.7</version>
</dependency>
<dependency>
<groupId>org.webjars</groupId>
<artifactId>jquery</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<java.version>1.8</java.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>Gradle – build.gradle
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.9.RELEASE")
}
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
jar {
baseName = 'websocketapp'
version = '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")
testCompile("org.springframework.boot:spring-boot-starter-test")
}실행 가능한 JAR 파일을 생성하고 아래와 같이 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
여기에 주어진 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>이제 응용 프로그램이 그림과 같이 Tomcat 포트 8080에서 시작되었습니다.
이제 URL을 누르십시오. http://localhost:8080/ 웹 브라우저에서 웹 소켓을 연결하고 인사말을 보내고 메시지를받습니다.
Batch Service는 단일 작업에서 둘 이상의 명령을 실행하는 프로세스입니다. 이 장에서는 Spring Boot 애플리케이션에서 배치 서비스를 생성하는 방법을 배우게됩니다.
CSV 파일 내용을 HSQLDB에 저장하는 예를 고려해 보겠습니다.
Batch Service 프로그램을 생성하려면 빌드 구성 파일에 Spring Boot Starter Batch 종속성과 HSQLDB 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")이제 클래스 경로 리소스 (src / main / resources) 아래에 간단한 CSV 데이터 파일을 추가하고 파일 이름을 다음과 같이 file.csv로 지정합니다.
William,John
Mike, Sebastian
Lawarance, Lime다음으로 HSQLDB 용 SQL 스크립트를 작성합니다 – classpath 리소스 디렉터리 아래 – request_fail_hystrix_timeout
DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS (
user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
first_name VARCHAR(20),
last_name VARCHAR(20)
);그림과 같이 USERS 모델에 대한 POJO 클래스를 만듭니다.
package com.tutorialspoint.batchservicedemo;
public class User {
private String lastName;
private String firstName;
public User() {
}
public User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
@Override
public String toString() {
return "firstName: " + firstName + ", lastName: " + lastName;
}
}이제 CSV 파일에서 데이터를 읽은 후 SQL에 데이터를 쓰기 전에 작업을 수행 할 중간 프로세서를 만듭니다.
package com.tutorialspoint.batchservicedemo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;
public class UserItemProcessor implements ItemProcessor<User, User> {
private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);
@Override
public User process(final User user) throws Exception {
final String firstName = user.getFirstName().toUpperCase();
final String lastName = user.getLastName().toUpperCase();
final User transformedPerson = new User(firstName, lastName);
log.info("Converting (" + user + ") into (" + transformedPerson + ")");
return transformedPerson;
}
}아래와 같이 CSV에서 데이터를 읽고 SQL 파일에 쓰기 위해 배치 구성 파일을 생성 해 보겠습니다. 구성 클래스 파일에 @EnableBatchProcessing 주석을 추가해야합니다. @EnableBatchProcessing 주석은 Spring Boot 애플리케이션의 배치 작업을 활성화하는 데 사용됩니다.
package com.tutorialspoint.batchservicedemo;
import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
@Autowired
public JobBuilderFactory jobBuilderFactory;
@Autowired
public StepBuilderFactory stepBuilderFactory;
@Autowired
public DataSource dataSource;
@Bean
public FlatFileItemReader<User> reader() {
FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
reader.setResource(new ClassPathResource("file.csv"));
reader.setLineMapper(new DefaultLineMapper<User>() {
{
setLineTokenizer(new DelimitedLineTokenizer() {
{
setNames(new String[] { "firstName", "lastName" });
}
});
setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
{
setTargetType(User.class);
}
});
}
});
return reader;
}
@Bean
public UserItemProcessor processor() {
return new UserItemProcessor();
}
@Bean
public JdbcBatchItemWriter<User> writer() {
JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
writer.setDataSource(dataSource);
return writer;
}
@Bean
public Job importUserJob(JobCompletionNotificationListener listener) {
return jobBuilderFactory.get("importUserJob").incrementer(
new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
}
@Bean
public Step step1() {
return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
}
}그만큼 reader() 메소드는 CSV 파일에서 데이터를 읽는 데 사용되며 writer () 메소드는 데이터를 SQL에 쓰는 데 사용됩니다.
다음으로, 작업 완료 후 알림에 사용되는 작업 완료 알림 리스너 클래스를 작성해야합니다.
package com.tutorialspoint.batchservicedemo;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;
@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
private final JdbcTemplate jdbcTemplate;
@Autowired
public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void afterJob(JobExecution jobExecution) {
if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
log.info("!!! JOB FINISHED !! It's time to verify the results!!");
List<User> results = jdbcTemplate.query(
"SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
@Override
public User mapRow(ResultSet rs, int row) throws SQLException {
return new User(rs.getString(1), rs.getString(2));
}
});
for (User person : results) {
log.info("Found <" + person + "> in the database.");
}
}
}
}이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행합니다.
Maven의 경우 다음과 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
여기에 주어진 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>다음과 같이 콘솔 창에서 출력을 볼 수 있습니다.
Apache Kafka는 내결함성 메시징 시스템을 기반으로 메시지를 게시하고 구독하는 데 사용되는 오픈 소스 프로젝트입니다. 빠르고 확장 가능하며 설계에 따라 배포됩니다. Kafka를 처음 사용하거나 더 잘 이해하고 싶다면이 링크를 참조하십시오. www.tutorialspoint.com/apache_kafka/
이 장에서는 Spring Boot 애플리케이션에서 Apache Kafka를 구현하는 방법을 살펴 보겠습니다.
먼저 빌드 구성 파일에 Spring Kafka 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>2.1.0.RELEASE</version>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'메시지 생성
Apache Kafka로 메시지를 생성하려면 다음과 같이 Producer 구성에 대한 Configuration 클래스를 정의해야합니다.
package com.tutorialspoint.kafkademo;
import java.util.HashMap;
import java.util.Map;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
@Configuration
public class KafkaProducerConfig {
@Bean
public ProducerFactory<String, String> producerFactory() {
Map<String, Object> configProps = new HashMap<>();
configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
return new DefaultKafkaProducerFactory<>(configProps);
}
@Bean
public KafkaTemplate<String, String> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
}메시지를 게시하려면 Kafka Template 객체를 자동으로 연결하고 표시된대로 메시지를 생성합니다.
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
public void sendMessage(String msg) {
kafkaTemplate.send(topicName, msg);
}메시지 소비
메시지를 사용하려면 아래와 같이 Consumer 구성 클래스 파일을 작성해야합니다.
package com.tutorialspoint.kafkademo;
import java.util.HashMap;
import java.util.Map;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
@EnableKafka
@Configuration
public class KafkaConsumerConfig {
@Bean
public ConsumerFactory<String, String> consumerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:2181");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
return new DefaultKafkaConsumerFactory<>(props);
}
@Bean
public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory<String, String>
factory = new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
return factory;
}
}다음으로 리스너를 작성하여 메시지를 듣습니다.
@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
System.out.println("Received Messasge in group - group-id: " + message);
}메인 Spring Boot 애플리케이션 클래스 파일에서 ApplicationRunner 클래스 실행 메서드에서 sendMessage () 메서드를 호출하고 동일한 클래스 파일에서 메시지를 사용합니다.
주요 Spring Boot 애플리케이션 클래스 파일 코드는 다음과 같습니다.
package com.tutorialspoint.kafkademo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
@SpringBootApplication
public class KafkaDemoApplication implements ApplicationRunner {
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
public void sendMessage(String msg) {
kafkaTemplate.send("tutorialspoint", msg);
}
public static void main(String[] args) {
SpringApplication.run(KafkaDemoApplication.class, args);
}
@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
System.out.println("Received Messasge in group - group-id: " + message);
}
@Override
public void run(ApplicationArguments args) throws Exception {
sendMessage("Hi Welcome to Spring For Apache Kafka");
}
}전체 빌드 구성 파일에 대한 코드는 다음과 같습니다.
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>kafka-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>kafka-demo</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>2.1.0.RELEASE</version>
</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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
testCompile('org.springframework.boot:spring-boot-starter-test')
}이제 실행 가능한 JAR 파일을 만들고 다음과 같이 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행하십시오.
Maven의 경우 다음과 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
여기에 주어진 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>콘솔 창에서 출력을 볼 수 있습니다.
Twilio는 3 번째의 SMS를 전송하고 우리의 응용 프로그램에서 음성 통화를하는 데 사용 파티 응용 프로그램입니다. 이를 통해 SMS를 보내고 프로그래밍 방식으로 음성 통화를 할 수 있습니다.
이 장에서는 Twilio와 함께 Spring Boot를 사용하여 SMS 전송 및 음성 통화를 구현하는 방법을 알아 봅니다.
Note− Twilio의 Trail 계정을 사용하여 SMS를 보내고 음성 통화를했습니다. www.twilio.com 에서 Twilio에 대해 자세히 알아볼 수 있습니다 .
먼저 빌드 구성 파일에 Twilio 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>7.16.1</version>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"이제 다음과 같이 정적 블록에서 ACCOUNT_SID 및 AUTH_ID로 Twilio 계정을 초기화합니다.
static {
Twilio.init(ACCOUNT_SID, AUTH_ID);
}SMS 보내기
SMS를 보내려면 Message.create () 메서드에 From-number 및 to-number를 제공해야합니다. 메시지 본문 내용은 다음과 같이 Message.creator () 메소드를 제공해야합니다.
Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
"Message from Spring Boot Application").create();주요 Spring Boot 애플리케이션 클래스 파일은 다음과 같습니다.
package com.tutorialspoint.smsdemo;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;
@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
private final static String ACCOUNT_SID = "<your-account-sid>";
private final static String AUTH_ID = "<your-auth-id>";
static {
Twilio.init(ACCOUNT_SID, AUTH_ID);
}
public static void main(String[] args) {
SpringApplication.run(SmsdemoApplication.class, args);
}
@Override
public void run(ApplicationArguments arg0) throws Exception {
Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
"Message from Spring Boot Application").create();
}
}구성 파일을 빌드하는 전체 코드는 다음과 같습니다.
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>smsdemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>smsdemo</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>7.16.1</version>
</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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
testCompile('org.springframework.boot:spring-boot-starter-test')
compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"
}실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 스프링 부트 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음과 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
아래 주어진 명령을 사용하여 JAR 파일을 실행하십시오-
java –jar <JARFILE>이제 "to-number"로 SMS를 받게됩니다.
"to-number"로 메시지를 받았습니다.
Sent from your Twilio trail account
- Message from Spring Boot ApplicationNote−이 예에서는 Trail 계정을 사용했습니다. 따라서 SMS를 보내기 전에 번호를 확인해야합니다.
음성 통화
Twilio를 사용하여 음성 통화를하려면 Call.creator () 메서드를 호출해야합니다. 이 방법의 경우 여기에 표시된대로 to-number, from-number 및 음성 메모를 제공해야합니다.
Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
new URI("http://demo.twilio.com/docs/voice.xml")).create();기본 Spring Boot 애플리케이션 클래스 파일의 코드는 다음과 같습니다.
package com.tutorialspoint.smsdemo;
import java.net.URI;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;
@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
private final static String ACCOUNT_SID = "<ACCOUNT-SID>";
private final static String AUTH_ID = "AUTH-ID";
static {
Twilio.init(ACCOUNT_SID, AUTH_ID);
}
public static void main(String[] args) {
SpringApplication.run(SmsdemoApplication.class, args);
}
@Override
public void run(ApplicationArguments arg0) throws Exception {
Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
new URI("http://demo.twilio.com/docs/voice.xml")).create();
}
}전체 빌드 구성 파일에 대한 코드는 다음과 같습니다.
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>smsdemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>smsdemo</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>7.16.1</version>
</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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
testCompile('org.springframework.boot:spring-boot-starter-test')
compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"
}다음 Maven 또는 Gradle 명령을 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음과 같이 명령을 사용하십시오.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용하십시오.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 여기에 주어진 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>이제 Twilio에서 "to-number"로 전화를 받게됩니다.
통화 참석 후 아무 키나 누르면 음성 메모가 들립니다. https://demo.twilio.com/docs/voice.xml
Note−이 예에서는 Trail 계정을 사용했습니다. 따라서 전화를 걸기 전에 번호를 확인해야합니다.
단위 테스트는 개별 단위 또는 구성 요소 기능이 제대로 작동하는지 확인하기 위해 개발자가 수행하는 테스트 중 하나입니다.
이 튜토리얼에서는 Mockito 및 Web Controller를 사용하여 단위 테스트 케이스를 작성하는 방법을 살펴 보겠습니다.
Mockito
Mockito Mocks를 Spring Beans에 삽입하려면 빌드 구성 파일에 Mockito-core 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.13.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')String 값을 반환하는 메서드를 포함하는 Service 클래스를 작성하는 코드가 여기에 제공됩니다.
package com.tutorialspoint.mockitodemo;
import org.springframework.stereotype.Service;
@Service
public class ProductService {
public String getProductName() {
return "Honey";
}
}이제 표시된대로 ProductService 클래스를 다른 서비스 클래스 파일에 삽입하십시오.
package com.tutorialspoint.mockitodemo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
@Autowired
ProductService productService;
public OrderService(ProductService productService) {
this.productService = productService;
}
public String getProductName() {
return productService.getProductName();
}
}주요 Spring Boot 애플리케이션 클래스 파일은 다음과 같습니다.
package com.tutorialspoint.mockitodemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MockitoDemoApplication {
public static void main(String[] args) {
SpringApplication.run(MockitoDemoApplication.class, args);
}
}그런 다음 테스트에 대한 애플리케이션 컨텍스트를 구성하십시오. @Profile ( "test") 주석은 테스트 케이스가 실행 중일 때 클래스를 구성하는 데 사용됩니다.
package com.tutorialspoint.mockitodemo;
import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
@Profile("test")
@Configuration
public class ProductServiceTestConfiguration {
@Bean
@Primary
public ProductService productService() {
return Mockito.mock(ProductService.class);
}
}이제 주문 서비스에 대한 단위 테스트 케이스를 작성할 수 있습니다. src/test/resources 꾸러미.
package com.tutorialspoint.mockitodemo;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@SpringBootTest
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
public class MockitoDemoApplicationTests {
@Autowired
private OrderService orderService;
@Autowired
private ProductService productService;
@Test
public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
Mockito.when(productService.getProductName()).thenReturn("Mock Product Name");
String testName = orderService.getProductName();
Assert.assertEquals("Mock Product Name", testName);
}
}빌드 구성 파일의 전체 코드는 다음과 같습니다.
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>mockito-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mockito-demo</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.13.0</version>
</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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')
}다음 Maven 또는 Gradle1 명령을 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 다음과 같이 명령을 사용할 수 있습니다.
mvn clean install콘솔 창에서 테스트 결과를 볼 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build나머지 결과는 콘솔 창에서 볼 수 있습니다.
Spring Boot는 Rest Controller 파일에 대한 단위 테스트를 작성하는 쉬운 방법을 제공합니다. SpringJUnit4ClassRunner 및 MockMvc의 도움으로 웹 애플리케이션 컨텍스트를 생성하여 Rest Controller 파일에 대한 단위 테스트를 작성할 수 있습니다.
단위 테스트는 src/test/java 테스트 작성을위한 디렉토리 및 클래스 경로 리소스는 src/test/resources 예배 규칙서.
단위 테스트 작성을 위해 아래와 같이 빌드 구성 파일에 Spring Boot Starter Test 종속성을 추가해야합니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
testCompile('org.springframework.boot:spring-boot-starter-test')테스트 케이스를 작성하기 전에 먼저 RESTful 웹 서비스를 빌드해야합니다. RESTful 웹 서비스 구축에 대한 자세한 내용은이 튜토리얼에서 제공하는 동일한 장을 참조하십시오.
REST 컨트롤러에 대한 단위 테스트 작성
이 섹션에서는 REST 컨트롤러에 대한 단위 테스트를 작성하는 방법을 살펴 보겠습니다.
먼저 MockMvc를 사용하여 웹 애플리케이션 컨텍스트를 생성하는 데 사용되는 Abstract 클래스 파일을 생성하고 mapToJson () 및 mapFromJson () 메서드를 정의하여 Java 객체를 JSON 문자열로 변환하고 JSON 문자열을 Java 객체로 변환해야합니다.
package com.tutorialspoint.demo;
import java.io.IOException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@WebAppConfiguration
public abstract class AbstractTest {
protected MockMvc mvc;
@Autowired
WebApplicationContext webApplicationContext;
protected void setUp() {
mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}
protected String mapToJson(Object obj) throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.writeValueAsString(obj);
}
protected <T> T mapFromJson(String json, Class<T> clazz)
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.readValue(json, clazz);
}
}다음으로 AbstractTest 클래스를 확장하는 클래스 파일을 작성하고 GET, POST, PUT 및 DELETE와 같은 각 메소드에 대한 단위 테스트를 작성하십시오.
GET API 테스트 케이스의 코드는 다음과 같습니다. 이 API는 제품 목록을보기위한 것입니다.
@Test
public void getProductsList() throws Exception {
String uri = "/products";
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
.accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
Product[] productlist = super.mapFromJson(content, Product[].class);
assertTrue(productlist.length > 0);
}POST API 테스트 케이스의 코드는 다음과 같습니다. 이 API는 제품을 생성하기위한 것입니다.
@Test
public void createProduct() throws Exception {
String uri = "/products";
Product product = new Product();
product.setId("3");
product.setName("Ginger");
String inputJson = super.mapToJson(product);
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
.contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(201, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is created successfully");
}PUT API 테스트 케이스의 코드는 다음과 같습니다. 이 API는 기존 제품을 업데이트하기위한 것입니다.
@Test
public void updateProduct() throws Exception {
String uri = "/products/2";
Product product = new Product();
product.setName("Lemon");
String inputJson = super.mapToJson(product);
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
.contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is updated successsfully");
}API 테스트 삭제 사례에 대한 코드는 다음과 같습니다. 이 API는 기존 제품을 삭제합니다.
@Test
public void deleteProduct() throws Exception {
String uri = "/products/2";
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is deleted successsfully");
}전체 컨트롤러 테스트 클래스 파일은 다음과 같습니다.
package com.tutorialspoint.demo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import com.tutorialspoint.demo.model.Product;
public class ProductServiceControllerTest extends AbstractTest {
@Override
@Before
public void setUp() {
super.setUp();
}
@Test
public void getProductsList() throws Exception {
String uri = "/products";
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
.accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
Product[] productlist = super.mapFromJson(content, Product[].class);
assertTrue(productlist.length > 0);
}
@Test
public void createProduct() throws Exception {
String uri = "/products";
Product product = new Product();
product.setId("3");
product.setName("Ginger");
String inputJson = super.mapToJson(product);
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
.contentType(MediaType.APPLICATION_JSON_VALUE)
.content(inputJson)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(201, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is created successfully");
}
@Test
public void updateProduct() throws Exception {
String uri = "/products/2";
Product product = new Product();
product.setName("Lemon");
String inputJson = super.mapToJson(product);
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
.contentType(MediaType.APPLICATION_JSON_VALUE)
.content(inputJson)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is updated successsfully");
}
@Test
public void deleteProduct() throws Exception {
String uri = "/products/2";
MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
int status = mvcResult.getResponse().getStatus();
assertEquals(200, status);
String content = mvcResult.getResponse().getContentAsString();
assertEquals(content, "Product is deleted successsfully");
}
}실행 가능한 JAR 파일을 만들고 아래에 주어진 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용할 수 있습니다.
mvn clean install이제 콘솔 창에서 테스트 결과를 볼 수 있습니다.
Gradle의 경우 아래와 같이 명령을 사용할 수 있습니다.
gradle clean build나머지 결과는 아래와 같이 콘솔 창에서 볼 수 있습니다.
Spring Boot는 데이터베이스 용 데이터 소스를 생성하는 데 매우 좋은 지원을 제공합니다. Spring Boot에서 DataSource를 만들기 위해 추가 코드를 작성할 필요가 없습니다. 종속성을 추가하고 구성 세부 정보를 수행하는 것만으로도 DataSource를 만들고 데이터베이스를 연결하는 데 충분합니다.
이 장에서는 Spring Boot JDBC 드라이버 연결을 사용하여 데이터베이스를 연결합니다.
먼저 빌드 구성 파일에 Spring Boot Starter JDBC 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.boot:spring-boot-starter-jdbc')H2 데이터베이스에 연결
H2 데이터베이스를 연결하려면 빌드 구성 파일에 H2 데이터베이스 종속성을 추가해야합니다.
Maven 사용자의 경우 pom.xml 파일에 아래 종속성을 추가하십시오.
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>Gradle 사용자의 경우 build.gradle 파일에 아래 종속성을 추가하십시오.
compile('com.h2database:h2')H2 데이터베이스를 연결하려면 classpath src / main / resources 디렉터리에 schema.sql 파일과 data.sql 파일을 만들어야합니다.
schema.sql 파일은 다음과 같습니다.
CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));data.sql 파일은 다음과 같습니다.
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');MySQL 연결
MySQL 데이터베이스를 연결하려면 빌드 구성 파일에 MySQL 종속성을 추가해야합니다.
Maven 사용자의 경우 pom.xml 파일에 다음 종속성을 추가하십시오.
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>Gradle 사용자의 경우 build.gradle 파일에 다음 종속성을 추가하십시오.
compile('mysql:mysql-connector-java')이제 다음과 같이 MySQL에서 데이터베이스와 테이블을 만듭니다.
속성 파일 사용자의 경우 application.properties 파일에 다음 속성을 추가합니다.
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000YAML 사용자의 경우 application.yml 파일에 다음 속성을 추가합니다.
spring:
datasource:
driverClassName: com.mysql.jdbc.Driver
url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
username: "root"
password: "root"
testOnBorrow: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 30000
validationQuery: SELECT 1
max-active: 15
max-idle: 10
max-wait: 8000Redis 연결
Redis는 인 메모리 데이터 구조를 저장하는 데 사용되는 오픈 소스 데이터베이스입니다. Spring Boot 애플리케이션에서 Redis 데이터베이스를 연결하려면 빌드 구성 파일에 Redis 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가해야합니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가해야합니다.
compile('org.springframework.boot:spring-boot-starter-data-redis')Redis 연결의 경우 RedisTemplate을 사용해야합니다. RedisTemplate의 경우 JedisConnectionFactory 세부 정보를 제공해야합니다.
@Bean
JedisConnectionFactory jedisConnectionFactory() {
JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
jedisConFactory.setHostName("localhost");
jedisConFactory.setPort(6000);
jedisConFactory.setUsePool(true);
return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(jedisConnectionFactory());
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(new StringRedisSerializer());
template.setValueSerializer(new StringRedisSerializer());
return template;
}이제 RedisTemplate 클래스를 자동으로 연결하고 Redis 데이터베이스의 데이터에 액세스합니다.
@Autowired
RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);JDBC 템플릿
Spring Boot 애플리케이션에서 JdbcTemplate을 사용하여 관계형 데이터베이스에 액세스하려면 빌드 구성 파일에 Spring Boot Starter JDBC 종속성을 추가해야합니다.
그런 다음 JdbcTemplate 클래스를 @Autowired하면 Spring Boot는 자동으로 데이터베이스를 연결하고 JdbcTemplate 객체에 대한 데이터 소스를 설정합니다.
@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");@Repository 주석을 클래스 파일에 추가해야합니다. @Repository 주석은 Spring Boot 애플리케이션을위한 데이터베이스 저장소를 만드는 데 사용됩니다.
@Repository
public class ProductServiceDAO {
}다중 데이터 소스
단일 Spring Boot 애플리케이션에 'n'개의 데이터 소스를 유지할 수 있습니다. 여기에 주어진 예제는 Spring Boot 애플리케이션에서 둘 이상의 데이터 소스를 생성하는 방법을 보여줍니다. 이제 응용 프로그램 속성 파일에 두 개의 데이터 소스 구성 세부 정보를 추가합니다.
속성 파일 사용자의 경우 application.properties 파일에 다음 속성을 추가합니다.
spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000
spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000Yaml 사용자는 application.yml 파일에 다음 속성을 추가해야합니다.
spring:
dbProductService:
driverClassName: com.mysql.jdbc.Driver
url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
password: "root"
username: "root"
testOnBorrow: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 30000
validationQuery: SELECT 1
max-active: 15
max-idle: 10
max-wait: 8000
dbUserService:
driverClassName: com.mysql.jdbc.Driver
url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
password: "root"
username: "root"
testOnBorrow: true
testWhileIdle: true
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 30000
validationQuery: SELECT 1
max-active: 15
max-idle: 10
max-wait: 8000이제 Configuration 클래스를 만들어 여러 데이터 소스에 대한 DataSource 및 JdbcTemplate을 만듭니다.
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;
@Configuration
public class DatabaseConfig {
@Bean(name = "dbProductService")
@ConfigurationProperties(prefix = "spring.dbProductService")
@Primary
public DataSource createProductServiceDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "dbUserService")
@ConfigurationProperties(prefix = "spring.dbUserService")
public DataSource createUserServiceDataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "jdbcProductService")
@Autowired
public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
return new JdbcTemplate(productServiceDS);
}
@Bean(name = "jdbcUserService")
@Autowired
public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
return new JdbcTemplate(userServiceDS);
}
}그런 다음 @Qualifier 주석을 사용하여 JDBCTemplate 객체를 자동 연결합니다.
@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;
@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;클래스 경로에 Spring Boot 보안 종속성이 추가되면 Spring Boot 애플리케이션은 모든 HTTP 엔드 포인트에 대한 기본 인증을 자동으로 요구합니다. 끝점 "/"및 "/ home"에는 인증이 필요하지 않습니다. 다른 모든 엔드 포인트에는 인증이 필요합니다.
Spring Boot 애플리케이션에 Spring Boot 보안을 추가하려면 빌드 구성 파일에 Spring Boot Starter Security 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile("org.springframework.boot:spring-boot-starter-security")웹 애플리케이션 보안
먼저 Thymeleaf 템플릿을 사용하여 안전하지 않은 웹 애플리케이션을 만듭니다.
그런 다음 아래에 home.html 파일을 만듭니다. src/main/resources/templates 예배 규칙서.
<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml"
xmlns:th = "http://www.thymeleaf.org"
xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Spring Security Example</title>
</head>
<body>
<h1>Welcome!</h1>
<p>Click <a th:href = "@{/hello}">here</a> to see a greeting.</p>
</body>
</html>간단한보기 /hello Thymeleaf 템플릿을 사용하여 HTML 파일에 정의됩니다.
이제 아래에 hello.html을 만듭니다. src/main/resources/templates 예배 규칙서.
<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml"
xmlns:th = "http://www.thymeleaf.org"
xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Hello World!</title>
</head>
<body>
<h1>Hello world!</h1>
</body>
</html>이제 Spring MVC – 홈 및 헬로우 뷰용 뷰 컨트롤러를 설정해야합니다.
이를 위해 WebMvcConfigurerAdapter를 확장하는 MVC 구성 파일을 만듭니다.
package com.tutorialspoint.websecuritydemo;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/home").setViewName("home");
registry.addViewController("/").setViewName("home");
registry.addViewController("/hello").setViewName("hello");
registry.addViewController("/login").setViewName("login");
}
}이제 빌드 구성 파일에 Spring Boot Starter 보안 종속성을 추가하십시오.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile("org.springframework.boot:spring-boot-starter-security")이제 기본 인증을 사용하여 HTTP 끝점에 액세스하도록 애플리케이션을 보호하는 데 사용되는 웹 보안 구성 파일을 만듭니다.
package com.tutorialspoint.websecuritydemo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/", "/home").permitAll()
.anyRequest().authenticated()
.and()
.formLogin()
.loginPage("/login")
.permitAll()
.and()
.logout()
.permitAll();
}
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
auth
.inMemoryAuthentication()
.withUser("user").password("password").roles("USER");
}
}이제 아래에 login.html 파일을 만듭니다. src/main/resources 사용자가 로그인 화면을 통해 HTTP 엔드 포인트에 액세스 할 수 있도록 허용하는 디렉토리.
<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Spring Security Example </title>
</head>
<body>
<div th:if = "${param.error}">
Invalid username and password.
</div>
<div th:if = "${param.logout}">
You have been logged out.
</div>
<form th:action = "@{/login}" method = "post">
<div>
<label> User Name : <input type = "text" name = "username"/> </label>
</div>
<div>
<label> Password: <input type = "password" name = "password"/> </label>
</div>
<div>
<input type = "submit" value = "Sign In"/>
</div>
</form>
</body>
</html>마지막으로 hello.html 파일을 업데이트하여 사용자가 애플리케이션에서 로그 아웃하고 아래와 같이 현재 사용자 이름을 표시 할 수 있도록합니다.
<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
<head>
<title>Hello World!</title>
</head>
<body>
<h1 th:inline = "text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
<form th:action = "@{/logout}" method = "post">
<input type = "submit" value = "Sign Out"/>
</form>
</body>
</html>주요 Spring Boot 애플리케이션의 코드는 다음과 같습니다.
package com.tutorialspoint.websecuritydemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class WebsecurityDemoApplication {
public static void main(String[] args) {
SpringApplication.run(WebsecurityDemoApplication.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>websecurity-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>websecurity-demo</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-thymeleaf')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')
}이제 실행 가능한 JAR 파일을 만들고 다음 Maven 또는 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행합니다.
Maven 사용자는 다음과 같이 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle 사용자는 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 아래에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>URL을 누르십시오. http://localhost:8080/웹 브라우저에서. 다음과 같이 출력을 볼 수 있습니다.
이 장에서는 Spring Boot Security 메커니즘과 JWT를 사용한 OAuth2에 대해 자세히 알아 봅니다.
인증 서버
Authorization Server는 Web API 보안을위한 최고의 아키텍처 구성 요소입니다. Authorization Server는 앱과 HTTP 엔드 포인트가 애플리케이션의 기능을 식별 할 수 있도록하는 중앙 인증 지점 역할을합니다.
리소스 서버
리소스 서버는 리소스 서버 HTTP 끝점에 액세스하기 위해 클라이언트에 액세스 토큰을 제공하는 응용 프로그램입니다. HTTP 끝점, 정적 리소스 및 동적 웹 페이지를 포함하는 라이브러리 모음입니다.
OAuth2
OAuth2는 애플리케이션 웹 보안이 클라이언트의 리소스에 액세스 할 수 있도록하는 인증 프레임 워크입니다. OAuth2 애플리케이션을 구축하려면 허가 유형 (인증 코드), 클라이언트 ID 및 클라이언트 시크릿에 중점을 두어야합니다.
JWT 토큰
JWT 토큰은 두 당사자간에 보호되는 클레임을 나타내는 데 사용되는 JSON 웹 토큰입니다. www.jwt.io/ 에서 JWT 토큰에 대해 자세히 알아볼 수 있습니다 .
이제 JWT 토큰의 도움으로 Authorization Server, Resource Server를 사용할 수있는 OAuth2 애플리케이션을 빌드 할 것입니다.
다음 단계를 사용하여 데이터베이스에 액세스하여 JWT 토큰으로 Spring Boot Security를 구현할 수 있습니다.
먼저 빌드 구성 파일에 다음 종속성을 추가해야합니다.
Maven 사용자는 pom.xml 파일에 다음 종속성을 추가 할 수 있습니다.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security.oauth</groupId>
<artifactId>spring-security-oauth2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-jwt</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>Gradle 사용자는 build.gradle 파일에 다음 종속성을 추가 할 수 있습니다.
compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')
compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")어디,
Spring Boot Starter Security − Spring Security 구현
Spring Security OAuth2 − OAUTH2 구조를 구현하여 Authorization Server 및 Resource Server를 활성화합니다.
Spring Security JWT − 웹 보안을위한 JWT 토큰 생성
Spring Boot Starter JDBC − 사용자의 사용 가능 여부를 확인하기 위해 데이터베이스에 액세스합니다.
Spring Boot Starter Web − HTTP 엔드 포인트를 작성합니다.
H2 Database − 인증 및 권한 부여를위한 사용자 정보를 저장합니다.
전체 빌드 구성 파일은 다음과 같습니다.
<?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>websecurityapp</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>websecurityapp</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>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security.oauth</groupId>
<artifactId>spring-security-oauth2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-jwt</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-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.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()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')
compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")
}이제 기본 Spring Boot 애플리케이션에서 @EnableAuthorizationServer 및 @EnableResourceServer 어노테이션을 추가하여 동일한 애플리케이션에서 인증 서버 및 리소스 서버로 작동합니다.
또한 다음 코드를 사용하여 JWT Token을 사용하여 Spring Security로 API에 액세스하기위한 간단한 HTTP 엔드 포인트를 작성할 수 있습니다.
package com.tutorialspoint.websecurityapp;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@EnableAuthorizationServer
@EnableResourceServer
@RestController
public class WebsecurityappApplication {
public static void main(String[] args) {
SpringApplication.run(WebsecurityappApplication.class, args);
}
@RequestMapping(value = "/products")
public String getProductName() {
return "Honey";
}
}인증을 위해 사용자 정보를 저장할 POJO 클래스를 정의하려면 다음 코드를 사용하십시오.
package com.tutorialspoint.websecurityapp;
import java.util.ArrayList;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;
public class UserEntity {
private String username;
private String password;
private Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Collection<GrantedAuthority> getGrantedAuthoritiesList() {
return grantedAuthoritiesList;
}
public void setGrantedAuthoritiesList(Collection<GrantedAuthority> grantedAuthoritiesList) {
this.grantedAuthoritiesList = grantedAuthoritiesList;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}이제 다음 코드를 사용하고 Spring Boot 인증을 위해 org.springframework.security.core.userdetails.User 클래스를 확장하는 CustomUser 클래스를 정의하십시오.
package com.tutorialspoint.websecurityapp;
import org.springframework.security.core.userdetails.User;
public class CustomUser extends User {
private static final long serialVersionUID = 1L;
public CustomUser(UserEntity user) {
super(user.getUsername(), user.getPassword(), user.getGrantedAuthoritiesList());
}
}@Repository 클래스를 생성하여 데이터베이스에서 사용자 정보를 읽고이를 Custom 사용자 서비스로 보내고 부여 된 권한 "ROLE_SYSTEMADMIN"을 추가 할 수도 있습니다.
package com.tutorialspoint.websecurityapp;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Repository;
@Repository
public class OAuthDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public UserEntity getUserDetails(String username) {
Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
String userSQLQuery = "SELECT * FROM USERS WHERE USERNAME=?";
List<UserEntity> list = jdbcTemplate.query(userSQLQuery, new String[] { username },
(ResultSet rs, int rowNum) -> {
UserEntity user = new UserEntity();
user.setUsername(username);
user.setPassword(rs.getString("PASSWORD"));
return user;
});
if (list.size() > 0) {
GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ROLE_SYSTEMADMIN");
grantedAuthoritiesList.add(grantedAuthority);
list.get(0).setGrantedAuthoritiesList(grantedAuthoritiesList);
return list.get(0);
}
return null;
}
}표시된대로 DAO 저장소 클래스를 호출하기 위해 org.springframework.security.core.userdetails.UserDetailsService를 확장하는 사용자 정의 사용자 세부 사항 서비스 클래스를 작성할 수 있습니다.
package com.tutorialspoint.websecurityapp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class CustomDetailsService implements UserDetailsService {
@Autowired
OAuthDao oauthDao;
@Override
public CustomUser loadUserByUsername(final String username) throws UsernameNotFoundException {
UserEntity userEntity = null;
try {
userEntity = oauthDao.getUserDetails(username);
CustomUser customUser = new CustomUser(userEntity);
return customUser;
} catch (Exception e) {
e.printStackTrace();
throw new UsernameNotFoundException("User " + username + " was not found in the database");
}
}
}다음으로 @configuration 클래스를 만들어 웹 보안을 활성화하고 암호 인코더 (BCryptPasswordEncoder)를 정의하고 AuthenticationManager 빈을 정의합니다. 보안 구성 클래스는 WebSecurityConfigurerAdapter 클래스를 확장해야합니다.
package com.tutorialspoint.websecurityapp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
@Autowired
private CustomDetailsService customDetailsService;
@Bean
public PasswordEncoder encoder() {
return new BCryptPasswordEncoder();
}
@Override
@Autowired
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(customDetailsService).passwordEncoder(encoder());
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().anyRequest().authenticated().and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.NEVER);
}
@Override
public void configure(WebSecurity web) throws Exception {
web.ignoring();
}
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
}이제 OAuth2 구성 클래스를 정의하여 클라이언트 ID, 클라이언트 시크릿을 추가하고, 토큰 서명자 키 및 검증 자 키에 대한 JwtAccessTokenConverter, 개인 키 및 공개 키를 정의하고 범위가있는 토큰 유효성에 대해 ClientDetailsServiceConfigurer를 구성하십시오.
package com.tutorialspoint.websecurityapp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
@Configuration
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
private String clientid = "tutorialspoint";
private String clientSecret = "my-secret-key";
private String privateKey = "private key";
private String publicKey = "public key";
@Autowired
@Qualifier("authenticationManagerBean")
private AuthenticationManager authenticationManager;
@Bean
public JwtAccessTokenConverter tokenEnhancer() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setSigningKey(privateKey);
converter.setVerifierKey(publicKey);
return converter;
}
@Bean
public JwtTokenStore tokenStore() {
return new JwtTokenStore(tokenEnhancer());
}
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
endpoints.authenticationManager(authenticationManager).tokenStore(tokenStore())
.accessTokenConverter(tokenEnhancer());
}
@Override
public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
security.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
}
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
clients.inMemory().withClient(clientid).secret(clientSecret).scopes("read", "write")
.authorizedGrantTypes("password", "refresh_token").accessTokenValiditySeconds(20000)
.refreshTokenValiditySeconds(20000);
}
}이제 openssl을 사용하여 개인 키와 공개 키를 만듭니다.
다음 명령을 사용하여 개인 키를 생성 할 수 있습니다.
openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem공개 키 생성을 위해 아래 명령을 사용할 수 있습니다.
openssl rsa -in jwt.pem -puboutSpring Boot 1.5 릴리스 이후 버전의 경우 application.properties 파일에 아래 속성을 추가하여 OAuth2 리소스 필터 순서를 정의합니다.
security.oauth2.resource.filter-order=3YAML 파일 사용자는 YAML 파일에 아래 속성을 추가 할 수 있습니다.
security:
oauth2:
resource:
filter-order: 3이제 클래스 경로 리소스 아래에 schema.sql 및 data.sql 파일을 만듭니다. src/main/resources/directory 애플리케이션을 H2 데이터베이스에 연결합니다.
schema.sql 파일은 다음과 같습니다.
CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));data.sql 파일은 다음과 같습니다.
INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES (
1, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG'); INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES ( 2, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG');Note − 비밀번호는 데이터베이스 테이블에 Bcrypt Encoder 형식으로 저장해야합니다.
다음 Maven 또는 Gradle 명령을 사용하여 실행 가능한 JAR 파일을 만들고 Spring Boot 애플리케이션을 실행할 수 있습니다.
Maven의 경우 아래 명령을 사용할 수 있습니다.
mvn clean install“BUILD SUCCESS”후 대상 디렉토리에서 JAR 파일을 찾을 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
이제 여기에 표시된 명령을 사용하여 JAR 파일을 실행하십시오.
java –jar <JARFILE>응용 프로그램은 Tomcat 포트 8080에서 시작됩니다.
이제 POSTMAN을 통해 POST 메서드 URL을 눌러 OAUTH2 토큰을 얻습니다.
http://localhost:8080/oauth/token
이제 다음과 같이 요청 헤더를 추가하십시오.
Authorization − 클라이언트 ID 및 클라이언트 비밀을 사용한 기본 인증.
Content Type − 응용 프로그램 / x-www-form-urlencoded
이제 다음과 같이 요청 매개 변수를 추가합니다.
- grant_type = 비밀번호
- username = 사용자 이름
- password = 비밀번호
이제 API를 누르고 다음과 같이 access_token을 얻습니다.
이제 다음과 같이 요청 헤더에서 Bearer 액세스 토큰으로 Resource Server API를 누르십시오.
그러면 아래와 같이 출력을 볼 수 있습니다.
Google Cloud Platform은 클라우드 환경에서 Spring Boot 애플리케이션을 실행하는 클라우드 컴퓨팅 서비스를 제공합니다. 이 장에서는 GCP 앱 엔진 플랫폼에 Spring Boot 애플리케이션을 배포하는 방법을 살펴 보겠습니다.
먼저 Spring Initializer 페이지 www.start.spring.io 에서 Gradle 빌드 Spring Boot 애플리케이션을 다운로드합니다 . 다음 스크린 샷을 관찰하십시오.
이제 build.gradle 파일에서 Google Cloud appengine 플러그인 및 appengine 클래스 경로 종속성을 추가합니다.
build.gradle 파일의 코드는 다음과 같습니다.
buildscript {
ext {
springBootVersion = '1.5.9.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
}
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'
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')
}이제 간단한 HTTP 끝점을 작성하면 다음과 같이 문자열 성공을 반환합니다.
package com.tutorialspoint.appenginedemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class AppengineDemoApplication {
public static void main(String[] args) {
SpringApplication.run(AppengineDemoApplication.class, args);
}
@RequestMapping(value = "/")
public String success() {
return "APP Engine deployment success";
}
}다음으로, src / main / appengine 디렉토리 아래에 app.yml 파일을 추가하십시오.
runtime: java
env: flex
handlers:
- url: /.*
script: this field is required, but ignored이제 Google Cloud 콘솔로 이동하여 페이지 상단의 Google Cloud Shell 활성화를 클릭합니다.
이제 Google Cloud Shell을 사용하여 소스 파일과 Gradle 파일을 Google 클라우드 머신의 홈 디렉토리로 이동합니다.
이제 gradle appengineDeploy 명령을 실행하면 애플리케이션이 Google Cloud appengine에 배포됩니다.
Note − GCP는 결제가 활성화되어 있어야하며 애플리케이션을 appengine에 배포하기 전에 GCP에서 appengine 플랫폼을 만들어야합니다.
애플리케이션을 GCP appengine 플랫폼에 배포하는 데 몇 분 정도 걸립니다.
빌드가 성공하면 콘솔 창에서 서비스 URL을 볼 수 있습니다.
이제 서비스 URL을 누르고 출력을 확인하십시오.
Google Cloud SQL
Google Cloud SQL을 Spring Boot 애플리케이션에 연결하려면 application.properties 파일에 다음 속성을 추가해야합니다.
JDBC URL 형식
jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>Note − Spring Boot 애플리케이션과 Google Cloud SQL은 동일한 GCP 프로젝트에 있어야합니다.
application.properties 파일은 다음과 같습니다.
spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance = springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = root&password = rootspring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000YAML 파일 사용자는 application.yml 파일에 아래 속성을 추가 할 수 있습니다.
spring:
datasource:
driverClassName: com.mysql.jdbc.Driver
url: "jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance=springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=root&password=root"
password: "root"
username: "root"
testOnBorrow: true
testWhileIdle: true
validationQuery: SELECT 1
max-active: 15
max-idle: 10
max-wait: 8000이 장에서는 Gradle 빌드와 함께 Spring Boot 애플리케이션을 사용하여 Google OAuth2 로그인을 추가하는 방법을 살펴 보겠습니다.
먼저 빌드 구성 파일에 Spring Boot OAuth2 보안 종속성을 추가하면 빌드 구성 파일이 아래에 제공됩니다.
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.projects'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
repositories {
mavenCentral()
}
dependencies {
compile('org.springframework.boot:spring-boot-starter')
testCompile('org.springframework.boot:spring-boot-starter-test')
compile('org.springframework.security.oauth:spring-security-oauth2')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
}이제 아래와 같이 메인 Spring Boot 애플리케이션 클래스 파일에서 Spring Boot를 통해 인증 한 후 Google에서 사용자 프린시 펄을 읽기 위해 HTTP Endpoint를 추가하십시오.
package com.tutorialspoint.projects.googleservice;
import java.security.Principal;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class GoogleserviceApplication {
public static void main(String[] args) {
SpringApplication.run(GoogleserviceApplication.class, args);
}
@RequestMapping(value = "/user")
public Principal user(Principal principal) {
return principal;
}
}이제 웹 보안을 위해 OAuth2SSO를 활성화하는 구성 파일을 작성하고 다음과 같이 index.html 파일에 대한 인증을 제거합니다.
package com.tutorialspoint.projects.googleservice;
import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
@EnableOAuth2Sso
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.csrf()
.disable()
.antMatcher("/**")
.authorizeRequests()
.antMatchers("/", "/index.html")
.permitAll()
.anyRequest()
.authenticated();
}
}다음으로, 정적 리소스 아래에 index.html 파일을 추가하고 아래와 같이 Google 사용자 주체를 읽기 위해 사용자 HTTP 엔드 포인트로 리디렉션 할 링크를 추가합니다.
<!DOCTYPE html>
<html>
<head>
<meta charset = "ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<a href = "user">Click here to Google Login</a>
</body>
</html>Note − Google Cloud 콘솔에서-Gmail 서비스, 분석 서비스 및 Google+ 서비스 API를 활성화합니다.
그런 다음 자격 증명 섹션으로 이동하여 자격 증명을 만들고 OAuth 클라이언트 ID를 선택합니다.
다음으로 OAuth2 동의 화면에 제품 이름을 제공합니다.
다음으로 애플리케이션 유형을 "웹 애플리케이션"으로 선택하고 승인 된 JavaScript 원본 및 승인 된 리디렉션 URI를 제공합니다.
이제 OAuth2 클라이언트 ID 및 클라이언트 시크릿이 생성됩니다.
다음으로 애플리케이션 속성 파일에 클라이언트 ID와 클라이언트 시크릿을 추가합니다.
security.oauth2.client.clientId = <CLIENT_ID>
security.oauth2.client.clientSecret = <CLIENT_SECRET>
security.oauth2.client.accessTokenUri = https://www.googleapis.com/oauth2/v3/token
security.oauth2.client.userAuthorizationUri = https://accounts.google.com/o/oauth2/auth
security.oauth2.client.tokenName = oauth_token
security.oauth2.client.authenticationScheme = query
security.oauth2.client.clientAuthenticationScheme = form
security.oauth2.client.scope = profile email
security.oauth2.resource.userInfoUri = https://www.googleapis.com/userinfo/v2/me
security.oauth2.resource.preferTokenInfo = false이제 실행 가능한 JAR 파일을 만들고 다음 Gradle 명령을 사용하여 Spring Boot 애플리케이션을 실행할 수 있습니다.
Gradle의 경우 다음과 같이 명령을 사용할 수 있습니다.
gradle clean build"BUILD SUCCESSFUL"후에 build / libs 디렉토리에서 JAR 파일을 찾을 수 있습니다.
java –jar <JARFILE> 명령을 사용하여 JAR 파일을 실행하면 Tomcat 포트 8080에서 애플리케이션이 시작됩니다.
이제 URL을 누르십시오. http://localhost:8080/ Google 로그인 링크를 클릭하십시오.
Google 로그인 화면으로 리디렉션되고 Gmail 로그인 세부 정보가 제공됩니다.
로그인이 성공하면 Gmail 사용자의 Principal 개체를 받게됩니다.
