Databases: JPA

Database entity

Make a Book entity that contains the following fields. You may ignore the

• id: integer, primary key, automatically generated
• title: string, at most 255 characters long, must be present
• author: string, at most 255 characters long, must be present
• publishedAt: date, optional
• pages: integer, optional
• price: java.math.BigDecimal with precision "10,2", optional
• StockStatus: enum values stored as strings
  • IN_STOCK
  • OUT_OF_STOCK
  • UNKNOWN

Store the books in the database table books.

• Override the methods equals() and hashCode() so that they function based on the primary key.
• Why is it beneficial? When can it cause problems?

JPA

Make a class BookStore that handles the above Book entities via JPA. Implement the following operations:

// Constructor, gets the name of a persistence unit, and creates an appropriate `EntityManager` for it.
BookStore(String persistenceUnitName);

// Adds a new book into the database, and returns its identifier.
int addBook(Book newBook);

// Deletes the book with the given id (if it exists in the database).
void removeBookById(int bookId);

// Gets all books present in the database.
java.util.List<Book> getAllBooks();

Make a command line application that tests the BookStore class.

JPA relations

Create an entity Author that represents the author of a book:

• id: integer, primary key, automatically generated
• name: string, at most 255 characters long, compulsory
• birthDate: date - only year/month/day, optional

Copy the Book entity (as described in the Database entity section) to your new project.

• Add an author field, an Author entity. Call the inverse side of this relation books.
  • A book may have multiple authors, and an author multiple books.
  • Override the methods equals() and hashCode() so that they function based on the primary key.
    • You may use Lombok’s @ToString(of={"..."}) annotation.

• Implement the following functionalities.

  // Adds an author.
  Author addAuthor(String name, Date birthDate /* can be null */);
  
  // Removes an author.
  void removeAuthor(Author author);
  
  // Adds a book with one author. It will be UNKNOWN in stock.
  Book addBook(String title, Author author);
  
  // Associates a book with an author.
  void assignAuthorToBook(Author author, Book book);
  
  // Removes a book.
  void removeBook(Book book);

• Make a command line application that uses the above functionalities to manipulate authors and books.
  • Let the application store the entities in the local database books.

• Experiment with different CascadeType settings for the connections between the books and the authors.

Enterprise Applications

Servlets

Make a project with a web application ScopeTest that contains a servlet. From the context root, make the servlet accessible under /test.

• The setup file contains a reminder on how to create a web application.

The servlet has to do the following.

• Respond to GET requests.
  • If you click here, you should see content generated by the servlet.
• Print the arguments of the request in a table on the page. (Look at the address bar of your browser after you click the links.)
  • For example, here we pass the parameter a with the value b.
  • Make sure you see all three values when you click here.
• Start a session (if it doesn’t already exist) and write its session ID.
  • Maintain a counter value (starting at 0) in the session scope.
    • Increase its value on every page access.
    • Print its value on the page.
  • Make a similar counter for the application scope, too.

Try the application in various ways, and see what happens.

• using one browser
• using multiple browsers
  • … if you remove the session cookies
  • … if you restart the application server

Servlets: JSP, JPA

Create a web application called business.

1. Make a single servlet that responds to GET requests.
   • At /companies, let the servlet return a page with a list of (built-in) company names.
   • At /products, let the servlet return a page with a list of (built-in) product names.
   • Note: use request.getServletPath() to determine which path is being accessed.
2. Make a JSP page company.jsp.
   • You can use a Map<String, List<String>> field in your servlet to store the company names and their associated products.
   • The JSP file will serve requests to /companies. Let the JSP file list all companies.
   • Add a form to the page. With it, the user can add a company.
     • Let the form use the POST method.
     • Let the servlet handle POST requests, too.
     • Use Post-Redirect-Get in the servlet.
3. Make a JSP page product.jsp.
   • The JSP file will serve requests to /company/COMPANY_NAME.
     • If COMPANY_NAME is not a valid company name, set the status code to SC_NOT_FOUND (404).
     • Optionally, configure web.xml to redirect to an error.html file upon page not found.
   • Let the JSP file list all products for the given company.
   • Add a form to the page. With it, the user can add a product for the company.
     • You can add an input of type hidden to distinguish between this form and the previous one.
4. Change the servlet to use JPA.
   • Make two very simple entity types Company and Product.
   • Change the above servlet and JSP file to use these entities instead of the Map.
     • Store the data in jdbc/company in GlassFish.

Stateless EJB

The setup file contains a reminder on how to create EJBs.

1. Make an application that has a stateless EJB named Company with the interface CompanyInterface.
   1. In the EJB and its interface, make a method hasProduct that takes a String and returns a boolean value.
      • The product names that the company produces can be built into the company as a “magic constant” (a set of strings) for now.
      • Make a JNDI client, too, and test the application with it.
   2. Now, support product names in several languages the following way.
      • Make local beans for each language: CompanyProductsEn, CompanyProductsHu etc. contain the list of product names in the appropriate language. The local beans have a method getProductNames that simply return the list.
      • Company will have a separate variable for each language, and the appropriate local EJB will be injected into it.
      • hasProduct now takes an additional parameter, a String for the language. The method returns false if the language is not known, otherwise it takes the products from the local bean, and returns whether the product name is present in the list.

RESTful services: JAX-RS, JAXB

To create a RESTful service, you will need a Dynamic Web Module. Have a look at web.xml for configuration options.

1. Make a @WebService with a @WebMethod named isBetween that takes three parameters. Let it return true iff param1 is between param2 and param3.
   • Separate this functionality into three @WebMethods: setLowerBound, setUpperBound and isBetween. The implementing class will store the bounds, and isBetween only takes one number; it will check whether the parameter value is between the two stored values.
2. Make such a RESTful service that can be used to store company names and the names of their products.
   • Serve simple strings in the following way.
     • Store the company names in a Map, and associate them with a List of their product names.
     • A GET request to /companies will return the names of all companies in a comma separated string.
     • A GET request to /company/FamousCompany will return the product names for FamousCompany in a comma separated string.
     • To add new companies and products, send a POST request to /add/NewCompany and /add/NewCompany/NewProduct. (Here, NewCompany and NewProduct are arbitrary names.)
   • Serve XML and JSON content at and /company/FamousCompany/xml and /company/FamousCompany/json. Create the class Company that stores its products in a list of strings, and use JAXB annotations to produce the XML and JSON.

Miscellaneous exercises

JPA

1. Make an entity (File>New>JPA Entity) called TestEntity in the package test.entity, which is a simple class annotated with @Entity.
   1. Note that the class is listed in persistence.xml (under JPA Content in Project Explorer) in the Managed classes part. Also, have a look at the Source tab.
   2. Let it have an int field called id. It will be the entity’s primary key: annotate it with @Id. Also, add @GeneratedValue.
2. Experiment with MyEntity instances: create some of them, persist them and query them.
3. Experiment with persistence.xml settings, e.g. try to set eclipselink.ddl-generation to drop-and-create-tables instead of create-tables.
4. Convert the Company, Person and Product classes from before to entities.
   1. First, only convert the fields with built-in types.
   2. You will have to add an id for each. Annotate them with @Id.