java类javax.persistence.TypedQuery的实例源码

@SuppressWarnings("unchecked")
/**
 * 分页条件查询
 * @param cq 条件
 * @param pageable 分页信息
 * @param <T> 领域类（实体类）范型
 * @return 分页结果
 */
public static <T> Page<T> findAll(CriteriaQuery<T> cq, Pageable pageable) {
    Class<T> domainClass = cq.getResultType();
    Root<T> root;
    if (CollectionUtils.isEmpty(cq.getRoots())) {
        root = cq.from(domainClass);
    } else {
        root = (Root<T>) cq.getRoots().iterator().next();
    }
    EntityManager em = getEntityManager(domainClass);
    if (pageable == null) {
        List<T> list = findAll(cq);
        return new PageImpl<T>(list);
    } else {
        Sort sort = pageable.getSort();
        cq.orderBy(QueryUtils.toOrders(sort, root, em.getCriteriaBuilder()));
        TypedQuery<T> query = em.createQuery(cq);

        query.setFirstResult(pageable.getOffset());
        query.setMaxResults(pageable.getPageSize());

        Long total = count(cq);
        List<T> content = total > pageable.getOffset() ? query.getResultList() : Collections.<T> emptyList();

        return new PageImpl<T>(content, pageable, total);
    }
}

private <T> Page<T> readPage(TypedQuery<Long> countQuery, TypedQuery<T> query, Pageable pageable) {
    query.setFirstResult(pageable.getOffset());
    query.setMaxResults(pageable.getPageSize());

    return PageableExecutionUtils.getPage(query.getResultList(), pageable,
        () -> executeCountQuery(countQuery));
}

@LogDuration(limit = 50)
public ReconciledTransaction getReconciledTransaction(String regNo, String accountNo, String id) {
    TypedQuery<ReconciledTransaction> q = em.createQuery("select rt from ReconciledTransaction rt " +
            "where rt.account.regNo=:regNo and rt.account.accountNo=:accountNo and rt.id=:id", ReconciledTransaction.class);
    q.setParameter("regNo", regNo);
    q.setParameter("accountNo", accountNo);
    q.setParameter("id", id);
    return q.getSingleResult();
}

public List<ProductEntity> findByLevelEnabled(String categoryName, String productType, int minLevel, boolean enabled, boolean premium) {
    TypedQuery<ProductEntity> query = entityManager.createNamedQuery("ProductEntity.findByLevelEnabled", ProductEntity.class);
    query.setParameter("categoryName", categoryName);
    query.setParameter("productType", productType);
    query.setParameter("enabled", enabled);
    query.setParameter("minLevel", minLevel);
    query.setParameter("premium", premium);
    return query.getResultList();
}

public List<Student> getAllStudents() {
    CriteriaQuery<Student> cq = em.getCriteriaBuilder().createQuery(Student.class);
    Root<Student> student = cq.from(Student.class);
    cq.select(student);
    cq.where(cb.isTrue(student.get(Student_.active)));
    cq.distinct(true);
    TypedQuery<Student> q = em.createQuery(cq);
    return q.getResultList();
}

/**
 * Find customer by its semantic key. Note this will throw {@link NoResultException} which will roll back the
 * transaction if the customer is not found - if this is a problem consider using
 * {@link #findCustomer(String)}.
 */
@LogDuration(limit = 50)
public Customer getCustomer(String customerNo) {
    TypedQuery<Customer> q = em.createQuery("select c from Customer c where c.sid=:sid", Customer.class);
    q.setParameter("sid", customerNo);
    return q.getSingleResult();
}

public List<String> getSportsOfPlayer(String playerId) {
        logger.info("getSportsOfPlayer");
        List<String> sports = new ArrayList<>();

        try {
            CriteriaQuery<String> cq = cb.createQuery(String.class);
            if (cq != null) {
                Root<Player> player = cq.from(Player.class);
                Join<Player, Team> team = player.join(Player_.teams);
                Join<Team, League> league = team.join(Team_.league);

                // Get MetaModel from Root
                //EntityType<Player> Player_ = player.getModel();

                // set the where clause
                cq.where(cb.equal(player.get(Player_.id), playerId));
                cq.select(league.get(League_.sport)).distinct(true);
                TypedQuery<String> q = em.createQuery(cq);
                sports = q.getResultList();
            }

//        Player player = em.find(Player.class, playerId);
//        Iterator<Team> i = player.getTeams().iterator();
//        while (i.hasNext()) {
//            Team team = i.next();
//            League league = team.getLeague();
//            sports.add(league.getSport());
//        }
        } catch (Exception ex) {
            throw new EJBException(ex);
        }
        return sports;
    }

@Override
public ShiftTemplate getTemplate(Integer tenantId) {
    TypedQuery<ShiftTemplate> q = entityManager.createNamedQuery("ShiftTemplate.get", ShiftTemplate.class);
    q.setParameter("tenantId", tenantId);
    List<ShiftTemplate> result = q.getResultList();
    if (result.isEmpty()) {
        return null;
    } else if (1 != result.size()) {
        throw new IllegalStateException("Each tenant can only have 1 template! Found " + result.size()
                + "templates!");
    } else {
        return result.get(0);
    }
}

public List<LobbyEntity> findAllOpen() {
    Date dateNow = new Date();
    Date datePast = new Date(dateNow.getTime() - 35000);

    TypedQuery<LobbyEntity> query = entityManager.createNamedQuery("LobbyEntity.findAllOpen", LobbyEntity.class);
    query.setParameter("dateTime1", datePast);
    query.setParameter("dateTime2", dateNow);
    return query.getResultList();
}

public void getUserByUsernameAlt2(String username) {
    TypedQuery<UserEntity> q = em.createQuery(
            "select * from Users where name = '" + username + "'",
            UserEntity.class);

    UserEntity res = q.getSingleResult();
}