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


  1. this technological concepts are really well being and wonderful thus it is very much interesting and very well good too, really i got more information from your knowledge.

    Digital Marketing services in Chennai

  2. Very nice post here thanks for it .I always like and such a super contents of these
    post.Excellent and very cool idea and great content of different kinds of the valuable
    information's. seo company in chennai

  3. Thank you for sharing such a nice and interesting blog with us. I have seen that all will say the same thing repeatedly. But in your blog, I had a chance to get some useful and unique information. I would like to suggest your blog in my dude circle. please keep on updates. hope it might be much useful for us. keep on updating...
    seo company in chennai
    Digital Marketing company in chennai

  4. This post is really nice and informative. The explanation given is really comprehensive and informative.. Android Training in Chennai

  5. I am very happy when read this blog post because blog post written in good manner and write on good topic. Thanks for sharing valuable information.
    Bangalore Web Designing Company, UI Designing Company Bangalore

  6. This comment has been removed by the author.

  7. Thanks for the information. Helped us to convince most on how this process works and what they could achieve by following these guidelines.
    UI Design Company Bangalore, Web Application Development Services in Bangalore

  8. This comment has been removed by the author.

  9. Very Much Usefull inforamtion for Java job seekers Like me and thank you for sharing ......

  10. Helpful as always. Every post you write produce a massive value to your readers that is the only reason it is so popular and has great authority.

    Hadoop Training in Chennai

    Dot Net Training in Chennai

  11. Thank you for sharing useful information about Interview. Here I prefer some more useful information aboutInterview Tips for Job