Need help setting up Hibernate

[Brian Jones Jr.]

I'm trying to add Hibernate JPA to my webapp, and I am having two problems.

1) There's an error message by the @Entity annotation on the Person.class. It says, "The table Person cannot be resolved"
2) I can't create a SessionFactory in the TestEntityManager class, so my tests never run. An exception is thrown when the EntityManager is created, but the SessionFactory is null. I'm not sure if the EntityManager exception is related to the null SessionFactory.

In regards to the Person.class error, I tried a few different solutions. I tried a couple from here: http://stackoverflow.com/questions/7475228/problem-with-jpa-project-in-eclipse-error-in-class-annotated-entity-table-x. I don't want to turn off the validator, because that seems useful. I tried using the JPA tools to create tables from entities, but I got the following stack trace:

Oct 18, 2016 3:08:15 PM org.hibernate.jpa.internal.util.LogHelper logPersistenceUnitInformation
INFO: HHH000204: Processing PersistenceUnitInfo [
    name: primary
    ...]
Oct 18, 2016 3:08:15 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {5.0.10.Final}
Oct 18, 2016 3:08:15 PM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
Oct 18, 2016 3:08:15 PM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
Oct 18, 2016 3:08:15 PM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {5.0.1.Final}
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH10001002: Using Hibernate built-in connection pool (not for production use!)
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001005: using driver [org.postgresql.Driver] at URL [jdbc:postgresql://localhost:5432/postgres]
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001001: Connection properties: {user=postgres, password=****}
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH10001003: Autocommit mode: false
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.PooledConnections <init>
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
Oct 18, 2016 3:08:16 PM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.PostgreSQLDialect
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.env.internal.LobCreatorBuilderImpl useContextualLobCreation
INFO: HHH000424: Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException
Oct 18, 2016 3:08:16 PM org.hibernate.type.BasicTypeRegistry register
INFO: HHH000270: Type registration [java.util.UUID] overrides previous : org.hibernate.type.UUIDBinaryType@34f5090e
Oct 18, 2016 3:08:16 PM org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000227: Running hbm2ddl schema export
Oct 18, 2016 3:08:16 PM org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete
Oct 18, 2016 3:08:16 PM org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000227: Running hbm2ddl schema export
Oct 18, 2016 3:08:16 PM org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete
Oct 18, 2016 3:08:16 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH10001008: Cleaning up connection pool [jdbc:postgresql://localhost:5432/postgres]

I also tried the solution from this link: http://stackoverflow.com/questions/7865753/eclipse-reports-error-on-my-jpa-project. I tried refreshing my connection to the DB using the JPA view, but the error didn't go away. I am able to ping by DB from the  view. I can also see my DB using pg admin. Do you have any other ideas on how I can create the Person table? What am I missing?

Now for the second problem. I tried to make a Util class for creating the SessionFactory, but I'm not sure where I have gone wrong. Can you take a look at my configurations and tell me if they are correct? Do you thin the problem is in another class, or am I missing another class? thanks.

Here's the credentials that I used for logging into postgres

name: postgres
host: localhost
port: 5432
Maintenance DB: postgres
Username: postgres
password: postgres

Person.class

package com.myapp.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Access;
import static javax.persistence.AccessType.FIELD;

/**
 * A Person object is used for storing data about the members who use the
 * website.
 *
 */
@Entity
@Table(name= "person")  
public class Person {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String firstName;
	private String lastName;

	public Person() {
	}

	public Person(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
}

Test Class. This is where the sessionFactory is set to null

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Persistence;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import com.myapp.database.HibernateUtil;
import com.myapp.model.Person;

public class TestEntityManager {

	private static SessionFactory sessionFactory;

	private static EntityManager entityManager;

	private static Session session;

	@BeforeClass
	public static void runOnceBeforeClass() {
		System.out.println("@BeforeClass - runOnceBeforeClass");
		// this is set to null
		sessionFactory = HibernateUtil.getSessionFactory();  
		// exception is thrown from this line
		entityManager = Persistence.createEntityManagerFactory("primary")  
				.createEntityManager();
		
		System.out.println("exit: runOnceBeforeClass");
	}

	@AfterClass
	public static void runOnceAfterClass() {
		System.out.println("@AfterClass - runOnceAfterClass");
	}

	@Test
	public void testEntityManagerPersist() {
		System.out.println("testEntityManagerPersist()");

		session = sessionFactory.openSession();
		session.beginTransaction();
		entityManager.persist(new Person("Alice", "Stewart"));
		entityManager.persist(new Person("Bob", "Stewart"));
		entityManager.getTransaction().commit();
		entityManager.close();
	}

	@Test
	public void testEntityManagerQuery() {
		System.out.println("testEntityManager()");

		session = sessionFactory.openSession();
		session.beginTransaction();
		List<Person> result = entityManager.createQuery("from Person", Person.class).getResultList();
		for (Person person : result) {
			System.out.println("Person: " + person.getFirstName() + " " + person.getLastName());
		}
		entityManager.getTransaction().commit();
		entityManager.close();
	}
}

This is where I implement the SessionFactory

package com.myapp.database;

import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataBuilder;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.SessionFactoryBuilder;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl;
import org.hibernate.boot.registry.BootstrapServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.boot.registry.internal.BootstrapServiceRegistryImpl;

import com.myapp.model.Person;

/**
 * Class is used for Native Bootstrapping the Hibernate SessionFactory.
 * Documentation for native bootstrapping can be found here:
 * 
 * https://docs.jboss.org/hibernate/orm/5.0/topical/html/bootstrap/NativeBootstrapping.html
 */
public final class HibernateUtil {

	private static BootstrapServiceRegistry bootstrapServiceRegistry;
	private static StandardServiceRegistryBuilder standardServiceRegistryBuilder;
	private static SessionFactory sessionFactory;
	private static Metadata metadata;
	
	private HibernateUtil() {
		buildSvcRegistry();
		buildMetadataSources();
	}

	private static void buildSvcRegistry() {
		// Building the ServiceRegistry
		bootstrapServiceRegistry = new BootstrapServiceRegistryImpl();
		standardServiceRegistryBuilder = new StandardServiceRegistryBuilder(bootstrapServiceRegistry);
	}

	private static void buildMetadataSources() {
		MetadataSources sources = new MetadataSources(bootstrapServiceRegistry);
		// alternatively, we can build the MetadataSources without passing
		// a service registry, in which case it will build a default
		// BootstrapServiceRegistry to use
		// MetadataSources sources = new MetadataSources();

		// add a class using JPA/Hibernate annotations for mapping
		sources.addAnnotatedClass(Person.class);

		// add the name of a class using JPA/Hibernate annotations for mapping.
		// differs from above in that accessing the Class is deferred which is
		// important if using runtime bytecode-enhancement
		// sources.addAnnotatedClassName("org.hibernate.example.Customer");

		MetadataBuilder metadataBuilder = sources.getMetadataBuilder();
		// Use the JPA-compliant implicit naming strategy
		metadataBuilder.applyImplicitNamingStrategy(ImplicitNamingStrategyJpaCompliantImpl.INSTANCE);
		// specify the schema name to use for tables, etc when none is
		// explicitly specified
		metadataBuilder.applyImplicitSchemaName("my_default_schema");
		Metadata metadata = metadataBuilder.build();
		buildSessionFactory();
	}

	private static void buildSessionFactory() {
		//Add custom SessionFactoryBuilder here if you would like to adjust that building process
		sessionFactory = metadata.buildSessionFactory();
	}

	public static BootstrapServiceRegistry getBootstrapRegistry() {
		return bootstrapServiceRegistry;
	}

	public static void setBootstrapRegistry(BootstrapServiceRegistry bootstrapRegistry) {
		HibernateUtil.bootstrapServiceRegistry = bootstrapRegistry;
	}

	public static StandardServiceRegistryBuilder getStandardRegistryBuilder() {
		return standardServiceRegistryBuilder;
	}

	public static void setStandardRegistryBuilder(StandardServiceRegistryBuilder standardRegistryBuilder) {
		HibernateUtil.standardServiceRegistryBuilder = standardRegistryBuilder;
	}
	
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}

}

persistence.xml

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

<persistence version="2.1"
	xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
        http://xmlns.jcp.org/xml/ns/persistence
        http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<persistence-unit name="primary">

		<provider>org.hibernate.ejb.HibernatePersistence</provider>

		<!-- Annotated entity classes -->
		<class>com.myapp.model.Person</class>
		
		<properties>
			<property name="hibernate.connection.url" value="jdbc:postgresql://localhost/postgres" />
			<property name="hibernate.connection.driver_class" value="org.postgresql.Driver" />
			<property name="hibernate.connection.username" value="postgres" />
			<property name="hibernate.connection.password" value="postgres" />
			<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect" />
			<property name="hibernate.hbm2ddl.auto" value="create-drop" />
		</properties>

	</persistence-unit>

</persistence>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.myapp</groupId>
	<artifactId>my-app</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>my-app Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<properties>
		<!-- Explicitly declaring the source encoding eliminates the following 
			message: -->
		<!-- [WARNING] Using platform encoding (UTF-8 actually) to copy filtered 
			resources, i.e. build is platform dependent! -->
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

		<!-- EAP component version management BOM -->
		<version.jboss.bom>10.1.0.Final</version.jboss.bom>

		<!-- WildFly Maven plug-in to deploy your WAR to a local WildFly container -->
		<version.wildfly.maven.plugin>1.0.2.Final</version.wildfly.maven.plugin>

		<!-- other plug-in versions -->
		<version.war.plugin>3.0.0</version.war.plugin>

		<!-- maven-compiler-plugin -->
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.source>1.8</maven.compiler.source>
	</properties>

	<dependencyManagement>
		<dependencies>
			<!-- JBoss distributes a complete set of Java EE 7 APIs including a Bill 
				of Materials (BOM). A BOM specifies the versions of a "stack" (or a collection) 
				of artifacts. We use this here so that we always get the correct versions 
				of artifacts. Here we use the jboss-javaee-7.0-with tools stack (you can 
				read this as the JBoss stack of the Java EE 7 APIs, with some extras tools 
				for your project, such as Arquillian for testing) -->
			<dependency>
				<groupId>org.wildfly.bom</groupId>
				<artifactId>wildfly-javaee7-with-tools</artifactId>
				<version>${version.jboss.bom}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<dependencies>

		<!-- First declare the APIs we depend on and need for compilation. All 
			of them are provided by WildFly -->

		<!-- Import the CDI API, we use provided scope as the API is included in 
			WildFly -->
		<dependency>
			<groupId>javax.enterprise</groupId>
			<artifactId>cdi-api</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- Import the Common Annotations API (JSR-250), we use provided scope 
			as the API is included in WildFly -->
		<dependency>
			<groupId>org.jboss.spec.javax.annotation</groupId>
			<artifactId>jboss-annotations-api_1.2_spec</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- Import the JAX-RS API, we use provided scope as the API is included 
			in WildFly -->
		<dependency>
			<groupId>org.jboss.spec.javax.ws.rs</groupId>
			<artifactId>jboss-jaxrs-api_2.0_spec</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- Import the JPA API, we use provided scope as the API is included in 
			WildFly -->
		<dependency>
			<groupId>org.hibernate.javax.persistence</groupId>
			<artifactId>hibernate-jpa-2.1-api</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- Import the EJB API, we use provided scope as the API is included in 
			WildFly. EJB beans make it a lot easier to work with a database via JPA. 
			Using JPA outside an EJB requires a lot of verbose and error prone code for 
			obtaining an entity manager, starting a transaction and committing it or 
			rolling it back. -->
		<dependency>
			<groupId>org.jboss.spec.javax.ejb</groupId>
			<artifactId>jboss-ejb-api_3.2_spec</artifactId>
			<scope>provided</scope>
		</dependency>

		<!-- Bean Validation Implementation -->
		<!-- Provides portable constraints such as @Email -->
		<!-- Hibernate Validator is shipped in WildFly -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<scope>provided</scope>
			<exclusions>
				<exclusion>
					<groupId>org.slf4j</groupId>
					<artifactId>slf4j-api</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<!--Import dependencies to hibernate packages(eg. hibernate-core) depending 
			on features you want to use like Hibernate Session used in the quickstart -->
		<!--please note that scope is provided as these jars are shipped with as7 -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

	</dependencies>

	<build>
		<!-- Maven will append the version to the finalName (which is the name 
			given to the generated WAR, and hence the context root) -->
		<finalName>${project.artifactId}</finalName>
		<plugins>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>${version.war.plugin}</version>
				<configuration>
					<!-- Java EE doesn't require web.xml, Maven needs to catch up! -->
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
			<!-- The WildFly plug-in deploys your WAR to a local WildFly container -->
			<!-- To use, run: mvn package wildfly:deploy -->
			<plugin>
				<groupId>org.wildfly.plugins</groupId>
				<artifactId>wildfly-maven-plugin</artifactId>
				<version>${version.wildfly.maven.plugin}</version>
			</plugin>
		</plugins>
	</build>

</project>

This is the output when i run the test class

@BeforeClass - runOnceBeforeClass
Oct 18, 2016 3:35:05 PM org.hibernate.jpa.internal.util.LogHelper logPersistenceUnitInformation
INFO: HHH000204: Processing PersistenceUnitInfo [
    name: primary
    ...]
Oct 18, 2016 3:35:05 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {5.0.10.Final}
Oct 18, 2016 3:35:05 PM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
Oct 18, 2016 3:35:05 PM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
Oct 18, 2016 3:35:06 PM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {5.0.1.Final}
Oct 18, 2016 3:35:06 PM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH10001002: Using Hibernate built-in connection pool (not for production use!)
@AfterClass - runOnceAfterClass