Tengo el siguiente bean:

import java.util.List;
import javax.faces.bean.RequestScoped;
import javax.annotations.ManagedBean;
import javax.persistence.EntityManager;
import listener.EMF;
import model.CustomerOrder;

@MangedBean
@RequestScoped
public class OrderBean {

    private List<CustomerOrder> orderList;

    /**
     * Creates a new instance of OrderBean
     */
    public OrderBean() {
        EntityManager em = EMF.createEntityManager();
        this.orderList = em.createNamedQuery("CustomerOrder.findAll").getResultList();
        System.out.println("=== Orderlist ===");
        for (CustomerOrder order : orderList) {
            System.out.println(order.getNumber());
        }
        em.close();
    }

    public List<CustomerOrder> getOrderList() {
        System.out.println("=== In getOrderList ===");
        return orderList;
    }

    public void setOrderList(List<CustomerOrder> orderList) {
        this.orderList = orderList;
    }

}

La clase CustomerOrder es una clase JPA:

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.*;
import java.util.regex.*;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import listener.EMF;
import regex.AttachmentAnalyzer;

@Entity
@Table(name = "customerorder")
@NamedQueries({
    @NamedQuery(name = "CustomerOrder.findAll", query = "SELECT c FROM CustomerOrder c"),
    @NamedQuery(name = "CustomerOrder.findById", query = "SELECT c FROM CustomerOrder c WHERE c.id = :id"),
    @NamedQuery(name = "CustomerOrder.findByNumber", query = "SELECT c FROM CustomerOrder c WHERE c.number = :number"),
    @NamedQuery(name = "CustomerOrder.findByCalculationparameter", query = "SELECT c FROM CustomerOrder c WHERE c.calculationparameter = :calculationparameter"),
    @NamedQuery(name = "CustomerOrder.findByActive", query = "SELECT c FROM CustomerOrder c WHERE c.active = :active"),
    @NamedQuery(name = "CustomerOrder.findByLastupdate", query = "SELECT c FROM CustomerOrder c WHERE c.lastupdate = :lastupdate")})
public class CustomerOrder implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id")
    private Integer id;
    @Size(max = 255)
    @Column(name = "number")
    private String number;
    @Column(name = "calculationparameter")
    private BigDecimal calculationparameter;
    @Column(name = "active")
    private Short active;
    @Basic(optional = false)
    @NotNull
    @Column(name = "lastupdate")
    @Temporal(TemporalType.TIMESTAMP)
    private Date lastupdate;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "customerorderId")
    private List<Orderline> orderlineList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "customerorderId")
    private List<Attachment> attachmentList;
    @JoinColumn(name = "lastupdateby", referencedColumnName = "id")
    @ManyToOne(optional = false)
    private User lastupdateby;
    @JoinColumn(name = "customer_id", referencedColumnName = "id")
    @ManyToOne
    private Customer customerId;
    @Transient
    private boolean validOrder;

    public CustomerOrder() {
    }

    public CustomerOrder(Email email) {
        this.attachmentList = email.getAttachments();
        EntityManager em = EMF.createEntityManager();
        List<Customer> customers = em.createNamedQuery("Customer.findAll").getResultList();
        User systemUser = (User) em.createNamedQuery("User.findByName").setParameter("name", "system").getSingleResult();
        em.close();
        for (Customer customer : customers) {
            String fromAddressFilter = customer.getEmailaddressfilter();
            String subjectFilter = customer.getEmailsubjectfilter();
            String subject = email.getSubject();
            String content = email.getContent();
            if (isMatch(email.getSubject(), subjectFilter)
                    && isMatch(email.getFromAddress(), fromAddressFilter)) {
                this.validOrder = true;
                this.active = 1;
                AttachmentAnalyzer analyzer = new AttachmentAnalyzer(customer, subject, content, attachmentList);
                this.number = analyzer.getNumber();
                this.calculationparameter = analyzer.getCalculationParameter();
                this.orderlineList = analyzer.getOrderlineList();
                this.customerId = customer;
                this.lastupdateby = systemUser;
                for (Attachment a : attachmentList) {
                    a.setCustomerorderId(this);
                }
                for (Orderline o : orderlineList) {
                    o.setCustomerorderId(this);
                    o.setLastupdateby(systemUser);
                }
            } else {
                this.validOrder = false;
            }
        }
    }

    private boolean isMatch(String string, String filter) {
        Pattern pattern;
        pattern = Pattern.compile(filter);
        Matcher matcher = pattern.matcher(string);
        boolean isMatch = matcher.find();
        return isMatch;
    }


// getters, setters and overrided hashCode, equal and toString methods omitted 

}

Quartz llama al constructor de la clase JPA CustomerOrder (correo electrónico de correo electrónico) cuando se recibe un nuevo mensaje de correo electrónico. Probé esto y esto funciona. Tengo algunos registros de pedidos de clientes en mi base de datos.

Finalmente mi página JSF:

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html">
    <h:head>
        <title>Test page</title>
    </h:head>
    <h:body>
        <h:dataTable var="order" value="#{orderBean.orderList}" >
            <h:column>
                #{order.customerId}
            </h:column>
        </h:dataTable>
    </h:body>
</html>

Espero que esto muestre los campos customerId de la tabla con los pedidos de clientes en la base de datos. Sin embargo, solo devuelve una tabla vacía.

Al menos esperaría que en mi terminal del servidor se muestren los mensajes Sysout del bean, pero incluso estos no se muestran.

Pregunta: ¿Qué tiene de malo mi código? ¿Por qué no se muestran las entradas de mi base de datos? ¿Cómo puedo depurar este problema?