import io.requery.Entity; //导入依赖的package包/类
@Override
public String modelName() {
    // it's important that the AnnotationMirror is used here since the model name needs to be
    // known before process() is called
    if (Mirrors.findAnnotationMirror(element(), Entity.class).isPresent()) {
        return Mirrors.findAnnotationMirror(element(), Entity.class)
                .flatMap(mirror -> Mirrors.findAnnotationValue(mirror, "model"))
                .map(value -> value.getValue().toString())
                .filter(name -> !Names.isEmpty(name))
                .orElse("default");
    } else if (Mirrors.findAnnotationMirror(element(),
            javax.persistence.Entity.class).isPresent()) {
        Elements elements = processingEnvironment.getElementUtils();
        Name packageName = elements.getPackageOf(element()).getQualifiedName();
        String[] parts = packageName.toString().split("\\.");
        return parts[parts.length - 1];
    }
    return "";
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public Optional<TypeMirror> builderType() {
    Optional<Entity> entityAnnotation = annotationOf(Entity.class);
    if (entityAnnotation.isPresent()) {
        Entity entity = entityAnnotation.get();
        Elements elements = processingEnvironment.getElementUtils();
        TypeMirror mirror = null;
        try {
            Class<?> builderClass = entity.builder(); // easiest way to get the class TypeMirror
            if (builderClass != void.class) {
                mirror = elements.getTypeElement(builderClass.getName()).asType();
            }
        } catch (MirroredTypeException typeException) {
            mirror = typeException.getTypeMirror();
        }
        if (mirror != null && mirror.getKind() != TypeKind.VOID) {
            return Optional.of(mirror);
        }
    }
    if (builderFactoryMethod().isPresent()) {
        return Optional.of(builderFactoryMethod().get().getReturnType());
    }
    return ElementFilter.typesIn(element().getEnclosedElements()).stream()
            .filter(element -> element.getSimpleName().toString().contains("Builder"))
            .map(Element::asType)
            .filter(Objects::nonNull)
            .filter(type -> type.getKind() != TypeKind.VOID)
            .findFirst();
}
 

import io.requery.Entity; //导入依赖的package包/类
private boolean isEntity(TypeElement element) {
    return Mirrors.findAnnotationMirror(element, Entity.class).isPresent() ||
        (getOption(GENERATE_JPA, true) &&
         Mirrors.findAnnotationMirror(element, javax.persistence.Entity.class).isPresent());
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public PropertyNameStyle propertyNameStyle() {
    return annotationOf(Entity.class)
            .map(Entity::propertyNameStyle)
            .orElse(PropertyNameStyle.BEAN);
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public PropertyVisibility propertyVisibility() {
    return annotationOf(Entity.class)
            .map(Entity::propertyVisibility)
            .orElse(PropertyVisibility.PRIVATE);
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public boolean isCacheable() {
    return annotationOf(Entity.class).map(Entity::cacheable)
        .orElse( annotationOf(Cacheable.class).map(Cacheable::value).orElse(true));
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public boolean isCopyable() {
    return annotationOf(Entity.class).map(Entity::copyable).orElse(false);
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public boolean isImmutable() {
    // check known immutable type annotations then check the annotation value
    return ImmutableAnnotationKind.of(element()).isPresent() || isUnimplementable() ||
            annotationOf(Entity.class).map(Entity::immutable).orElse(false);
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public boolean isStateless() {
    return isImmutable() || isUnimplementable() ||
        annotationOf(Entity.class).map(Entity::stateless).orElse(false);
}
 

import io.requery.Entity; //导入依赖的package包/类
@Override
public boolean isUnimplementable() {
    boolean extendable = annotationOf(Entity.class).map(Entity::extendable).orElse(true);
    return !extendable || (element().getKind().isClass() &&
        element().getModifiers().contains(Modifier.FINAL));
}