Ora possiamo iniziare a costruire la nostra applicazione.
Per prima cosa implementiamo il modello. Il nostro dominio in questo caso è l’utente e sarà rappresentato dalla classe User.java. Questa classe rappresenterà il nostro utente nel sistema. Verranno quindi implementati i metodi setter/getter che modificheranno le proprietà id, username, password
User.java
package it.sample.webapp.model;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* Defines a model that represents a user in the system.
*/
@Entity
@Table(name = "user")
public class User implements Serializable {
private static final long serialVersionUID = -2230673925164485629L;
@Id
@GeneratedValue
private Long id;
private String username;
private String password;
/**
* Sets the unique id for this user
* @param id unique id to be assigned
*/
public void setId(Long id) {
this.id = id;
}
/**
* Gets the unique id assigned to this user
* @return the unique id
*/
public Long getId() {
return id;
}
/**
* Gets the name of this user
* @return the name
*/
public final String getUsername() {
return username;
}
/**
* Sets the name of this user.
* @param name the name to set
*/
public final void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
A questo punto possiamo implementare gli oggetti DAO per l’accesso al DB.
Per fare questo implementiamo prima un’interfaccia generica che espone i metodi principali di accesso al DB (delete, getAll, getById,save) e poi una classe astratta che esegue un’implementazione di default della classe GenericDao. Ci preoccuperemo di implementare l’interfaccia in un secondo momento.
GenericDao.java
package it.sample.webapp.dao;
import java.io.Serializable;
import java.util.List;
/**
* Defines a generic data access object that is extended by all the DAOs in the
* system. This interface defines the common CRUD methods like <code>save</code>,
* <code>delete</code> <code>getAll</code> and <code>getById</code>.
*/
public interface GenericDao <T, ID extends Serializable> {
/**
* Gets the list of all objects of this type
* @return list of this objects; the list can be empty
*/
public List<T> getAll();
/**
* Gets the object using specified primary key
* @param id primary key (ID) of the object to retrieve
* @return object corresponding to the specified primary key (ID)
* @throws javax.persistence.NoResultException when object
* corresponding to the specified ID (primary key) is not found. This is a
* <code>RuntimeException</code>
*/
public T getById(ID id);
/**
* Saves the specified object. Handles both insert as well as update
* @param object the object to save
* @return managed copy of the original object. Use this object if you want
* the future changes managed (persisted).
* @throws javax.persistence.PersistenceException when the specified object
* could not be persisted. This is a
* <code>RuntimeException</code>
*/
public T save(T object);
/**
* Deletes the object that corresponds to the specified primary key (ID)
* @param object the object to delete
* @throws javax.persistence.PersistenceException when the specified object
* could not be deleted. This is a
* <code>RuntimeException</code>
*/
public void delete(ID id);
}
BaseJpaDao.java
package it.sample.webapp.dao.jpa;
import java.io.Serializable;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import it.sample.webapp.dao.GenericDao;
/**
* Defines a Base DAO that provides JPA implementation.
* This class keeps the reference to the <code>EntityManager</code> and
* provides a default implementation for methods defined in the <code>GenericDao</code>
* interface.
*/
public abstract class BaseJpaDao<T, ID extends Serializable> implements GenericDao<T, ID> {
private Class<T> persistentClass;
protected EntityManager entityManager;
/**
* Constructor that takes in a class to see which type of entity to persist
* @param persistentClass the class type you'd like to persist
*/
public BaseJpaDao(final Class<T> persistentClass) {
this.persistentClass = persistentClass;
}
/**
* Gets the <code>EntityManager</code> used by this DAO
* @return the entityManager used for persistence
*/
public final EntityManager getEntityManager() {
return entityManager;
}
/**
* Sets the <code>EntityManager</code> used by this DAO
* @param entityManager the entityManager to be used for persistence
*/
@PersistenceContext
public final void setEntityManager(EntityManager entityManager) {
this.entityManager = entityManager;
}
@Override
public void delete(ID id) {
this.entityManager.remove(id);
}
@SuppressWarnings("unchecked")
@Override
public List<T> getAll() {
Query q = this.entityManager.createQuery("FROM " +
this.persistentClass.getName());
return q.getResultList();
}
@Override
public T getById(ID id) {
final T data= this.entityManager.find(persistentClass, id);
return data;
}
@Override
public T save(T object) {
try {
final T data = this.entityManager.merge(object);
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}