java类org.hibernate.annotations.Cache的实例源码

public void setCache(Cache cacheAnn) {
    if ( cacheAnn != null ) {
        cacheRegion = BinderHelper.isEmptyAnnotationValue( cacheAnn.region() ) ?
                null :
                cacheAnn.region();
        cacheConcurrentStrategy = getCacheConcurrencyStrategy( cacheAnn.usage() );
        if ( "all".equalsIgnoreCase( cacheAnn.include() ) ) {
            cacheLazyProperty = true;
        }
        else if ( "non-lazy".equalsIgnoreCase( cacheAnn.include() ) ) {
            cacheLazyProperty = false;
        }
        else {
            throw new AnnotationException( "Unknown lazy property annotations: " + cacheAnn.include() );
        }
    }
    else {
        cacheConcurrentStrategy = null;
        cacheRegion = null;
        cacheLazyProperty = true;
    }
}

public AnnotationVisitor visitAnnotation(String arg0, boolean arg1) {
    Type annotationType = Type.getType(arg0);
    switch(stage) {
    case CLASSSTAGE: {
        if (annotationType.getClassName().equals(Cache.class.getName())){
            annotation = Cache.class.getName();
        }
        break;
    }
    case FIELDSTAGE: {
        if (annotationType.getClassName().equals(Id.class.getName())){
            idMutators.put(fieldName, retrieveMutators());
        }
        if (annotationType.getClassName().equals(Hydrated.class.getName())){
            annotation = Hydrated.class.getName();
        }
        break;
    }
    default : {
        annotation = null;
        fieldName = null;
        break;
    }
    }
    return this;
}

private static String getInheritanceHierarchyRoot(Class<?> myEntityClass) {
    String myEntityName = myEntityClass.getName();
    if (inheritanceHierarchyRoots.containsKey(myEntityName)) {
        return inheritanceHierarchyRoots.get(myEntityName);
    }
    Class<?> currentClass = myEntityClass;
    boolean eof = false;
    while (!eof) {
        Class<?> superclass = currentClass.getSuperclass();
        if (superclass.equals(Object.class) || !superclass.isAnnotationPresent(Entity.class)) {
            eof = true;
        } else {
            currentClass = superclass;
        }
    }

    if (!currentClass.isAnnotationPresent(Cache.class)) {
        currentClass = myEntityClass;
    }

    inheritanceHierarchyRoots.put(myEntityName, currentClass.getName());
    return inheritanceHierarchyRoots.get(myEntityName);
}

public AnnotationVisitor visitAnnotation(String arg0, boolean arg1) {
    Type annotationType = Type.getType(arg0);
    switch(stage) {
    case CLASSSTAGE: {
        if (annotationType.getClassName().equals(Cache.class.getName())){
            annotation = Cache.class.getName();
        }
        break;
    }
    case FIELDSTAGE: {
        if (annotationType.getClassName().equals(Id.class.getName())){
            idMutators.put(fieldName, retrieveMutators());
        }
        if (annotationType.getClassName().equals(Hydrated.class.getName())){
            annotation = Hydrated.class.getName();
        }
        break;
    }
    default : {
        annotation = null;
        fieldName = null;
        break;
    }
    }
    return this;
}

private static String getInheritanceHierarchyRoot(Class<?> myEntityClass) {
    String myEntityName = myEntityClass.getName();
    if (inheritanceHierarchyRoots.containsKey(myEntityName)) {
        return inheritanceHierarchyRoots.get(myEntityName);
    }
    Class<?> currentClass = myEntityClass;
    boolean eof = false;
    while (!eof) {
        Class<?> superclass = currentClass.getSuperclass();
        if (superclass.equals(Object.class) || !superclass.isAnnotationPresent(Entity.class)) {
            eof = true;
        } else {
            currentClass = superclass;
        }
    }

    if (!currentClass.isAnnotationPresent(Cache.class)) {
        currentClass = myEntityClass;
    }

    inheritanceHierarchyRoots.put(myEntityName, currentClass.getName());
    return inheritanceHierarchyRoots.get(myEntityName);
}

public AnnotationVisitor visitAnnotation(String arg0, boolean arg1) {
    Type annotationType = Type.getType(arg0);
    switch(stage) {
    case CLASSSTAGE: {
        if (annotationType.getClassName().equals(Cache.class.getName())){
            annotation = Cache.class.getName();
        }
        break;
    }
    case FIELDSTAGE: {
        if (annotationType.getClassName().equals(Id.class.getName())){
            idMutators.put(fieldName, retrieveMutators());
        }
        if (annotationType.getClassName().equals(Hydrated.class.getName())){
            annotation = Hydrated.class.getName();
        }
        break;
    }
    default : {
        annotation = null;
        fieldName = null;
        break;
    }
    }
    return this;
}

public void visit(String arg0, Object arg1) {
    if (Cache.class.getName().equals(annotation) && "region".equals(arg0)) {
        cacheRegion = (String) arg1;
    }
    if (Hydrated.class.getName().equals(annotation) && "factoryMethod".equals(arg0)) {
        HydrationItemDescriptor itemDescriptor = new HydrationItemDescriptor();
        itemDescriptor.setFactoryMethod((String) arg1);
        itemDescriptor.setMutators(retrieveMutators());
        cacheMutators.put(fieldName, itemDescriptor);
    }
}

private static String getInheritanceHierarchyRoot(Class<?> myEntityClass) {
    String myEntityName = myEntityClass.getName();
    if (inheritanceHierarchyRoots.containsKey(myEntityName)) {
        return inheritanceHierarchyRoots.get(myEntityName);
    }
    Class<?> currentClass = myEntityClass;
    boolean eof = false;
    while (!eof) {
        Class<?> superclass = currentClass.getSuperclass();
        if (superclass.equals(Object.class) || !superclass.isAnnotationPresent(Entity.class)) {
            eof = true;
        } else {
            currentClass = superclass;
        }
    }

    if (!currentClass.isAnnotationPresent(Cache.class)) {
        currentClass = myEntityClass;
    }

    inheritanceHierarchyRoots.put(myEntityName, currentClass.getName());
    return inheritanceHierarchyRoots.get(myEntityName);
}

private static Cache determineCacheSettings(XClass clazzToProcess, Mappings mappings) {
    Cache cacheAnn = clazzToProcess.getAnnotation( Cache.class );
    if ( cacheAnn != null ) {
        return cacheAnn;
    }

    Cacheable cacheableAnn = clazzToProcess.getAnnotation( Cacheable.class );
    SharedCacheMode mode = determineSharedCacheMode( mappings );
    switch ( mode ) {
        case ALL: {
            cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
            break;
        }
        case ENABLE_SELECTIVE: {
            if ( cacheableAnn != null && cacheableAnn.value() ) {
                cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
            }
            break;
        }
        case DISABLE_SELECTIVE: {
            if ( cacheableAnn == null || cacheableAnn.value() ) {
                cacheAnn = buildCacheMock( clazzToProcess.getName(), mappings );
            }
            break;
        }
        default: {
            // treat both NONE and UNSPECIFIED the same
            break;
        }
    }
    return cacheAnn;
}

public void setCache(Cache cacheAnn) {
    if ( cacheAnn != null ) {
        cacheRegionName = BinderHelper.isEmptyAnnotationValue( cacheAnn.region() ) ? null : cacheAnn.region();
        cacheConcurrencyStrategy = EntityBinder.getCacheConcurrencyStrategy( cacheAnn.usage() );
    }
    else {
        cacheConcurrencyStrategy = null;
        cacheRegionName = null;
    }
}

@ManyToMany
@JoinTable(name = "user_badge", joinColumns = { @JoinColumn(name = "user_id") }, inverseJoinColumns = { @JoinColumn(name = "badge_id") })
@Fetch(FetchMode.SUBSELECT)
@OrderBy("id")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public Set<Badge> getBadges() {
    return badges;
}

@ManyToMany
//�м����,��������Ĭ����������
@JoinTable(name = "ACCT_USER_ROLE", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "ROLE_ID") })
//Fecth���Զ���
@Fetch(FetchMode.SUBSELECT)
//���ϰ�id����.
@OrderBy("id")
//�����ж���id�Ļ���.
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public List<AcctRole> getRoleList() {
    return roleList;
}

public void visit(String arg0, Object arg1) {
    if (Cache.class.getName().equals(annotation) && "region".equals(arg0)) {
        cacheRegion = (String) arg1;
    }
    if (Hydrated.class.getName().equals(annotation) && "factoryMethod".equals(arg0)) {
        HydrationItemDescriptor itemDescriptor = new HydrationItemDescriptor();
        itemDescriptor.setFactoryMethod((String) arg1);
        itemDescriptor.setMutators(retrieveMutators());
        cacheMutators.put(fieldName, itemDescriptor);
    }
}

public void visit(String arg0, Object arg1) {
    if (Cache.class.getName().equals(annotation) && "region".equals(arg0)) {
        cacheRegion = (String) arg1;
    }
    if (Hydrated.class.getName().equals(annotation) && "factoryMethod".equals(arg0)) {
        HydrationItemDescriptor itemDescriptor = new HydrationItemDescriptor();
        itemDescriptor.setFactoryMethod((String) arg1);
        itemDescriptor.setMutators(retrieveMutators());
        cacheMutators.put(fieldName, itemDescriptor);
    }
}

/**
    * The GisFeature, the Alternate name refers to
    * 
    * @return the GisFeature, the AlternateName refers to
    */
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(nullable = false, name = "street")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Index(name = "Alternatenameosmnameindex")
   public OpenStreetMap getStreet() {
return street;
   }

/**
    * Return the Adms of a directly higher Level in the adm the tree structure
    * @return The Adms of a directly higher Level <br>
    * <b>Example</b> Returns the Adm(s) with level 2 if the current
    *         Adm has a level equals to 1
    */
   @OneToMany(cascade = { CascadeType.ALL }, mappedBy = "parent")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Fetch(FetchMode.SELECT)
   public List<Adm> getChildren() {
return children;
   }

/**
    * Returns The parent Adm in the Adm tree structure
    * 
    * @return The parent Adm (with lower Level)
    */
   @ManyToOne(fetch = FetchType.EAGER)
   @JoinColumn(nullable = true, name = "parent")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Index(name = "admadmindex")
   public Adm getParent() {
return parent;
   }

/**
 * @return A list of the {@link AlternateName}s for this street
 */
@OneToMany(cascade = { CascadeType.ALL }, mappedBy = "street")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@Fetch(FetchMode.SELECT)
public List<AlternateOsmName> getAlternateNames() {
    return alternateNames;
}

/**
 * @return the houseNumbers associated to that street
 */
@OneToMany(cascade = { CascadeType.ALL }, mappedBy = "street")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Fetch(FetchMode.SELECT)
@Sort(comparator=HouseNumberComparator.class,type=SortType.COMPARATOR)
public SortedSet<HouseNumber> getHouseNumbers() {
    return houseNumbers;
}

/**
    * @return the gisFeature associated to this zip code
    */
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(nullable = true, name = "gisFeature")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Index(name = "zipcodefeatureidindex")
   public GisFeature getGisFeature() {
return this.gisFeature;
   }

/**
 * @return the street associated to this house number
 */
 @ManyToOne(fetch = FetchType.LAZY)//TODO HN
 @JoinColumn(nullable = false, name = "street")
 @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
 @Index(name = "housenumberstreetindex")
public OpenStreetMap getStreet() {
    return street;
}

/**
    * @return The Adm with the higher Level that this GisFeature is linked to
    *         (the deeper in the Adm tree). See Important Notes for admXcode
    *         for {@link GisFeature}
    */
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "adm", unique = false, referencedColumnName = "id", nullable = true)
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Index(name = "gisfeatureadmindex")
   public Adm getAdm() {
return adm;
   }

/**
    * @return A list of the {@link AlternateName}s for this GisFeature
    */
   @OneToMany(cascade = { CascadeType.ALL }, mappedBy = "gisFeature")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Fetch(FetchMode.SELECT)
   public Set<AlternateName> getAlternateNames() {
return alternateNames;
   }

/**
    * @return the zip codes for the city
    */
@OneToMany(cascade = { CascadeType.ALL }, mappedBy = "gisFeature")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@Fetch(FetchMode.SELECT)
//TODO tests zip
public Set<ZipCode> getZipCodes() {
    return zipCodes;
}

/**
    * The GisFeature, the Alternate name refers to
    * 
    * @return the GisFeature, the AlternateName refers to
    */
   @ManyToOne(fetch = FetchType.LAZY)
   @JoinColumn(nullable = false, name = "gisFeature")
   @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
   @Index(name = "AlternatenameGisFeatureindex")
   public GisFeature getGisFeature() {
return gisFeature;
   }

/**
 * @return questions
 */
@ManyToMany(fetch = FetchType.LAZY)
   @JoinTable(name = "haq_chart_question",
      joinColumns = { @JoinColumn(name = "haq_chart_id") }, 
      inverseJoinColumns = { @JoinColumn(name = "question_id") })
   @ForeignKey(name="fk_haqchq_haq_chart_id", inverseName="fk_haqchq_haq_question_id")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public List<Question> getQuestions() {
    return this.questions;
}

/**
 * @return answers all possible answers of a question of given type
 */
@OneToMany(fetch = FetchType.LAZY, mappedBy = "questionType", cascade=CascadeType.ALL, orphanRemoval=true)
@IndexColumn(name = "sort_order")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public List<Answer> getAnswers() {
    return this.answers;
}

/**
 * @return Sender - owner of a message
 */
@ManyToOne(fetch = FetchType.LAZY, optional=false)
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@JoinColumn(name = "sender_user_id", nullable = false, insertable=true, updatable=false)
@ForeignKey(name="fk_message_sender_user_id")
public User getSender() {
    return this.sender;
}

/**
 * @return Receiver - user who receives a message
 */
@ManyToOne(fetch = FetchType.LAZY, optional=false)
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@JoinColumn(name = "receiver_user_id", nullable = false, insertable=true, updatable=false)
@ForeignKey(name="fk_message_receiver_user_id")
public User getReceiver() {
    return this.receiver;
}

/**
 * @return inReplyToMessage
 */
@ManyToOne(fetch = FetchType.LAZY, optional=true)
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@JoinColumn(name = "in_reply_to_message_id", nullable = true, insertable=true, updatable=false)
@ForeignKey(name="fk_message_in_reply_to_message_id")
public Message getInReplyToMessage() {
    return this.inReplyToMessage;
}