import javax.persistence.metamodel.Type; //导入依赖的package包/类
public Attribute<?, ?> filter() {
    Type<?> type = forModel(metamodel).filter(rootType);
    Attribute<?, ?> result = null;
    for (int i = 1; i < pathElements.length; i++) {
        if (!(type instanceof ManagedType)) {
            throw new PersistenceException("Cannot navigate through simple property "
                    + pathElements[i] + " of type " + type.getJavaType());
        }
        result = ((ManagedType<?>)type).getAttribute(pathElements[i]);
        if (result.isCollection()) {
            type = ((PluralAttribute<?, ?, ?>)result).getElementType();
        } else {
            type = ((SingularAttribute<?, ?>)result).getType();
        }
    }
    return result;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
public static Type toType(Bindable bindable) {
	switch ( bindable.getBindableType() ) {
		case ENTITY_TYPE: {
			return (EntityType) bindable;
		}
		case SINGULAR_ATTRIBUTE: {
			return ( (SingularAttribute) bindable ).getType();
		}
		case PLURAL_ATTRIBUTE: {
			return ( (PluralAttribute) bindable ).getElementType();
		}
		default: {
			throw new ParsingException( "Unexpected Bindable type : " + bindable );
		}
	}
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<?> getIdType() {
	if ( getHierarchy().getIdentifierDescriptor() instanceof IdentifierDescriptorSingleAttribute ) {
		final SingularAttribute idAttribute = ( (IdentifierDescriptorSingleAttribute) getHierarchy().getIdentifierDescriptor() )
				.getIdAttribute();
		if ( idAttribute instanceof SingularAttributeBasic ) {
			return ( (SingularAttributeBasic) idAttribute ).getOrmType();
		}
		else if ( idAttribute instanceof SingularAttributeEmbedded ) {
			return ( (SingularAttributeEmbedded) idAttribute ).getEmbeddablePersister();
		}
		else {
			throw new IllegalStateException( "Expected BASIC or EMBEDDED attribute type for identifier" );
		}
	}
	return null;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<java.lang.String> getElementType() {
  return new Type<java.lang.String>() {

    @Override
    public Class<java.lang.String> getJavaType() {
      return java.lang.String.class;
    }

    @Override
    public javax.persistence.metamodel.Type.PersistenceType getPersistenceType() {
      return null;
    }

  };
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
private Path getSelectedPath(int index, javax.persistence.criteria.Path<?> path) {
    if (path.getParentPath() != null) {
        Type<?> type = getType(path.getModel());
        if (type.getPersistenceType() == PersistenceType.BASIC
            || type.getPersistenceType() == PersistenceType.EMBEDDABLE) {
            return getSelectedPath(index, path.getParentPath());
        }
        return getSelectedPath(index, path.getParentPath()).append(getName(path.getModel()));
    }
    if (path.getAlias() == null) {
        path.alias("alias" + index);
    }
    return new Path(path.getAlias());
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
private Class<?> getSelectedType(javax.persistence.criteria.Path<?> path) {
    Type<?> type = getType(path.getModel());
    if (type.getPersistenceType() == PersistenceType.BASIC
        || type.getPersistenceType() == PersistenceType.EMBEDDABLE) {
        return getSelectedType(path.getParentPath());
    } else {
        return type.getJavaType();
    }
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <R> Type<R> getElementType(Attribute<?, ?> attr) {
    if (attr instanceof SingularAttribute) {
        return ((SingularAttribute<?,R>) attr).getType();
    } else {
        return ((PluralAttribute<?,?,R>)attr).getElementType();
    }
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
public static Set<Class> getSubclasses(Class<?> parent, EntityManager entityManager) {
    return entityManager.getMetamodel().getEntities().stream()
            .filter(entityType -> parent != entityType.getJavaType() && parent.isAssignableFrom(entityType.getJavaType()))
            .map(Type::getJavaType)
            .collect(Collectors.toCollection(HashSet::new));
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Before
public void initialize() throws ParseException, NoSuchMethodException {
    Metamodel metamodel = mock(Metamodel.class);
    SecurePersistenceUnitUtil persistenceUnitUtil = mock(SecurePersistenceUnitUtil.class);
    accessManager = mock(DefaultAccessManager.class);
    SecurityContext securityContext = mock(SecurityContext.class);
    EntityType entityType = mock(EntityType.class);
    SingularAttribute idAttribute = mock(SingularAttribute.class);
    SingularAttribute nameAttribute = mock(SingularAttribute.class);
    SingularAttribute parentAttribute = mock(SingularAttribute.class);
    PluralAttribute childrenAttribute = mock(PluralAttribute.class);
    MapAttribute relatedAttribute = mock(MapAttribute.class);
    Type integerType = mock(Type.class);
    when(metamodel.getEntities()).thenReturn(Collections.<EntityType<?>>singleton(entityType));
    when(metamodel.managedType(MethodAccessTestBean.class)).thenReturn(entityType);
    when(metamodel.entity(MethodAccessTestBean.class)).thenReturn(entityType);
    when(accessManager.getContext()).thenReturn(securityContext);
    when(securityContext.getAliases()).thenReturn(Collections.singleton(CURRENT_PRINCIPAL));
    when(securityContext.getAliasValue(CURRENT_PRINCIPAL)).thenReturn(NAME);
    when(entityType.getName()).thenReturn(MethodAccessTestBean.class.getSimpleName());
    when(entityType.getJavaType()).thenReturn((Class)MethodAccessTestBean.class);
    when(entityType.getAttributes()).thenReturn(new HashSet(Arrays.asList(
            idAttribute, nameAttribute, parentAttribute, childrenAttribute, relatedAttribute)));
    when(entityType.getAttribute("id")).thenReturn(idAttribute);
    when(entityType.getAttribute("name")).thenReturn(nameAttribute);
    when(entityType.getAttribute("parent")).thenReturn(parentAttribute);
    when(entityType.getAttribute("children")).thenReturn(childrenAttribute);
    when(entityType.getAttribute("related")).thenReturn(relatedAttribute);
    when(idAttribute.getName()).thenReturn("id");
    when(idAttribute.isCollection()).thenReturn(false);
    when(idAttribute.getType()).thenReturn(integerType);
    when(idAttribute.getPersistentAttributeType()).thenReturn(PersistentAttributeType.BASIC);
    when(idAttribute.getJavaType()).thenReturn(Integer.TYPE);
    when(idAttribute.getJavaMember()).thenReturn(MethodAccessTestBean.class.getDeclaredMethod("getId"));
    when(nameAttribute.getName()).thenReturn("name");
    when(nameAttribute.isCollection()).thenReturn(false);
    when(nameAttribute.getType()).thenReturn(integerType);
    when(nameAttribute.getPersistentAttributeType()).thenReturn(PersistentAttributeType.BASIC);
    when(nameAttribute.getJavaType()).thenReturn(String.class);
    when(nameAttribute.getJavaMember()).thenReturn(MethodAccessTestBean.class.getDeclaredMethod("getName"));
    when(parentAttribute.getName()).thenReturn("parent");
    when(parentAttribute.isCollection()).thenReturn(false);
    when(parentAttribute.getType()).thenReturn(entityType);
    when(parentAttribute.getPersistentAttributeType()).thenReturn(PersistentAttributeType.MANY_TO_ONE);
    when(parentAttribute.getJavaType()).thenReturn(MethodAccessTestBean.class);
    when(parentAttribute.getJavaMember()).thenReturn(MethodAccessTestBean.class.getDeclaredMethod("getParent"));
    when(childrenAttribute.getName()).thenReturn("children");
    when(childrenAttribute.isCollection()).thenReturn(true);
    when(childrenAttribute.getElementType()).thenReturn(entityType);
    when(childrenAttribute.getJavaMember())
        .thenReturn(MethodAccessTestBean.class.getDeclaredMethod("getChildren"));
    when(relatedAttribute.getName()).thenReturn("related");
    when(relatedAttribute.isCollection()).thenReturn(true);
    when(relatedAttribute.getKeyJavaType()).thenReturn(MethodAccessTestBean.class);
    when(relatedAttribute.getBindableJavaType()).thenReturn(MethodAccessTestBean.class);
    when(relatedAttribute.getElementType()).thenReturn(entityType);
    when(relatedAttribute.getJavaMember())
        .thenReturn(MethodAccessTestBean.class.getDeclaredMethod("getRelated"));

    entityFilter = new EntityFilter(metamodel, persistenceUnitUtil, initializeAccessRules(metamodel));
    DefaultAccessManager.Instance.register(accessManager);
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public Type<E> getElementType() {
	return getElementDescriptor();
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type getType() {
	return getEmbeddablePersister();
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type getType() {
	return getOrmType();
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<?> getIdType() {
  return null;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public javax.persistence.metamodel.Type.PersistenceType getPersistenceType() {
  return null;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<T> getType() {
  return null;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<String> getElementType() {
  // TODO Auto-generated method stub
  return null;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public Type<java.lang.String> getElementType() {
  return new ElementType();
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@Override
public javax.persistence.metamodel.Type.PersistenceType getPersistenceType() {
  return PersistenceType.BASIC;
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
/**
 * Parse an @Entity
 *
 * @param entityFactory
 * @param metadata
 * @param sessionFactory
 */
void parse(QEntityFactory entityFactory, EntityType<?> metadata, SessionFactoryImplementor sessionFactory)
{
	this.metamodelEntity = metadata;
	this.name = metadata.getName();

	for (Attribute<?, ?> attribute : metadata.getAttributes())
	{
		parseFields(entityFactory, sessionFactory, null, attribute);
	}

	// Parse top-level properties

	// Add identifier property
	{
		if (!metadata.hasSingleIdAttribute())
			throw new IllegalArgumentException("@IdClass Entity not supported! " + metadata.getJavaType());

		Type idType = metadata.getIdType();

		switch (idType.getPersistenceType())
		{
			case BASIC:
				break; // No action necessary, will be processed like a normal field
			case EMBEDDABLE:
			{
				EmbeddableType<?> emb = (EmbeddableType<?>) idType;

				parseEmbeddable(entityFactory, sessionFactory, "id", emb);
				break;
			}
			default:
				throw new IllegalArgumentException("Cannot handle id type: " + idType.getPersistenceType() + ": " + idType);
		}
	}

	// Add links to descendants
	{
		final List<QEntity> descendants = entityFactory.getSubclasses(clazz);

		if (!descendants.isEmpty())
			this.descendants = descendants;
	}


	// Figure out the id method/field
	final String idPropertyName = getIdPropertyName();

	if (idPropertyName != null)
		this.idProperty = new PropertyWrapper(clazz, idPropertyName);
}
 

import javax.persistence.metamodel.Type; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <E2 extends IEntity<?>> RelationSetAttribute(SetAttribute<? super E, ? super E2> attribute, MetaJpaConstructor<? super E2, R, ?> constructor) {
    super((A)(Object)attribute, CollectionType.SET, (Type<R>)attribute.getElementType());
    this.constructor = (MetaJpaConstructor<? extends IEntity<?>, R, ?>) constructor;
}