Why Spring Boot?
In a traditional monolithic approach for developing web/RESTful application, a WAR is created and deployed on a web server like: Tomcat, Jboss, IBM WebSphere etc.
From a microservices point of view, we need to develop services as executable, self-contained JAR files with an embedded HTTP listener.

Spring Boot features:

1. 1. Self-Contained web server: We can easily embed HTTP listeners for the web application. We can easily create a self-contained HTTP server using embedded tomcat, jetty etc.
   2. Standalone application: We can create a standalone executable application. It has SpringApplication class which provides the convenient way to bootstrap a spring application which can be started from the main method just by calling static method SpringApplication.run().
   3. Externalized configuration: It allows us to externalize the configuration so that we can work with the same application in various environments. We can use YAML files to externalize the configuration.
   4. YAML Support: It provides support for YAML configuration by default.
   5. Application Properties: It provides a rich set of application properties, for example: server-port, application-name and many more.
   6. Actuator: It provides production readiness by actuators such as metrics and health check.
   7. Type-safe configuration: It also provides a strong type-safe way to handle the configuration by allowing the developer to create a bean and populating it with the property value from a configuration file using annotation.
   8. Logging: It provides out of the box logging for all internal logging. Logback is provided by default without any additional configuration, which can be altered if needed.
   9. Security: It provides the feature of enabling the basic security by using the spring boot started security. It enables the basic security by default, which can be further enhanced to utilize the full strength of Spring security.

Related Articles:
Getting started with Spring Boot, Create your first REST API application

The post Introduction to Spring Boot appeared first on Manish Sanger.

Prerequisite:

1. Maven 3.X
2. Java 1.8/1.7

Getting Started – Step by Step guide

The best way to bootstrap your Spring Boot projects is to use Spring Initializr

It allows you to bootstrap various type of Spring Boot application from a simple web UI. You can select various available libraries from UI as per your requirement.

There are various option to generate, you can choose from Maven/Gradle project, with Java/Kotlin/Groovy and appropriate spring boot version. We will be using Maven, Java and Spring Boot 2.0.0 here.

Define group, artifact, name & description of the application on the UI.

Click on “Switch to the full version” at the bottom left to see the list all available library options to be included in the project. For this article, I have selected the following as this is just a basic article to get started with Spring Boot.

Web:
-Web
-Jersey(JAX-RS)

Ops:
-Actuator

Click on “Generate Project” button at the bottom of the screen to download bootstrap project with Spring Boot.

Spring Initializr- Spring Boot, bootstrap your first REST API application

Import the project in your favorite IDE – Eclipse, IntelliJ Idea, STS or any other. I am using IntelliJ Idea on Mac OSX.

Project Structure will look like as follows:

Spring boot – REST API project structure

Here is pom.xml dependencies, downloaded from Spring Initializr.

Spring Boot REST API – maven dependencies

spring-boot-starter-web – Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container.

spring-boot-starter-actuator – Actuator provides production readiness of the application by monitoring our application, gathering metrics, understanding traffic, state of database etc. Will see actuator in more details in my next article.

Here is the Application file, which has the main method to run the Spring Boot application to make it executable:

@SpringBootApplication

public class SpringbootdemoApplication {

public static void main(String[] args) {

SpringApplication.run(SpringbootdemoApplication.class, args);

}

}

Create a Rest Controller, to create your first REST endpoint. Here is the code:

@RestController

@RequestMapping(value = "/", produces = MediaType.APPLICATION_JSON_VALUE)

public class HelloController {

@RequestMapping("/")

public ResponseEntity<Response<List>> index() {

HttpHeaders headers = new HttpHeaders();

List listData = new ArrayList<>();

listData.add("This is a First REST API with Spring boot");

listData.add("Test2");
return new ResponseEntity<>(new Response<>(HttpStatus.OK.value(),

"First Spring Boot REST API is working", listData), HttpStatus.OK);

}

}

I create a class named Response to convert data to JSON and define a proper response format. This is not required, but I always prefer to have a class like this as it easy to format/standardize your response and pass HTTP status code &message to variety of API consumers.

@JsonInclude(value = Include.NON_EMPTY)

public class Response {

private int status;

private String message;

private T data;
public Response(int status, String message, T data) {

super();

this.status = status;

this.message = message;

this.data = data;

}
public Response() {

super();

}
public int getStatus() {

return status;

}
public String getMessage() {

return message;

}
public T getData() {

return data;

}

}

You can also use lombok project (https://projectlombok.org/), if you don’t want to write/generate getters & setters.

That’s it, now we are ready to launch our first sample Spring Boot REST API project.

Go to Terminal and use the following commands to run the application.

mvn clean install

java -jar springbootdemo-0.0.1-SNAPSHOT.jar

You can also run from your IDE. I am using IntelliJ Idea, so I can run it from IDE itself.

Once the run is complete, you can access it on http://localhost:8080/ or via postman. We haven’t made any configuration changes to it will run on localhost and default port 8080.

Here is the response:

Spring Boot – REST API Response

You can access Actuator Health and Info as follows:
http://localhost:8080/actuator/health
http://localhost:8080/actuator/info

The post Getting started with Spring Boot, Create your first REST API application appeared first on Manish Sanger.

Many organizations such as Netflix and Amazon used this technique to functionally partition their applications into smaller atomic units.

Micro-services originated from the idea of hexagonal architecture. Hexagonal architecture is also known as the Ports and Adapters Pattern.
Hexagonal Architecture >>

Monolithic Application

Let’s take an example of an E-commerce application. In a typical monolithic architecture, all modules are part of the same project/package and are connected with single database technology as shown in the architecture above. Here are some of the problem, which developer and business were facing with Monolithic architecture over the period of time:

1. In older and large applications, codebase increased over the period of time and it takes ages to build and deploy.
2. There is a technology constraint with the application, new features have to be developed with old technology stack, or it requires a huge amount of effort to upgrade the version or using latest tools and technologies available.
3. Each module is tightly coupled with other modules, so if you change one module it will impact the other module also, so maintaining the monolithic applications are more error-prone.
4. When you make a change in any module, whole application has to be built and deployed again.
5. You can’t scale only one section of the application. For example, in an E-commerce application, search and browse catalog usually have the highest load, in the monolithic approach we can’t only scale these two services only, we have to scale the whole application on separate server instances behind a load balancer.

In traditional monolithic application, we build a .war or .ear and deploy it on an application server like Tomcat, JBoss, WebLogic, WebSphere etc. In micro-service architecture, each micro-service will be built as a jar, embedded with all the dependencies and run as a standalone Java process.
Micro-services may also have their own containers for execution. Container technology like Docker is an ideal choice for micro-services deployment.

Microservices Architecture

Benefits of using micro-services:

1. Can use different architecture, technology and version of the technology for each micro-service.
2. Enabling experimentation and innovation. for example, recommendation engine, where we keep changing the recommendation algorithm.
3. Elastically and selectively scalable, we can select only the selected service where application receives the highest load. For example: Search and Catalog section of the e-commerce application.
4. This enables building up an organic system, where we keep adding the feature in an agile way over the period of time without impacting the existing system.
5. This helps in reduction of technology debt, we can change/upgrade technologies with much lesser effort/impact as compare to monolithic.
6. It supporting event-driven architecture, for example: In e-commerce when an order is received various service has to be invoked like: save order, update inventory, send email/SMS/push notification, data analysis, delivery etc.
7. Micro-service are the key enabler for DevOps. It advocates automating as much as possible, for example, continuous integration – testing, automatic infrastructure provisioning, automatic build, automatic deployment etc.

The post Microservices – An Introduction appeared first on Manish Sanger.