Spring Boot:

Main Method
The main method should be writing the Spring Boot Application class. This class should
be annotated with @SpringBootApplication.

Import org.springframework.boot.SpringApplication;i

mport org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

Spring Boot Servlet Initializer

the Spring Boot Application @SpringBootApplication class extend the

SpringBootServletInitializerclass. Spring Boot Servlet Initializer class file allows you to
configure the application when it is launched by using Servlet Container.

@SpringBootApplication

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

Setting Main Class

In Spring Boot, we need to mention the main class that should start in the build file. For
this purpose, you can use the following pieces of code −

For Maven, add the start class in pom.xml properties as shown below −

<start-class>com.ib.DemoApplication</start-class>

Simple Rest Endpoint in Spring Boot Application class file using the code as shown
below −

@SpringBootApplication

@RestController

public class DemoApplication extends SpringBootServletInitializer {

@Override protected
SpringApplicationBuilderconfigure(SpringApplicationBuilderapplication) {

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";

}
 }

Beans and Dependency Injection

In Spring Boot, we can use Spring Framework to define our beans and their dependency
injection. The @ComponentScan annotation is used to find beans and the corresponding
injected with @Autowired annotation.

Spring Boot - Runners

Application Runner and Command Line Runner interfaces lets you to execute the code
after the Spring Boot application is started. You can use these interfaces to perform any
actions immediately after the application has started.

Spring Boot - Application Properties

Command Line Properties

Step 1 − After creating an executable JAR file, run it by using the command java –jar
<JARFILE>.

Java -jar abc.jar --server.port=9090

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

YAML File
Spring Boot supports YAML based properties configurations to run the application.
Instead of application.properties, we can use application.ymlfile. 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

@Value("${property_key_name}")
Ex:-
@Value("${spring.application.name}")

Code :-

@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() {

returnname;

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 active profile in application.properties
f 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 −

Java -jar abc.jar --spring.profiles.active=dev

Spring Boot - Logging

Console Log Output

java –jar demo.jar --debug

You can also add the debug mode to your application.properties file as shown here −

debug = true
File Log Output

logging.path = /var/tmp/

You can specify the own log file name using the property shown below −

logging.file = /var/tmp/mylog.log

Note − files will rotate automatically after reaching the size 10 MB.

Log Levels
logging.level.root = WARN

Spring Boot - Building RESTful Web Services

Note − For building a RESTful Web Services, we need to add the Spring Boot Starter
Web dependency into the build configuration file.

If you are a Maven user, use the following code to add the below dependency in your
pom.xml file −

<dependency>

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

</dependency>

Rest Controller

The @RestController annotation is used to define the RESTful web services. It serves
JSON, XML and custom response. Its syntax is shown below −

@RestController
public class ProductServiceController {
}

Request Mapping
The @RequestMapping annotation is used to define the Request URI to access the
REST Endpoints. We can define Request method to consume and produce object. The
default request method is GET.

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

Request Body
The @RequestBody annotation is used to define the request body content type.

public ResponseEntity<Object> createProduct(@RequestBody Product product) {

}

Path Variable
The @PathVariable annotation is used to define the custom or dynamic request URI. The
Path variable in request URI is defined as curly braces {} as shown below −

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {

}

Request Parameter
The @RequestParam annotation is used to read the request parameters from the Request
URL. By default, it is a required parameter. We can also set default value for request
parameters as shown here −

public ResponseEntity<Object> getProduct(

@RequestParam(value = "name", required = false, defaultValue = "honey") String
name) {
}

Code :-

@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)

publicResponseEntity<Object>delete(@PathVariable("id") Stringid){

productRepo.remove(id);

return new ResponseEntity<>("Product is deleted successsfully",HttpStatus.OK);

@RequestMapping(value ="/products/{id}",method =RequestMethod.PUT)

publicResponseEntity<Object> updateProduct(@PathVariable("id") Stringid,
@RequestBody Product product) {

productRepo.remove(id);

product.setId(id);
productRepo.put(id, product);

Return newResponseEntity<>("Product is updated successsfully",HttpStatus.OK);

@RequestMapping(value = "/products",method = RequestMethod.POST)

publicResponseEntity<Object>createProduct(@RequestBodyProduct product){

productRepo.put(product.getId(), product);
 Return new ResponseEntity<>("Product is created
successfully",HttpStatus.CREATED);

@RequestMapping(value ="/products") publicResponseEntity<Object>getProduct() {

return newResponseEntity<>(productRepo.values(), HttpStatus.OK);

Spring Boot - Exception Handling

Controller Advice
The @ControllerAdvice is an annotation, to handle the exceptions globally.
Exception Handler
The @ExceptionHandler is an annotation used to handle the specific exceptions and
sending the custom responses to the client.

The complete code to handle the exception is given below. In this example, we used the
PUT API to update the product. Here, while updating the product, if the product is not
found, then return the response error message as “Product not found”. Note that the
ProductNotFoundException exception class should extend the RuntimeException.

Public class ProductNotfoundException extendsRuntimeException {

private static final long serialVersionUID = 1L;

The Controller Advice class to handle the exception globally is given below. We can
define any Exception Handler methods in this class file.

@ControllerAdvice
public class ProductExceptionController {

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {

Return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);

The Product Service API controller file is given below to update the Product. If the
Product is not found, then it throws the ProductNotFoundExceptionclass.

@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 - Interceptor

To work with interceptor, you need to create @Component class that supports it and it
should implement the HandlerInterceptor interface.

The following are the three methods you should know about while working on
Interceptors −

preHandle() method − This is used to perform operations before sending the request to
the controller. This method should return true to return the response to the client.

postHandle() method − This is used to perform operations before sending the response to
the client.

afterCompletion() method − This is used to perform operations after completing the

request and response.

Observe the following code for a better understanding −

@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"); }

The code for Application Configuration class file to register the Interceptor into
Interceptor Registry – ProductServiceInterceptorAppConfig.java is given below −

@Component

public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {

@Autowired

ProductServiceInterceptor productServiceInterceptor;

@Override
public void addInterceptors(InterceptorRegistry registry) {

registry.addInterceptor(productServiceInterceptor); }

The code for Controller class file ProductServiceController.java is given below −

@RestController

public class ProductServiceController {

private static Map<String, Product> productRepo = new HashMap<>();

static{

Producthoney = new Product();

honey.setId("1");

honey.setName("Honey");

productRepo.put(honey.getId(),honey);

Product almond = newProduct();

almond.setId("2");

almond.setName("Almond");

productRepo.put(almond.getId(), almond);

@RequestMapping(value ="/products")

publicResponseEntity<Object> getProduct(){

return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);

}
Spring Boot - Servlet Filter
By using filter, we can perform two operations at two instances −

 Before sending the request to the controller

 Before sending a response to the client.

In doFilter() method, we have added the System.out.println statements to print the

remote host and remote address.

@Component\

public class SimpleFilter implements Filter {

@Override

public void destroy() {}

@Override

public void doFilter(ServletRequest request,ServletResponse response,

FilterChainfilterchain)

throwsIOException, 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 - Rest Template

Rest Template is used to create applications that consume RESTful Web Services. You
can use the exchange() method to consume the web services for all HTTP methods. The
code given below shows how to create Bean for Rest Template to auto wiring the Rest
Template object.

@SpringBootApplication

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

@Bean

public RestTemplate getRestTemplate() {

return new RestTemplate();

GET
Consuming the GET API by using RestTemplate - exchange() method

You will have to follow the given points to consume the API −

 Autowired the Rest Template Object.

 Use HttpHeaders to set the Request Headers.
 Use HttpEntity to wrap the request object.
 Provide the URL, HttpMethod, and Return type for Exchange() method.

@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();

POST
Consuming POST API by using RestTemplate - exchange() method

You will have to follow the points given below to consume the API −

Autowired the Rest Template Object.

Use the HttpHeaders to set the Request Headers.

Use the HttpEntity to wrap the request object. Here, we wrap the Product object to send
it to the request body.

Provide the URL, HttpMethod, and Return type for exchange() method.

@RestController

public class ConsumeWebService {

@Autowired RestTemplaterestTemplate;

@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();
}

Spring Boot - File Handling

File Upload

you can use MultipartFile as a Request Parameter and this API should consume Multi-
Part form data value.

@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"; }

}@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;

File Download
you should use InputStreamResource for downloading a File. We need to set the
HttpHeader Content-Disposition in Response and need to specify the response Media
Type of the application.

Note − In the following example, file should be available on the specified path where the
application is running.

@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( Medi
aType.parseMediaType("application/txt")).body(resource);

return responseEntity;
}

Spring Boot - Service Components

Service Components are the class file which contains @Service annotation. These class
files are used to write business logic in a different layer, separated from @RestController
class file. The logic for creating a service component class file is shown here −

Public interface ProductService {}

The class that implements the Interface with @Service annotation is as shown −

@Service public class ProductServiceImpl implements ProductService {}

Code full with diffrent layers:-

public interface ProductService {

public abstract void createProduct(Product product);

public abstract void updateProduct(String id, Product product);

public abstract void deleteProduct(String id);

public abstractCollection<Product>getProducts();}

The following code will let you to create a class which implements the ProductService
interface with @Service annotation and write the business logic to store, retrieve, delete
and updates the 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(); }

The code here show the Rest Controller class file, here we @Autowired the
ProductService interface and called the methods.

@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);

}

Spring Boot - Thymeleaf

Web Application
You can use Thymeleaf templates to create a web application in Spring Boot. You will
have to follow the below steps to create a web application in Spring Boot by using
Thymeleaf.

Use the following code to create a @Controller class file to redirect the Request URI to
HTML file −

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

@Controller

public class WebController {

@RequestMapping(value = "/index")

public String index() {

return "index";

In the above example, the request URI is /index, and the control is redirected into the
index.html file. Note that the index.html file should be placed under the templates
directory and all JS and CSS files should be placed under the static directory in
classpath. In the example shown, we used CSS file to change the color of the text.

Maven users can add the following dependency into the pom.xml file −

<dependency>

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

</dependency>

Spring Boot - CORS Support

Cross-Origin Resource Sharing (CORS) is a security concept that allows restricting the
resources implemented in web browsers. It prevents the JavaScript code producing or
consuming the requests against different origin.

For example, your web application is running on 8080 port and by using JavaScript you
are trying to consuming RESTful web services from 9090 port. Under such situations,
you will face the Cross-Origin Resource Sharing security issue on your web browsers.

Two requirements are needed to handle this issue −

RESTful web services should support the Cross-Origin Resource Sharing.

RESTful web service application should allow accessing the API(s) from the 8080 port.

Enable CORS in Controller Method

We need to set the origins for RESTful web service by using @CrossOrigin annotation for the controller
method. This @CrossOrigin annotation supports specific REST API, and not for the entire application.

@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")

public ResponseEntity<Object> getProduct() {

return null;