Spring Boot

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”. We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.

Provide a radically faster and widely accessible getting started experience for all Spring development.
Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults.
Provide a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration).
Absolutely no code generation and no requirement for XML configuration.

>Embedded Servlet Container , Datsource, JDBCTemplate, JPA
ØBatch Processing : Event & async processing

Actuator –
Non functional features – MVC endpoints
  & trace  

Sample POM-

xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"












package com.example.mvc;

import java.util.concurrent.atomic.AtomicLong;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

public class HelloWorldController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    public @ResponseBody Greeting sayHello(@RequestParam(value="name", required=false, defaultValue="Stranger") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));


package com.example.mvc;

public class Greeting {

    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;

    public long getId() {
        return id;

    public String getContent() {
        return content;



package com.example.rest;

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

public class MyController {

    public MyThing thing() {
            return new MyThing("Vikalp");


package com.example.rest;

import javax.xml.bind.annotation.XmlRootElement;

public class MyThing {
public MyThing()

public MyThing(String name){
this.name = name;
private String name;

public String getName() {
return name;

public void setName(String name) {
this.name = name;

Boot Application

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

public class DemoApplication {

private static final Logger log = LoggerFactory.getLogger(DemoApplication.class);

public static void main(String[] args) {

public CommandLineRunner loadData(CustomerRepository repository) {
return (args) -> {
// save a couple of customers
repository.save(new Customer("Jack", "Bauer"));
repository.save(new Customer("Chloe", "O'Brian"));
repository.save(new Customer("Kim", "Bauer"));
repository.save(new Customer("David", "Palmer"));
repository.save(new Customer("Michelle", "Dessler"));

// fetch all customers
log.info("Customers found with findAll():");
for (Customer customer : repository.findAll()) {

// fetch an individual customer by ID
Customer customer = repository.findOne(1L);
log.info("Customer found with findOne(1L):");

// fetch customers by last name
log.info("Customer found with findByLastNameStartsWithIgnoreCase('Bauer'):");
for (Customer bauer : repository
.findByLastNameStartsWithIgnoreCase("Bauer")) {


package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;

import com.vaadin.annotations.Theme;
import com.vaadin.data.util.BeanItemContainer;
import com.vaadin.server.FontAwesome;
import com.vaadin.server.VaadinRequest;
import com.vaadin.spring.annotation.SpringUI;
import com.vaadin.ui.Button;
import com.vaadin.ui.Grid;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.TextField;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;

 * The UI code (and the Servlet declaration) used by the application stub can be found
 *  in the MyUI.java file. Let us read it through to see how it works. The init() 
 *  method of a UI class is triggered when a user enters your web application.
 *   The VerticalLayout is one of the most used layout components, 
 *   which are used to position and display other Vaadin components in your UI classes.
 *    The example code creates one TextField to allow the user to input her name and a 
 *    Button whose click listener dynamically adds a new Label component to the main layout.
 *     In the end of the init() method, we just configure the main layout and place
 *      components into it and set it to be the content of MyUI.
*  To test your first Vaadin application, right-click on the project and choose Debug as
 ▸ Maven build…​. The debug mode is slightly slower than the basic run mode, but it often 
 helps you to figure out what is happening in your application.

public class VaadinUI extends UI {

private final CustomerRepository repo;

private final CustomerEditor editor;

private final Grid grid;

private final TextField filter;

private final Button addNewBtn;

public VaadinUI(CustomerRepository repo, CustomerEditor editor) {
this.repo = repo;
this.editor = editor;
this.grid = new Grid();
this.filter = new TextField();
this.addNewBtn = new Button("New customer", FontAwesome.ALIGN_CENTER);

protected void init(VaadinRequest request) {
// build layout
HorizontalLayout actions = new HorizontalLayout(filter, addNewBtn);

VerticalLayout mainLayout = new VerticalLayout(actions, grid, editor);

// Configure layouts and components

grid.setHeight(300, Unit.PIXELS);
grid.setColumns("id", "firstName", "lastName");

filter.setInputPrompt("Filter by last name");

// Hook logic to components

// Replace listing with filtered content when user changes filter
filter.addTextChangeListener(e -> listCustomers(e.getText()));

// Connect selected Customer to editor or hide if none is selected
grid.addSelectionListener(e -> {
if (e.getSelected().isEmpty()) {
} else {
editor.editCustomer((Customer) grid.getSelectedRow());

// Instantiate and edit new Customer the new button is clicked
addNewBtn.addClickListener(e -> editor.editCustomer(new Customer("", "")));

// Listen changes made by the editor, refresh data from backend
editor.setChangeHandler(() -> {

// Initialize listing

// tag::listCustomers[]
private void listCustomers(String text) {
if (StringUtils.isEmpty(text)) {
grid.setContainerDataSource(new BeanItemContainer(Customer.class, repo.findAll()));
} else {
new BeanItemContainer(Customer.class, repo.findByLastNameStartsWithIgnoreCase(text)));
// end::listCustomers[]


package com.example;

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;

public interface CustomerRepository extends JpaRepository {

List findByLastNameStartsWithIgnoreCase(String lastName);

package com.example;

import org.springframework.beans.factory.annotation.Autowired;

import com.vaadin.data.fieldgroup.BeanFieldGroup;
import com.vaadin.event.ShortcutAction;
import com.vaadin.server.FontAwesome;
import com.vaadin.spring.annotation.SpringComponent;
import com.vaadin.spring.annotation.UIScope;
import com.vaadin.ui.Button;
import com.vaadin.ui.CssLayout;
import com.vaadin.ui.TextField;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.ui.themes.ValoTheme;

 * A simple example to introduce building forms. As your real application is
 * probably much more complicated than this example, you could re-use this form in
 * multiple places. This example component is only used in VaadinUI.
 * In a real world application you'll most likely using a common super class for all your
 * forms - less code, better UX. See e.g. AbstractForm in Virin
 * (https://vaadin.com/addon/viritin).
public class CustomerEditor extends VerticalLayout {

private final CustomerRepository repository;

* The currently edited customer
private Customer customer;

/* Fields to edit properties in Customer entity */
TextField firstName = new TextField("First name");
TextField lastName = new TextField("Last name");

/* Action buttons */
Button save = new Button("Save", FontAwesome.SAVE);
Button cancel = new Button("Cancel");
Button delete = new Button("Delete", FontAwesome.TRASH_O);
CssLayout actions = new CssLayout(save, cancel, delete);

public CustomerEditor(CustomerRepository repository) {
this.repository = repository;

addComponents(firstName, lastName, actions);

// Configure and style components

// wire action buttons to save, delete and reset
save.addClickListener(e -> repository.save(customer));
delete.addClickListener(e -> repository.delete(customer));
cancel.addClickListener(e -> editCustomer(customer));

public interface ChangeHandler {

void onChange();

public final void editCustomer(Customer c) {
final boolean persisted = c.getId() != null;
if (persisted) {
// Find fresh entity for editing
customer = repository.findOne(c.getId());
else {
customer = c;

// Bind customer properties to similarly named fields
// Could also use annotation or "manual binding" or programmatically
// moving values from fields to entities before saving
BeanFieldGroup.bindFieldsUnbuffered(customer, this);


// A hack to ensure the whole form is visible
// Select all text in firstName field automatically

public void setChangeHandler(ChangeHandler h) {
// ChangeHandler is notified when either save or delete
// is clicked
save.addClickListener(e -> h.onChange());
delete.addClickListener(e -> h.onChange());


package com.example;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

public class Customer {

private Long id;

private String firstName;

private String lastName;

protected Customer() {

public Customer(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;

public Long getId() {
return 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;

public String toString() {
return String.format("Customer[id=%d, firstName='%s', lastName='%s']", id,
firstName, lastName);


 Deployable war file

The first step in producing a deployable war file is to provide a SpringBootServletInitializer subclass and override its configure method. This makes use of Spring Framework’s Servlet 3.0 support and allows you to configure your application when it’s launched by the servlet container.

public class Application extends SpringBootServletInitializer {
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
public static void main(String[] args) throws Exception {
class, args);
Applications can fall into more than one category:
  • Servlet 3.0+ applications with no web.xml.
  • Applications with a web.xml.
  • Applications with a context hierarchy.
  • Applications without a context hierarc

What is Volatile means in Java

Volatile guarantees this in Java:
1) There is a global ordering on the reads and writes to a volatile variable. This implies that every thread accessing a volatile field will read its current value before continuing, instead of (potentially) using a cached value. (However, there is no guarantee about the relative ordering of volatile reads and writes with regular reads and writes, meaning that it's generally not a useful threading construct.)
2)  After java 5, Volatile reads and writes establish a happens-before relationship, much like acquiring and releasing a mutex.
Using volatile may be faster than a lock, but it will not work in some situations.The range of situations in which volatile is effective was expanded in Java 5; in particular, double-checked locking now works correctly.

Where to use Volatile :
Best case will be where where the variable updates should be visible to all threads because The value of this variable will never be cached thread-locally: all reads and writes will go straight to "main memory". and Access to the variable acts as though it is enclosed in a synchronized block, synchronized on itself.

Danger of Volatile:
Atomic operations are not thread safe with volatile variables. see this Code :

volatile int i;
i += 5;

Here i += 5 is not thread safe and  this is equivalent to
int temp;
synchronized (i) {
  temp = i;
temp += 5;

synchronized (i) {
  i = temp;

Solution of this in Java 5: Java Atomic package

Java Atomic package works on principle of CAS (compare and swap). The signature of any CAS method is -

   boolean compareAndSet(expectedValue, updateValue);

As Described in Java Doc:

"This method (which varies in argument types across different classes) atomically sets a variable to the updateValue if it currently holds the expectedValue, reporting true on success. The classes in this package also contain methods to get and unconditionally set values, as well as a weaker conditional atomic update operation weakCompareAndSet described below.
The specifications of these methods enable implementations to employ efficient machine-level atomic instructions that are available on contemporary processors. However on some platforms, support may entail some form of internal locking. Thus the methods are not strictly guaranteed to be non-blocking -- a thread may block transiently before performing the operation."

Instances of classes AtomicBooleanAtomicIntegerAtomicLong, and AtomicReference each provide access and updates to a single variable of the corresponding type. Each class also provides appropriate utility methods for that type.

Example of Increment method in Atomic class :

class Sequencer {
   private final AtomicLong sequenceNumber
     = new AtomicLong(0);
   public long next() {
     return sequenceNumber.getAndIncrement();

Unix commands : Top 10 frequently asked interview questions

In most of banks, the unix or linux is prefered application hosting platform, compare to the windows. It is always added advantage for candidate to be familiar with unix commands. These are basic unix commands which are sometime asked to candidate for checking his\her unix skills.  These questions are mainly related to log search, find commands and unix processes. These commands are very handy if we are investigating any issue in production\uat. As application developer we must have came across these unix commands. Mostly questions are not asked in depth and they just confirm your familiarity with unix commands. These are most frequently asked unix commands in interview.

1) How to find hidden files in current directory?

   $ ls -lrta

2) How to find current running processes in unix server?

  $ ps -ef

and if we want to find specific process we can use 'grep' with pipe
  $ ps -ef | grep -i 'application'

3) How to find process which is taking maximum memory in server?
  $ top
  top command tell us about cpu usage , process id and other details. below is output of top command

4) How to find Exception in log files available in current directory and how to find number of occurrence?
   $ grep 'Exception' log1.txt | wc -l

5) find all files in current and subdirectories which contains 'log' name?

   $ find . -name 'log'

6) How do you access command line arguments from within a shell script?

Arguments passed from the command line to a shell script can be accessed within the shell script by using a $ (dollar sign) immediately followed with the argument's numeric position on the command line.

7) How to tails last 200 lines of any log fine?
    $ tail -200f filename.txt

8) How to find remaining disk space in unix\linux server?

    $ df -kl

df -kl
Filesystem   1024-blocks      Used Available Capacity  iused    ifree %iused  Mounted on

/dev/disk0s2   244277768 153679844  90341924    63% 38483959 22585481   63%   /

9) How to make any script file executable?
    $chmod 755 *.sh

10) How to kill process in unix server?
    $ kill -9 #pid
these #pid can be found using ps -ef command.

BASIC Unix Command List
  • ls --- lists your files
    ls -l --- lists your files in 'long format', which contains lots of useful information, e.g. the exact size of the file, who owns the file and who has the right to look at it, and when it was last modified.
    ls -a --- lists all files, including the ones whose filenames begin in a dot, which you do not always want to see.
    There are many more options, for example to list files by size, by date, recursively etc.
  • more filename --- shows the first part of a file, just as much as will fit on one screen. Just hit the space bar to see more or q to quit. You can use /pattern to search for a pattern.
  • mv filename1 filename2 --- moves a file (i.e. gives it a different name, or moves it into a different directory (see below)
  • cp filename1 filename2 --- copies a file
  • rm filename --- removes a file. It is wise to use the option rm -i, which will ask you for confirmation before actually deleting anything. You can make this your default by making an alias in your .cshrc file.
  • diff filename1 filename2 --- compares files, and shows where they differ
  • wc filename --- tells you how many lines, words, and characters there are in a file
  • chmod options filename --- lets you change the read, write, and execute permissions on your files. The default is that only you can look at them and change them, but you may sometimes want to change these permissions. For example, chmod o+r filename will make the file readable for everyone, and chmod o-r filename will make it unreadable for others again. Note that for someone to be able to actually look at the file the directories it is in need to be at least executable. 
  • File Compression
    • gzip filename --- compresses files, so that they take up much less space. Usually text files compress to about half their original size, but it depends very much on the size of the file and the nature of the contents. There are other tools for this purpose, too (e.g. compress), but gzip usually gives the highest compression rate. Gzip produces files with the ending '.gz' appended to the original filename.
    • gunzip filename --- uncompresses files compressed by gzip.
    • gzcat filename --- lets you look at a gzipped file without actually having to gunzip it (same as gunzip -c). You can even print it directly, using gzcat filename | lpr
  • printing
    • lpr filename --- print. Use the -P option to specify the printer name if you want to use a printer other than your default printer. For example, if you want to print double-sided, use 'lpr -Pvalkyr-d', or if you're at CSLI, you may want to use 'lpr -Pcord115-d'. See 'help printers' for more information about printers and their locations.


Directories, like folders on a Macintosh, are used to group files together in a hierarchical structure.
  • mkdir dirname --- make a new directory
  • cd dirname --- change directory. You basically 'go' to another directory, and you will see the files in that directory when you do 'ls'. You always start out in your 'home directory', and you can get back there by typing 'cd' without arguments. 'cd ..' will get you one level up from your current position. You don't have to walk along step by step - you can make big leaps or avoid walking around by specifying pathnames.
  • pwd --- tells you where you currently are.

  • We are covering here -'Java garbage collection interview questions' or 'Java memory interview questions' in d...
  • Java util.collections is one of the most important package in java and the important of this package can be understand by...
  • Java Concurrency interview question - In year 2004 when technology gurus said innovation in Java is gone down and Sun Microsystems [Now Or...
  • 'Java investment bank interview' generally contains 'Java Design Pattern' questions. If you want to be a professional Java ...