Java NamedQuery类代码示例

import javax.persistence.NamedQuery; //导入依赖的package包/类
private NamedQueries getNamedQueries(Element tree, XMLContext.Default defaults) {
	//TODO avoid the Proxy Creation (@NamedQueries) when possible
	List<NamedQuery> queries = (List<NamedQuery>) buildNamedQueries( tree, false, defaults );
	if ( defaults.canUseJavaAnnotations() ) {
		NamedQuery annotation = getPhysicalAnnotation( NamedQuery.class );
		addNamedQueryIfNeeded( annotation, queries );
		NamedQueries annotations = getPhysicalAnnotation( NamedQueries.class );
		if ( annotations != null ) {
			for ( NamedQuery current : annotations.value() ) {
				addNamedQueryIfNeeded( current, queries );
			}
		}
	}
	if ( queries.size() > 0 ) {
		AnnotationDescriptor ad = new AnnotationDescriptor( NamedQueries.class );
		ad.setValue( "value", queries.toArray( new NamedQuery[queries.size()] ) );
		return AnnotationFactory.create( ad );
	}
	else {
		return null;
	}
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
private void addNamedQueryIfNeeded(NamedQuery annotation, List<NamedQuery> queries) {
	if ( annotation != null ) {
		String queryName = annotation.name();
		boolean present = false;
		for ( NamedQuery current : queries ) {
			if ( current.name().equals( queryName ) ) {
				present = true;
				break;
			}
		}
		if ( !present ) {
			queries.add( annotation );
		}
	}
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public LockOptions determineLockOptions(NamedQuery namedQueryAnnotation) {
	LockModeType lockModeType = namedQueryAnnotation.lockMode();
	Integer lockTimeoutHint = getInteger( namedQueryAnnotation.name(), "javax.persistence.lock.timeout" );

	LockOptions lockOptions = new LockOptions( LockModeConverter.convertToLockMode( lockModeType ) );
	if ( lockTimeoutHint != null ) {
		lockOptions.setTimeOut( lockTimeoutHint );
	}

	return lockOptions;
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public static void bindQuery(NamedQuery queryAnn, Mappings mappings, boolean isDefault) {
	if ( queryAnn == null ) return;
	if ( BinderHelper.isEmptyAnnotationValue( queryAnn.name() ) ) {
		throw new AnnotationException( "A named query must have a name when used in class or package level" );
	}
	//EJBQL Query
	QueryHintDefinition hints = new QueryHintDefinition( queryAnn.hints() );
	String queryName = queryAnn.query();
	NamedQueryDefinition queryDefinition = new NamedQueryDefinitionBuilder( queryAnn.name() )
			.setLockOptions( hints.determineLockOptions( queryAnn ) )
			.setQuery( queryName )
			.setCacheable( hints.getBoolean( queryName, QueryHints.CACHEABLE ) )
			.setCacheRegion( hints.getString( queryName, QueryHints.CACHE_REGION ) )
			.setTimeout( hints.getTimeout( queryName ) )
			.setFetchSize( hints.getInteger( queryName, QueryHints.FETCH_SIZE ) )
			.setFlushMode( hints.getFlushMode( queryName ) )
			.setCacheMode( hints.getCacheMode( queryName ) )
			.setReadOnly( hints.getBoolean( queryName, QueryHints.READ_ONLY ) )
			.setComment( hints.getString( queryName, QueryHints.COMMENT ) )
			.setParameterTypes( null )
			.createNamedQueryDefinition();

	if ( isDefault ) {
		mappings.addDefaultQuery( queryDefinition.getName(), queryDefinition );
	}
	else {
		mappings.addQuery( queryDefinition.getName(), queryDefinition );
	}
	if ( LOG.isDebugEnabled() ) {
		LOG.debugf( "Binding named query: %s => %s", queryDefinition.getName(), queryDefinition.getQueryString() );
	}
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public Object createNamedQuery(Objectref objRef) {
	String namedQuery = getStringFromObjectref(objRef);
	for(Class<?> entityClass : managedEntityClasses) {
		if(entityClass.isAnnotationPresent(NamedQuery.class)) {
			if(entityClass.getAnnotation(NamedQuery.class).name().equals(namedQuery)) {
				String jpqlQueryString = entityClass.getAnnotation(NamedQuery.class).query();
				return hqlAnalyzer.getQLSelectStatement(jpqlQueryString, null);
			}
		}
	}
	return null;
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public void testEntityAnnotation() throws Exception {

		Assert.assertNotNull(IssueHJIII100Type.class
				.getAnnotation(NamedQuery.class));

		Assert.assertEquals(
				1,
				IssueHJIII100Type.class.getAnnotation(NamedQuery.class).hints().length);
	}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public String getQueryString(String namedQueryName) {
	NamedQueries namedQueries = (NamedQueries) entityClass.getAnnotation(NamedQueries.class);
	for (NamedQuery namedQuery : namedQueries.value()) {
		if (namedQuery.name().equals(namedQueryName)) return namedQuery.query();
	}
	throw new QueryException("Named query " + namedQueryName + " not found in class " + entityClass.getName());
}
 

import javax.persistence.NamedQuery; //导入依赖的package包/类
public static void bindQueries(NamedQueries queriesAnn, Mappings mappings, boolean isDefault) {
	if ( queriesAnn == null ) return;
	for (NamedQuery q : queriesAnn.value()) {
		bindQuery( q, mappings, isDefault );
	}
}