Hibernate on Janik von Rotz

Build a Java 3-tier application from scratch - Part 1: Introduction and project setup

Sun, 15 Mar 2015 16:57:38 +0000

Welcome to my first post of the Java 3-tier application tutorial. In this tutorial I will tell show how you can develope a Model-View-Controller based Java desktop and server application using the latest tools and frameworks.

This tutorial uses advanced techniques and programming paradigms, make sure to meet at least the following requirements:

MySQL Database design and administration
Eclipse development
Java classes, interfaces and generics
MVC programming concept
ORM techniques
JAX-RS with jackson aka RESTeasy with JSON
Restful webservices
CRUD Data access object
Booo to XML, hail to JSON
Gradle build and task scripts

I also recommend to finish my other tutorial first (if not done yet): Superb Java development with Gradle, Hibernate, FlywayDB, JavaFX and Eclipse Part 1 and Part 2.

To accomplish this tutorial you will need several development tools and frameworks.

I will definitely use these programs:

Eclipse: The development IDE recommended for this tutorial.
MySQL server: OpenSource database server.
Gradle: A task runner and package manager for your Java project (in case you’re a web developer that would be bower and grunt).
JavaFX Scene Builder Tool to create user interfaces.

Architecture

Our strategy for this project is quite simple. EclipseLink will communicate with the database and acts as our ORM, JAX-RS is used to create our JSON restful webservice and JavaFX is the framework for our client app. Below is a picture that shows our Architecture, the commuication flow and where we use 3rd party libraries.

Our application architecture consists of 3 eclipse projects:

client: Thin app to interact with the application
webservice: Communicates with the database and serves the REST interfaces.
common: Components used by both projects.

Project setup

Now we are going to set up these 3 projects with gradle.

Create a project folder /../<project> somewhere on your drive.
To this folder add 3 more directories: common, webservice and client.
In the project folder and within these 3 directories add a build.gradle file.
Add a second file called settings.gradle to the project folder.
Open your command line and navigate to the project folder: cd <project>.
Update the file content as showed below.

settings.gradle

include ":common", ":webservice", ":client"

This file will tell gradle that we work with a multiproject setup.

build.gradle

subprojects {

  apply plugin: "java"
  apply plugin: "eclipse"

  repositories {
    mavenCentral()
  }

  configurations {
    lombok
  }

  dependencies {
     testCompile 'junit:junit:4.+'
     compile 'org.projectlombok:lombok:1.+'
     lombok 'org.projectlombok:lombok:1.+'
  }

  // install lombok for Eclipse

  sourceSets.each{ sourceSet ->
    sourceSet.compileClasspath += configurations.lombok
    sourceSet.ext.delombok = new File(buildDir, "generated-src/delombok/" + sourceSet.name);
  }

  task installLombok() {
    dependsOn configurations.lombok
  } << {
      File jarFile = null;
      configurations.lombok.resolvedConfiguration.resolvedArtifacts.find {
          if ("lombok".equals(it.name)) {
              jarFile = it.file;
          }
      }
      javaexec {
          main="-jar"
          args = [
              jarFile,
              "install",
              "auto"
          ]
      }
  }
  eclipseProject.dependsOn installLombok

  // install lombok for Javadoc

  task delombok() {
    dependsOn configurations.compile
    dependsOn configurations.lombok
  } << {
      File jarFile = null;
      configurations.lombok.resolvedConfiguration.resolvedArtifacts.find {
          if ("lombok".equals(it.name)) {
              jarFile = it.file;
          }
      }
      sourceSets.each{ sourceSet ->
          def classPath = sourceSet.compileClasspath.files.join(";")
          def delombokPath = sourceSet.ext.delombok
          delombokPath.mkdirs();
          javaexec {
              main = "-jar"
              args jarFile, "delombok"
              if (!classPath.empty) {
                  args "-c", classPath
              }
              args "-d", delombokPath
              args sourceSet.allJava.srcDirs
          }
      }
  }

  javadoc {
      dependsOn delombok
      source = sourceSets.main.ext.delombok
  }
}

This is the master gradle build file and contains definition for each subproject. The java and eclipse plugin allows us to import the 3 projects into Eclipse as a Java project. Maven central is our main repository, this is the provider where we download our libraries. Within this project we will make use of project lombok. This project intends to get rid of the implementation process of getter and setter methods by generating them with annotations. You will see in the next chapter how this works.

common/build.gradle

dependencies {
  compile 'org.eclipse.persistence:javax.persistence:2.+'
  compile 'org.eclipse.persistence:eclipselink:2.+'

  compile 'org.codehaus.jackson:jackson-core-asl:1.+'
  compile 'org.codehaus.jackson:jackson-mapper-asl:1.+'
  
  compile 'org.jboss.resteasy:resteasy-jaxrs:3.+'
  compile 'org.jboss.resteasy:resteasy-jaxb-provider:3.+'
  compile 'org.jboss.resteasy:resteasy-client:3.+'
  
  compile 'org.apache.commons:commons-lang3:3.+'
  compile 'com.typesafe:config:1.+'
  compile 'org.slf4j:slf4j-simple:1.+'
  compile 'com.github.javafaker:javafaker:0.+'
}

Both application components going to use these libraries: EclipseLink: ORM for Java. jackson core: Core components of jackson to parse JSON data. jackson mapper: Convert between POJO and JSON. RESTeasy client: client api to consume the webservice. RESTeasy: JAX-RS implementation to develop RESTful client and server applications. Apache Commons: popular and reusable Java components. Typesafe Config: JVM configuration library. Java Faker: library to create fake data.

webservice/build.gradle

apply plugin: 'jetty'

dependencies {
  compile project(':common')
  compile 'mysql:mysql-connector-java:5.+'
  compile 'org.jboss.resteasy:resteasy-jackson-provider:2.+'
  providedCompile 'javax.servlet:javax.servlet-api:3.+'
}

jettyRun.webAppSourceDirectory = file("src/main/resources")

task seed(type:JavaExec) {
   main = 'ch.issueman.webservice.Seed'
   classpath = sourceSets.main.runtimeClasspath
}

Jetty is our application server, instead of the default webapp folder we will use the resources folder to configure the application. The MySQL connector is the database driver for EclipseLink. The custom seed task allows us to execute the main method of our Seed class.

client/build.gradle

dependencies {
  compile project(':common')
}

The client uses common dependencies only.

Run two gradle tasks on the command line.
- gradle build: This will build the Java application project.
- gradle eclipse: Creates the required files such as .project to import the projects into eclipse.
Finally set the workspace path of eclipse to the folder that contains the <project> directory and import the projects within the <project> folder.

Congratulation you’ve finished the first part of this tutorial. Can’t wait to see you in the next part ;)

Update

2015-03-28: I’ve replaced Hibernate with EclipseLink and dropped FlywayDB as we create the database with EclipseLink.
2015-04-01: Added project lombok to eclipse and and project dependencies.

Links

Here are all links to the other parts of this tutorial.

Source

Several Java tutorials from Mykong.com
How do I use Lombok with Eclipse, Gradle, and Javadocs?

Superb Java development with Gradle, Hibernate, FlywayDB, JavaFX and Eclipse – Part 2

Thu, 05 Mar 2015 17:01:57 +0000

As promised here’s the sequel to my last tutorial: Part 1

This time we create a basic rich application with JavaFX. It will be quite simple, but still a good example to show how you can structure a complex project according to MVC.

Update

We will start with a refresh of the file structure. The picture below shows yellow marked the new packages and directories. On the right side is a preview of the application window labeled with the type of each component.

Create the new packages.
Move the files to their new folders. Eclipse will automatically update the namespace and import commands.
In the hibernate configuration file update the mapping property.

hibernate.cfg.xml

<mapping class="ch.hslu.issueman.model.Person"/>

Finally create the JavaFX view file Home.fxml in the view directory. We will update this file later.

Install

To create the visual layout I’ve used JavaFX Scene Builder. Please install this tool, we will need to edit the Home.fxml file.

Coding - Controller

To connect the view with the Person Controller we have to provide scene builder objects and methods. I assume you’ve completed the first tutorial and will only show the changes to file.

PersonController.java - begin

import java.net.URL;
import java.util.List;
import java.util.ResourceBundle;
import javafx.collections.FXCollections;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Button;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.control.cell.PropertyValueFactory;
import ch.hslu.issueman.model.Person;

A lot of new dependencies required by JavaFX.

At the end of the file before the closing } inser the following snippets.

	@FXML
	private Button btAdd;
	
	@FXML
	private Button btUpdate;
	
	@FXML
	private Button btDelete;
	
	@FXML
	private TextField txName;
	
	@FXML
	private TableView<Person> tvPerson;
	
	@FXML
	private TableColumn<Person, Integer> tcId;
	
	@FXML
	private TableColumn<Person, String> tcName;

These objects allows us to set and get values from the application interface.

	@Override
	public void initialize(URL arg0, ResourceBundle arg1) {
		tcId.setCellValueFactory(new PropertyValueFactory<Person, Integer>("id"));		
		tcName.setCellValueFactory(new PropertyValueFactory<Person, String>("name"));
		refreshPersonTable();
	}

Whenever the application is startet the initialize method will be called. In this function we tell the table view column which value of the person it has to display and also call the refreshPersonTable method which is added next.

	public void refreshPersonTable(){
		tvPerson.setItems(FXCollections.observableArrayList(getAll()));
	}

In this method we feed the table view with a person array.

	@FXML
	public void clickTableView(){
		txName.textProperty().set(tvPerson.getSelectionModel().getSelectedItem().getName());
	}

As you can see there’s a FXML-Annotation as well. This tag allows us to connect an event added by the scene build with a function in the controller. Whenever a row is clicked in the table view we load the content to the form part (if you have got more than one field its recommanded to store the chosen object in a temporary variable).

	@FXML
	public void clickAdd(){
		controller.persist(new Person(txName.getText()));
		refreshPersonTable();
	}
	
	@FXML
	public void clickUpdate(){
		Person p = tvPerson.getSelectionModel().getSelectedItem();
		p.setName(txName.getText());
		controller.update(p);
		refreshPersonTable();
	}
	
	@FXML
	public void clickDelete(){
		controller.delete(tvPerson.getSelectionModel().getSelectedItem());
		refreshPersonTable();
	}

Some more event methods for the buttons.

Design

Designing the user interface is very easy.

Open the Home.fxml file with scene builder.
Connect the scene with the PersonController.
Add the components showed in the preview and connect them with the fxml objects and methods.

If you don’t know how to accomplish that yet you can copy the fxml definitions below.

Home.fxml

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.scene.image.*?>
<?import javafx.scene.effect.*?>
<?import javafx.scene.paint.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.text.*?>
<?import java.lang.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.layout.AnchorPane?>

<AnchorPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="300.0" prefWidth="400.0" xmlns="http://javafx.com/javafx/8" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.hslu.issueman.controller.PersonController">
   <effect>
      <Glow />
   </effect>
   <children>
      <TableView fx:id="tvPerson" onMouseClicked="#clickTableView" prefHeight="307.0" prefWidth="187.0">
         <columns>
            <TableColumn fx:id="tcId" prefWidth="50.0" text="ID" />
            <TableColumn fx:id="tcName" prefWidth="135.0" text="Name" />
         </columns>
      </TableView>
      <Button fx:id="btAdd" layoutX="200.0" layoutY="99.0" mnemonicParsing="false" onMouseClicked="#clickAdd" text="Add" />
      <Button fx:id="btUpdate" layoutX="248.0" layoutY="99.0" mnemonicParsing="false" onMouseClicked="#clickUpdate" text="Update" />
      <Button fx:id="btDelete" layoutX="317.0" layoutY="99.0" mnemonicParsing="false" onMouseClicked="#clickDelete" text="Delete" />
      <TextField fx:id="txName" layoutX="196.0" layoutY="61.0" />
   </children>
</AnchorPane>

And we are almost done.

Coding - Application

To launch the whole scene we have to update the App.java code as showed below.

App.java

package ch.hslu.issueman;
	
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.stage.Stage;
import javafx.scene.Scene;

public class App extends Application {
	@Override
	public void start(Stage primaryStage) {
		try {
			primaryStage.setResizable(false);
			primaryStage.setTitle("Issue Manager");
			primaryStage.setScene(new Scene(FXMLLoader.load(getClass().getResource("view/Home.fxml"))));
			primaryStage.show();			
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		launch(args);
	}
}

Hurray! We are done! You can run the application now and should be able to add, edit and delete people from the list all whilst they are stored in the MySQL database.

Source

You can download the source code of the project here: https://codeberg.org/janikvonrotz/issue-manager/releases/tag/1.1

Superb Java development with Gradle, Hibernate, FlywayDB, JavaFX and Eclipse - Part 1

Tue, 03 Mar 2015 23:53:04 +0000

Wow that’s the best Java tutorial I’ve seen so far!

-You in a few minutes.

Sounds selfish, doesn’t it? Well it has the right to be, it took me 2 hours to write that! Don’t hesitate now and turn on your dev machine. After this tutorial you have to rethink your Java development process and if you don’t have one yet this is the best place to start. I will show you the most advanced tools to speed up your Java development environment and collaboration capabilities. In this tutorial we are going to develop a simple MVC (Model, View, Controller) application ruled by the DRY (Don’t repeat yourself) approach.

The crappy picture below shows what’s going on according to my brain.

So what do I excepect from you? Well, make sure you know at least a little bit about the following topics:

Java Collection Framework
Java Classes and Interfaces
Java Development with Eclipse
MySQL database and SQL scripts
Feeling comfortable with the command line

Let’s get startet with the tools. You don’t have to install them yet, first I will explain them in detail.

Gradle: A task runner and package manager for your Java project (in case you’re a web developer that would be bower and grunt).
Hibernate ORM: Object Relation Manager that simplifies database transactions by applying an abstraction layer.
Flyway: An awesome database migration tool (works perfect within a team and git as version control).
JavaFX: Framework for rich application.
Eclipse: The development IDE of your choice.
MySQL server: OpenSource database server.

Got it? Now we are going to install some stuff.

Installation

Start with MySQL. The easiest way to get MySQL on your computer is to install a whole web development stack. They usually come with phpmyadmin which is greate to view your database content and other usefull tools preinstalled. I recommand the Nginx Stack by Bitnami.
Next, if not done yet, install Eclipse.
And finally get Gradle to run.

As told Gradle is our servant for the project. Follow these steps to set up our project directory and dependencies.

Create a project folder somewhere on your disk C:/../<project>.
Open the command line (on windows please use PowerShell) and open the project folder cd C:/../<project>.
In the project folder create a file named build.gradle.
In the order as showed below, paste the snippets into the file.

build.gradle - start

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'mysql:mysql-connector-java:5.1.34'
        classpath 'org.flywaydb:flyway-gradle-plugin:3.1'
    }
}

Adds the Flyway database migration tool to your gradle task library.

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'flyway'

Gradle plugins to set up the project.

repositories {
    mavenCentral()
}

Gradle gets dependencies from the maven repository.

dependencies {
    compile 'org.hibernate:hibernate-core:4.3.8.Final'
    compile 'mysql:mysql-connector-java:5.1.34'
    
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

These commands compile hibernate, mysql and depending libraries for our Java project.

flyway {
    url = 'jdbc:mysql://localhost:3306'
    user = 'issuemanager'
    password = 'issuemanager'
    schemas = ['issuemanager']
}

Flyway task configuration section. Make sure to update these fields.

build.gradle - end

Open http://localhost/phpmyadmin, login and setup a user and a database with the same definitions.
On your command line run: gradle build. This will download and compile all dependencies.
Run: gradle eclipse. This will create the files required to import the project into eclipse.
Start eclipse and import the project. Don’t close the command line yet!
Update the eclipse project structure according to the yellow marked files and directories showed below. Leave all the files except build.gradle empty.

Update the *.sql files with these statements:

V1__create_person_table.sql

create table person(
    id int NOT NULL AUTO_INCREMENT, PRIMARY KEY (id),
    name varchar(100) NOT NULL
);

This snippets creates the MySQL person table.

V2__add_people.sql.sql

insert into PERSON (NAME) values ('Axel');
insert into PERSON (NAME) values ('Mr. Foo');
insert into PERSON (NAME) values ('Ms. Bar');

This snippet adds people to the persons table.

Switch back to your command line and run: gradle flywayMigrate. This will create the person table according to your snippets.

If everything worked fine so far we are ready to write some code.

Coding - Controller

We will start with the DAO interface and the CRUD (create, read, update, delete) controller.

Update the Data Access Object interface.

DAO.java

package ch.hslu.issueman;

import java.io.Serializable;
import java.util.List;

public interface DAO<T, Id extends Serializable> {
	
	public void persist(T t);
	public T getById(Id id);
	public List<T> getAll();
	public void update(T t);
	public void delete(T t);
	public void deleteAll();
}

This interface defines the functions required to communicate with the database later. As you can see we will use generics as we don’t want to create the same interface implementation for every model (despite we only have one model in this example).

Update the basic Controller class.

I will split the controller in multiple snippets and explain what’s going on in detail.

Controller.java - start

package ch.hslu.issueman;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

public class Controller<T, Id extends Serializable> implements DAO<T, Id> {

	private final Class<T> clazz;
	private Session currentSession;
	private Transaction currentTransaction;
	
	protected Controller(Class<T> clazz) {
        this.clazz = clazz;
    }

clazz and the extended Controller constructor is a workaround to store the generic class type and retrieved it later.
currentSession is used to store a MySQL database access session.
currentTransaction is helper to manage database commits.

public Session openCurrentSession() {
		currentSession = getSessionFactory().openSession();
		return currentSession;
	}
	public Session openCurrentSessionwithTransaction() {
		currentSession = getSessionFactory().openSession();
		currentTransaction = currentSession.beginTransaction();
		return currentSession;
	}	
	public void closeCurrentSession() {
		currentSession.close();
	}
	public void closeCurrentSessionwithTransaction() {
		currentTransaction.commit();
		currentSession.close();
	}	
	private static SessionFactory getSessionFactory() {
		Configuration configuration = new Configuration().configure();
		StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder()
				.applySettings(configuration.getProperties());
		SessionFactory sessionFactory = configuration.buildSessionFactory(builder.build());
		return sessionFactory;
	}

	public Session getCurrentSession() {
		return currentSession;
	}
	public void setCurrentSession(Session currentSession) {
		this.currentSession = currentSession;
	}
	public Transaction getCurrentTransaction() {
		return currentTransaction;
	}
	public void setCurrentTransaction(Transaction currentTransaction) {
		this.currentTransaction = currentTransaction;
	}

These lines provide methods to interact with the hibernate session manager. Not very interesting also quite common. Below you’ll see that we will use CurrentSession to read from the database and CurrentSessionwithTransaction for operations such as delete in the database.

	public void persist(T t) {
		openCurrentSessionwithTransaction();
		getCurrentSession().save(t);
		closeCurrentSessionwithTransaction();
	}

	public T getById(Id id) {
		openCurrentSession();
		@SuppressWarnings("unchecked")
		T t = (T) getCurrentSession().get(clazz, id);
		closeCurrentSession();
		return t;
	}

	@SuppressWarnings("unchecked")
	public List<T> getAll() {
		openCurrentSession();
		List<T> list = (List<T>) getCurrentSession().createQuery("from " + clazz.getName()).list();
		closeCurrentSession();
		return list;
	}

	public void update(T t) {
		openCurrentSessionwithTransaction();
		getCurrentSession().update(t);
		closeCurrentSessionwithTransaction();
	}

	public void delete(T t) {
		openCurrentSessionwithTransaction();
		getCurrentSession().delete(t);
		closeCurrentSessionwithTransaction();
	}
	
	public void deleteAll() {
		openCurrentSessionwithTransaction();
		List<T> people = getAll();
		for (T t : people) {
			delete(t);
		}
		closeCurrentSessionwithTransaction();
	}

	public void printToJson(List<T> l) {
		
		int size = l.size();
		System.out.println("[");
		for (T i : l) {
			System.out.println(((Model) i).toJson());
			if (--size != 0){System.out.print(",");}
		}
		System.out.print("]");			
	}
}

This is the implementation of the DAO interface. Checkout the getAll method, there you’ll see how the class name workaround is used. The console output of values is Json styled.

Controller.java - end

That’s it, this is our basic Controller that will be used by each Model Controller to interact with the database.

Coding - Model

Now you will see the allmighty power of hibernate. It never was easier to connect a model with a SQL table.

Update the model interface.

Model.java

package ch.hslu.issueman;

public interface Model {
	public String toJson();
}

Easy but usefull. Every model has to implement the toJson method, because why not?

Update the Person model with some special markup.

Person.java

package ch.hslu.issueman;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="person")
public class Person implements Model{
	
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	@Column(name="id")
    private int id; 
	
	@Column(name="name")
    private String name;
	
	public Person() {}

	public Person(String name) {
		setName(name);
	}
	
	public int getId() {
		return id;
	}
		
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String toJson() {
		return "{\"id\": \"" + getId() + "\", \"name\":\"" + getName() + "\"}";
	}

}

Those @-Annotation will tell hibbernate which column belongs to which object attribute. Awesome! Isn’t it?

Update the hibernate configuration file.

hibernate.cfg.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
   <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
   <property name="hibernate.connection.url">jdbc:mysql://localhost/issuemanager</property>
   <property name="hibernate.connection.username">issuemanager</property>
   <property name="hibernate.connection.password">issuemanager</property>
   <property name="show_sql">true</property>
   <property name="hibernate.current_session_context_class">thread</property>
   <mapping class="ch.hslu.issueman.Person"/>
</session-factory>
</hibernate-configuration>

Add the same values as already used to configure flyway. Very important is the mapping property which finalizes the mapping process of the model with database table.

Coding - App

This is the last coding part of the first tutorial.

Update the Person Controller.

PersonController.java

package ch.hslu.issueman;

import java.util.List;

public class PersonController implements DAO<Person, Integer>{
	
	private static Controller<Person, Integer> controller;
	
	public PersonController() {
		controller = new Controller<Person, Integer>(Person.class);
	}
	
	public void persist(Person person) {
		controller.persist(person);
	}

	public Person getById(Integer id) {
		Person person = controller.getById(id);
		return person;
	}

	public List<Person> getAll() {
		List<Person> people = controller.getAll();
		return people;
	}

	public void update(Person person) {
		controller.update(person);
	}

	public void deleteById(Integer id) {
		controller.delete(controller.getById(id));
	}

	public void delete(Person person) {
		controller.delete(person);
	}
	
	public void deleteAll() {
		controller.deleteAll();
	}

	public void printToJson(List<Person> people) {
		controller.printToJson(people);	
	}
}

As you can see the Person Controller uses the basic Controller to do some CRUD actions. Every model controller must implement the DAO interface and must use the basic Controller. This strategy allows us to define model depended actions within the CRUD methods.

Update the application code.

App.java

package ch.hslu.issueman;

public class App {

	public static void main(String[] args) {
		
		PersonController PersonController = new PersonController();
//		PersonController.deleteAll();
		
//		Person person4 = new Person("Fyodor Dostoevsky");
//		Person person5 = new Person("Leo Tolstoy");
//		Person person6 = new Person("Jane Austen");
//		
//		PersonController.persist(person4);
//		PersonController.persist(person5);
//		PersonController.persist(person6);

//		PersonController.deleteById(6);
		
//		person4.setName("Frodo");
//		PersonController.update(person4);
				
		PersonController.printToJson(PersonController.getAll());
	
		System.exit(0);
	}

}

This example application class shows how the Person Controller is used to retrieve and store Person object. Uncomment or comment sections to test the CRUD methods.

Finally run the application.

You should see a lot of hibernate blabla and of course the Json outpout of the person table.

Hibernate: select person0_.id as id1_0_, person0_.name as name2_0_ from person person0_
[
{"id": "1", "name":"Axel"}
,{"id": "2", "name":"Mr. Foo"}
,{"id": "3", "name":"Ms. Bar"}
]

That was the first part of this tutorial and of course it was just a peek into these great tools. Hibernate offers much more possibilites to connect different models and do other awesome stuff. So don’t miss the documentation on their website or other tutorials. I hope to see you soon in the next chapter when we create a rich client application with JavaFX.

Update

2015-03-05: Part 2 has been released: https://janikvonrotz.ch/2015/03/05/superb-java-development-with-gradle-hibernate-flywaydb-javafx-and-eclipse-part-2/

Source

You can get the project from here: https://codeberg.org/janikvonrotz/issue-manager/releases/tag/v1.0