The simplest "form" on the application index page is just a button that issues an HTTP POST to the getAllBooks function in the Book Search Controller. This function handles HTTP POST operations to the relative URL /list-all-books. The HTML for this button form is shown below:

<form action="list-all-books" method="post">
    <button type="submit" class="btn btn-primary">List all books</button>
</form>

The getAllBooks function that handles the button form HTTP POST operation in the Book Search controller is shown below:

    @RequestMapping(value = "/list-all-books", method = RequestMethod.POST)
    public String getAllBooks( RedirectAttributes redirect ) {
        List<BookInfo> bookInfoList = getBookTableService().getBooks();
        if (bookInfoList != null && bookInfoList.size() > 0) {
            redirect.addFlashAttribute(BOOK_LIST, bookInfoList);
        }
        return "redirect:/";
    }

The code in the getAllBooks() function calls the BookTableService function getBooks() which returns all of the book information in the database as a List object that contains the BookInfo entries.

The List object is returned as a flash attribute (flash attributes have a "life" of one page display - when the page is refreshed or redisplayed, the flash attribute will be cleared). Standard page attributes are limited to String values. Flash attributes may be consist of any object type (such as the List of BookInfo objects).

Adding information about a book to the database

The "Add a book" tab on the main page brings the user to the "Enter Book Information" form. The form for this page is handled by the AddBookController class. The saveBook() function in this class saves the information received from the form in the database. The code for the saveBook() function is shown below:

    @RequestMapping( value="/save-book", method = RequestMethod.POST)
    public String saveBook(@Valid BookInfo bookForm,  Errors errors, RedirectAttributes redirectAttributes) {
        if (! errors.hasErrors()) {
            if (bookForm != null) {
                getBookTableService().writeToBookTable(bookForm);
                redirectAttributes.addFlashAttribute("book_saved", "Saved the information for " + bookForm.getTitle());
            } else {
                logger.info("bookForm argument is null");
            }
        } else {
            redirectAttributes.addFlashAttribute("errors", errors);
        }
        return "redirect:addbook";
    }

As in the previous examples, the saveBook function is annotated with a @RequestMapping annotation.

The saveBook function shows how the Spring framework can save coding effort. The field data from the form on the web page is packaged by the Spring framework into the BookInfo object that is one of the arguments to the saveBook function (note that the form input field names correspond to String members in the BookInfo class).

The function declaration also contains the @Valid annotation. This tells the Spring framework that it should perform validation on the BookInfo data. If there are problems with the input data, information about the errors will be contained in the Errors object.

Spring framework validation checking uses annotations associated with the BookInfo object. These annotations are shown below.

public class BookInfo {
    @NotBlank(message="A book title is required")
    private String title;
    @NotBlank(message="An author name is required")
    private String author;
    @NotBlank(message="Please include a genre for the book")
    private String genre;
    private String publisher;
    @Digits(integer=4, fraction=0, message="Please enter a year")
    private String year;
    @Pattern(regexp="^\\d{0,8}(\\.\\d{1,4})?$", message="Please enter a price i.e., 16, 16.00, 15.95")
    private String price;

If a form field (BookInfo element) fails validation, the error can be displayed in the HTML. For example, the JSP logic for an error in the book title field is shown below:

<div class="form-group row">
      <label for="title" class="col-sm-4 col-form-label">Title</label>
       <div class="col-sm-8">
	    <input type="text" id="title" name="title" placeholder="Title">
	    <c:if test="${errors.hasFieldErrors('title')}">
	       <div class="error">
                  ${errors.getFieldError("title").getDefaultMessage()}
	  </div>
     </c:if>
   </div> <!-- col-sm-8 -->
</div>

DynamoDB

DynamoDB is an Amazon Web Services "noSQL" database. DynamoDB has a number of attractive features. These include:

• DynamoDB can be easily scaled as the database workload increases.
• DynamoDB has excellent performance
• DynamoDB is a managed AWS resource and requires zero system administration.
• DynamoDB has a flexible database schema. New, non-index, attributes can be added to a DynamoDB table without having to rebuild the database
• The user only pays for database reads, writes and storage. There are no 24/7 server costs.
• DynamoDB has a "free tier" that is available to all AWS customers (not just new customers)

For the Book Search application, with relatively little data and low data traffic, DynamoDB usage is free, since it falls within the free tier. In contrast, a relational database like AWS RDS/Postgres runs on a server 24-hours a day, seven days a week. This results in monthly AWS charges.

Indexing the DynamoDB Database

DynamoDB supports index query operations and table scans. Most of the BookTableService search operations use indexed DynamoDB queries. The exception is the findBookByTitle() operation which will the scan the entire book information database for a book title substring.

An example of the book table information is shown below:

DynamoDB tables must have a hash index. The hash index is a value that is unique across all table values.

For the book table, the hash key is composed of the book title. Since books by different authors may have the same title, the title hash index is combined with a "range key", consisting of the author name. For this application the book title, author pair is assumed to be a unique value. A query on title, author pair will return only one book.

In order to allow the database to be searched by author, a DynamoDB "global secondary index" is also used. A query on this index may return more than one book.

The other DynamoDB attributes (e.g., publisher, date) are not used to return values in a DynamoDB query. These values can be searched in a DynamoDB scan operation that will read all of the items in the database. Scan operations can be expensive for large databases, since the user is charged for the amount of data read.

DynamoDB Code

The DynamoDB book table is created by the CreateBookTable class. The code that builds the table constructs the hash and range key index from the title and author attributes. A global secondary index is created from the author attribute.

The code that constructs the DynamoDB queries and the book title scan is contained in the BookTableService class.

A note on testing

Software developers are encouraged to follow the practice of "test driven development" where unit test code is written for all software components. In developing software that makes use of DynamoDB, I have found that test driven development is a necessity. Amazon's DynamoDB documentation could be better and it is easy to write DynamoDB code that does not function properly. Unit tests are often the only way to know in advance that the DynamoDB code works.

The database functions in the BookTableSearch object have versions that take a table name argument. This allows the unit test code to use DynamoDB tables that are created and deleted by the test code.

Book Search Demonstration Application on GitHub

Topstone software has published the Java Book Search demonstration application on GitHub (see Spring and DynamoDB Book Search application). This software is available under the Apache 2 open source license.

The Java and HTML code was on this page has been "pretty printed" for HTML display using http://hilite.me/

Amazon Cloud Architecture, Spring and Elasticsearch Consulting

Topstone Software has extensive experience building scalable web applications on Amazon Web Services. We can help you design your AWS application architecture to provide scalability and optimized cost.

We designed and built the nderground social network. nderground is a social network designed for privacy and security. nderground has been live with close to 100% uptime for over three years.

At Topstone Software we have experience building Spring framework applications that utilize a variety of AWS services. These include Elasticsearch, DynamoDB, S3, the Simple Email System and Elastic Beanstalk. We can provide the consulting help to speed your application development or we can develop applications to your specification.

References

• Spring in Action, Fifth Edition by Craig Walls, Manning Publications, 2018 (available through the Manning Early Access Program)

Ian Kaplan, Topstone Software Consulting, June 2018