Java Version类代码示例

import javax.persistence.Version; //导入依赖的package包/类
@Override
public Optional<Boolean> isPostable(BeanAttributeInformation attributeDesc) {
	Optional<Column> column = attributeDesc.getAnnotation(Column.class);
	Optional<Version> version = attributeDesc.getAnnotation(Version.class);
	if (!version.isPresent() && column.isPresent()) {
		return Optional.of(column.get().insertable());
	}
	Optional<GeneratedValue> generatedValue = attributeDesc.getAnnotation(GeneratedValue.class);
	if (generatedValue.isPresent()) {
		return Optional.of(false);
	}
	return Optional.empty();
}
 

import javax.persistence.Version; //导入依赖的package包/类
@Override
public Optional<Boolean> isPatchable(BeanAttributeInformation attributeDesc) {
	Optional<Column> column = attributeDesc.getAnnotation(Column.class);
	Optional<Version> version = attributeDesc.getAnnotation(Version.class);
	if (!version.isPresent() && column.isPresent()) {
		return Optional.of(column.get().updatable());
	}
	Optional<GeneratedValue> generatedValue = attributeDesc.getAnnotation(GeneratedValue.class);
	if (generatedValue.isPresent()) {
		return Optional.of(false);
	}
	return Optional.empty();
}
 

import javax.persistence.Version; //导入依赖的package包/类
private boolean include(Class<?> type, PropertyDescriptor descriptor) {
   Field field = findField(type, descriptor.getName());
   if (field == null) {
      return false;
   }
   if (hasAnnotation(Version.class, descriptor.getReadMethod(), field)) {
      return false;
   }
   if (hasAnnotation(Transient.class, descriptor.getReadMethod(), field)) {
      return false;
   }
   if (Modifier.isStatic(field.getModifiers())) {
      return false;
   }
   if (Modifier.isTransient(field.getModifiers())) {
      return false;
   }
   return true;
}
 

import javax.persistence.Version; //导入依赖的package包/类
/**
 * Builds the property for the given attribute.
 *
 * @param attribute
 *            the attribute to inspect
 * @param columnMetadata
 *            the attached (or overriden) column metadata
 * @param override
 *            the AssociationOverride found for this attribute
 * @return the property that represents the attribute or {@code null} if not persistent
 */
<X> Property<X, ?> buildProperty(final AttributeAccessor attribute, final Column columnMetadata,
		final AssociationOverride override) {
	if (attribute.isPersistent()) {
		if (CollectionProperty.isCollectionProperty(attribute)) {
			return new CollectionProperty<>(this, attribute, override);
		} else if (MapProperty.isMapProperty(attribute)) {
			return new MapProperty<>(this, attribute, override);
		} else if (EntityProperty.isEntityProperty(attribute)) {
			return new EntityProperty<>(this.context, getTable(), attribute, override);
		} else if (attribute.isAnnotationPresent(Embedded.class)) {
			return new EmbeddedProperty<>(this, attribute);
		} else if (attribute.isAnnotationPresent(Version.class)) {
			return new VersionProperty<>(this.context, this.table, attribute, columnMetadata);
		} else {
			return new PrimitiveProperty<>(this.context, this.table, attribute, columnMetadata);
		}
	}
	return null;
}
 

import javax.persistence.Version; //导入依赖的package包/类
public static Property<Serializable> getVersionProperty(Class<?> entityClass)
{
    List<PropertyCriteria> criteriaList = new LinkedList<PropertyCriteria>();
    criteriaList.add(new AnnotatedPropertyCriteria(Version.class));

    String fromMappingFiles = PersistenceUnitDescriptorProvider.getInstance().versionField(entityClass);
    if (fromMappingFiles != null)
    {
        criteriaList.add(new NamedPropertyCriteria(fromMappingFiles));
    }

    for (PropertyCriteria criteria : criteriaList)
    {
        PropertyQuery<Serializable> query =
            PropertyQueries.<Serializable> createQuery(entityClass).addCriteria(criteria);
        Property<Serializable> result = query.getFirstResult();
        if (result != null)
        {
            return result;
        }
    }

    return null;
}
 

import javax.persistence.Version; //导入依赖的package包/类
@Override
public Object process(AnnotationInfo ctx, Object value) {
    if (ctx.isAnnotationPresent(Id.class)
            || ctx.isAnnotationPresent(Version.class)) {
        return null;
    }
    return value;
}
 

import javax.persistence.Version; //导入依赖的package包/类
public static String getRecVersionFieldName(Class<? extends BaseMybatisModel> modelClass) {
    for (Method method : modelClass.getMethods()) {
        String methodName = method.getName();
        if (method.isAnnotationPresent(Version.class)) {
            return methodName.substring(3, 4).toLowerCase() + methodName.substring(4);
        }
    }
    return null;
}
 

import javax.persistence.Version; //导入依赖的package包/类
public static String getRecVersionColumnName(Class<? extends BaseMybatisModel> modelClass) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
    for (Method method : modelClass.getMethods()) {
        if (method.isAnnotationPresent(Version.class)) {
            for (int i = 0; i < method.getAnnotations().length; i++) {
                Annotation annotation = method.getAnnotations()[i];
                if (annotation.annotationType().equals(Column.class)) {
                    Method annotationMethod = annotation.getClass().getDeclaredMethod("name", method.getParameterTypes());
                    return annotationMethod.invoke(annotation, null).toString();
                }
            }
        }
    }
    return null;
}
 

import javax.persistence.Version; //导入依赖的package包/类
private boolean hasJpaAnnotations(MetaAttribute attribute) {
	List<Class<? extends Annotation>> annotationClasses = Arrays.asList(Id.class, EmbeddedId.class, Column.class,
			ManyToMany.class, ManyToOne.class, OneToMany.class, OneToOne.class, Version.class,
			ElementCollection.class);
	for (Class<? extends Annotation> annotationClass : annotationClasses) {
		if (attribute.getAnnotation(annotationClass) != null) {
			return true;
		}
	}
	return false;
}
 

import javax.persistence.Version; //导入依赖的package包/类
protected void initializeChecks(final Column annotation, final Collection<Check> checks, final AccessibleObject fieldOrMethod) {
    /* If the value is generated (annotated with @GeneratedValue) it is allowed to be null
     * before the entity has been persisted, same is true in case of optimistic locking
     * when a field is annotated with @Version.
     * Therefore and because of the fact that there is no generic way to determine if an entity
     * has been persisted already, a not-null check will not be performed for such fields.
     */
    if (!annotation.nullable() && !fieldOrMethod.isAnnotationPresent(GeneratedValue.class) && !fieldOrMethod.isAnnotationPresent(Version.class)
            && !fieldOrMethod.isAnnotationPresent(NotNull.class))
        if (!containsCheckOfType(checks, NotNullCheck.class))
            checks.add(new NotNullCheck());

    // add Length check based on Column.length parameter, but only:
    if (!fieldOrMethod.isAnnotationPresent(Lob.class) && // if @Lob is not present
            !fieldOrMethod.isAnnotationPresent(Enumerated.class) && // if @Enumerated is not present
            !fieldOrMethod.isAnnotationPresent(Length.class) // if an explicit @Length constraint is not present
    ) {
        final LengthCheck lengthCheck = new LengthCheck();
        lengthCheck.setMax(annotation.length());
        checks.add(lengthCheck);
    }

    // add Range check based on Column.precision/scale parameters, but only:
    if (!fieldOrMethod.isAnnotationPresent(Range.class) // if an explicit @Range is not present
            && annotation.precision() > 0 // if precision is > 0
            && Number.class.isAssignableFrom(fieldOrMethod instanceof Field ? ((Field) fieldOrMethod).getType() : ((Method) fieldOrMethod).getReturnType()) // if numeric field type
    ) {
        /* precision = 6, scale = 2  => -9999.99<=x<=9999.99
         * precision = 4, scale = 1  =>   -999.9<=x<=999.9
         */
        final RangeCheck rangeCheck = new RangeCheck();
        rangeCheck.setMax(Math.pow(10, annotation.precision() - annotation.scale()) - Math.pow(0.1, annotation.scale()));
        rangeCheck.setMin(-1 * rangeCheck.getMax());
        checks.add(rangeCheck);
    }
}
 

import javax.persistence.Version; //导入依赖的package包/类
/**
 * <p>Getter for the field <code>version</code>.</p>
 *
 * @return a {@link java.lang.Integer} object.
 */
@Version
@Column(name="VERSION")
public Integer getVersion()
{
    return this.version;
}
 

import javax.persistence.Version; //导入依赖的package包/类
@Column(name = DbColumnNames.ENTITY_VERSION)
@Nullable
@Override
@Version
public Long getEntityVersion() {
    return this.entityVersion;
}
 

import javax.persistence.Version; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@Version
@Column(name = "version")
public int getModificationCounter() {

  return super.getModificationCounter();
}
 

import javax.persistence.Version; //导入依赖的package包/类
/**
 * Get the version for the attached file.
 * @return the version for the attached file
 * @motivation for hibernate
 */
@Column(nullable=false)
@Version
private Integer getVersion()
{
  return _version;
}
 

import javax.persistence.Version; //导入依赖的package包/类
/**
 * @motivation for hibernate
 */
@Version
@Column(nullable = false)
private Integer getVersion()
{
  return _version;
}