Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #3

Questo è il terzo di una serie di articoli, la parte precedente si trova qui: Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #2

CREAZIONE DEL MODEL: LA CLASSE USER
Riprendiamo la creazione della nostra semplice web application e vediamo in questa terza parte come aggiungere al nostro progetto l’interazione con un database relazionale sul quale verrano salvati gli utenti creati.
Iniziamo con il modellare i nostri oggetti “utente” e creiamo quindi la classe User che conterrà le informazioni che caratterizzano i nostri utenti che, per semplicità, rappresentiamo solo con nome, cognome e nazione di provenienza, oltre ad un id univoco con il quale saranno salvati nel database.
Il codice della classe User sarà quindi il seguente:

package com.dede.app1st.model;

public class User {

	private int id;
	private String firstname;
	private String lastname;
	private String country;

	public User(String fn, String ln, String country) {
		firstname = fn;
		lastname = ln;
		this.country = country;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public String getCountry() {
		return country;
	}

	public void setCountry(String country) {
		this.country = country;
	}
}

CREAZIONE DEL DATABASE
Una volta che abbiamo identificato gli attributi che rappresentano i nostri utenti, definendo la classe User, dobbiamo creare un database ed una relativa tabella nel quale gli utenti creati vengano memorizzati. Per farlo utilizziamo PostgreSQL come database relazionale.
Apriamo il tool di amministrazione pgAdmin e sulla nostra installazione di PostgreSQL creiamo un nuovo database che chiamiamo “firstapp”. Nel database “firstapp” creiamo la nostra tabella “users” che conterrà 4 colonne corrispondenti agli attributi precedentemente definiti all’interno della classe User:

  • id
  • firstname
  • lastname
  • country

Per creare tale tabella clicchiamo sull’icona Immagine Icona esecuzione SQL
che ci apre l’editor per l’inserimento di manuale di statement SQL ed inseriamo il seguente script SQL:

CREATE TABLE users {
	user_id SERIAL PRIMARY KEY,
	firstname VARCHAR(40) NOT NULL,
	lastname  VARCHAR(40) NOT NULL,
	country   VARCHAR(40)
}

Clicchiamo sull’icona “Run” (triangolino verde) per mandare in esecuzione lo statement e se tutto è andato a buon fine dovremmo vedere un messaggio che ci comunica l’avvenuta creazione della tabella.
L’immagine seguente riassume le operazioni per la creazione della tabella appena descritte.

Immagine Create Table PgAdmin

INTRODURRE LA SPECIFICA JPA ED HIBERNATE
Per la manipolazione dei dati salvati sul database attraverso le classiche operazioni CRUD (Create, Read, Update, Delete) utilizziamo Hibernate, un framework che ci fornisce la cosiddetta funzionalità di ORM, Object-Relational Mapping. Hibernate costituisce infatti un’implementazione della specifica JPA, Java Persistence API, appartenente alla piattaforma Java EE e ci permette in sostanza di mappare i nostri oggetti Java con le nostre tabelle del database e ci semplifica le attività necessarie a garantire la persistenza dei dati e l’accesso ad essi.
Per poterlo utilizzare dobbiamo includere le sue librerie nel progetto. Andiamo all’indirizzo http://hibernate.org/orm/downloads/ e scarichiamo l’ultima versione disponibile che, al momento della stesura di questo post è la 4.3.6
Scompattiamo lo zip scaricato e copiamo tutti i jar contenuti nella cartella lib/required sotto la cartella WebContent/lib del nostro progetto.

Librerie Hibernate nel progetto Eclipse

MAPPING TRA OGGETTI JAVA E TABELLE
Ora che abbiamo aggiunto Hibernate al nostro progetto possiamo procedere con il mapping tra la nostra classe User e la tabella “users” che abbiamo creato nel database PosgreSQL. Per farlo dobbiamo utilizzare una serie di annotations messe a disposizione dalla specifica JPA per indicare su quale tabella deve essere mappata una classe e, per ciascuna variabile d’istanza qual è la corrispondente colonna nella tabella del database.

Le annotations della specifica JPA che utilizziamo sono:

  • @Entity
    • Viene utilizzata per indicare che una determinata classe rappresenta una entità e sarà cioè mappata con una relativa tabella del database
  • @Table
    • Viene utilizzata per indicare su quale tabella del database deve essere mappata la classe annotata. Di default si assume che la tabella del database abbia lo stesso nome della classe Java annotata. Nel caso in cui il nome della classe e quello della tabella siano diversi, occorre valorizzare l’attributo “name” dell’annotation, specificando il nome della tabella.
      Nel nostro caso, ad esempio, la classe java si chiama “User” e la tabella del database si chiama invece “Users”, al plurale, per cui dobbiamo esplicitare il nome di quest’ultima tramite l’attributo name dell’annotation, come segue:

      @Entity
      @Table( name = "USERS")
      public class User {
      
  • @Column
    • Viene utilizzata per indicare su quale colonna della tabella viene mappata la proprietà della classe java annotata. Di default JPA assume che il nome dei membri della classe sia lo stesso dei nomi delle colonne della tabella su cui è mappata. Se è cosÏ, l’annotation @Column può essere omessa, altrimenti deve essere inserita e deve essere valorizzato il suo attributo “name” con il nome esatto della colonna della tabella.
      Inoltre l’annotation @column può essere utilizzata per raffinare il più possibile la definizione della colonna su cui è mappata la proprietà della classe, tramite altri attributi come “length“, “nullable“, “unique“, ecc..
  • @Id
    • Viene utilizzata per dichiarare una proprietà della classe java come primary key della tabella su cui è mappata la classe entity.
  • @GeneratedValue
    • Viene utilizzata per specificare la gestione degli identificativi degli oggetti e quindi dei record della tabella. Permette di utilizzare diverse modalità di gestione degli id tramite la valorizzazione dell’attributo “strategy”.

Modifichiamo quindi la nostra classe User come segue:

package com.dede.app1st.model;

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 = "USERS")
public class User {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name="user_id", nullable=false, unique=true)
	private int id;
	
	@Column(name="firstname", length=40, nullable=false)
	private String firstname;
	
	@Column(name="lastname", length=40, nullable=false)
	private String lastname;
	
	@Column(name="country", length=40, nullable=true)
	private String country;

        // GETTERS e SETTERS omessi per brevità
}

La figura seguente mostra la corrispondenza tra le proprietà annotate della nostra classe User e le colonne della tabella Users che abbiamo precedentemente creato nel database PostgreSQL.

JPA Entity class e tabella database

CONFIGURARE HIBERNATE
A questo punto dobbiamo creare il file di configurazione di Hibernate con le informazioni o, più precisamente, le properties necessarie per la connessione al database PostgreSQL.
Creiamo quindi sotto src il file hibernate.cfg.xml in cui dobbiamo andare a specificare quale sarà il driver che dovrà utilizzare il DriverManager per connettersi a PostgreSQL, l’indirizzo a cui si trova il database, il suo nome e le credenziali di accesso ad esso, username e password.
Il contenuto del nostro file di configurazione di Hibernate sarà il seguente:

<hibernate-configuration>
	<session-factory>

		<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
		<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>

		<property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/firstapp</property>
		<property name="hibernate.connection.username">postgres</property>
		<property name="hibernate.connection.password">dede</property>
		<property name="show_sql">false</property>

	</session-factory>
</hibernate-configuration>

Inoltre, sempre nel file hibernate.cfg.xml, dovremo effettuare il mapping di tutte le classi che vogliamo gestire tramite Hibernate. Per fare questo occorre indicare i nomi di tali classi all’interno del tag “mapping”, nel modo seguente:

<mapping class="com.dede.app1st.model.User"/>

Dopo aver effettuato la configurazione di Hibernate, dobbiamo recuperare il driver jdbc di PostgreSQL ed inserirlo tra le librerie utilizzate dall’applicazione.
Il driver può essere scaricato all’indirizzo: http://jdbc.postgresql.org/download.html ed una volta effettuato il download copiamo il file “postgresql-9.3-1102.jdbc41.jar” nella cartella WEB-INF/lib.

La figura seguente mostra il progetto Eclipse aggiornato con il file hibernate.cfg.xml ed il suo contenuto e con la libreria dei driver jdbc di PostgreSQL.
Hibernate configuration e postgres driver

EFFETTUARE UNA TRANSAZIONE

Ora che abbiamo predisposto tutto per la storicizzazione degli utenti, creando un database relazionale ed implementando uno strato di ORM con Hibernate, dobbiamo modificare il modo in cui la nostra servlet gestisce queste richieste di creazione. Una volta che viene premuto il pulsante “create” del form per la creazione di un nuovo utente la servlet, che prima si occupava semplicemente di forwardare la richiesta ad una pagina JSP per la visualizzazione del messaggio di avvenuta creazione e delle informazioni stesse sull’utente appena creato, ora dovrà occuparsi di salvare effettivamente l’utente nel database, sfruttando l’architettura messa a disposizione.
Per fare questo dobbiamo utilizzare i seguenti oggetti che Hibernate ci mette a disposizione:

  • Configuration
  • ServiceRegistry, StandardServiceRegistry e StandardServiceRegistryBuilder
  • SessionFactory
  • Session

Configuration è la classe attraverso cui viene caricata la configurazione. Se, come nel nostro caso, la configurazione è definita come da default nel file hibernate.cfg.xml, basta semplicemente istanziare un nuovo oggetto di questa classe ed invocare su di esso il metodo configure().

Configuration config = new Configuration().configure();

ServiceRegistry e StandardServiceRegistry sono due interfacce e StandardServiceRegistryBuilder è il builder da utilizzare per la creazione di oggetti che implementano tali interfacce, necessari per la creazione di una SessionFactory. In Hibernate 4 è infatti necessario passare un’implementazione di ServiceRegistry come parametro del metodo buildSessionFactory() della classe Configuration.

ServiceRegistry servReg = new StandardServiceRegistryBuilder().applySettings(config.getProperties()).build();

SessionFactory, piuttosto intuitivamente, è la factory che ci permette di ottenere le sessioni tramite le quali eseguiremo le operazioni sul database.

SessionFactory factory = config.buildSessionFactory(servReg);

Una volta ottenuta una sessione tramite la factory possiamo eseguire la transazione che ci permette di inserire nel database il record relative all’utente che abbiamo creato. I passi da eseguire per farlo sono:

  • Iniziare una transazione tramite il metodo beginTransaction() della Session
  • Creare l’oggetto della classe User da storicizzare
  • Invocare il metodo save() della Session, passandogli l’oggetto da far persistere nel database
  • Effettuare il commit dell’operazione appena eseguita, tramite il metodo commit() della transazione
  • Chiudere la sessione
Session session = factory.openSession();
session.beginTransaction();
User u = new User(request.getParameter("firstname"), request.getParameter("lastname"), request.getParameter("country"));
session.save(u);
session.getTransaction().commit();
session.close();

NUOVA GESTIONE DELLA RICHIESTA
Utilizzando gli oggetti introdotti e descritti nel paragrafo precedente andiamo a modificare il metodo doPost() della nostra servlet AddUser in modo che gestisca le richieste andando ad inserire un record nella tabella del database.
La figura seguente mostra la nuova implementazione:

Hibernate transaction in servlet doPost()

ESEGUIRE L’APPLICAZIONE

A questo punto facciamo nuovamente il run dell’applicazione, clicchiamo sul link per la creazione di un nuovo utente, inseriamo le informazioni nel form e premiamo “create”.

Esecuzione web application tomcat

Le informazioni inserite nel form vengono sempre inviate tramite il metodo POST del protocollo HTTP alla nostra Servlet AddUser che crea un nuovo utente, inserendolo questa volta effettivamente nel database, e ci mostra poi, come già faceva nella prima versione, le informazioni sul nuovo utente creato tramite la pagina JSP “useradd.jsp”.
Nella figura seguente vediamo il risultato di questo flusso di esecuzione per la creazione dell’utente:

Web Application - JSP creazione utente

A questo punto dobbiamo andare a verificare se il nuovo utente è stato effettivamente inserito nel nostro database. Apriamo quindi pgAdmin3, la console di amministrazione di PostgreSQL, ed andiamo ad effettuare una query di selezione sulla tabella user del nostro database.

In pgAdmin clicchiamo sull’icona che apre la finestra in cui è possibile eseguire i propri statement SQL. Inseriamo quindi la query:

SELECT * FROM USERS

e come possiamo vedere troviamo il record relativo all’utente che abbiamo inserito tramite la nostra applicazione.

Web Application - Inserimento record database

Vai alla quarta parte: Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #4

21 thoughts on “Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #3

  1. Pingback: Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #2 | Dede Blog

  2. Pingback: Creare una semplice web application con JAVA, Eclipse, Tomcat, Hibernate e PostgreSQL – Parte #4 | Dede Blog

  3. Ho seguito tutto ma dopo che inserisco i dati (nome, cognome, nazione) e clicco “create” mi dice HTTP Status 500 – Unknown entity: model.User

    Secondo me il problema nella classe User.java che non si capisce bene come è stata modificata, in particolare il costruttore. Potresti scrivermelo?

    • Ciao, come hai risolto? Ho il tuo stesso problema. Praticamente devi mettere dopo mapping class (nel file hibernate.cfg.xml) il path della classe che hai messo come entity. Ma pur facendolo mi da errore e non so come mai.

      org.hibernate.MappingException: Unknown entity: com.dede.app1st.User
      org.hibernate.metamodel.internal.MetamodelImpl.entityPersister(MetamodelImpl.java:620)
      org.hibernate.internal.SessionImpl.getEntityPersister(SessionImpl.java:1606)
      org.hibernate.event.internal.AbstractSaveEventListener.saveWithGeneratedId(AbstractSaveEventListener.java:104)
      org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.saveWithGeneratedOrRequestedId(DefaultSaveOrUpdateEventListener.java:192)
      org.hibernate.event.internal.DefaultSaveEventListener.saveWithGeneratedOrRequestedId(DefaultSaveEventListener.java:38)
      org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.entityIsTransient(DefaultSaveOrUpdateEventListener.java:177)
      org.hibernate.event.internal.DefaultSaveEventListener.performSaveOrUpdate(DefaultSaveEventListener.java:32)
      org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.onSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:73)
      org.hibernate.internal.SessionImpl.fireSave(SessionImpl.java:675)
      org.hibernate.internal.SessionImpl.save(SessionImpl.java:667)
      org.hibernate.internal.SessionImpl.save(SessionImpl.java:662)
      com.dede.app1st.AddUser.doPost(AddUser.java:35)
      javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
      javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
      org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)

      • Ciao Mauro, scusa il ritardo.
        Sei sicuro di aver messo il path corretto per la classe User?
        Se hai mantenuto la stessa struttura dell’esempio, da quello che vedo manca il package “model“.

        Dovrebbe essere infatti
        mapping class="com.dede.app1st.model.User"

        mentre dall’errore si vede che cerca:
        com.dede.app1st.User (senza “model” per intenderci)

        • Grazie per la risposta, la mia struttura è diversa e il path è quello (senza model). Ho provato mille soluzioni trovate su internet per il problema dell’enthity ma nessuna ha dato risultato ed ho dovuto abbandonare questo tutorial purtroppo. Perché è veramente ben fatto e non ce ne sono simili in giro.

          • Scusa se scrivo nuovamente. Secondo me l’errore non dipende da quella dichiarazione perché, anche mettendo scritte a caso dopo mapping class, l’errore che mi dà è sempre lo stesso. Ho provato con mapping class=blabla e l’errore risulta sempre essere Unknown entity

          • Ciao. Sono veramente un neofita allo sbaraglio. Ho seguito il tutorial per cominciare e anche io ottenevo lo stesso errore. Alla fine ho deciso di usare la stessa versione di Hibernate del tutorial (ovvero la 4.3.6). In lib ho cancellato i file jar della versione più nuova ed inserito quelli della 4.3.6 (non cancellando il jar relativo al driver ovviamente). Con mia sorpresa ha funzionato. Spero possa essere stato di aiuto.

          • Ciao a tutti,
            effettivamente, appurato che le definizioni del model nel file di configurazione erano corrette, avevo anch’io ipotizzato che il problema fosse legato alle versioni di Hibernate.
            Grazie Daniele per aver effettuato la prova che io non ho mai trovato il tempo di fare e per averne condiviso l’esito con tutti.

            Davis

          • Ciao a tutti, ho riscontrato lo stesso problema, e ho immaginato anch’io che si trattasse di versioni di hibernate diverse ma ho cercato un’alternativa nel caso in cui in una situazione reale magari non mi ricordo qual è quella giusta o non posso per qualche ragione usarla. Cercando un po’ sul web è venuto fuori che questo tipo di errore indica che anche se hai annotato la classe non l’hai effettivamente aggiunta alla configurazione nel doPost della servlet. per intenderci era questo:
            Configuration conf= new Configuration().configure();
            conf.addAnnotatedClass(Users.class);
            ServiceRegistry serv= new StandardServiceRegistryBuilder().applySettings(conf.getProperties()).build();

            SessionFactory factory =conf.buildSessionFactory(serv);
            …bla bla bla
            così ha funzionato senza dover cambiare le versioni . Complimenti per il tutorial è fatto davvero bene, Thanks

  4. Ciao, ho seguito tutti i tuoi passi, ma quando clicco sul tasto “create”, mi compare il seguente errore “HTTP Status 500 – Unable to create requested service [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment]”

    • EDIT: avevo sbagliato a mettere la password nel file xml, una volta aggiustatoq uesto pero, mid a il seguente errore “HTTP Status 500 – Unknown entity: com.dede.app1st.controller.User”

  5. org.hibernate.MappingException: Unknown entity: com.dede.app1st.controller.User
    org.hibernate.metamodel.internal.MetamodelImpl.entityPersister(MetamodelImpl.java:620)
    org.hibernate.internal.SessionImpl.getEntityPersister(SessionImpl.java:1605)
    org.hibernate.event.internal.AbstractSaveEventListener.saveWithGeneratedId(AbstractSaveEventListener.java:104)
    org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.saveWithGeneratedOrRequestedId(DefaultSaveOrUpdateEventListener.java:192)
    org.hibernate.event.internal.DefaultSaveEventListener.saveWithGeneratedOrRequestedId(DefaultSaveEventListener.java:38)
    org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.entityIsTransient(DefaultSaveOrUpdateEventListener.java:177)
    org.hibernate.event.internal.DefaultSaveEventListener.performSaveOrUpdate(DefaultSaveEventListener.java:32)
    org.hibernate.event.internal.DefaultSaveOrUpdateEventListener.onSaveOrUpdate(DefaultSaveOrUpdateEventListener.java:73)
    org.hibernate.internal.SessionImpl.fireSave(SessionImpl.java:674)
    org.hibernate.internal.SessionImpl.save(SessionImpl.java:666)
    org.hibernate.internal.SessionImpl.save(SessionImpl.java:661)
    com.dede.app1st.controller.AddUser.doPost(AddUser.java:46)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
    org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)

  6. Purtroppo ho lo stesso identico problema, anche provando a mettere la stessa versione di hibernate la storia non cambia.

    • Ciao Gabriele,
      l’utilizzo della stessa versione di Hibernate sembrava aver risolto il problema, come da commenti di Daniele e Mauro sopra. Tu sei sicuro di avere tutto il resto configurato correttamente?
      Davis

      • Ciao Davis,
        si hai ragione ho risolto cambiando la versione mi ero dimenticato queste due righe nel file User.java:
        @Entity
        @Table( name = “USERS”).
        Inoltre visto che è un problema comune volevo ricordare di fare questi import:
        import javax.persistence.Column;
        import javax.persistence.Entity;
        import javax.persistence.GeneratedValue;
        import javax.persistence.GenerationType;
        import javax.persistence.Id;
        import javax.persistence.Table;
        e no quelli relativi al framework hibernate essendo deprecati.

        Grazie mille della risposta Davis e complimentoni per la guida.

  7. Dopo vari tentativi il mio problema era il file xml non farmattato correttamente

    mancava questa parte

    grande Davis, grazie per l’articolo, è fatto benissimo

    ciao!

  8. Mi pare di aver fatto tutto come spiegato ma continuo ad avere questi errori:

    org.hibernate.exception.JDBCConnectionException: Error calling Driver#connect
    org.hibernate.engine.jdbc.connections.internal.BasicConnectionCreator$1$1.convert(BasicConnectionCreator.java:122)
    org.hibernate.engine.jdbc.connections.internal.BasicConnectionCreator.convertSqlException(BasicConnectionCreator.java:140)
    org.hibernate.engine.jdbc.connections.internal.DriverConnectionCreator.makeConnection(DriverConnectionCreator.java:58)
    org.hibernate.engine.jdbc.connections.internal.BasicConnectionCreator.createConnection(BasicConnectionCreator.java:75)
    org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl.configure(DriverManagerConnectionProviderImpl.java:106)
    org.hibernate.boot.registry.internal.StandardServiceRegistryImpl.configureService(StandardServiceRegistryImpl.java:111)
    org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:234)
    org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:206)
    org.hibernate.engine.jdbc.internal.JdbcServicesImpl.buildJdbcConnectionAccess(JdbcServicesImpl.java:260)
    org.hibernate.engine.jdbc.internal.JdbcServicesImpl.configure(JdbcServicesImpl.java:94)
    org.hibernate.boot.registry.internal.StandardServiceRegistryImpl.configureService(StandardServiceRegistryImpl.java:111)
    org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:234)
    org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:206)
    org.hibernate.cfg.Configuration.buildTypeRegistrations(Configuration.java:1887)
    org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1845)
    controller.InsertObject.doPost(InsertObject.java:46)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
    org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)

  9. Dalla versione 5: Quando si fa “configuration.buildSessionFactory(sr)”, si perdono tutte le informazioni di configuration chiamate da configuration.configure().
    Cercando su internet ho trovato soluzione cosi, non so se è la più efficente ma funziona:
    “StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder() .configure(“hibernate.cfg.xml”).build();
    Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().build();
    SessionFactory factory = metadata.getSessionFactoryBuilder().build();”

Leave a Reply

Your email address will not be published. Required fields are marked *