Connecting the View to the Backend

In the previous chapter, you created the view using Vaadin components and layouts. In this chapter, you will connect the view to the backend to display and update data.

You can find the backend code in the src/main/java directory.

This chapter covers:

  • Spring Boot.

  • How to create a Spring Service for interfacing the backend.

  • How to access a service from the view.

An Introduction to Spring Boot

Vaadin starter projects use Spring Boot on the server, although you can use Vaadin also without it. Spring Boot is an opinionated, convention-over-configuration approach to creating Spring applications. Spring Boot automates much of the required configuration and manages an embedded Tomcat server, so you don’t need to deploy the application to a separate server.

In this tutorial, you use the following features that are configured by Spring Boot:

  • Spring Data for accessing the database through JPA and Hibernate.

  • An embedded H2 Database for development, and PostgreSQL for production.

  • Spring Boot DevTools for automatic code reload.

  • Embedded Tomcat server for deployment.

  • Spring Security for authenticating users.

Backend Overview

The starter you downloaded contains the entities and repositories you need, along with a sample data generator.

Domain Model: Entities

The Vaadin CRM application has three JPA entities that make up its domain model: Contact, Company, and Status. A contact belongs to a company and has a status.

You can find the entities in the com.example.application.data.entity package.

Entity model diagram

Database Access: Repositories

The application uses Spring Data JPA repositories for database access. Spring Data provides implementations of basic create, read, update, and delete (CRUD) database operations when you extend from the JpaRepository interface.

You can find the repositories in the com.example.application.data.repository package.

Sample Data Generator

The com.example.application.data.generator package contains a sample data generator that populates the database with data. It uses CommandLineRunner, which Spring Boot runs when the application starts up.

Creating a Service for Accessing the Database

Instead of accessing the database directly from the view, you will create a Spring Service. The service class handles the application’s business logic and, in larger applications, it will often transform database entities into data-transfer objects (DTO) for views. In this tutorial, you will create a single service that provides all the methods you need.

Create a new class, CrmService.java, in the data.service package with the following content:

CrmService.java

  1. package com.example.application.data.service;
  3. import com.example.application.data.entity.Company;
  4. import com.example.application.data.entity.Contact;
  5. import com.example.application.data.entity.Status;
  6. import com.example.application.data.repository.CompanyRepository;
  7. import com.example.application.data.repository.ContactRepository;
  8. import com.example.application.data.repository.StatusRepository;
  9. import org.springframework.stereotype.Service;
  11. import java.util.List;
  13. @Service 1
  14. public class CrmService {
  16.     private final ContactRepository contactRepository;
  17.     private final CompanyRepository companyRepository;
  18.     private final StatusRepository statusRepository;
  20.     public CrmService(ContactRepository contactRepository,
  21.                       CompanyRepository companyRepository,
  22.                       StatusRepository statusRepository) { 2
  23.         this.contactRepository = contactRepository;
  24.         this.companyRepository = companyRepository;
  25.         this.statusRepository = statusRepository;
  26.     }
  28.     public List<Contact> findAllContacts(String stringFilter) {
  29.         if (stringFilter == null || stringFilter.isEmpty()) { 3
  30.             return contactRepository.findAll();
  31.         } else {
  32.             return contactRepository.search(stringFilter);
  33.         }
  34.     }
  36.     public long countContacts() {
  37.         return contactRepository.count();
  38.     }
  40.     public void deleteContact(Contact contact) {
  41.         contactRepository.delete(contact);
  42.     }
  44.     public void saveContact(Contact contact) {
  45.         if (contact == null) { 4
  46.             System.err.println("Contact is null. Are you sure you have connected your form to the application?");
  47.             return;
  48.         }
  49.         contactRepository.save(contact);
  50.     }
  52.     public List<Company> findAllCompanies() {
  53.         return companyRepository.findAll();
  54.     }
  56.     public List<Status> findAllStatuses(){
  57.         return statusRepository.findAll();
  58.     }
  59. }

  1. The @Service annotation will make this a Spring-managed service that you can inject into your view.

  2. Use Spring constructor injection to autowire the database repositories.

  3. Check if there is an active filter, return either all contacts or use the repository to filter based on the string.

  4. Service classes often include validation and other business rules before making the data persistent. Here, you check that you aren’t accidentally trying to save a null object.

Implementing Filtering in the Repository

Add the search() method to the contacts repository to provide the service class with the required method for filtering contacts.

ContactRepository.java

  1. public interface ContactRepository extends JpaRepository<Contact, Long> {
  3.   @Query("select c from Contact c " +
  4.       "where lower(c.firstName) like lower(concat('%', :searchTerm, '%')) " +
  5.       "or lower(c.lastName) like lower(concat('%', :searchTerm, '%'))") 1
  6.     List<Contact> search(@Param("searchTerm") String searchTerm); 2
  7. }
  1. Uses the @Query annotation to define a custom query. In this case, it checks if the string matches the first or the last name, and ignores the case. The query uses Java Persistence Query Language (JPQL) which is an SQL-like language for querying JPA-managed databases.

Note that you do not need to implement the method. Spring Data will provide the implementation based on the query.

Using the Backend Service From the View

You can now inject the CrmService into the list view to access the backend.

ListView.java

  1. package com.example.application.views.list;
  3. import com.example.application.data.entity.Contact;
  4. import com.example.application.data.service.CrmService;
  5. import com.vaadin.flow.component.Component;
  6. import com.vaadin.flow.component.button.Button;
  7. import com.vaadin.flow.component.grid.Grid;
  8. import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
  9. import com.vaadin.flow.component.orderedlayout.VerticalLayout;
  10. import com.vaadin.flow.component.textfield.TextField;
  11. import com.vaadin.flow.data.value.ValueChangeMode;
  12. import com.vaadin.flow.router.PageTitle;
  13. import com.vaadin.flow.router.Route;
  14. import com.vaadin.flow.theme.Theme;
  16. import java.util.Collections;
  18. @Route(value = "")
  19. @Theme(themeFolder = "flowcrmtutorial")
  20. @PageTitle("Contacts | Vaadin CRM")
  21. public class ListView extends VerticalLayout {
  22.     Grid<Contact> grid = new Grid<>(Contact.class);
  23.     TextField filterText = new TextField();
  24.     ContactForm form;
  25.     CrmService service;
  27.     public ListView(CrmService service) { 1
  28.         this.service = service;
  29.         addClassName("list-view");
  30.         setSizeFull();
  31.         configureGrid();
  32.         configureForm();
  34.         add(getToolbar(), getContent());
  35.         updateList(); 2
  36.     }
  38.     private Component getContent() {
  39.         HorizontalLayout content = new HorizontalLayout(grid, form);
  40.         content.setFlexGrow(2, grid);
  41.         content.setFlexGrow(1, form);
  42.         content.addClassNames("content");
  43.         content.setSizeFull();
  44.         return content;
  45.     }
  47.     private void configureForm() {
  48.         form = new ContactForm(service.findAllCompanies(), service.findAllStatuses()); 3
  49.         form.setWidth("25em");
  50.     }
  52.     private void configureGrid() {
  53.         grid.addClassNames("contact-grid");
  54.         grid.setSizeFull();
  55.         grid.setColumns("firstName", "lastName", "email");
  56.         grid.addColumn(contact -> contact.getStatus().getName()).setHeader("Status");
  57.         grid.addColumn(contact -> contact.getCompany().getName()).setHeader("Company");
  58.         grid.getColumns().forEach(col -> col.setAutoWidth(true));
  59.     }
  61.     private HorizontalLayout getToolbar() {
  62.         filterText.setPlaceholder("Filter by name...");
  63.         filterText.setClearButtonVisible(true);
  64.         filterText.setValueChangeMode(ValueChangeMode.LAZY);
  65.         filterText.addValueChangeListener(e -> updateList()); 4
  67.         Button addContactButton = new Button("Add contact");
  69.         HorizontalLayout toolbar = new HorizontalLayout(filterText, addContactButton);
  70.         toolbar.addClassName("toolbar");
  71.         return toolbar;
  72.     }
  74.     private void updateList() { 5
  75.         grid.setItems(service.findAllContacts(filterText.getValue()));
  76.     }
  77. }

  1. Autowire CrmService through the constructor. Save it in a field, so you can access it from other methods.

  2. Call updateList() once you have constructed the view.

  3. Use the service to fetch companies and statuses.

  4. Call updateList() any time the filter changes.

  5. updateList() sets the grid items by calling the service with the value from the filter text field.

Build the project, refresh the browser, and verify that you can now see contacts in the grid. Try filtering the contents by typing into the filter text field.

The grid displays 4 contacts after filtering with the string

migration assistance

Download free e-book.
The complete guide is also available in an easy-to-follow PDF format.

https://pages.vaadin.com/en/build-a-modern-web-app-with-spring-boot-vaadin-pdf

Open in anew tab

Show code

render-banner.ts

  1. export class RenderBanner extends HTMLElement {
  2.   connectedCallback() {
  3.     this.renderBanner();
  4.   }
  6.   renderBanner() {
  7.     let bannerWrapper = document.getElementById('tocBanner');
  9.     if (bannerWrapper) {
  10.       return;
  11.     }
  13.     let tocEl = document.getElementById('toc');
  15.     // Add an empty ToC div in case page doesn't have one.
  16.     if (!tocEl) {
  17.       const pageTitle = document.querySelector(
  18.         'main > article > header[class^=PageHeader-module--pageHeader]'
  19.       );
  20.       tocEl = document.createElement('div');
  21.       tocEl.classList.add('toc');
  23.       pageTitle?.insertAdjacentElement('afterend', tocEl);
  24.     }
  26.     // Prepare banner container
  27.     bannerWrapper = document.createElement('div');
  28.     bannerWrapper.id = 'tocBanner';
  29.     tocEl?.appendChild(bannerWrapper);
  31.     // Banner elements
  32.     const text = document.querySelector('.toc-banner-source-text')?.innerHTML;
  33.     const link = document.querySelector('.toc-banner-source-link')?.textContent;
  35.     const bannerHtml = `<div class='toc-banner'>
  36.           <a href='${link}'>
  37.             <div class="toc-banner--img"></div>
  38.             <div class='toc-banner--content'>${text}</div>
  39.           </a>
  40.         </div>`;
  42.     bannerWrapper.innerHTML = bannerHtml;
  44.     // Add banner image
  45.     const imgSource = document.querySelector('.toc-banner-source .image');
  46.     const imgTarget = bannerWrapper.querySelector('.toc-banner--img');
  48.     if (imgSource && imgTarget) {
  49.       imgTarget.appendChild(imgSource);
  50.     }
  51.   }
  52. }