完整的Web应用程序Tomcat JSF Primefaces JPA Hibernate –第1部分

最新推荐文章于 2021-07-23 21:35:33 发布

dnc8371

最新推荐文章于 2021-07-23 21:35:33 发布

阅读量146

点赞数

文章标签：数据库过滤器 java hibernate servlet

我们创建了这篇文章，将展示如何使用以下工具创建完整的Web应用程序：Tomcat7，带有Primefaces的JSF2（Facelets和Libraries）（具有AutoComplete），JPA / Hibernate（具有NxN关系），使用Filter登录。要查看具有JSF + EJB + JPA + JBoss 7的完整Web应用程序，请单击此处。

要运行此文章的代码，您将需要以下制品（在此文章最后一页中将找到所有jar文件）：

您可以使用所需的任何数据库，您将需要数据库的特定驱动程序并在persistence.xml上编辑URL连接。

在本文的结尾，您将找到带有所有需要下载的库的源代码。

您将在今天的帖子中看到以下内容：

模型的实体类。关系NxN（@ManyToMany），具有JoinFetch，Enum作为属性的NamedQueries。
通用DAO，应用程序事务方法，用于填充查询参数的通用方法。
使用findReferenceOn方法对事务进行外观处理，请注意使用entityManager.merge（）方法。
筛选器。
ManagedBeans。如何在另一个ManagedBean中注入一个ManagedBean，有关@ViewScoped的观察。
JSFMessageUtil。
配置文件：log4j.properties，messages.properties。
xhtml页面，Facelets。
Primefaces AutoComplete，带有“ forClass”的JSF转换器。
在JSF中使用CSS / javascript / images的最简单方法。
“ web.xml”配置。
增强应用程序的安全性。
运行应用程序。

您将在此处找到的应用程序具有Dog and Person CRUD（创建，读取，更新和删除）；只有管理员才能访问Dog CRUD。 在运行此应用程序之前，您应该创建一个名为“ JSFCrudDB”的数据库 。

模型类

以下类是模型类，它们应位于“ com.model”包中：

package com.model;

public enum Role {
 ADMIN, USER;
}

package com.model;

import java.io.Serializable;

import javax.persistence.*;

@Entity
@Table(name = 'USERS')
@NamedQuery(name = 'User.findUserByEmail', query = 'select u from User u where u.email = :email')
public class User implements Serializable {
 private static final long serialVersionUID = 1L;

 public static final String FIND_BY_EMAIL = 'User.findUserByEmail';

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private int id;

 @Column(unique = true)
 private String email;
 private String password;
 private String name;
 @Enumerated(EnumType.STRING)
 private Role role;

 // get and set

 public boolean isAdmin() {
  return Role.ADMIN.equals(role);
 }

 public boolean isUser() {
  return Role.USER.equals(role);
 }

 @Override
 public int hashCode() {
  return getId();
 }

 @Override
 public boolean equals(Object obj) {
  if (obj instanceof User) {
   User user = (User) obj;
   return user.getId() == id;
  }

  return false;
 }
}

package com.model;

import java.io.Serializable;
import java.util.List;

import javax.persistence.*;

@Entity
@NamedQuery(name = 'Person.findUserByIdWithDogs', query = 'select p from Person p left join fetch p.dogs where p.id = :personId')
public class Person implements Serializable {

 private static final long serialVersionUID = 1L;
 public static final String FIND_USER_BY_ID_WITH_DOGS = 'Person.findUserByIdWithDogs';

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private int id;
 private int age;
 private String name;

 @ManyToMany
 private List<Dog> dogs;

 // get and set

 @Override
 public int hashCode() {
  return id;
 }

 @Override
 public boolean equals(Object obj) {
  if (obj instanceof Person) {
   Person person = (Person) obj;
   return person.getId() == id;
  }

  return false;
 }
}

package com.model;

import java.io.Serializable;
import java.util.List;

import javax.persistence.*;

@Entity
public class Dog implements Serializable{
 private static final long serialVersionUID = 1L;

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private int id;
 private int age;
 private String name;

 @ManyToMany(mappedBy='dogs')
 private List<Person> persons;

 // get and set

 @Override
 public int hashCode() {
  return id;
 }

 @Override
 public boolean equals(Object obj) {
  if (obj instanceof Dog) {
   Dog dog = (Dog) obj;
   return dog.getId() == id;
  }

  return false;
 }

 @Override
 public String toString() {
  return name;
 }
}

关于上面的代码：

Person类具有名为“ Person.findUserByIdWithDogs”的查询。该查询将热切加载Person类的Dog列表。如果我们尝试在没有事务的情况下访问Dog列表，并且此查询将发生LazyInitializationException。解决这种情况的其他方法是使用OpenSessionInView模式。此模式可能会产生N + 1个查询效果。如果您想了解更多有关此异常的信息，请单击此处。
使用JPA / Hibernate映射枚举非常容易。如您所见，有一个带有@Enumerated批注的选项，它将数据库表字段设置为String。如果您想了解有关此注释的更多信息，并了解如何将枚举映射为ORDINAL，请单击此处。
始终重写equals / hashCode方法。这些方法通常由几个框架调用。通过实施这些方法，解决了许多Primefaces“错误”。

您将需要在“ src / META-INF”文件夹中创建“ persistence.xml”文件：

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

<persistence version='2.0'
 xmlns='http://java.sun.com/xml/ns/persistence' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
 xsi:schemaLocation='http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd'>

 <persistence-unit name='JSFCrudPU' transaction-type='RESOURCE_LOCAL'>
  <provider>org.hibernate.ejb.HibernatePersistence</provider>

  <properties>
   <property name='javax.persistence.jdbc.driver' value='org.postgresql.Driver' />
   <property name='javax.persistence.jdbc.url' value='jdbc:postgresql://localhost:5432/JSFCrudDB' />
   <property name='javax.persistence.jdbc.user' value='postgres' />
   <property name='javax.persistence.jdbc.password' value='postgres' />
   <property name='hibernate.dialect' value='org.hibernate.dialect.PostgreSQLDialect' />
   <property name='hibernate.connection.shutdown' value='true' />
   <property name='hibernate.hbm2ddl.auto' value='update' />
   <property name='hibernate.show_sql' value='false' />
            <property name='hibernate.format_sql' value='false'/>
  </properties>
 </persistence-unit>
</persistence>

关于上面的代码：

值为“ update”的“ hibernate.hbm2ddl.auto”属性指示JPA在必要时根据模型类更新数据库。将此选项保留为“ update ”或任何其他可能会更新生产/客户数据库的值不是一个好习惯。在生产环境中使用“ validate ”选项并手动创建和执行sql脚本始终是一件好事。
hibernate.show_sql和hibernate.format_sql属性用于在控制台中显示查询。在文件log4j.properties（第08页）中，有一个选项将允许显示查询参数值。

道

在“ com.dao”包中，您将需要创建以下类：

package com.dao;

import java.io.Serializable;
import java.util.*;
import java.util.Map.*;

import javax.persistence.*;
import javax.persistence.criteria.CriteriaQuery;

abstract class GenericDAO<T> implements Serializable {
 private static final long serialVersionUID = 1L;

 private static final EntityManagerFactory emf = Persistence.createEntityManagerFactory('JSFCrudPU');
 private EntityManager em;

 private Class<T> entityClass;

 public void beginTransaction() {
  em = emf.createEntityManager();

  em.getTransaction().begin();
 }

 public void commit() {
  em.getTransaction().commit();
 }

 public void rollback() {
  em.getTransaction().rollback();
 }

 public void closeTransaction() {
  em.close();
 }

 public void commitAndCloseTransaction() {
  commit();
  closeTransaction();
 }

 public void flush() {
  em.flush();
 }

 public void joinTransaction() {
  em = emf.createEntityManager();
  em.joinTransaction();
 }

 public GenericDAO(Class<T> entityClass) {
  this.entityClass = entityClass;
 }

 public void save(T entity) {
  em.persist(entity);
 }

 public void delete(T entity) {
  T entityToBeRemoved = em.merge(entity);

  em.remove(entityToBeRemoved);
 }

 public T update(T entity) {
  return em.merge(entity);
 }

 public T find(int entityID) {
  return em.find(entityClass, entityID);
 }

 public T findReferenceOnly(int entityID) {
  return em.getReference(entityClass, entityID);
 }

 // Using the unchecked because JPA does not have a
 // em.getCriteriaBuilder().createQuery()<T> method
 @SuppressWarnings({ 'unchecked', 'rawtypes' })
 public List<T> findAll() {
  CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
  cq.select(cq.from(entityClass));
  return em.createQuery(cq).getResultList();
 }

 // Using the unchecked because JPA does not have a
 // query.getSingleResult()<T> method
 @SuppressWarnings('unchecked')
 protected T findOneResult(String namedQuery, Map<String, Object> parameters) {
  T result = null;

  try {
   Query query = em.createNamedQuery(namedQuery);

   // Method that will populate parameters if they are passed not null and empty
   if (parameters != null && !parameters.isEmpty()) {
    populateQueryParameters(query, parameters);
   }

   result = (T) query.getSingleResult();

  } catch (NoResultException e) {
   System.out.println('No result found for named query: ' + namedQuery);
  } catch (Exception e) {
   System.out.println('Error while running query: ' + e.getMessage());
   e.printStackTrace();
  }

  return result;
 }

 private void populateQueryParameters(Query query, Map<String, Object> parameters) {
  for (Entry<String, Object> entry : parameters.entrySet()) {
   query.setParameter(entry.getKey(), entry.getValue());
  }
 }
}

package com.dao;

import java.util.*;

import com.model.Person;

public class PersonDAO extends GenericDAO<Person> {

 private static final long serialVersionUID = 1L;

 public PersonDAO() {
  super(Person.class);
 }

 public Person findPersonWithAllDogs(int personId) {
  Map<String, Object> parameters = new HashMap<String, Object>();
  parameters.put('personId', personId);

  return super.findOneResult(Person.FIND_USER_BY_ID_WITH_DOGS, parameters);
 }
}

package com.dao;

import java.util.*;

import com.model.User;

public class UserDAO extends GenericDAO<User> {

 private static final long serialVersionUID = 1L;

 public UserDAO() {
        super(User.class);
    }

    public User findUserByEmail(String email){
        Map<String, Object> parameters = new HashMap<String, Object>();
        parameters.put('email', email);     

        return super.findOneResult(User.FIND_BY_EMAIL, parameters);
    }
}

package com.dao;

import com.model.Dog;

public class DogDAO extends GenericDAO<Dog> {

 private static final long serialVersionUID = 1L;

 public DogDAO() {
        super(Dog.class);
    }
}

关于上面的代码：

DAO类具有允许Façades控制交易的方法。应用此模式是为了避免使用OpenSessionInView模式。 OpenSessionInView模式可能会导致查询的N + 1效果。在开发人员控制交易的情况下，更容易理解交易流程，但是我们的代码更加冗长。如果您想了解有关OpenSessionInView和N + 1效果的更多信息，请单击此处。
您将在GenericDAO类中找到一个名为“ populateQueryParameters”的方法。如果需要，此方法将动态填充查询的所有参数。类PersonDAO和UserDAO具有如何调用此方法的示例代码。

外墙

在“ com.facade”包中，您将需要创建以下类：

package com.facade;

import com.dao.UserDAO;
import com.model.User;

public class UserFacade {
 private UserDAO userDAO = new UserDAO();

 public User isValidLogin(String email, String password) {
  userDAO.beginTransaction();
  User user = userDAO.findUserByEmail(email);

  if (user == null || !user.getPassword().equals(password)) {
   return null;
  }

  return user;
 }
}

package com.facade;

import java.io.Serializable;
import java.util.List;

import com.dao.DogDAO;
import com.model.Dog;

public class DogFacade implements Serializable{
 private static final long serialVersionUID = 1L;

 private DogDAO dogDAO = new DogDAO();

 public void createDog(Dog dog) {
  dogDAO.beginTransaction();
  dogDAO.save(dog);
  dogDAO.commitAndCloseTransaction();
 }

 public void updateDog(Dog dog) {
  dogDAO.beginTransaction();
  Dog persistedDog = dogDAO.find(dog.getId());
  persistedDog.setAge(dog.getAge());
  persistedDog.setName(dog.getName());
  dogDAO.update(persistedDog);
  dogDAO.commitAndCloseTransaction();
 }

 public Dog findDog(int dogId) {
  dogDAO.beginTransaction();
  Dog dog = dogDAO.find(dogId);
  dogDAO.closeTransaction();
  return dog;
 }

 public List<Dog> listAll() {
  dogDAO.beginTransaction();
  List<Dog> result = dogDAO.findAll();
  dogDAO.closeTransaction();
  return result;
 }

 public void deleteDog(Dog dog) {
  dogDAO.beginTransaction();
  Dog persistedDog = dogDAO.findReferenceOnly(dog.getId());
  dogDAO.delete(persistedDog);
  dogDAO.commitAndCloseTransaction();
 }
}

package com.facade;

import java.io.Serializable;
import java.util.List;

import com.dao.DogDAO;
import com.dao.PersonDAO;
import com.model.Dog;
import com.model.Person;

public class PersonFacade implements Serializable {
 private static final long serialVersionUID = 1L;

 private PersonDAO personDAO = new PersonDAO();
 private DogDAO dogDAO = new DogDAO();

 public void createPerson(Person person) {
  personDAO.beginTransaction();
  personDAO.save(person);
  personDAO.commitAndCloseTransaction();
 }

 public void updatePerson(Person person) {
  personDAO.beginTransaction();
  Person persistedPerson = personDAO.find(person.getId());
  persistedPerson.setName(person.getName());
  persistedPerson.setAge(person.getAge());
  personDAO.commitAndCloseTransaction();
 }

 public void deletePerson(Person person){
  personDAO.beginTransaction();
  Person persistedPersonWithIdOnly = personDAO.findReferenceOnly(person.getId());
  personDAO.delete(persistedPersonWithIdOnly);
  personDAO.commitAndCloseTransaction();

 }

 public Person findPerson(int personId) {
  personDAO.beginTransaction();
  Person person = personDAO.find(personId);
  personDAO.closeTransaction();
  return person;
 }

 public List<Person> listAll() {
  personDAO.beginTransaction();
  List<Person> result = personDAO.findAll();
  personDAO.closeTransaction();

  return result;
 }

 public Person findPersonWithAllDogs(int personId) {
  personDAO.beginTransaction();
  Person person = personDAO.findPersonWithAllDogs(personId);
  personDAO.closeTransaction();
  return person;
 }

 public void addDogToPerson(int dogId, int personId) {
  personDAO.beginTransaction();
  dogDAO.joinTransaction();
  Dog dog = dogDAO.find(dogId);
  Person person = personDAO.find(personId);
  person.getDogs().add(dog);
  dog.getPerson().add(person);
  personDAO.commitAndCloseTransaction();
 }

 public void removeDogFromPerson(int dogId, int personId) {
  personDAO.beginTransaction();
  dogDAO.joinTransaction();
  Dog dog = dogDAO.find(dogId);
  Person person = personDAO.find(personId);
  person.getDogs().remove(dog);
  dog.getPerson().remove(person);
  personDAO.commitAndCloseTransaction();
 }
}

关于上面的代码：

每笔交易都由开发者控制。开发人员有责任永不忘记已完成的交易。
PersonFacade类使用名为“ findReferenceOnly ”的方法。与仅涉及仅需要实体ID的操作的“ find ”方法相比，该方法具有更好的性能。将在数据库中触发查询，以仅获取该实体的ID。如果调用了其他任何属性，则将在数据库中激发一个新查询以带来该信息。根据《 Pro JPA 2：掌握Java™持久性API 》一书，该方法还可以用于编辑列表中的项目。例如，在方法Person.addDoAgToPerson中，可以将“ find ”方法替换为“ findReferenceOnly ”
这两种方法” Person.addDogToPerson”，并在DogDAO类‘Person.removeDogFromPerson’调用方法‘joinTransaction’。 DogDAO中的EntityManager将使用从PersonDAO开始的同一事务。

关心EntityManager.merge（）

看一下下面的代码：

只需调用这样的方法：“ entityManager.merge（dog） ”，而不是查询持久化对象并更新数据，会更容易。如果在从视图接收的文件中调用merge方法，则可能会损坏数据库数据的完整性。开发人员必须注意这种合并方法。如果未加载惰性关系，并且在合并的实体中此关系为null，则JPA / Hibernate将在数据库中擦除此关系。例如，如果开发人员调用方法entityManager.merge（dog）和dog.getPersons（）== null，则JPA / Hibernate将删除数据库中它们之间的所有关系。

最佳实践是在数据库中查找对象而不是对其进行编辑。

在这个项目中，对象是从数据库中加载的，并且处于分离状态。对于这种特殊情况，您发现对象已分离并且惰性关系不为null，JPA不会删除数据库数据关系。如果该对象是手动创建的，并且关系的值是List <Person> == null，则JPA将删除数据库数据。

过滤

在“ com.filter”包中，您将需要创建以下类：

package com.filter;

import java.io.IOException;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;

public class AbstractFilter {

 public AbstractFilter() {
  super();
 }

 protected void doLogin(ServletRequest request, ServletResponse response, HttpServletRequest req) throws ServletException, IOException {
  RequestDispatcher rd = req.getRequestDispatcher('/pages/public/login.xhtml');
  rd.forward(request, response);
 }

 protected void accessDenied(ServletRequest request, ServletResponse response, HttpServletRequest req) throws ServletException, IOException {
  RequestDispatcher rd = req.getRequestDispatcher('/pages/public/accessDenied.xhtml');
  rd.forward(request, response);
 }
}

package com.filter;

import java.io.IOException;
import java.util.*;

import javax.servlet.*;
import javax.servlet.http.*;

import com.model.User;

/**
 * Servlet Filter implementation class UserCheckFilter
 */
public class LoginCheckFilter extends AbstractFilter implements Filter {
 private static List<String> allowedURIs;

 /**
  * @see Filter#init(FilterConfig)
  */
 public void init(FilterConfig fConfig) throws ServletException {
  if(allowedURIs == null){
   allowedURIs = new ArrayList<String>();
   allowedURIs.add(fConfig.getInitParameter('loginActionURI'));
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/main.css.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/theme.css.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/primefaces.js.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/primefaces.css.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/jquery/jquery.js.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/messages/messages.png.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/images/ui-icons_2e83ff_256x240.png.xhtml');
   allowedURIs.add('/JSFCrudApp/javax.faces.resource/images/ui-icons_38667f_256x240.png.xhtml');
  }
 }

 /**
  * @see Filter#destroy()
  */
 public void destroy() {
 }

 /**
  * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
  */
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  HttpServletRequest req = (HttpServletRequest) request;
  HttpSession session = req.getSession();

  if (session.isNew()) {
   doLogin(request, response, req);
   return;
  }

  User user = (User) session.getAttribute('user');

  if (user == null && !allowedURIs.contains(req.getRequestURI())) {
   System.out.println(req.getRequestURI());
   doLogin(request, response, req);
   return;
  }

  chain.doFilter(request, response);
 }
}

package com.filter;

import java.io.IOException;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;

import com.model.User;

public class AdminPagesFilter extends AbstractFilter implements Filter {

 @Override
 public void destroy() {

 }

 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  HttpServletRequest req = (HttpServletRequest) request;
  User user = (User) req.getSession(true).getAttribute('user');

  if (!user.isAdmin()) {
   accessDenied(request, response, req);
   return;
  }

  chain.doFilter(request, response);
 }

 @Override
 public void init(FilterConfig arg0) throws ServletException {

 }
}

package com.filter;

import java.io.IOException;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;

import com.model.User;

public class DefaultUserPagesFilter extends AbstractFilter implements Filter {

 @Override
 public void destroy() {

 }

 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  HttpServletRequest req = (HttpServletRequest) request;
  User user = (User) req.getSession(true).getAttribute('user');

  if(!user.isUser() && !user.isAdmin()){
   accessDenied(request, response, req);
   return;
  }

  chain.doFilter(request, response);
 }

 @Override
 public void init(FilterConfig arg0) throws ServletException {

 }
}

关于上面的代码：

实现Filter接口的类负责用户的授权和身份验证。在第13页上，将提供有关我们为什么需要检查用户是否已登录及其在每次请求时的角色的更多信息。
方法“ fConfig.getInitParameter（“ loginActionURI”）; 在类LoginCheckFilter中调用的“”将从“ web.xml ”文件中加载属性。 “ loginActionURI”属性具有一个值，用于指示过滤器的登录页面；过滤器将使用此属性，以允许每个用户（无论是否登录）都访问该特定页面（您将在第12页中看到该属性值）。将该属性值添加到无需登录用户即可允许调用的URL列表中。在“ web.xml”文件中保留此允许的URL列表是一个好习惯，但是对于商品，本文中的“ web.xml”中仅添加了一个以显示操作方法。
每个过滤器监视用户可以访问的目录。另一种方法是拥有一个带有所有允许的URL及其允许的角色的文件，例如“ JSFCrud / protected / manager; admin-manager”。

继续第二部分。

参考：在uaiHebert博客上，我们的JCG合作伙伴 Hebert Coelho的Tomcat JSF Primefaces JPA Hibernate完整Web应用程序。

翻译自: https://www.javacodegeeks.com/2012/07/full-web-application-tomcat-jsf.html

dnc8371

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
完整的Web应用程序Tomcat JSF Primefaces JPA Hibernate –第1部分

我们创建了这篇文章，将展示如何使用以下工具创建完整的Web应用程序：Tomcat7，带有Primefaces的JSF2（Facelets和Libraries）（具有AutoComplete），JPA / Hibernate（具有NxN关系），使用Filter登录。要查看具有JSF + EJB + JPA + JBoss 7的完整Web应用程序，请单击此处。要运行此文章的代码，您将...
复制链接

扫一扫