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.

In java 8, predicate is an functional interface java.util.function.Predicate<T> which defines an abstract method named test, that accepts an object of generic type T and returns a boolean. Predicate can be used as assignment target for a lambda expression or method reference.

Example:

package com.manishsanger.Predicate;

public class Vehicle {

private String type;

private Integer displacement;
public Vehicle(String type, Integer displacement) {

this.type = type;

this.displacement = displacement;

}
@Override

public String toString() {

return "Vehicle - Type:" + this.getType() + ", Displacement:" + this.getDisplacement() +"cc";

}
public String getType() {

return type;

}
public void setType(String type) {

this.type = type;

}
public Integer getDisplacement() {

return displacement;

}
public void setDisplacement(Integer displacement) {

this.displacement = displacement;

}

}

If we need to get the vehicle whose displacement is more that 1500 cc, we can write a predicate for it as below:

public class VehiclePredicate {

public static Predicate<Vehicle> isDisplacementAbove1500() {

return vehicle -> vehicle.getDisplacement() >= 1500;

}

}

We can user this predicate in filter(), to filter list of vehicle by condition in the predicate.

package com.manishsanger.Predicate;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {

List<Vehicle> vehicles = Arrays.asList(

new Vehicle("SUV", 2200),

new Vehicle("SUV", 1800),

new Vehicle("SEDAN", 1600),

new Vehicle("HATCHBACK", 1400),

new Vehicle("SUV", 2800)

);
//Using default filter() method, using stream and lambda expression.
//return all Vehicles those have displacement more than 1500

System.out.println("All vehicles those have displacement more than 1500, Using default filter() method.");

vehicles.stream().filter(vehicle -> {

return vehicle.getDisplacement() >= 1500;

}).collect(Collectors.toList()).forEach(System.out::println);
//return all Vehicles those have displacement more than 1500

System.out.println("All SUV those have displacement more than 1500, Using default filter() method.");

vehicles.stream().filter(vehicle -> {

return vehicle.getType().equals("SUV") && vehicle.getDisplacement() >= 1500;

}).collect(Collectors.toList()).forEach(System.out::println);
}

}

Following will be the output:

All vehicles those have displacement more than 1500, Using default filter() method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

All SUV those have displacement more than 1500, Using default filter() method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SUV, Displacement:2800cc

We can also define our own custom filter method(), Now add a filterVehicles() method in VehiclePredicate class.

public static List<Vehicle> filterVehicles(List vehicles, Predicate<Vehicle> predicate) {

return vehicles.stream().filter(predicate).collect(Collectors.toList());

}

Add following code to Main class, to filter data using custom Predicate filter:

//Using custom filter method and java 8 lambda

System.out.println("\nAll vehicles those have displacement more than 1500, Using default custom filter method.");

VehiclePredicate.filterVehicles(vehicles, vehicle -> {

return vehicle.getDisplacement() >= 1500;

}).forEach(System.out::println);

Here is the output:

All vehicles those have displacement more than 1500, Using default custom filter method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

Here is how you can filter the list without lambda expression:

//Using custom filter method and without lambda

System.out.println("\nAll vehicles those have displacement more than 1500, Using default custom filter method without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500()).forEach(System.out::println);

Here is the output, for the above block of code:

All vehicles those have displacement more than 1500, Using default custom filter method.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

Java 8 Predicate Methods
Let’s now go through the methods available for Predicate:

1. Default Predicate and (Predicate other)

It returns a composed predicate that represents a logical AND of two predicates.

To understand this let’s add another predicate in the VehiclePredicates class:

public static Predicate<Vehicle> isTypeSUV() {

return vehicle -> vehicle.getType().equals("SUV");

}

Now we can apply and() and or() function if we want to predicate for Vehicle of type SUV and displacement more than 1500 cc.

Here is the code for Main method:

//Multiple filter with AND logical operator

System.out.println("\nAll SUV those have displacement more than 1500, Using custom Predicate filter without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500().and(VehiclePredicate.isTypeSUV())).forEach(System.out::println);

//Multiple filter with OR logical operator

System.out.println("\nAll Vehicle those have displacement more than 1500 or SUV, Using custom Predicate filter without lambda.");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isDisplacementAbove1500().or(VehiclePredicate.isTypeSUV())).forEach(System.out::println);

Here is the output:

All SUV those have displacement more than 1500, Using custom Predicate filter without lambda.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SUV, Displacement:2800cc

All Vehicle those have displacement more than 1500 or SUV, Using custom Predicate filter without lambda.

Vehicle - Type:SUV, Displacement:2200cc

Vehicle - Type:SUV, Displacement:1800cc

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:SUV, Displacement:2800cc

2. Default Predicate negate()
It return an predicate that represents logical NOT operator.

For example all Vehicles other than SUV:

//default negate(), Logical NOT operator. All vehicles other than SUV

System.out.println("\nAll vehicles other than SUV, using negate()");

VehiclePredicate.filterVehicles(vehicles, VehiclePredicate.isTypeSUV().negate()).forEach(System.out::println);

Here is the output:

All vehicles other than SUV, using negate()

Vehicle - Type:SEDAN, Displacement:1600cc

Vehicle - Type:HATCHBACK, Displacement:1400cc

3. Boolean test (T t)
Predicate test evaluates this predicate on the given argument.
For example we can pass an Vehicle object to check if this predicate return true or false:

Add the following code in main method:

//boolean test(T t) predicate

System.out.println("\nboolean test predicate");

Vehicle testVehicle = new Vehicle("SUV", 1000);

System.out.println(VehiclePredicate.isTypeSUV().test(testVehicle));

System.out.println(VehiclePredicate.isDisplacementAbove1500().test(testVehicle));

Here is the output:

boolean test(T t) predicate

true

false

4. static Predicate isEqual(Object targetRef)
Returns a predicate that tests if two arguments are equal according to Objects.equals() method.

Let’s say we overridden equals() method for Vehicle class

@Override

public boolean equals(Object obj) {

Vehicle vehicle = (Vehicle) obj;

if (this.getType().equals(vehicle.getType()) && this.getDisplacement().equals(vehicle.getDisplacement())) {

return true;

}

return false;

}

Now let’s say we have a Vehicle which has standard type & displacement. Then we can get a Predicate, that will test if the given Vehicle is standard or not.

//static Predicate isEqual(Object targetRef)

System.out.println("\nstatic Predicate isEqual(Object targetRef)");

Predicate standardVehiclePredicate = Predicate.isEqual(new Vehicle("SUV", 1800));

System.out.println(standardVehiclePredicate.test(new Vehicle("SUV", 1800)));

System.out.println(standardVehiclePredicate.test(new Vehicle("SUV", 1500)));

Here is the output:

static Predicate isEqual(Object targetRef)

true

false

Click here to see the source code

The post Predicate – Functional Interface (Java 8) appeared first on Manish Sanger.

Java introduced Functional interface & Lambda Expressions in Java 8, to leverage functional programming to reduce verbosity.

What is functional Interface?

A Functional Interface is an interface which specifies exactly one abstract method. Its implementation may be treated as Lambda Expression.

Note: An interface is still a functional interface if it has many default methods, as long as it specifies only one abstract method.

Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface’s abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere

While the main use of Functional interfaces is for lambda expressions, method references, and constructor references, they can still be used, like any interface, with anonymous classes, implemented by classes, or created by factory methods.

Java 8 provides some inbuilt functional interfaces like Comparable, Runnable, Callable etc.

If you want to define any functional interface of your own, you can use annotation @FunctionalInterface for compiler level errors. It will allow to specify only one abstract method.

Example:

@FunctionalInterface

public interface SomeInterface {

public String someMethod(String param);

}

A functional interface is valid even if the @FunctionalInterface annotation would be omitted. It is only for informing the compiler to enforce single abstract method inside interface.

Public interface SomeInterface {

String someMethod(String param);

}

//With default method

@FunctionalInterface

Public interface SomeInterface {

public String someMethod(String param);

default void someDefaultMethod(){

//method Implementation

}
}
// When overriding methods from the java.lang.Object
@FunctionalInterface

Public interface SomeInterface {

public String someMethod(String param);

@Override

public String toString();  //Overridden from Object class
@Override

public boolean equals(Object obj); //Overridden from Object class
}

The signature of abstract method in functional interface is called Functional descriptor because it defines the signature of the lambda expression.

Java 8 has introduced several functional interfaces in java.util.function package which can be used to describe the signature of various lambda expressions.

Here is the complete list of functional interfaces available in java.util.functional:

1. Predicate
2. Consumer
3. Function<T, R>
4. Supplier
5. UnaryOperator
6. BinaryOperator
7. BiPredicate<L, R>
8. BiConsumer<T, U>
9. BiFunction<T, U, R>

The post Functional Interface – Java 8 appeared first on Manish Sanger.

Object var1 = (Object arg1, Object arg2) -> {System.out.println("Hello Lambda")};

Object var1 = method(Object arg1, (Object arg2, Object arg3) -> {arg2 + arg3});

Lambda expression explained:

Lambda Expression

() -> {System.out.println("Hello Lambda")};

//With one parameters

(String hello) -> {System.out.println(hello)};

(String str1, String str2) -> {System.out.println(str1 + str2)};

(a,b) -> {a+b}

Note: Either you have to define the data type for all the parameters or none of them. You can’t choose define for some of them.
 
Lambda Operator (->)
The arrow (->) separates the method signature from the implementation.
 
Method implementation (Lambda body ):
Body of the Lambda expression can have expression or statements.
Note:
1. If there is only one statement in the body, curly braces are not required and return type is same as of body expression.
2. If there are more than one statements, then is must be in curly braces and return type will be as value return form the code block, void if nothing is returned.
 
 
Few more example of lambda expression:
//no argument and returns void

() -> {}

() -> "Hello Lambda"

() -> {return "Hello Lambda"}

The post Lambda Expressions appeared first on Manish Sanger.

New features introduced in java 8

Here are the list of high level features introduced in Java 8 along with lots of enhancement at complier and JVM level:

1. Lambda Expressions
Lambda expression is a concise representation of an anonymous function which can be passed as an argument to a method or stored in a variable. Click Here more details

2. Functional Interface
A Functional Interface is an interface which specifies exactly one abstract method. Click Here more details
3. Method References
4. Default methods in interface
5. Optional
6. Stream API
7. Date API
8. Nashorn, JavaScript Engine

The post What new features were added in Java8? appeared first on Manish Sanger.