下面列出了怎么用org.hibernate.Criteria的API类实例代码及写法，或者点击链接到github查看源代码。
/**
* get CurrentHealth Check Details from DB.
*
* @param componentId
* @param environmentId
* @param regionID
* @param healthCheckType
* @return
* @
*/
private static HealthCheckVO getCurrentHealthCheckDetails(final int componentId, final int environmentId,
final long regionID,final HealthCheckType healthCheckType) {
Session session = HibernateConfig.getSessionFactory().getCurrentSession();
Transaction txn = session.beginTransaction();
Criteria hcCrit = session.createCriteria(HealthCheckEntity.class,"hc");
hcCrit.add(Restrictions.eq("hc.component.componentId", componentId));
hcCrit.add(Restrictions.eq("hc.environment.environmentId", environmentId));
hcCrit.add(Restrictions.eq("hc.region.regionId", regionID));
if(healthCheckType != null) {
hcCrit.add(Restrictions.eq("hc.healthCheckType.healthCheckTypeId", healthCheckType.getHealthCheckTypeId()));
}
hcCrit.setMaxResults(1);
HealthCheckEntity hcEnt = (HealthCheckEntity) hcCrit.uniqueResult();
txn.commit();
if(hcEnt == null){
return null;
}
HealthCheckVO hcVO = new HealthCheckVO();
hcVO.setHealthCheckId(hcEnt.getHealthCheckId());
if(hcEnt.getCurrentStatus() != null){
hcVO.setCurrentStatus(hcEnt.getCurrentStatus().getStatusId());
}
return hcVO;
}
@Override
public Role findByRoleType(RoleType roleType) {
Role role = null;
try {
Criteria criteria = getHibernateTemplate().getSessionFactory()
.getCurrentSession().createCriteria(Role.class);
Criterion criterion = Restrictions.eq("roleType", roleType);
criteria.add(criterion);
role = (Role) criteria.uniqueResult();
} catch(Exception e) {
logger.error("Error in fetching data by roleType : " +roleType, e);
}
return role;
}
/**
* Get the previous days number of apis for a particular component
*
* @return int
*/
private static int getPreiousNumApis(final int compId, final Date date, final int envId) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(Calendar.DATE, -1);
Session session = HibernateConfig.getSessionFactory().getCurrentSession();
Transaction txn = session.beginTransaction();
Criteria ctrStsCrit = session.createCriteria(ApiStatusEntity.class, "as");
ctrStsCrit.add(Restrictions.eq("as.component.componentId",compId));
ctrStsCrit.add(Restrictions.eq("as.environment.environmentId",envId));
ctrStsCrit.add(Restrictions.eq("as.statusDate", new java.sql.Date(cal.getTimeInMillis()) ));
ctrStsCrit.setMaxResults(1);
ApiStatusEntity apiSts =(ApiStatusEntity) ctrStsCrit.uniqueResult();
int totalApi = 0;
if(apiSts != null){
totalApi = apiSts.getTotalApi();
}
txn.commit();
return totalApi;
}
public List<SbiWhatifWorkflow> getWorkflowByModel(int modelId) {
logger.debug("IN");
Session aSession = null;
try {
aSession = getSession();
Criteria criteria = aSession.createCriteria(SbiWhatifWorkflow.class);
Criterion rest1 = Restrictions.eq("modelId", modelId);
criteria.add(rest1);
criteria.addOrder(Order.asc("sequcence"));
return criteria.list();
} catch (HibernateException he) {
logger.error("Error loading workflow for model" + modelId, he);
throw new SpagoBIRuntimeException("Error loading workflow for model" + modelId, he);
} finally {
if (aSession != null) {
if (aSession.isOpen())
aSession.close();
}
logger.debug("OUT");
}
}
@Transactional(readOnly = true)
public List<MessageBundleProperty> getAllProperties(String locale, String basename, String module) {
Criteria query = sessionFactory.getCurrentSession().createCriteria(MessageBundleProperty.class);
query.setCacheable(true);
if (StringUtils.isNotEmpty(locale)) {
query.add(Restrictions.eq("locale", locale));
}
if (StringUtils.isNotEmpty(basename)) {
query.add(Restrictions.eq("baseName", basename));
}
if (StringUtils.isNotEmpty(module)) {
query.add(Restrictions.eq("moduleName", module));
}
return (List<MessageBundleProperty>) query.list();
}
public long getDownloadedSizeByUserSince (final User user, final Date date)
{
Long result =
getHibernateTemplate ().execute (new HibernateCallback<Long> ()
{
@Override
public Long doInHibernate (Session session)
throws HibernateException, SQLException
{
Criteria criteria = session.createCriteria (
NetworkUsage.class);
criteria.setProjection (Projections.sum ("size"));
criteria.add (Restrictions.eq ("isDownload", true));
criteria.add (Restrictions.eq ("user", user));
criteria.add (Restrictions.gt ("date", date));
return (Long) criteria.uniqueResult ();
}
});
return (result == null) ? 0 : result;
}
@Override
public List<ConfidenceData> getDataAfterTimestampInBin(String crisisCode, String attributeCode, String labelCode,
Long timestamp, Integer bin) {
Criteria criteria = getCurrentSession().createCriteria(ConfidenceData.class);
Criterion criterion = Restrictions.conjunction()
.add(Restrictions.eq("crisisCode", crisisCode))
.add(Restrictions.eq("attributeCode", attributeCode))
.add(Restrictions.eq("labelCode", labelCode))
.add(Restrictions.ge("timestamp", timestamp))
.add(Restrictions.eq("bin", bin));
criteria.add(criterion);
try {
List<ConfidenceData> objList = (List<ConfidenceData>) criteria.list();
return objList;
} catch (HibernateException e) {
logger.error("exception", e);
e.printStackTrace();
}
return null;
}
@Override
public long getCurrentNumberOfPods(int envId, String componentIdsStrg, boolean isParentComponents) throws ParseException {
List<Integer> comIdList = DaoUtil.convertCSVToList(componentIdsStrg);
Session session = sessionFactory.openSession();
DetachedCriteria subMaxDate = DetachedCriteria.forClass(K8sPodsContainersEntity.class);
subMaxDate.setProjection(Projections.max("statusDate"));
Criteria crtCurrentCont = session.createCriteria(K8sPodsContainersEntity.class, "contSts");
crtCurrentCont.createCriteria("contSts.component", "component");
crtCurrentCont.add(Property.forName("statusDate").eq(subMaxDate));
DaoUtil.addEnvironmentToCriteria(envId, isParentComponents, comIdList, crtCurrentCont);
crtCurrentCont.setProjection(Projections.sum("totalPods"));
long currentNumOfCont = (long) (crtCurrentCont.uniqueResult() == null ? (long)0 : crtCurrentCont.uniqueResult());
session.close();
return currentNumOfCont;
}
@Override
public List<ConfidenceData> getDataInIntervalWithBin(String crisisCode, String attributeCode, String labelCode, Long timestamp1,
Long timestamp2, Integer bin) {
Criteria criteria = getCurrentSession().createCriteria(ConfidenceData.class);
Criterion criterion = Restrictions.conjunction()
.add(Restrictions.eq("crisisCode", crisisCode))
.add(Restrictions.eq("attributeCode", attributeCode))
.add(Restrictions.eq("labelCode", labelCode))
.add(Restrictions.ge("timestamp", timestamp1))
.add(Restrictions.le("timestamp", timestamp2))
.add(Restrictions.ge("bin", bin));
criteria.add(criterion);
try {
List<ConfidenceData> objList = (List<ConfidenceData>) criteria.list();
return objList;
} catch (HibernateException e) {
logger.error("exception", e);
e.printStackTrace();
}
return null;
}
public int getChannelMessagesCount(ChatChannel channel, String context, Date date) {
if (channel == null) {
// default to the first one
List<ChatChannel> channels = getContextChannels(context, true);
if (channels != null && channels.size() > 0) {
channel = channels.iterator().next();
}
}
int count = 0;
if (channel != null) {
Criteria c = this.getSessionFactory().getCurrentSession().createCriteria(ChatMessage.class);
c.add(Expression.eq("chatChannel", channel));
if (date != null) {
c.add(Expression.ge("messageDate", date));
}
c.setProjection(Projections.rowCount());
count = ((Long) c.uniqueResult()).intValue();
}
return count;
}
@Override
public List<ConfidenceData> getDataBeforeTimestampGranularityWithBin(String crisisCode, String attributeCode, String labelCode,
Long timestamp, Long granularity, Integer bin) {
Criteria criteria = getCurrentSession().createCriteria(ConfidenceData.class);
Criterion criterion = Restrictions.conjunction()
.add(Restrictions.eq("crisisCode", crisisCode))
.add(Restrictions.eq("attributeCode", attributeCode))
.add(Restrictions.eq("labelCode", labelCode))
.add(Restrictions.le("timestamp", timestamp))
.add(Restrictions.eq("granularity", granularity))
.add(Restrictions.ge("bin", bin));
criteria.add(criterion);
try {
List<ConfidenceData> objList = (List<ConfidenceData>) criteria.list();
return objList;
} catch (HibernateException e) {
logger.error("exception", e);
e.printStackTrace();
}
return null;
}
@SuppressWarnings("unchecked")
private static List<TimeseriesFeed> findTimeseriesFeedsWith(TimeseriesMetadata timeseriesMetadata, Session session) {
Criteria criteria = session.createCriteria(TimeseriesFeed.class);
List<TimeseriesFeed> timeseriesFeeds = criteria
.add(Restrictions.eq("timeseriesId", timeseriesMetadata.getTimeseriesId()))
// .add(Restrictions.eq("serviceUrl", timeseriesMetadata.getServiceUrl()))
// .add(Restrictions.eq("phenomenon", timeseriesMetadata.getPhenomenon()))
// .add(Restrictions.eq("procedure", timeseriesMetadata.getProcedure()))
// .add(Restrictions.eq("offering", timeseriesMetadata.getOffering()))
// .add(Restrictions.eq("featureOfInterest", timeseriesMetadata.getFeatureOfInterest()))
.list();
return timeseriesFeeds;
}
@Override
protected Collection<ProbandListEntry> handleFindByTrialProbandDepartment(
Long trialId, Long probandDepartmentId) throws Exception {
org.hibernate.Criteria listEntryCriteria = createListEntryCriteria();
if (trialId != null) {
listEntryCriteria.add(Restrictions.eq("trial.id", trialId.longValue()));
}
if (probandDepartmentId != null) {
listEntryCriteria.createCriteria("proband", CriteriaSpecification.INNER_JOIN).add(Restrictions.eq("department.id", probandDepartmentId.longValue()));
}
return listEntryCriteria.list();
}
@Override
public List<E> findUniqueByCriteria(Criterion criterion, String uniqueField) {
Criteria criteria = getCurrentSession().createCriteria(entityClass);
criteria.add(criterion);
criteria.setProjection(Projections.distinct(Projections.property(uniqueField)));
return criteria.list();
}
@Override
public List<ConfidenceData> getDataByCrisis(String crisisCode) {
Criteria criteria = getCurrentSession().createCriteria(ConfidenceData.class);
criteria.add(Restrictions.eq("crisisCode", crisisCode));
try {
List<ConfidenceData> objList = (List<ConfidenceData>) criteria.list();
return objList;
} catch (HibernateException e) {
logger.error("exception", e);
e.printStackTrace();
}
return null;
}
@Override
public List<UserConnection> getByUserIdAndProviderUserId(String userId,
String providerUserId) {
Criteria criteria = getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(UserConnection.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.eq("providerUserId", providerUserId));
return criteria.list();
}
public Optional<ServerBackup> lastSuccessfulBackup() {
List results = (List) getHibernateTemplate().execute((HibernateCallback) session -> {
Criteria criteria = session.createCriteria(ServerBackup.class);
criteria.add(Restrictions.eq("status", BackupStatus.COMPLETED));
criteria.setMaxResults(1);
criteria.addOrder(Order.desc("id"));
return criteria.list();
});
return results.isEmpty() ? Optional.empty() : Optional.of((ServerBackup) results.get(0));
}
@Override
public Criteria setProjection(Projection projection) {
CriteriaImpl.this.projection = projection;
CriteriaImpl.this.projectionCriteria = this;
setResultTransformer(PROJECTION);
return this;
}
private void createCriteriaSQLAliasMap() {
int i = 0;
for(final Criteria crit : criteriaInfoMap.keySet()){
final CriteriaInfoProvider value = criteriaInfoMap.get( crit );
String alias = crit.getAlias();
if ( alias == null ) {
// the entity name
alias = value.getName();
}
criteriaSQLAliasMap.put( crit, StringHelper.generateAlias( alias, i++ ) );
}
criteriaSQLAliasMap.put( rootCriteria, rootSQLAlias );
}
@Override
public Collection findByCode(String code) {
Criteria criteria = getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(Collection.class);
criteria.add(Restrictions.eq("code", code));
try {
return (Collection) criteria.uniqueResult();
} catch (HibernateException e) {
logger.error("Hibernate exception while finding a collection by code: "+code + "/t"+e.getStackTrace());
return null;
}
}
@Override
public String toSqlString(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
final String[] columns = criteriaQuery.findColumns( propertyName, criteria );
final Type type = criteriaQuery.getTypeUsingProjection( criteria, propertyName );
final StringBuilder fragment = new StringBuilder();
if ( columns.length > 1 ) {
fragment.append( '(' );
}
final SessionFactoryImplementor factory = criteriaQuery.getFactory();
final int[] sqlTypes = type.sqlTypes( factory );
for ( int i = 0; i < columns.length; i++ ) {
final boolean lower = ignoreCase && (sqlTypes[i] == Types.VARCHAR || sqlTypes[i] == Types.CHAR ||
sqlTypes[i] == Types.NVARCHAR || sqlTypes[i] == Types.NCHAR);
if ( lower ) {
fragment.append( factory.getDialect().getLowercaseFunction() ).append( '(' );
}
fragment.append( columns[i] );
if ( lower ) {
fragment.append( ')' );
}
fragment.append( getOp() ).append( "?" );
if ( i < columns.length - 1 ) {
fragment.append( " and " );
}
}
if ( columns.length > 1 ) {
fragment.append( ')' );
}
return fragment.toString();
}
@Deprecated
@SuppressWarnings("unchecked")
public static List<ComplexRule> searchOwnComplex(String userID, String row, String text) {
Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();
Criteria crit = session.createCriteria(ComplexRule.class);
List<ComplexRule> rules = crit.add(Restrictions.and(Restrictions.eq(OWNER_ID, Integer.valueOf(userID)),
Restrictions.ilike(row, text))).list();
session.getTransaction().commit();
return rules;
}
public Optional<ContentReviewItem> findByProviderAndExternalId(Integer providerId, String externalId) {
Criteria c = sessionFactory.getCurrentSession()
.createCriteria(ContentReviewItem.class)
.add(Restrictions.eq("providerId", providerId))
.add(Restrictions.eq("externalId", externalId));
return Optional.ofNullable((ContentReviewItem) c.uniqueResult());
}
public void deleteMappings(final Site aSite) {
// Run the deletion.
txTemplate.execute(
new TransactionCallback() {
@SuppressWarnings("unchecked")
public Object doInTransaction(TransactionStatus ts) {
try {
Criteria query = getSession().createCriteria(Mapping.class);
query.createCriteria("permission")
.createCriteria("site")
.add(Restrictions.eq("oid", aSite.getOid()));
List<Mapping> mappings = query.list();
for(Mapping m: mappings) {
getSession().delete(m);
}
}
catch(Exception ex) {
log.debug("Setting Rollback Only", ex);
ts.setRollbackOnly();
}
return null;
}
}
);
// Clear the session to evict anything
// that we don't want hanging around.
getSession().clear();
}
@Override
public String toSqlString(Criteria criteria, int loc, CriteriaQuery criteriaQuery) throws HibernateException {
final StringBuilder buf = new StringBuilder();
String separator = "";
for ( Projection projection : elements ) {
buf.append( separator ).append( projection.toSqlString( criteria, loc, criteriaQuery ) );
loc += getColumnAliases( loc, criteria, criteriaQuery, projection ).length;
separator = ", ";
}
return buf.toString();
}
@SuppressWarnings("unchecked")
public static List<Subscription> getUserSubscriptions(String userID) {
Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();
Criteria crit = session.createCriteria(Subscription.class);
List<Subscription> subscriptions = crit.add(Restrictions.eq(USER_ID, Integer.valueOf(userID))).list();
session.getTransaction().commit();
return subscriptions;
}
@Deprecated
@SuppressWarnings("unchecked")
public static void updateComplexRuleSubscribtion(String ruleName, boolean subscribed) {
Session session = getSessionFactory().getCurrentSession();
session.beginTransaction();
Criteria crit = session.createCriteria(ComplexRule.class);
List<ComplexRule> rules = crit.add(Restrictions.eq(RULE_NAME, ruleName)).list();
if (rules.size() == 1) {
ComplexRule rule = rules.get(0);
rule.setSubscribed(subscribed);
session.saveOrUpdate(rule);
}
session.getTransaction().commit();
}
public JobRun getLatestJobRun() throws Exception {
JobRun r = getHibernateTemplate().execute(session -> {
JobRun jobRun = null;
Criteria c = session.createCriteria(JobRunImpl.class);
c.setMaxResults(1);
c.addOrder(Order.desc("id"));
List jobs = c.list();
if(jobs != null && jobs.size() > 0){
jobRun = (JobRun) jobs.get(0);
}
return jobRun;
});
return r;
}
/**
* Lookup a {@link SCCSubscriptionJson} object for given sccId.
* @param id the scc id
* @return SCC Subscription or null
*/
public static SCCSubscription lookupSubscriptionBySccId(Long id) {
if (id == null) {
return null;
}
Session session = getSession();
Criteria c = session.createCriteria(SCCSubscription.class);
c.add(Restrictions.eq("sccId", id));
return (SCCSubscription) c.uniqueResult();
}
@Override
public Boolean exist(String code) {
Criteria criteria = getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(Collection.class);
criteria.add(Restrictions.eq("code", code));
criteria.add(Restrictions.ne("status", CollectionStatus.TRASHED));
Collection collection = (Collection) criteria.uniqueResult();
return collection != null;
}