import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
private Predicate buildPropertyRestriction(
		MapJoin<PersistentTemplate, String, String> propertiesMap,
		Map<String, String> someProperties) {
	Path<?> keyPath = propertiesMap.key();
	Path<?> valuePath = propertiesMap.value();
	List<Predicate> keyValuePairs = new LinkedList<Predicate>();
	for (Map.Entry<String, String> entry : someProperties.entrySet()) {
		Predicate keyPredicate = criteriaBuilder.equal(keyPath,
				entry.getKey());
		Predicate valuePredicate = criteriaBuilder.equal(valuePath,
				entry.getValue());
		Predicate keyValuePair = criteriaBuilder.and(keyPredicate,
				valuePredicate);
		keyValuePairs.add(keyValuePair);
	}
	return criteriaBuilder.or(keyValuePairs
			.toArray(new Predicate[keyValuePairs.size()]));
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Predicate mapToMapPredicate(final ComparisonNode node, final Path<Object> fieldPath,
        final A enumField) {
    if (!enumField.isMap()) {
        return null;
    }
    final String[] graph = node.getSelector().split("\\" + FieldNameProvider.SUB_ATTRIBUTE_SEPERATOR);
    final String keyValue = graph[graph.length - 1];
    if (fieldPath instanceof MapJoin) {
        // Currently we support only string key .So below cast is safe.
        return cb.equal(cb.upper((Expression<String>) (((MapJoin<?, ?, ?>) fieldPath).key())),
                keyValue.toUpperCase());
    }

    return cb.equal(cb.upper(fieldPath.get(enumField.getKeyFieldName())), keyValue.toUpperCase());
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public Expression<?> joinMapValue(Expression<?> currentCriteriaPath, MetaAttribute pathElement, Object key) {
	MapJoin<Object, Object, Object> mapJoin = ((From<?, ?>) currentCriteriaPath).joinMap(pathElement.getName(),
			JoinType.LEFT);
	Predicate mapJoinCondition = cb.equal(mapJoin.key(), key);
	Predicate nullCondition = cb.isNull(mapJoin.key());
	addPredicate(cb.or(mapJoinCondition, nullCondition));
	return mapJoin;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
public List<Object> findMapJoin() {
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Object> c = cb.createQuery();
    Root<Employee> emp = c.from(Employee.class);
    EntityType<Employee> emp_ = emp.getModel();
    MapJoin<Employee, String, Phone> phone = emp.join(emp_.getMap("phones", String.class, Phone.class));
    c.multiselect(emp.get(emp_.getSingularAttribute("name", String.class)), phone.key(), phone.value());

    return em.createQuery(c).getResultList();
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
public WordTemplateQuery hasProperties(Map<String, String> someProperties) {
	Subquery<Long> subQuery = query.subquery(Long.class);
	Root<PersistentTemplate> fromSubQuery = subQuery
			.from(PersistentTemplate.class);
	Path<Long> id = fromSubQuery.get("id");
	subQuery.select(id);
	MapJoin<PersistentTemplate, String, String> propertiesMap = fromSubQuery
			.joinMap("properties", JoinType.INNER);
	subQuery.where(buildPropertyRestriction(propertiesMap, someProperties));
	subQuery.groupBy(id);
	subQuery.having(criteriaBuilder.equal(criteriaBuilder.count(id),
			someProperties.size()));
	restrictions.add(persistentTemplate.get("id").in(subQuery));
	return this;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public <K, V> MapJoin<X, K, V> join(MapAttribute<? super X, K, V> map) {
	// TODO Auto-generated method stub
	return null;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public <X, K, V> MapJoin<X, K, V> joinMap(String attributeName) {
	// TODO Auto-generated method stub
	return null;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public <X, K, T, V extends T> MapJoin<X, K, V> treat(MapJoin<X, K, T> join,
		Class<V> type) {
	// TODO Auto-generated method stub
	return null;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
	@SuppressWarnings("unchecked")
	public <X, K, T, V extends T> MapJoin<X, K, V> treat(MapJoin<X, K, T> join, Class<V> type) {
//		return ( (MapJoinImplementor) join ).treatAs( type );
		throw new NotYetImplementedException(  );
	}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public <K, V> MapJoin<T, K, V> join( MapAttribute<? super T, K, V> arg0 )
{
	// TODO Auto-generated method stub
	return null;
}
 

import javax.persistence.criteria.MapJoin; //导入依赖的package包/类
@Override
public <X, K, V> MapJoin<X, K, V> joinMap( String arg0 )
{
	// TODO Auto-generated method stub
	return null;
}