## Using Math.pow in Java

In this quick post, we will get an understanding of Using Math.pow in Java. power of the number in a very simple term indicates as to how many times to use a number for multiplication.

### 1.  Example

`Math.pow` have a very simple signature like

`public static double pow(double a, double b)`, where `'a'` indicates the base,  `'b'` indicated the exponent and `Math.pow()` will return the value as

``ab``

Let’s look into a very simple example to understand how Mah.pow works.

``````@Test
public void calculateIntPow(){
int a= 3;
int b=4;

int result = (int) Math.pow(a,b);

assertEquals(81, result);
}``````

Since we were expecting results in an int, it was required to cast the output to int to get desired results.We are not required to cast results in case desired output is in double (which is also output for  of the `Math.pow()` method)

``````@Test
public void calculateDoublePow(){
double a= 3.4;
int b=4;

double result =  Math.pow(a,b);

assertEquals(133.63, result, 2);
}``````

There are certain features/properties of this method, read  Math.pow for more detail.

### Summary

In this quick post, we get an understanding as to how to Use Math.pow method in Java to calculate the power of any given base.

# Initializing Arrays in Java

In this post, we will cover different options for Initializing Arrays in Java along with main differences with each option.

### Introduction

In this post, we will be covering some of the commonly used ways for Initializing Arrays in Java, we will also discuss briefly these different options and subtle differences between them.

### 1. Initializing using Loop

One of the simplest ways is to initialize an array using a loop, this method will fill one element at a time in the Array.

``````for( int i=0; i< length ; i++){
data[i] = i;
}``````

### 2. Initializing During Declaration

If we know about the size and element of the array, we can also initialize it at the declaration time.

``````int[] data = {101,201,130,401,350,660,771,880,890,891};

int[] data;
data = new int[] {100,200,300,400,500,600,710,800,900,912};

String[] strings = new String[] {"Sunday", "Monday","Tuesday"};``````

Please be aware the with above syntax, you will not be able to initialize after this, the system will be throwing a compile-time error if we will try to do this.

### 3. Arrays.fill()

Arrays class contains various methods for manipulating arrays, we can use any of the `Arrays.fill()` method to fill given the array with the same value.

``````long array[] = new long[15];
Arrays.fill(array, 20);``````

There are multiple variations of the fill method which can be used based on the requirement.

### 4. Arrays.setAll()

These methods set all elements of the specified array, using the provided generator function to compute each element.

``````int[] arr = new int[10];
Arrays.setAll(arr, (index) -> 1 + index);``````

### Summary

In this short post, we covered different options to Initializing Arrays in Java. These are handy techniques and commonly used in the day to day development.

In this post, we will explore as of how to Log Incoming Requests In Spring. We will explore different options to accomplish it along with the build in feature provided by Spring.

### 1. Introduction

Having the ability to log incoming request in a web application is a very common requirement for modern web applications.In this article, we will be covering how to do it using Spring’s logging filter.

### 2. Dependency Management

In order to add required logging dependencies, we can add spring-core, for this article, we will be using Spring Boot which will handle dependency management for us. Checkout Building an Application with Spring Boot to learn about Spring Boot dependency management. We will add Spring Boot dependencies to start our web application.

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

### 3. Web Controller

In order to log incoming request, we need to have a Spring Controller in place, we will be using a simple controller for our post. Read  Creating a Web Application with Spring Boot to get an understanding of creating a web application using Spring Boot.

``````@RestController
public class LoggingDemoController {

@GetMapping("/demo/greeting")
public String sayHello(){
return "Hello Stranger !!!";
}
}``````

There is nothing special with this controller and it is simply returning `"Hello Stranger !!! "` to the client.

### 4. Custom Solutions

We will not get into details for this solution, but we can Spring provides interceptors to perform actions before and after web request.You can use `HandlerInterceptor` to create your custom implementation to log incoming request.

You have to be careful while using such approach as input stream will be marked as consumed the moment it is read for the first time.

We can also use Spring’s `ContentCachingRequestWrapper` to handle above issue by storing request stream in the cache but this needs a certain amount of work and customization.

### 5. Spring Built-In Request Logging

Spring comes with ready to use a feature which can log your request, all we are required to configure this ready to use solution. Spring comes with `AbstractRequestLoggingFilter`, that perform logging operations before and after a request is processed.

Before we get into implementation details, this filter requires a subclass to override the `beforeRequest(HttpServletRequest, String)` and `afterRequest(HttpServletRequest, String)` methods to perform the actual logging around the request.

Spring provides following 2 implementations for `AbstractRequestLoggingFilter`

1. `CommonsRequestLoggingFilter`
2. `ServletContextRequestLoggingFilter`

`ServletContextRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the `ServletContext` log.We are going to discuss `CommonsRequestLoggingFilter` in this post.

#### 5.1 CommonsRequestLoggingFilter using Spring Boot

Spring Boot is the new way to create and run your Spring-powered applications, we can enable `CommonsRequestLoggingFilter` by simply registering it as a bean with our application.

``````@Bean
public CommonsRequestLoggingFilter requestLoggingFilter() {
CommonsRequestLoggingFilter loggingFilter = new CommonsRequestLoggingFilter();
loggingFilter.setIncludeClientInfo(true);
loggingFilter.setIncludeQueryString(true);
return loggingFilter;
}``````

In addition to above configuration, we need to make sure to set log level as DEBUG for CommonsRequestLoggingFilter either through `application.properties` or `YAML`

``logging.level.org.springframework.web.filter.CommonsRequestLoggingFilter=DEBUG``

Once these configurations are in place, you should be able to see a similar output in the console

``````2017-10-25 19:52:02.708 DEBUG 70034 --- [io-10070-exec-4] o.s.w.f.CommonsRequestLoggingFilter      : Before request [uri=/demo/greeting;client=0:0:0:0:0:0:0:1]
2017-10-25 19:52:02.791 DEBUG 70034 --- [io-10070-exec-4] o.s.w.f.CommonsRequestLoggingFilter      : After request [uri=/demo/greeting;client=0:0:0:0:0:0:0:1]
``````

And voila, you have your requests are getting logged.

#### 5.2 CommonsRequestLoggingFilter without Spring Boot

If you are not using Spring Boot, You can configure this by using traditional Filter.We have following options to configure this in our traditional web application

1. Configure this `Filter` either through xml configuration or Java configuration with default values.
2. Create a custom filter by extending `CommonsRequestLoggingFilter` to modify default behaviour.

##### 5.2.1 CommonsRequestLoggingFilter using XML

If you want to use `CommonsRequestLoggingFilter` with no changes, you can simply configure it in your application configuration file as a filer

``````<filter>
<filter-name>requestLoggingFilter</filter-name>
<filter-class>org.springframework.web.filter.CommonsRequestLoggingFilter</filter-class>
<init-param>
<param-name>includeClientInfo</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>includeQueryString</param-name>
<param-value>true</param-value>
</init-param>
</filter>
``````
##### 5.2.2 CommonsRequestLoggingFilter using Java Web Initializer

If you are not a fan of using `XML` configuration for your web application, Spring provides a way to configure it using `WebApplicationInitializer`.Please note that `WebApplicationInitializer Interface` to be implemented in Servlet 3.0+ environments in order to configure the `ServletContext` programmatically.

``````public class MyWebAppInitializer implements WebApplicationInitializer {

@Override
public void onStartup(ServletContext container) {
XmlWebApplicationContext appContext = new XmlWebApplicationContext();
appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");

ServletRegistration.Dynamic dispatcher =

}

}``````
##### 5.2.3 Custom CommonsRequestLoggingFilter

If you want to customize behaviour of `CommonsRequestLoggingFilter`, you can always create your custom `Filter` by extending `CommonsRequestLoggingFilter`

``````public class CustomeRequestLoggingFilter extends CommonsRequestLoggingFilter {

// custom code
}
``````

You can use any of the above options to configure your custom Filter.

#### Summary

In this post, we explore as of how to Log Incoming Request in Spring.Spring comes with many hidden features which can always help us to avoid writing custom/duplicate code and `CommonsRequestLoggingFilter` is one of such hidden gem in Spring.

## Building an Application with Spring Boot

In this post, we will explore Building an Application with Spring Boot. We will cover different aspects of Spring Boot along with different options to build an application using Spring Boot.

### 1. Introduction

Spring Boot is an opinionated, convention over configuration.Spring Boot takes away most part of the project set up by taking an opinionated view of the Spring platform so that new and existing users can quickly get to the bits they need.Spring Boot makes it easy to create a Spring-powered enterprise application with minimum fuss.

### 2. Spring Boot Features

Spring Boot provides the following feature out of the box

1. It simplifies Spring dependencies by taking the opinionated view ( we will discuss it in more details).
2. Spring Boot provides a preconfigured set of technologies/framework to reduces error-prone configuration so we as a developer focused on building our business logic rather than thinking of project setup.
3. You really don’t need those big `XML configurations` for your project.
4. Embed Tomcat, Jetty or Undertow directly.
5. Provide opinionated `Maven POM` to simplify your configuration

### 3. Creating Spring Boot Project

One of the main challenges to starting up a new project is the initial setup for the project. We need to take a call about the different directory structure and also need to make sure we are following all the industry standards.If you are using Maven, you might already be using Maven startup artefact which helps us to do those initial setups more quickly.

Spring Initializr is another great tool to quickly start Spring Boot projects. Spring Initializr is a web application that generates Spring Boot projects. Keep in mind that it will only generate project structure and not any code for you based on your preference (`Maven or Gradle`). If you are starting your project, my recommendation is to start with Spring Initializr.

There are multiple ways to use Spring Boot Initializr to generate project structure for you.

1. Using  Spring Initializr Web Interface.
2. Use Spring Boot CLI tool.

##### 3.1 Using Spring Initializer Web Interface

This is the simplest way to generate project structure for your application.Open Spring Initializr Web interface your browser and you will be presented with a wizard to start your configurations.

You are required to fill some information in the web interface to start with

1. What kind of project you want to generate (Maven or Gradle)
2. What is your preferred language (Apart from Java you will get an option for Kotlin and Groovy)
3. Spring Boot Version
4. Standard project group and artefact details.
5. Dependencies.

Dependencies is an interesting feature in the web interface, based on your selected Dependencies, web interface will automatically add Spring Boot Starter dependencies in the generated `pom.xml` file.In case you want a more control on the generated project structure or not sure what all dependencies you want to add to your project, click on the “Switch to the full version”.

With the full version, you have the option to select Java version, packaging mode (maybe .war for traditional deployment) along with an option to select dependencies for your project. Once you click on “Generate Project” button, Spring Initializr will generate project you will be given a zip to download. You can import the unzipped project as a simple Maven/ Gradle based project in your IDE.

I will not be covering details as to how you can import this in your IDE. Please refer to relevant IDE document for more details.

##### 3.2 Using Spring Boot CLI

We can also use Spring Boot CLI to generate structure for your project, once you have installed CLI, open command prompt and type spring. If CLI is installed correctly, you should be seeing the very similar output on typing spring.

``````
usage: spring [--help] [--version]
[<args>]

Available commands are:

run [options]  [--] [args]
Run a spring groovy script
``````

We can use init as an additional parameter with spring to create a new project. Spring Boot CLI will internally be going to use start.spring.io to generate project structure for you.

``````localhost:~ javadevjournal\$ spring init --dependencies=web springboot-demo-project
Using service at https://start.spring.io
Project extracted to '/Users/umesh/springboot-demo-project'``````

It created springboot-demo-project directory with a maven based project using spring-boot-starter-web. This will create a project with the same default setting as available on the `start.spring.io` web interface. We can pass different parameters to customize project generation.

Let’s say we want to generate our project based on `Java 1.7`, we can pass `--java-version=1.8` as an additional parameter to Spring Boot CLI.

``````spring init --java-version=1.7 --dependencies=web springboot-demo-project
``````

When you will run above command, it will automatically set `java-version` in the generated `pom.xml` file as 1.7.

``````<properties>
<java.version>1.7</java.version>
</properties>
``````

If you are not sure what are the capabilities of the Spring init service, run init command with `--list flag`.

`` spring init --list``

### 4. Peek Inside pom.xml

Let’s start looking into `pom.xml` file to understand Spring Boot configurations in more detail. I will be covering only Spring Boot related changes in `pom.xml`. Here is the `pom.xml` file from our sample project.

``````<?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.umeshawasthi</groupId>
<artifactId>ems</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>

<name>ems</name>
<description>Employee Management System outline Spring Boot Features</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- project properties repository -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<!-- Spring boot test depedency -->
</dependencies>
</project>
``````

One of the main features of Spring Boot is the “Starters”, they are an easy way to add required dependencies (jars) in your classpath. When using Spring Boot, we don’t have to add jar/dependencies in your classpath (In case a starter is not available, you might have to add these dependencies in the `pom.xml` or can create your own custom starter). We just need to add correct `“Starters”` in our `pom.xml` file and Spring Boot will make sure to add those dependencies automatically.

### 5. Application Entry Point

``````@SpringBootApplication
public class EmsApplication {

public static void main(String[] args) {

SpringApplication.run(EmsApplication.class, args);
}
}
``````
##### 5.1 `@SpringBootApplication` Annotation

Our main class is using `@SpringBootApplication` annotation. `@SpringBootApplication` is equivalent to using `@Configuration`, `@EnableAutoConfiguration` and `@ComponentScan` with their default values.If you are starting your project, it’s recommended to use annotation. Using `@SpringBootApplication` in your main class is equivalent to following 3 annotations

1. `@Configuration` as a source of bean definitions.
2. `@EnableAutoConfiguration` It gives Spring Boot an idea as to how you want to configure your application.
3. `@ComponentScan` to automatically pick up all Spring components, including `@Configuration` classes.

##### 5.2 Main Method

Another interesting feature of our main class is the main method. This is a standard method that will follow standard Java workflow. Our main class will pass on control to Spring Boot SpringApplication class. SpringApplication Class run method will be used to the BootStrap application. We will be taking a more deep look into the SpringApplication later section.

### 6. Hello World Controller

``````package com.javadevjournal.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

@RequestMapping("/")
public String helloWorld(){
return "Hello World!!";
}
}
``````

There is nothing special in our `Controller`. It’s a standard `Spring-MVC` controller with standard Spring MVC annotations.

### 6. Running Application

It’s time to run our first Spring Boot powered application. We have multiple ways to run our Spring Boot application.

1. If you are using IDE, you can use IDE to run your application.
2. We can use `mvn spring-boot:run` command from the root directory to start our first Spring Boot application.
`````` .   ____          _            __ _ _
/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
'  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::        (v1.5.4.RELEASE)

2017-07-08 15:49:50.319  INFO 1238 --- [           main] com.javadevjournal.demo.EmsApplication   : Starting EmsApplication on localhost with

``````

Open up the browser of your choice and type `http://localhost:8080`, you should see “Hello World” as an output.

## Summary

Spring Boot provides a good boost to the Spring-based applications. In this post, we learned about different options of Building an Application with Spring Boot.Setting up a new project is always a challenging task and we need to make sure to manage all dependencies but with Spring Boot, it was really easy and we able to run our first web application with only new lines of code without thinking much about the required dependencies or the deployment.

## How to Use Custom Banners in Spring Boot

When we start our Spring Boot application, it comes up with a default Banner, in this post we will discuss how to use Custom Banners in Spring Boot application.

### Introduction

It’s highly likely that you want to release your own product/application based on the Spring Boot and want to display your own custom banner in place of default Spring Boot Banner.By default Spring

By default, Spring Boot application will display the following banner on startup

``````.   ____          _            __ _ _
/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
'  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::        (v1.5.7.RELEASE)<``````

### 1. Creating Custom Banner

In order to start, we need to create a custom banner which will be used to display on the application startup time. I will be using  Spring Boot Banner Generator to upload an image for generating ANSI character in the plain text.You can always generate it manually if you want :).

For this tutorial, I will be using  Spring Logo logo from Spring IO site.

### 2. Using The Custom Banner

In the above section, we have created a custom banner and it’s time to start using this custom banner.We will be creating a file `banner.txt` under the `src/main/resources` folder and will paste content in this file.

Spring Boot by default will pick content from the `banner.txt` file, in case it will find a banner.txt in our project classpath (resources folder of our application), it will pick custom banner content and will display it on the startup.

In case we want Spring Boot to pick banner content from other location and not from the default banner.txt, we can customize that by setting `banner.location` to the location of such a file

``banner.location=classpath:/path/to/banner/custom-banner.txt``

Here is the output when we run our application with new content in banner.txt file

##### 2.1 Using Image for Custom Banner

We can even use the image as a custom banner for our Spring Boot application, We can add `banner.gif`, `banner.jpg` or `banner.png` image file to your classpath and Spring Boot will automatically pick this image as a startup banner. Please note that we need to name these banner images as a `banner.extension` (e.g. `banner.jpg`).

You can use `banner.image.location` property to set a custom location for our banner image in the `application.properties` file, we can also use some additional properties to customize our banner

``````
banner.image.location=classpath:banner.gif # Banner image file location (jpg/png can also be used).
banner.image.width= # Width of the banner image in chars (default 76)
banner.image.height= # Height of the banner image in chars (default based on image height)
banner.image.margin= # Left hand image margin in chars (default 2)
banner.image.invert= # If images should be inverted for dark terminal themes (default false)
``````

Images will be converted into an ASCII art representation before getting printed on the startup which can add a lot of time on startup in case we have a complex image.It is recommended to use text format for a Custom Banners in Spring Boot.

If you want you can use `SpringApplication.setBanner(… )` method to set custom banner programmatically but in my opinion, this is not preferred way and you need to implement your own `printBanner()` provided under `org.springframework.boot.Banner` interface.

### Summary

In this short post, we learned how to use a Custom Banners in Spring Boot. We explored the option to create a custom banner using a banner.txt file or placing your custom image in your classpath.

## Introduction to Java 8 StringJoiner

In this short post, we will be covering Java 8 StringJoiner feature and will explore what are the different features and how this can be used more effectively with Java 8 Stream API.

### Introduction

Joining multiple strings in a very common tasks in day to day programming activity.There was no direct way to join multiple String in Java (Other than using the third party API’s). Java 8 Introduced a new class StringJoiner which can be used to join multiple Strings.`StringJoiner` is a kind of a `Collector`.

### 1. StringJoiner

StringJoiner is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix.

##### 1.1 Using Delimiter

One of the common use cases of the StringJoiner is to use a delimiter to join strings.

``````StringJoiner joiner = new StringJoiner(",");

System.out.println(joiner.toString());``````

Here is our `Junit` Test

``````@Test
public void stringJoinerTest(){

StringJoiner joiner = new StringJoiner(",");

assertEquals("Sunday,Monday,Tuesday", joiner.toString());
}``````
##### 1.2 Using Delimiter, Prefix and Suffix

StringJoiner also provides the way to predefined `prefix` and `suffix` in addition to the `delimiter`.

``````public static void joinerWithDelimiterWithPrefixAndSuffix(){
StringJoiner joiner = new StringJoiner(",", "Prefix-", "-Suffix");
joiner.toString();
}
``````

Output

``Prefix-Sunday-Suffix``

##### 1.3 Join Multiple StringJoiner

We can also merge multiple `StringJoiner` using StringJoiner’s `merge()` method

``````   StringJoiner joiner1= new StringJoiner("|");
StringJoiner joiner2= new StringJoiner(";");
StringJoiner joiner3= new StringJoiner(";");

joiner1.merge(joiner2);

joiner1.merge(joiner3);

System.out.println(joiner1.toString());
``````

Output

``one;two|three;four``

### 2. String.join()

`StringJoiner` is used internally by two static `String.join` methods

``````String output= String.join("-", "2017","09","30");
2017-09-30 //output
``````
``````List<String> list= Arrays.asList("one","two","three");
String output = String.join("-", list);

one-two-three //output``````

### 4. Collectors.joining

`StringJoiner` can be easily used with the new Java 8 Collection API.

``````List<Customer> customers = Arrays.asList(
new Customer("John", "Smith"),
new Customer("Umesh", "Awasthi"),
new Customer("Andy", "Flower")
);

final String customerJoin = customers.stream()
.map(Customer::getFirstName)
.collect(Collectors.joining(","));

System.out.println(customerJoin);
``````

Output

``John, Umesh, Andy``

### 5. Why StringJoiner

There can be a very natural question about why do we need `StringJoiner` when we already have `StringBuilder`? Or it internally use `StringBuilder` to perform most of the operations

With the Java 8 Stream API, StringJoiner is very useful as compared to the StringBuilder.Let’s take an example to understand the difference between using SpringJoiner and StringBuilder.

``````List<String> list = Arrays.asList("Foo","Bar");

//join string using StringJoiner
String output = list.stream().collect(Collectors.joining(","));

//using StringBuilder

String collectoutput =
list.stream().collect(Collector.of(StringBuilder::new,
(stringBuilder, str) -> stringBuilder.append(str).append(", "),
StringBuilder::append,
StringBuilder::toString));``````

### Summary

In this post, we got an Introduction to Java8 StringJoiner. We explored various features of the StringJoiner class and how to use it to join multiple Strings.We can also think of StringJoiner as a kind of Collector and can be really useful when working with parallel streams.

## Introduction to Spring Boot Starters

In this post, we will introduce Spring Boot Starters to you and will discuss what are the benefits and advantages of Spring Boot Starters.

### Introduction

Before starting any project be it a small project or an enterprise level application, one of the critical aspects is dependency management, doing it manually for a small application is not a hard job but when it comes to complex applications, managing all project dependencies manually is not ideal and prone to many issues as well wasting of the time which can be used in some other important aspects of the project.

Ond of the fundamental principle behind Spring Boot is to address similar issues.Spring Boot Starters are a set of convenient dependency descriptors which can be easily included in any level of application.These starters work as a  bootstrapping process for the Spring related technologies, we no longer need to worry about the dependencies and they will be automatically managed by Spring Boot Starters.

The starters contain a lot of the dependencies that you need to get a project up and running quickly and with a consistent, supported a set of managed transitive dependencies.

### 1. Why Do We Need Starters?

When we start with the Spring Boot, one of the fundamental questions which come to our mind is why do we need Spring Boot Starters? or how these starters will help me in my application?

As mentioned earlier, these starters work to bootstrap your application, all we need is to include correct starter in our application and Spring Boot will ensure that all dependencies required for the chosen starter are in your classpath.

To understand it more clearly, let’s take an example that we want to build a simple Spring Web-MVC application, in order to start, we need to think of the following points before actually starting working on our web application code.

• Correct Spring MVC Dependencies.
• Required dependencies for Web technologies (e.g We want to use Thymeleaf)
• We need to make sure that all these dependencies are compatible

With Spring Boot Starters, bootstrapping our Spring-MVC web application is really straightforward, We need to include spring-boot-starter-web starter in our pom.xml,

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

Above entry in pom.xml will ensure that all required dependencies should be in your classpath and we are all set to start working on our web application.

Currently, there are around 50+  starters offered by Spring Boot excluding third party starters.For the updated list of starters, please refer to  Spring Boot Starter

In this section, I will be covering some of the commonly used starters.

### 2. Web Starter

This is one of the most commonly used Spring Boot Starter, This starter will ensure that all required dependencies to create Spring Web application (including REST) are included in your classpath, it will also add tomcat-starter as default server to run our web application. To include Web Starter in our application, add following entry in pom.xml.

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

Now we can create our Spring-MVC Controller

`````` @RestController
public class SampleController {

@RequestMapping("/greeting")
String hello() {
return "HelloWorld!";
}
}
``````

If you run your application and access,`http://localhost:8080/greetings` you should be able to get “Hello Word” as the response.We created a `REST` controller with minimal code.

### 3. Data JPA Starter

Most of the application will need some persistence mechanism and JPA is established standard for the persistence, Spring Boot Starters comes with JPA Starters, You no longer have to configure those JPA dependencies manually, this can be easily achieved by adding JPA Starter in your application.

``````<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
``````

Spring JPA Starter provides automatic support for `H2, Derby and Hsqldb`.Let’s have a look at how easy is to create a sample JPA application using JPA starter.

``````@Entity
public class User {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String firstName;
private String lastName;

protected User() {
}

public User(String firstName, String lastName) {
//this.id = id;
this.firstName = firstName;
this.lastName = lastName;
}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

@Override
public String toString() {
return "User{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
'}';
}
}``````

Here is our UserRepository

``````public interface UserRepository extends CrudRepository<User,Long> {
List<User> findUserByLastName(String lastName);
}
``````

Time to test our code, here is the `JUnit` test

``````@RunWith(SpringRunner.class)
@SpringBootTest

@Autowired
UserRepository userRepository;

@Test

User user = userRepository.save(new User("Demo","User"));
User searchUser= userRepository.findOne(user.getId());

assertNotNull(searchUser);
assertEquals(user.getFirstName(),searchUser.getFirstName());

}

}``````

As we saw in above code, you longer need to specify those database configurations or extra DB configurations, by adding JPA starter, many features were available to us out of the box with no need to configure or code.

You can always modify/customize these configurations if needed.

### 4. Mail Starter

Sending email from our application is very common tasks and every application these days require to send emails from the system.Spring Boot Mail starter provides an easy way to handle this feature by hiding all complexities.

We can enable email support by simply adding mail starter in our application.

``````<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>``````

I am using Mailgun as my SMTP Server, here are the SMTP details added to my application.properties file

``````spring.mail.host=smtp.mailgun.org
[email protected]
spring.mail.properties.mail.transport.protocol=smtp
spring.mail.properties.mail.smtp.port=587
spring.mail.properties.mail.smtp.auth=true``````

Our EmailService class responsible for sending emails

``````@Component
public class JavaEmailService {

private JavaMailSender mailSender;

public JavaEmailService(JavaMailSender mailSender) {
this.mailSender = mailSender;
}

public void sendEmail(){
MimeMessagePreparator messagePreparator = mimeMessage -> {

MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);
helper.setFrom("[email protected]");
helper.setTo("[email protected]");
helper.setSubject("Sample mail subject");
helper.setText("Test Email");
};

mailSender.send(messagePreparator);
}
}``````

We have used  JavaMailSender provided by Spring for email. Time to test the code. Here is the `JUnit` test

``````@RunWith(SpringRunner.class)
@SpringBootTest
public class EmailTest {

@Autowired
JavaEmailService javaEmailService;

@Test
public void sendEmail(){

javaEmailService.sendEmail();

}
}``````

Again, a minimal code and configuration were needed to send a simple email, Spring Boot Mail Starter ensured that all required tools are already in place to quickly start working on the real problem.

Notice that we’re using  `JavaMailSender` in `JavaEmailService` bean – the bean was automatically created by Spring Boot.

### 5. Test Starter

We normally use Junit, Mockito or Spring Test for testing our application.We can easily include all these libraries in our application by adding Spring Boot Test starter.

``````<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>``````

Spring Boot will automatically find our correct version to be used for our application test. Here is a sample `JUnit` test

``````@RunWith(SpringRunner.class)
@SpringBootTest
public class EmailTest {

@Autowired
JavaEmailService javaEmailService;

@Test
public void sendEmail(){

javaEmailService.sendEmail();

}
}``````

Apart from these starters, below are other frequently used Spring Boot Starters

• spring-boot-starter-security
• spring-boot-starter-web-services
• spring-boot-starter-integration
• spring-boot-starter-validation
• spring-boot-starter-actuator

As mentioned earlier, please refer to  Spring Boot Starter for up to date list of the starters provided by Spring Boot.

### Summary

This article provides an Introduction to Spring Boot Starters, we discussed as to why do we need these starters and how they can help us to quickly bootstrap our application. We explored some of the most commonly used Spring Boot Starters.

Building an Application with Spring Boot

## Convert a Map to List in Java

In this post, we will learn as how to Convert a map to List in Java.We will see how to do this using JDK.

### 1. Conventional Method

To convert, Java `Map` to List, we can use the conventional constructor with `ArrayList`, however, there are few things to consider before we proceed with the conversion.

Java `Map` has 2 values while list contains only single value while converting Map to list, we need to take a call of converting either map `values` or `keys`, so either we will get a map of keys or list of values (we can get both by using some wrapper to have both values).

``````public class MapToList {

public static void main(String[] args) {

Map<Integer,String> map= getMap();

//Convert Map keys to List
List<Integer> keyList= new ArrayList<Integer>(map.keySet());
keyList.forEach(key-> System.out.println(key));

//Convert Map values to List
List<String> valueList= new ArrayList<String>(map.values());
keyList.forEach(value-> System.out.println(value));

}

static Map<Integer,String> getMap(){

Map<Integer, String> sampleMap=new HashMap<Integer,String>();
sampleMap.put(1,"Sunday");
sampleMap.put(2,"Monday");
sampleMap.put(3,"Tuesday");
sampleMap.put(4,"Wednesday");

return sampleMap;
}
}``````

Output for the above programme will be

``````1
2
3
4
``````

For valueList

``````Sunday
Monday
Tuesday
Wednesday
``````

### 2. Using Java 8

We can also use Java 8 Stream API to convert Map to List in Java.

``````public class MapToListJava8 {

public static void main(String[] args) {

Map<Integer,String> map= getMap();

List<Integer> keyList=map.keySet().stream().collect(Collectors.toList());
keyList.forEach(key-> System.out.println(key));

List<String> valueList=map.values().stream().collect(Collectors.toList());
valueList.forEach(value-> System.out.println(value));
}

static Map<Integer,String> getMap(){

Map<Integer, String> sampleMap=new HashMap<Integer,String>();
sampleMap.put(1,"Sunday");
sampleMap.put(2,"Monday");
sampleMap.put(3,"Tuesday");
sampleMap.put(4,"Wednesday");

return sampleMap;
}
}``````

My preference will be for the constructor based approach as it is more straight forward and easy to read rather than the Java 8 Stream API.

### 3. Summary

In this post, we explored as to how to convert a Map to List in Java, we learned how to convert it using a constructor and Java 8 Stream API.We can use a similar technique to convert `Map` to `Set` which we will cover in another post.

## Introduction to Spring Profiles Using Spring Boot

In this post, we will be exploring Spring Profiles using Spring Boot and will see how we can use it efficiently in our project.

### Introduction

Spring Profiles provides a powerful and easy way to control code and configuration based on the environment. Using Spring Profiles it’s possible to segregate parts of our application and make it only available in certain environments. We can use `@Profile` annotation to limit the availability of any `@Component`  or `@Configuration.`

### 1. Use `@Profile` Annotation

Main entry point for the Spring Profile is `@Profile` annotation which can be used to group things together. Let’s take a simple example for a Database connection bean where we want to make sure that certain DB connection should be active only in DEV mode but not in production or QA / Staging. We can use `@Profile` annotation to achieve this.

``````@Service
@Profile("development")
public class DevDBConnection implements  DatabaseService {

@Override
public void getDBConnection() {
System.out.println("DEV DB connection established");
}
}``````

Since we annotated DevDBConnection bean with “development” profile, it will only be available in the Spring container if development profile is active, in other words, if development profile is not active, this bean will not be available/active.

Default profile used by Spring profile is the default. All the beans with no profile annotation are specified belongs to the default profile. We can also set default profile in Spring Boot by  `@Profile("default")` or `@Profile({"default","development"}).`

### 2. Use @Profile Annotation

Spring Boot provides multiple ways to active profile. We can pass profile information through the command line or use application.properties, Spring Boot also provide a way to set profile programmatically.

##### 2.1 Using Command Line

We can pass profile information to Spring Boot using the switch through command prompt —`spring.profiles.active=development,staging`

##### 2.2 Using Property File

We can use standard Spring environment property spring.profiles.active property in our application.properties or `application.yaml` to specify active profiles.

``spring.profiles.active=development,staging``
##### 2.3 Programmatically setting profile

We can programmatically set active profile by calling `setAdditionalProfiles(...)` method provided by SpringApplication class

``````SpringApplication app = new SpringApplication(Application.class);

Take a note that spring.profiles.active property follows same ordering rule as followed by other properties defined by Spring Boot. Highest property source will overwrite any other property defined in the hierarchy. Please refer to Spring Boot documentation to understand how Spring Boot read these properties.

### 3. Profile Specific Configurations

One of the most interesting and powerful features provided by Spring Boot is the ability to define profile specific application.properties file and active these by main application.properties file.

To use profile specific configuration files, we need to the naming convention of `application-{profile}.properties` where profile defines the name of the intended profile. Profile specific files will be loaded from the same location as `application.properties` file, also be aware that profile specific properties will override properties defined in the default application.properties irrespective of whether the profile-specific files are inside or outside your packaged jar.

To understand it completely, let’s take the same example of Database configuration where we want to define different DB configurations for Development and Production.To achieve this using configuration files, we will define 2 configuration file namely `application-production.properties` and `application-development.properties.`

application-production.properties

``````db.url=jdbc:oracle:thin:@<host>:1521:<sid>
db.driver=oracle.jdbc.driver.OracleDriver
db.tableprefix= ``````

application-development.properties

``````db.url=jdbc:hsqldb:file:configurations
db.driver=org.hsqldb.jdbcDriver
db.tableprefix=
``````

In above example we used HSQL for Development while we want to use Oracle for production and based on the active profile, we can easily switch DB configurations.

Please read @ConfigurationProperties in Spring Boot to understand how Spring Boot Configuration works

### 4. Complete Example

Here is a complete example to understand how Spring Boot Profile work.

DataBase Service

``````public interface DatabaseService {

void getDBConnection();
}``````

Development Profile

``````@Service
@Profile("development")
public class DevDBConnection implements  DatabaseService {

@Override
public void getDBConnection() {
System.out.println("DEV DB connection established");
}
}``````

Production Profile

``````@Service
@Profile("production")
public class ProdDBConnection implements DatabaseService {

@Override
public void getDBConnection() {

System.out.println("Product DB connection establish");
}
}``````

Spring Boot Runner

``````@SpringBootApplication
public class SpringbootTutorialsApplication implements CommandLineRunner{

@Autowired
DatabaseService databaseService;

public static void main(String[] args) {

SpringApplication.run(SpringbootTutorialsApplication.class, args);
}

/**
* Callback used to run the bean.
*
* @param args incoming main method arguments
* @throws Exception on error
*/
@Override
public void run(String... args) throws Exception {
databaseService.getDBConnection();
}
}``````

output

if you run above example with development profile as active profile, we will have the following output

``DEV DB connection established``

### 5. Conclusion

In this post, we covered Spring Profile features, we learned how to use Spring Profile in Spring Boot using different options.Spring profile is a powerful way enable right profile in our application, ability to define profile specific configuration files in Spring Boot gives a lot of flexibility to manage our applications.

## Java 9 New Features

In this articles, we will be covering Java 9 new features at a high level.We will explore these features along with details as what are the improvements happening to the existing features.

### Introduction

Java 8 introduced a couple of new and exciting features like lambdas, streams and some of the API changes, Java 9 is coming up with rich feature sets like Jigsaw, Jshell (REPL),  collections and some API changes under the hood.In this, we will explore all Java 9 new features at a high level.You can get detail information of all Java 9 features available JDK 9.

### 1. Modular System – Jigsaw Project

The modular system is one of the main and defining features of the Java 9.Jigsaw will be responsible for bringing much-needed modularity to the Java platform.One of the main reason to bring modularity to the Java provides modular JVM which can help us to run JVM on different devices with less memory.

In another way, it’s a mechanism to run only modules and API required by a given application (e.g.application 1 need 3 modules to run completely while application 2 need only 1 module).

Modules will be defined/ described in a file called module-info.java located at the top of our Java code hierarchy.

In order to understand Java 9 Modular system, let’s take an example of the Order placement process where we need OMS (Order Management System) to place an order but for rest of the use cases (e.g. Browsing site or adding products to the shopping cart), we might not need OMS for our application. We can have a web-based application which allows placing an order, however, we can have other channels which can place an order and we need OMS module to process these orders correctly. To achieve this, we can define 2 modules in Java 9 and can define required dependencies

``````module com.javadevjournal.shop.order {
}``````

Here is a pictorial representation of the Java 9 Module system

Based on the requires statement, JVM will try to determine if it is able to resolve all modules. I strongly believe that Java 9 Modules feature will allow us to structure our application in a better way and will strongly enforce encapsulation and defined/ explicit dependencies.

### 2. JShell (REPL)

Many modern languages provide a tool (Mostly called as REPL or scripting tool) for real-time statement interpretation.One of the benefits of such tool is that you can easily test your code without creating a complete class or project.Java 9 will be introducing REPL or JShell which can be used to quickly run your code and compare results.

For more details and video tutorial, please read Introduction to Java 9 REPL and JShell

### 3. G1 (Default Garbage Collector)

Java 8 has 4 different Garbage Collector and default Garbage Collector in Java 8 is Parallel / Throughput Collector. G1 will be the new default Garbage Collector in Java 9. G1 was designed for better performance and know to have less number of GC pauses.

Get more insight of the all available Garbage Collectors and their feature in our other post Java Garbage Collector.

### 4. HTTP 2.0 Client

Java 9 is coming up with a new `HTTP 2.0` based client which can also be taken as a replacement for the famous.`HttpURLConnection` Java 9 will be providing full support for new `HTTP 2.0` and this new client will be supporting both `HTTP/2` protocol and WebSocket.

This new API will be introduced as first incubator module in Java which means it will be introduced as an experimental feature and based on the feedback it will either be added as a full featured module in next release or will be removed from the Java platform.

``````HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(new URI("www.travellingrants.com")).build();

HttpResponse<String> response = client.send(request,HttpResponse.BodyHandler.asString());

System.out.println(response.statusCode());
System.out.println(response.body());``````

It’s really easy and clean API, we no longer have to use `InputStream` or `Reader` and even our old friend.`HttpURLConnection`

HTTP 2.0 API also support an Asynchronous call by simply using `HttpClient#sendAsync()` method instead of `HttpClient#send` method.There is also option to cancel your request if server support `HTTP/2.`

### 5. StackWalker API

To put Stack Walk API  in Java 9 in simple words, It provides capabilities to walk through the stack in Java. StackWalker provides a snapshot of the current thread stack trace along with some methods to access it.

Please read our article StackWalker API In Java 9 to get more insight for this new Java 9 feature.

### 6. Process API

Before Java 9 there was a limited support for controlling and managing operating systems processes, even getting hold of simpler OS related process was not a simple one liner solution and require a lot of workarounds.

Java 9 is introducing a lot of improvements to process API for controlling and managing OS related process.

java.lang.ProcessHandle class contains most of the new features of the process API. To get an understanding let’s take an example of getting PID in both Java 8 and Java 9

##### Java 8
``````public static void getProcessIdByJava8(){

try {
String[] args = new String[] { "/bin/sh", "-c", "echo \$PPID" };
Process p = Runtime.getRuntime().exec(args);
InputStream p_out = p.getInputStream();
p.destroy();
if (s != null)
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}

}

``````
##### Java 9
``````public static void getProcessIdByJava9(){
System.out.println("Your Process id is :" + ProcessHandle.current().pid());
}``````

As we saw, getting operating system information using Java 9 process API is quite easy and clean.It gives Java developer an API to interact with the operating system and can be used to get information on the status of the JVM.

We can get a lot of other information from the process API. Read here for more details.

### 7.  Collection Factory Methods

Collection Factory Methods are introduced in Java 9 like Scala. Static methods have been provided by Java 9 on List, Set and Map interfaces which can easily returned unmodifiable collections by calling of() method of the respective interface.

### 8. Try With Resources Improvement

Java 7 introduced try-with-resources for managing resources automatically and to ensure that resources will be closed after execution of the program.

Before Java 9, in order to use try-with-resources, we will have to use something like this

``````try (BufferedReader br = new BufferedReader(new FileReader("/input.txt"))) {
String line;
while (null != (line = br.readLine())) {
// processing each line of file
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}``````

Or we will be using a very similar syntax, Above syntax provide a lot of features and auto management of the resources, however, we still need to declare a local variable to work with, Java 9 is a further refinement to this feature to avoid verbosity.

``````BufferedReader br = new BufferedReader(new FileReader("/input.txt"));

// Java 9 make it simple
try (br) {
String line;
while (null != (line = br.readLine())) {
// processing each line of file
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}``````

### 9. Interface Private Method

Java 8 came with certain enhancement while declaring interfaces, few of those features are

1. Method implementation in interface using default and static methods

However, it still not provide a way to create a private method in Interface. Java 9 will provide a way to have a private method in an interface.This feature will really be useful to avoid redundant code and promote code reusability.

``````public interface PrivateMethodExample {

private static String getDBDetails(){
return "MySQL";
}

private boolean checkConnection(String DBDetails){
return  DBDetails.equalsIgnoreCase("MySQL") ? true : false;
}

default void checkDBConnection(){
String dbName = getDBDetails();
boolean isAlive =   checkConnection(dbName);
}
}``````

### 10. Мulti-Resolution Image API

Java 9 will be introducing a new API defined under java.awt.image package, it will allow a set of images with different resolutions to be encapsulated into a single multi-resolution image.

For more details read Multi-Resolution Images.

### 11. Miscellaneous Java 9 Features

There are other features introduced in Java 9 which I will be covering in another post in more details, here is the list of some of the other features introduced in Java 9

1. Improvement to Optional API. Read java 8 optional to get a basic understanding of Optional API introduced in Java 8.
2. Unified JVM Logging.
3. Stream API Improvement.
4. Reactive Streams
5. CompletableFuture API Improvements