08. HelloJPA - AntonioDiaz/examples.spring.mvc GitHub Wiki

import javax.persistence.*;

@Entity
@Table(name = "T_PERSON")
public class Person {

	@Id
	@GeneratedValue
	private Long id;

	@Column(name = "FIRST_NAME")
	private String firstName;

	@Column(name = "LAST_NAME")
	private String lastName;

	@OneToOne(cascade = { CascadeType.ALL })
	@JoinColumn(name = "ID_CARD_ID")
	private IdCard idCard;

	@OneToMany(mappedBy = "person", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	private List<Phone> phones = new ArrayList<>();
	/* getters and setters.  */
}

import javax.persistence.*;

@Entity
@Table(name = "T_PHONE")
public class Phone {

	@Id
	@GeneratedValue
	private Long id;

	@Column(name = "NUMBER")
	private String number;

	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = "PERSON_ID")
	private Person person;

}

package com.daos;
public interface GenericDAO<T> {
	public void create(T item) throws Exception;
	public void update(T item) throws Exception;
	public void remove(T item) throws Exception;
}

package com.daos;

import java.util.List;
import com.persistence.Person;

public interface PersonDAO extends GenericDAO<Person> {
	public List<Person> getPersonAll();	
	public Person getPersonById(Long id);	
	public Person getPersonByIdJoin(Long id);	
	public List<Person> getPersonByNameEqual(String name);
	public List<Person> getPersonByNameLike(String name);
	public List<Person> getPersonsByPhone(String myPhone);	
	public List<Person> getPersonsByPhoneCriteria(String myPhone);
}

package com.daos;

import javax.persistence.*;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository
@Transactional
public class PersonDAOImpl implements PersonDAO {

	@PersistenceContext
	private EntityManager entityManager;
	
	@Override
	public void create(Person person) throws Exception {
		entityManager.persist(person);
	}

	@Override
	public void update(Person person) throws Exception {
		entityManager.merge(person);
	}

	@Override
	public void remove(Person person) throws Exception {
		entityManager.remove(entityManager.contains(person) ? person : entityManager.merge(person));
	}

	@Override
	public List<Person> getPersonAll() {
		return entityManager.createQuery("Select a From Person a", Person.class).getResultList();
	}

	@Override
	public Person getPersonById(Long id) {
		TypedQuery<Person> typedQuery = entityManager.createQuery("Select a From Person a Where a.id=:person_id", Person.class);
		Person person = null;
		try {
			person = typedQuery.setParameter("person_id", id).getSingleResult();
		} catch (NoResultException e) {	}
		return person;
	}
	
	@Override
	public Person getPersonByIdJoin(Long id) {
		TypedQuery<Person> typedQuery = entityManager.createQuery("Select a From Person a left join fetch a.phones s Where s.id=:person_id", Person.class);
		Person person = null;
		try {
			person = typedQuery.setParameter("person_id", id).getSingleResult();
		} catch (NoResultException e) {	}
		return person;
	}

	@Override
	public List<Person> getPersonByNameEqual(String name) {
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery<Person> query = builder.createQuery(Person.class);
		Root<Person> personRoot = query.from(Person.class);
		query.where(builder.equal(personRoot.get("firstName"), name));
		return entityManager.createQuery(query).getResultList();
	}
	
	@Override
	public List<Person> getPersonByNameLike(String name) {
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery<Person> query = builder.createQuery(Person.class);
		Root<Person> personRoot = query.from(Person.class);

		/* create like expresion. */ 
		EntityType<Person> type = entityManager.getMetamodel().entity(Person.class);
		SingularAttribute<Person, String> declaredSingularAttribute = type.getDeclaredSingularAttribute("firstName", String.class);
		Path<String> path = personRoot.get(declaredSingularAttribute);
		Expression<String> expresion = builder.lower(path);

		query.where(builder.like(expresion, name + "%"));
		return entityManager.createQuery(query).getResultList();
	}

	@Override
	public List<Person> getPersonsByPhone(String myPhone) {
		List<Person> resultList = null;
		TypedQuery<Person> typedQuery = entityManager.createQuery("Select a From Person a left join fetch a.phones s Where s.number=:my_number", Person.class);
		resultList = typedQuery.setParameter("my_number", myPhone).getResultList();
		return resultList;
	}
	
	@Override
	public List<Person> getPersonsByPhoneCriteria(String myPhone) {
		List<Person> resultList = null;
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery<Person> query = builder.createQuery(Person.class);
		Root<Person> personRoot = query.from(Person.class);
		Join<Object, Object> join = personRoot.join("phones",  JoinType.LEFT);
		query.where(builder.equal(join.get("number"), myPhone));
		resultList = entityManager.createQuery(query).getResultList();
		return resultList;
	}
	
	public List<Person> getPersonsByPhoneCriteriaAux(String myPhone) {
		List<Person> resultList = null;
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery<Person> query = builder.createQuery(Person.class);
		Root<Person> personRoot = query.from(Person.class);		
		Fetch<Person, Phone> myFetch = personRoot.fetch("phones",  JoinType.LEFT);
		query.where(builder.equal(personRoot.get("firstName"), myPhone));
		//query.where(builder.equal(myFetch.get("firstName"), myPhone));
		resultList = entityManager.createQuery(query).getResultList();
		return resultList;
	}
}

package com.services;

import java.util.List;
import com.persistence.Person;

public interface PersonManager {
	public void createUser(Person person) throws Exception;	
	public void updteUser(Person person) throws Exception;	
	public List<Person> queryPersonAll() throws Exception;	
	public Person queryPersonById(Long id) throws Exception;	
	public Person queryPersonByIdJoin(Long id) throws Exception;	
	public Person queryPersonByPhone(String myPhone) throws Exception;	
	public Person queryPersonByPhoneCriteria(String myPhone) throws Exception;	
	public List<Person> queryPersonByNameEqual(String name) throws Exception;
	public List<Person> queryPersonByNameLike(String name) throws Exception;
}

package com.services;

@Service
public class PersonManagerImpl implements PersonManager {

	@Autowired private PersonDAO personDAO;
	
	@Override
	public void createUser(Person person) throws Exception {
		personDAO.create(person);
	}

	@Override
	public List<Person> queryPersonAll() throws Exception {
		return personDAO.getPersonAll();
	}

	@Override
	public Person queryPersonById(Long id) throws Exception {
		return personDAO.getPersonById(id);
	}
	
	@Override
	public Person queryPersonByIdJoin(Long id) throws Exception {
		return personDAO.getPersonByIdJoin(id);
	}

	@Override
	public List<Person> queryPersonByNameEqual(String name) throws Exception {
		return personDAO.getPersonByNameEqual(name);
	}
	
	@Override
	public List<Person> queryPersonByNameLike(String name) throws Exception {
		return personDAO.getPersonByNameLike(name);
	}

	@Override
	public void updteUser(Person person) throws Exception {
		personDAO.update(person);
	}

	@Override
	public Person queryPersonByPhone(String myPhone) throws Exception {
		Person person = null;
		List<Person> persons = personDAO.getPersonsByPhone(myPhone);
		if (persons.size() > 1) {
			throw new Exception("More than one person.");
		}
		if (persons.size()==1) {
			person = persons.get(0);
		}
		return person;
	}
	
	@Override	
	public Person queryPersonByPhoneCriteria(String myPhone) throws Exception {
		Person person = null;
		List<Person> persons = personDAO.getPersonsByPhoneCriteria(myPhone);
		if (persons.size() > 1) {
			throw new Exception("More than one person.");
		}
		if (persons.size()==1) {
			person = persons.get(0);
		}
		return person;
	}
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.hibernate4.Hibernate4Module;

public class HibernateAwareObjectMapper extends ObjectMapper {

	private static final long serialVersionUID = 1L;

	public HibernateAwareObjectMapper() {
		registerModule(new Hibernate4Module());
	}
}

import javax.persistence.TypedQuery;

public List<ResourceEntity> getResources(String name, Integer author, String organization) {
	String queryStr = "Select a From ResourceEntity a join fetch a.uploadedUser as u where 1=1";
	if (StringUtils.isNotEmpty(name)) {
		queryStr += " and UPPER(a.name) like :name";
	}
	if (author!=null) {
		queryStr += " and u.id = :id_author";
	}
	if (StringUtils.isNotEmpty(organization)) {
		queryStr += " and UPPER(u.organization) like :organization";
	}
	TypedQuery<ResourceEntity> typedQuery = em.createQuery(queryStr, ResourceEntity.class);
	if (StringUtils.isNotEmpty(name)) {
		typedQuery = typedQuery.setParameter("name",  "%" + name.toUpperCase() + "%");
	}				
	if (author!=null) {
		typedQuery = typedQuery.setParameter("id_author", author);
	}
	if (StringUtils.isNotEmpty(organization)) {
		typedQuery = typedQuery.setParameter("organization", "%" + organization.toUpperCase() + "%");
	}
	return typedQuery.getResultList();
}