Hibernate example source code file (TestConsole.java)

This example Hibernate source code file (TestConsole.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

address, address, auditreader, io, list, null, null, object, person, person, scanner, string, stringbuilder, stringbuilder, testconsole, util

The Hibernate TestConsole.java source code

/*
 * Envers. http://www.jboss.org/envers
 *
 * Copyright 2008  Red Hat Middleware, LLC. All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU Lesser General Public License, v. 2.1.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT A WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License, v.2.1 along with this distribution; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * Red Hat Author(s): Adam Warski
 */
package org.hibernate.envers.demo;
import org.jboss.logging.Logger;


import org.hibernate.envers.query.AuditEntity;
import org.hibernate.envers.DefaultRevisionEntity;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.AuditReaderFactory;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import java.util.*;
import java.io.PrintStream;
import java.io.File;

/**
 * @author Adam Warski (adam at warski dot org)
 */
public class TestConsole {
    private EntityManager entityManager;

    public TestConsole(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    private String convertString(String s, String def) {
        if ("NULL".equals(s)) { return null; }
        if ("".equals(s)) { return def; }
        return s;
    }

    private int convertStringToInteger(String s, int def) {
        if ("".equals(s)) { return def; }
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            System.err.println("Invalid number, returning 0.");
            return 0;
        }
    }

    private void printPerson(StringBuilder sb, Person p) {
        sb.append("id = ").append(p.getId()).append(", name = ").append(p.getName())
                .append(", surname = ").append(p.getSurname());

        Address a = p.getAddress();
        if (a != null) {
            sb.append(", address = <").append(a.getId()).append("> ").append(a.getStreetName()).append(" ")
                    .append(a.getHouseNumber()).append("/").append(a.getFlatNumber());
        }
    }

    @SuppressWarnings({"unchecked"})
    private void printPersons(StringBuilder sb) {
        List<Person> persons = entityManager.createQuery(
                "select p from Person p order by p.id").getResultList();

        sb.append("Persons:\n");
        for (Person p : persons) {
            printPerson(sb, p);
            sb.append("\n");
        }
    }

    private void printPersonHistory(StringBuilder sb, int personId) {
        AuditReader reader = AuditReaderFactory.get(entityManager);

        List personHistory = reader.createQuery()
                .forRevisionsOfEntity(Person.class, false, true)
                .add(AuditEntity.id().eq(personId))
                .getResultList();

        if (personHistory.size() == 0) {
            sb.append("A person with id ").append(personId).append(" does not exist.\n");
        } else {
            for (Object historyObj : personHistory) {
                Object[] history = (Object[]) historyObj;
                DefaultRevisionEntity revision = (DefaultRevisionEntity) history[1];
                sb.append("revision = ").append(revision.getId()).append(", ");
                printPerson(sb, (Person) history[0]);
                sb.append(" (").append(revision.getRevisionDate()).append(")\n");
            }
        }
    }

    private void printPersonAtRevision(StringBuilder sb, int personId, int revision) {
        AuditReader reader = AuditReaderFactory.get(entityManager);

        Person p = reader.find(Person.class, personId, revision);
        if (p == null) {
            sb.append("This person does not exist at that revision.");
        } else {
            printPerson(sb, p);
        }
    }

    private void readAndSetAddress(Scanner scanner, Person p) {
        Address old = p.getAddress();

        String input = scanner.nextLine();
        if ("NULL".equals(input)) {
            p.setAddress(null);
            if (old != null) {
                old.getPersons().remove(p);
            }
        } else if ("".equals(input)) {
        } else {
            try {
                Integer id = Integer.valueOf(input);

                Address a = entityManager.find(Address.class, id);

                if (a == null) {
                    System.err.println("Unknown address id, setting to NULL.");
                    p.setAddress(null);
                    if (old != null) {
                        old.getPersons().remove(p);
                    }
                } else {
                    p.setAddress(a);

                    a.getPersons().add(p);

                    if (old != null) {
                        old.getPersons().remove(p);
                    }
                }
            } catch (NumberFormatException e) {
                System.err.println("Invalid address id, setting to NULL.");
                p.setAddress(null);
                if (old != null) {
                    old.getPersons().remove(p);
                }
            }
        }
    }

    private Person readNewPerson(PrintStream out, Scanner scanner) {
        Person p = new Person();

        out.print("Person name (NULL for null): ");
        p.setName(convertString(scanner.nextLine(), ""));

        out.print("Person surname (NULL for null): ");
        p.setSurname(convertString(scanner.nextLine(), ""));

        out.print("Person address id (NULL for null): ");
        readAndSetAddress(scanner, p);

        return p;
    }

    private void readModifyPerson(PrintStream out, Scanner scanner, int personId) {
        Person current = entityManager.find(Person.class, personId);

        if (current == null) {
            out.println("Person with id " + personId + " does not exist.");
            return;
        }

        out.print("Person name (NULL for null, enter for no change, current - " + current.getName() + "): ");
        current.setName(convertString(scanner.nextLine(), current.getName()));

        out.print("Person surname (NULL for null, enter for no change, current - " + current.getSurname() + "): ");
        current.setSurname(convertString(scanner.nextLine(), current.getSurname()));

        out.print("Person address id (NULL for null, enter for no change, current - " +
                (current.getAddress() == null ? "NULL" : current.getAddress().getId()) + "): ");
        readAndSetAddress(scanner, current);
    }

    private void printAddress(StringBuilder sb, Address a) {
        sb.append("id = ").append(a.getId()).append(", streetName = ").append(a.getStreetName())
                .append(", houseNumber = ").append(a.getHouseNumber())
                .append(", flatNumber = ").append(a.getFlatNumber())
                .append(", persons = (");

        Iterator<Person> iter = a.getPersons().iterator();
        while (iter.hasNext()) {
            Person p = iter.next();
            sb.append("<").append(p.getId()).append("> ").append(p.getName()).append(" ").append(p.getSurname());
            if (iter.hasNext()) {
                sb.append(", ");
            }
        }

        sb.append(")");
    }

    @SuppressWarnings({"unchecked"})
    private void printAddresses(StringBuilder sb) {
        List<Address> addresses = entityManager.createQuery(
                "select a from Address a order by a.id").getResultList();

        sb.append("Addresses:\n");
        for (Address a : addresses) {
            printAddress(sb, a);
            sb.append("\n");
        }
    }

    private void printAddressHistory(StringBuilder sb, int addressId) {
        AuditReader reader = AuditReaderFactory.get(entityManager);

        List addressHistory = reader.createQuery()
                .forRevisionsOfEntity(Address.class, false, true)
                .add(AuditEntity.id().eq(addressId))
                .getResultList();

        if (addressHistory.size() == 0) {
            sb.append("A address with id ").append(addressId).append(" does not exist.\n");
        } else {
            for (Object historyObj : addressHistory) {
                Object[] history = (Object[]) historyObj;
                DefaultRevisionEntity revision = (DefaultRevisionEntity) history[1];
                sb.append("revision = ").append(revision.getId()).append(", ");
                printAddress(sb, (Address) history[0]);
                sb.append(" (").append(revision.getRevisionDate()).append(")\n");
            }
        }
    }

    private void printAddressAtRevision(StringBuilder sb, int addressId, int revision) {
        AuditReader reader = AuditReaderFactory.get(entityManager);

        Address a = reader.find(Address.class, addressId, revision);
        if (a == null) {
            sb.append("This address does not exist at that revision.");
        } else {
            printAddress(sb, a);
        }
    }

    private Address readNewAddress(PrintStream out, Scanner scanner) {
        Address a = new Address();

        out.print("Street name (NULL for null): ");
        a.setStreetName(convertString(scanner.nextLine(), ""));

        out.print("House number: ");
        a.setHouseNumber(convertStringToInteger(scanner.nextLine(), 0));

        out.print("Flat number: ");
        a.setFlatNumber(convertStringToInteger(scanner.nextLine(), 0));

        a.setPersons(new HashSet<Person>());

        return a;
    }

    private void readModifyAddress(PrintStream out, Scanner scanner, int addressId) {
        Address current = entityManager.find(Address.class, addressId);

        if (current == null) {
            out.println("Address with id " + addressId + " does not exist.");
            return;
        }

        out.print("Street name (NULL for null, enter for no change, current - " + current.getStreetName() + "): ");
        current.setStreetName(convertString(scanner.nextLine(), current.getStreetName()));

        out.print("House number (enter for no change, current - " + current.getHouseNumber() + "): ");
        current.setHouseNumber(convertStringToInteger(scanner.nextLine(), current.getHouseNumber()));

        out.print("Flat number (enter for no change, current - " + current.getFlatNumber() + "): ");
        current.setFlatNumber(convertStringToInteger(scanner.nextLine(), current.getFlatNumber()));
    }

    private void start() {
        Scanner scanner = new Scanner(System.in);
        PrintStream out = System.out;

        while (true) {
            out.println("-----------------------------------------------");
            out.println("1 - list persons             5 - list addresses");
            out.println("2 - list person history      6 - list addresses history");
            out.println("3 - new person               7 - new address");
            out.println("4 - modify person            8 - modify address");
            out.println("9 - get person at revision  10 - get address at revision");
            out.println("                             0 - end");

            try {
                int choice = scanner.nextInt();

                scanner.nextLine();

                entityManager.getTransaction().begin();

                StringBuilder sb;
                int personId;
                int addressId;
                int revision;
                switch (choice) {
                    case 1:
                        sb = new StringBuilder();
                        printPersons(sb);
                        out.println(sb.toString());
                        break;
                    case 2:
                        out.print("Person id: ");
                        personId = scanner.nextInt(); scanner.nextLine();
                        sb = new StringBuilder();
                        printPersonHistory(sb, personId);
                        out.println(sb.toString());
                        break;
                    case 3:
                        Person p = readNewPerson(out, scanner);
                        entityManager.persist(p);
                        break;
                    case 4:
                        out.print("Person id: ");
                        personId = scanner.nextInt(); scanner.nextLine();
                        readModifyPerson(out, scanner, personId);
                        break;
                    case 5:
                        sb = new StringBuilder();
                        printAddresses(sb);
                        out.println(sb.toString());
                        break;
                    case 6:
                        out.print("Address id: ");
                        addressId = scanner.nextInt(); scanner.nextLine();
                        sb = new StringBuilder();
                        printAddressHistory(sb, addressId);
                        out.println(sb.toString());
                        break;
                    case 7:
                        Address a = readNewAddress(out, scanner);
                        entityManager.persist(a);
                        break;
                    case 8:
                        out.print("Address id: ");
                        addressId = scanner.nextInt(); scanner.nextLine();
                        readModifyAddress(out, scanner, addressId);
                        break;
                    case 9:
                        out.print("Person id: ");
                        personId = scanner.nextInt(); scanner.nextLine();
                        out.print("Revision number: ");
                        revision = scanner.nextInt(); scanner.nextLine();
                        if (revision <= 0) {
                            System.out.println("Revision must be greater then 0!");
                            continue;
                        }
                        sb = new StringBuilder();
                        printPersonAtRevision(sb, personId, revision);
                        out.println(sb.toString());
                        break;
                    case 10:
                        out.print("Address id: ");
                        addressId = scanner.nextInt(); scanner.nextLine();
                        out.print("Revision number: ");
                        revision = scanner.nextInt(); scanner.nextLine();
                        if (revision <= 0) {
                            System.out.println("Revision must be greater then 0!");
                            continue;
                        }
                        sb = new StringBuilder();
                        printAddressAtRevision(sb, addressId, revision);
                        out.println(sb.toString());
                        break;

                    case 0:
                        return;
                }
            } catch (InputMismatchException e) {
                // continuing
            } finally {
                entityManager.getTransaction().commit();
            }
        }
    }

    private boolean hasData() {
        return (((Long) entityManager.createQuery("select count(a) from Address a").getSingleResult()) +
                ((Long) entityManager.createQuery("select count(p) from Person p").getSingleResult())) > 0;
    }

    private void populateTestData() {
        entityManager.getTransaction().begin();

        if (!hasData()) {
            Person p1 = new Person();
            Person p2 = new Person();
            Person p3 = new Person();

            Address a1 = new Address();
            Address a2 = new Address();

            p1.setName("James");
            p1.setSurname("Bond");
            p1.setAddress(a1);

            p2.setName("John");
            p2.setSurname("McClane");
            p2.setAddress(a2);

            p3.setName("Holly");
            p3.setSurname("Gennaro");
            p3.setAddress(a2);

            a1.setStreetName("MI6");
            a1.setHouseNumber(18);
            a1.setFlatNumber(25);
            a1.setPersons(new HashSet<Person>());
            a1.getPersons().add(p1);

            a2.setStreetName("Nakatomi Plaza");
            a2.setHouseNumber(10);
            a2.setFlatNumber(34);
            a2.setPersons(new HashSet<Person>());
            a2.getPersons().add(p2);
            a2.getPersons().add(p3);

            entityManager.persist(a1);
            entityManager.persist(a2);

            entityManager.persist(p1);
            entityManager.persist(p2);
            entityManager.persist(p3);

            System.out.println("The DB was populated with example data.");
        }

        entityManager.getTransaction().commit();
    }

    public static void main(String[] args) {
        String userDbFile = System.getProperty("java.io.tmpdir") + File.separator + "_versions_demo.db";

        Map<String, String> configurationOverrides = new HashMap();
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("ConsolePU", configurationOverrides);
        EntityManager entityManager = emf.createEntityManager();

        TestConsole console = new TestConsole(entityManager);

        System.out.println("");
        System.out.println("Welcome to EntityVersions demo!");
        System.out.println("HSQLDB database file location: " + userDbFile);

        console.populateTestData();
        console.start();

        entityManager.close();
        emf.close();
    }
}