Spring Boot – Bootstrapping

Spring Boot – Bootstrapping ”; Previous Next This chapter will explain you how to perform bootstrapping on a Spring Boot application. Spring Initializer One of the ways to Bootstrapping a Spring Boot application is by using Spring Initializer. To do this, you will have to visit the Spring Initializer web page www.start.spring.io and choose your Build, Spring Boot Version and platform. Also, you need to provide a Group, Artifact and required dependencies to run the application. Observe the following screenshot that shows an example where we added the spring-boot-starter-web dependency to write REST Endpoints. Once you provided the Group, Artifact, Dependencies, Build Project, Platform and Version, click Generate Project button. The zip file will download and the files will be extracted. This section explains you the examples by using both Maven and Gradle. Maven After you download the project, unzip the file. Now, your pom.xml file looks as shown below − <?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 Once you download the project, unzip the file. Now your build.gradle file looks as shown below − 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”) } Class Path Dependencies Spring Boot provides a number of Starters to add the jars in our class path. For example, for writing a Rest Endpoint, we need to add the spring-boot-starter-web dependency in our class path. Observe the codes shown below for a better understanding − Maven dependency <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> Gradle dependency dependencies { compile(”org.springframework.boot:spring-boot-starter-web”) } Main Method The main method should be writing the Spring Boot Application class. This class should be annotated with @SpringBootApplication. This is the entry point of the spring boot application to start. You can find the main class file under src/java/main directories with the default package. In this example, the main class file is located at the src/java/main directories with the default package com.tutorialspoint.demo. Observe the code shown here for a better understanding − 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); } } Write a Rest Endpoint To write a simple Hello World Rest Endpoint in the Spring Boot Application main class file itself, follow the steps shown below − Firstly, add the @RestController annotation at the top of the class. Now, write a Request URI method with @RequestMapping annotation. Then, the Request URI method should return the Hello World string. Now, your main Spring Boot Application class file will look like as shown in the code given below − 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”; } } Create an Executable JAR Let us create an executable JAR file to run the Spring Boot application by using Maven and Gradle commands in the command prompt as shown below − Use the Maven command mvn clean install as shown below − After executing the command, you can see the BUILD SUCCESS message at the command prompt as shown below − Use the Gradle command gradle clean build as shown below − After executing the command, you can see the BUILD SUCCESSFUL message in the command prompt as shown below − Run Hello World with Java Once you have created an executable JAR file, you can find it under the following directories. For Maven, you can find the JAR file under the target directory as shown below − For Gradle, you can find the JAR file under the build/libs directory as shown below − Now, run the JAR file by using the command java –jar <JARFILE>. Observe that in the above example, the JAR file is named demo-0.0.1-SNAPSHOT.jar Once you run the jar file, you can see the output in the console window as shown below − Now, look at the console, Tomcat started on port 8080 (http). Now, go to the web browser and hit the URL http://localhost:8080/ and you can see the output as shown below − Print Page Previous Next Advertisements ”;

Spring Boot – Application Properties

Spring Boot – Application Properties ”; Previous Next Application Properties support us to work in different environments. In this chapter, you are going to learn how to configure and specify the properties to a Spring Boot application. Command Line Properties Spring Boot application converts the command line properties into Spring Boot Environment properties. Command line properties take precedence over the other property sources. By default, Spring Boot uses the 8080 port number to start the Tomcat. Let us learn how change the port number by using command line properties. Step 1 − After creating an executable JAR file, run it by using the command java –jar <JARFILE>. Step 2 − Use the command given in the screenshot given below to change the port number for Spring Boot application by using command line properties. Note − You can provide more than one application properties by using the delimiter −. Properties File Properties files are used to keep ‘N’ number of properties in a single file to run the application in a different environment. In Spring Boot, properties are kept in the application.properties file under the classpath. The application.properties file is located in the src/main/resources directory. The code for sample application.properties file is given below − server.port = 9090 spring.application.name = demoservice Note that in the code shown above the Spring Boot application demoservice starts on the port 9090. YAML File Spring Boot supports YAML based properties configurations to run the application. Instead of application.properties, we can use application.yml file. This YAML file also should be kept inside the classpath. The sample application.yml file is given below − spring: application: name: demoservice server: port: 9090 Externalized Properties Instead of keeping the properties file under classpath, we can keep the properties in different location or path. While running the JAR file, we can specify the properties file path. You can use the following command to specify the location of properties file while running the JAR − -Dspring.config.location = C:application.properties Use of @Value Annotation The @Value annotation is used to read the environment or application property value in Java code. The syntax to read the property value is shown below − @Value(“${property_key_name}”) Look at the following example that shows the syntax to read the spring.application.name property value in Java variable by using @Value annotation. @Value(“${spring.application.name}”) Observe the code given below for a better understanding − 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 − If the property is not found while running the application, Spring Boot throws the Illegal Argument exception as Could not resolve placeholder ”spring.application.name” in value “${spring.application.name}”. To resolve the placeholder issue, we can set the default value for the property using thr syntax given below − @Value(“${property_key_name:default_value}”) @Value(“${spring.application.name:demoservice}”) Spring Boot Active Profile Spring Boot supports different properties based on the Spring active profile. For example, we can keep two separate files for development and production to run the Spring Boot application. Spring active profile in application.properties Let us understand how to have Spring active profile in application.properties. By default, application. properties will be used to run the Spring Boot application. If you want to use profile based properties, we can keep separate properties file for each profile as shown below − application.properties server.port = 8080 spring.application.name = demoservice application-dev.properties server.port = 9090 spring.application.name = demoservice application-prod.properties server.port = 4431 spring.application.name = demoservice While running the JAR file, we need to specify the spring active profile based on each properties file. By default, Spring Boot application uses the application.properties file. The command to set the spring active profile is shown below − You can see active profile name on the console log as shown below − 2017-11-26 08:13:16.322 INFO 14028 — [ main] com.tutorialspoint.demo.DemoApplication : The following profiles are active: dev Now, Tomcat has started on the port 9090 (http) as shown below − 2017-11-26 08:13:20.185 INFO 14028 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 9090 (http) You can set the Production active profile as shown below − You can see active profile name on the console log as shown below − 2017-11-26 08:13:16.322 INFO 14028 — [ main] com.tutorialspoint.demo.DemoApplication : The following profiles are active: prod Now, Tomcat started on the port 4431 (http) as shown below − 2017-11-26 08:13:20.185 INFO 14028 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 4431 (http) Spring active profile for application.yml Let us understand how to keep Spring active profile for application.yml. We can keep the Spring active profile properties in the single application.yml file. No need to use the separate file like application.properties. The following is an example code to keep the Spring active profiles in application.yml file. Note that the delimiter (—) is used to separate each profile in application.yml file. 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 To command to set development active profile is given below − You can see active profile name on the console log as shown below − 2017-11-26 08:41:37.202 INFO 14104 — [ main] com.tutorialspoint.demo.DemoApplication : The following profiles are active: dev Now, Tomcat started on the port 9090 (http) as shown below − 2017-11-26 08:41:46.650 INFO 14104 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 9090 (http) The command to set Production active profile is given below − You can see active profile name on the console log as shown below − 2017-11-26 08:43:10.743 INFO 13400 — [ main] com.tutorialspoint.demo.DemoApplication : The following profiles are active: prod This will start Tomcat on the port 4431 (http) as shown below: 2017-11-26 08:43:14.473 INFO 13400 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 4431 (http) Print Page Previous Next