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.

AutoConfiguration

>Embedded Servlet Container , Datsource, JDBCTemplate, JPA

ØBatch Processing : Event & async processing

Ø

Actuator –

 

Non functional features – MVC endpoints

Security,

Audit,

Metrics

  & 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"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<modelVersion>4.0.0</modelVersion>

<groupId>org.springframework</groupId>

<artifactId>gs-crud-with-vaadin</artifactId>

<version>0.1.0</version>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>1.3.5.RELEASE</version>

</parent>

<dependencyManagement>

<dependencies>

<dependency>

<groupId>com.vaadin</groupId>

<artifactId>vaadin-bom</artifactId>

<version>7.6.4</version>

<type>pom</type>

<scope>import</scope>

</dependency>

</dependencies>

</dependencyManagement>

<properties>

<java.version>1.8</java.version>

</properties>

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<dependency>

<groupId>com.vaadin</groupId>

<artifactId>vaadin-spring-boot-starter</artifactId>

<version>1.0.0</version>

</dependency>

<dependency>

<groupId>com.h2database</groupId>

<artifactId>h2</artifactId>

</dependency>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.8.1</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>2.5</version>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

</dependencies>

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

</plugins>

</build>

</project> 

Example

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;

@Controller

@RequestMapping("/hello-world")

public class HelloWorldController {

    private static final String template = "Hello, %s!";

    private final AtomicLong counter = new AtomicLong();

    @RequestMapping(method=RequestMethod.GET)

    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;

    }

}

RestController

package com.example.rest;

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

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

@RestController

public class MyController {

    @RequestMapping("/thing")

    

    public MyThing thing() {

            return new MyThing("Vikalp");

    }

}

package com.example.rest;

import javax.xml.bind.annotation.XmlRootElement;

@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;

@SpringBootApplication

public class DemoApplication {

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

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class);

}

@Bean

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():");

log.info("-------------------------------");

for (Customer customer : repository.findAll()) {

log.info(customer.toString());

}

log.info("");

// fetch an individual customer by ID

Customer customer = repository.findOne(1L);

log.info("Customer found with findOne(1L):");

log.info("--------------------------------");

log.info(customer.toString());

log.info("");

// fetch customers by last name

log.info("Customer found with findByLastNameStartsWithIgnoreCase('Bauer'):");

log.info("--------------------------------------------");

for (Customer bauer : repository

.findByLastNameStartsWithIgnoreCase("Bauer")) {

log.info(bauer.toString());

}

log.info("");

};

}

}

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.

 */

@SpringUI

@Theme("valo")

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;

@Autowired

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);

}

@Override

protected void init(VaadinRequest request) {

// build layout

HorizontalLayout actions = new HorizontalLayout(filter, addNewBtn);

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

setContent(mainLayout);

// Configure layouts and components

actions.setSpacing(true);

mainLayout.setMargin(true);

mainLayout.setSpacing(true);

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()) {

editor.setVisible(false);

} 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(() -> {

editor.setVisible(false);

listCustomers(filter.getValue());

});

// Initialize listing

listCustomers(null);

}

// tag::listCustomers[]

private void listCustomers(String text) {

if (StringUtils.isEmpty(text)) {

grid.setContainerDataSource(new BeanItemContainer(Customer.class, repo.findAll()));

} else {

grid.setContainerDataSource(

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).

 */

@SpringComponent

@UIScope

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);

@Autowired

public CustomerEditor(CustomerRepository repository) {

this.repository = repository;

addComponents(firstName, lastName, actions);

// Configure and style components

setSpacing(true);

actions.setStyleName(ValoTheme.LAYOUT_COMPONENT_GROUP);

save.setStyleName(ValoTheme.BUTTON_PRIMARY);

save.setClickShortcut(ShortcutAction.KeyCode.ENTER);

// 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));

setVisible(false);

}

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;

}

cancel.setVisible(persisted);

// 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);

setVisible(true);

// A hack to ensure the whole form is visible

save.focus();

// Select all text in firstName field automatically

firstName.selectAll();

}

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;

@Entity

public class Customer {

@Id

@GeneratedValue

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;

}

@Override

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.

@SpringBootApplication
public class Application extends SpringBootServletInitializer {

@Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }

public static void main(String[] args) throws Exception {
        SpringApplication.run(Application.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