import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public JoinDescription singlePath(EntityPath<?> path) {
    Assert.notNull(path);

    singlePath = path;
    collectionPath = null;
    return this;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
/**
 * Add children joins to current join from specified paths
 *
 * @param paths children join paths
 * @return current join
 */
public JoinDescription nested(EntityPath<?>... paths) {
    for (EntityPath<?> path : paths) {
        JoinDescription join = J.left(path);
        join.parent = this;
        join.alias(J.path(this.getAlias(), join.getOriginalAlias()));
        addJoin(join);
    }

    return this;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@Override
public JoinerQueryBase<T, R> joins(EntityPath<?>... paths) {
    for (EntityPath<?> path : paths) {
        Assert.notNull(path);

        addJoin(J.left(path));
    }

    return this;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T extends EntityPath> T instantiate(Class<? extends EntityPath> generatedClass, String alias) {
    Assert.notNull(generatedClass);

    try {
        Constructor<? extends EntityPath> constructor = generatedClass.getConstructor(String.class);
        return (T) constructor.newInstance(alias);
    } catch (Exception e) {
        throw new JoinerException("Failed to create new instance of " + generatedClass, e);
    }
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void resolveJoinAlias(JoinDescription join, EntityPath<?> root) {
    Path<?> parent = join.getParent() != null ? join.getParent().getAlias() : root;

    Path<?> fieldOnParent = findPathOnParent(parent, join.getAlias().getType(), join);
    if (fieldOnParent instanceof CollectionPathBase) {
        join.collectionPath((CollectionPathBase<?, ?, ?>) fieldOnParent);
    } else if (fieldOnParent instanceof EntityPath) {
        join.singlePath((EntityPath<?>) fieldOnParent);
    } else {
        throw new JoinerException("Target field not found for join " + join);
    }
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
private void addJoins(List<JoinDescription> joins, JPAQuery query, EntityPath<?> rootPath, boolean doFetch) {
    for (JoinDescription join : joins) {
        joinerVendorRepository.addJoin(query, join);
        if (doFetch && join.isFetch()) {
            if (join.getJoinType().equals(JoinType.RIGHTJOIN)) {
                throw new JoinerException("Fetch is not supported for right join!");
            }
            joinerVendorRepository.addFetch(query, join, joins, rootPath);
        }
    }
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@Override
public void addFetch(JPAQuery query, JoinDescription joinDescription, Collection<JoinDescription> joins, EntityPath<?> rootPath) {
    String rootEntityAlias = rootPath.getMetadata().getName();
    String path = resolvePathToFieldFromRoot(rootEntityAlias, joinDescription, joins);

    String fetchHint = joinDescription.getJoinType().equals(com.mysema.query.JoinType.LEFTJOIN) ? "eclipselink.left-join-fetch" : "eclipselink.join-fetch";
    query.setHint(fetchHint, path);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@Test
@Transactional
public void testQuery() throws Exception {

	springfieldQueryTemplateRepository.save(new SpringfieldQueryTemplate("a", 1));
	springfieldQueryTemplateRepository.save(new SpringfieldQueryTemplate("b", 2));
	springfieldQueryTemplateRepository.save(new SpringfieldQueryTemplate("c", 3));
	
	List<SpringfieldQueryTemplate> result = springfieldQueryTemplateRepository.execute(
		new TemplateCallback<List<SpringfieldQueryTemplate>, EntityManager>() {
			public List<SpringfieldQueryTemplate> doInTemplate(EntityManager em) {

				//Using QueryDsl
				SpringfieldQueryTemplate alias = Alias.alias(SpringfieldQueryTemplate.class, "foo");
				EntityPath<SpringfieldQueryTemplate> foo = Alias.$(alias);
				StringPath fooName = Alias.$(alias.getName());
				NumberPath<Integer> fooAge = Alias.$(alias.getAge());
				
				JPAQuery query = new JPAQuery(em);
				query.from(foo);
				query.where(fooName.eq("a"));
				query.where(fooAge.eq(1));

				return query.list(foo);
			}
	});
	Assert.assertEquals(result.size(), 1);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
@Test
public void testResolveEntityPath() throws Exception {
	EntityPathResolver entityPathResolver = new EntityPathResolver();
	EntityPath<Person> entityPath = entityPathResolver.resolveEntityPath(Person.class);
	assertNotNull(entityPath);
	assertThat(entityPath.getType()).isEqualTo(Person.class);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
protected <K> GridDataSource createGridDataSource(final EntityPath<K> path,
        final OrderSpecifier<?> order, final boolean caseSensitive, final Predicate filters) {
    return new JPQLGridDataSource<K>(getSessionManager(), path, order, caseSensitive, filters);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public JPQLGridDataSource(HibernateSessionManager sessionManager,
        EntityPath<?> path, OrderSpecifier<?> order, boolean caseSensitive,
        Predicate filters) {
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
protected QueryDslContext(EntityPath entityPath, Map<String, Expression> queryPaths, Map<String,
        Expression> projectionPaths) {
    this.entityPath = entityPath;
    this.queryPaths = queryPaths;
    this.projectionPaths = projectionPaths;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public static Builder from(EntityPath type) {
    return new Builder(type);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public EntityPath getEntityPath() {
    return entityPath;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public Builder(EntityPath entityPath) {
    this.entityPath = entityPath;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public TupleJoinerQuery(EntityPath<T> from, Expression<?>... returnProjections) {
    super(from);
    this.returnProjections = returnProjections;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public JoinDescription(EntityPath<?> alias) {
    Assert.notNull(alias);

    originalAlias = alias;
    alias(alias);
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public EntityPath<?> getAlias() {
    return alias;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public EntityPath<?> getOriginalAlias() {
    return originalAlias;
}
 

import com.mysema.query.types.EntityPath; //导入依赖的package包/类
public EntityPath<?> getSinglePath() {
    return singlePath;
}