Java Id类代码示例

import org.springframework.data.annotation.Id; //导入依赖的package包/类
private Field getIdField(Class<?> domainClass) {
    Field idField = null;

    final List<Field> fields = FieldUtils.getFieldsListWithAnnotation(domainClass, Id.class);

    if (fields.isEmpty()) {
        idField = ReflectionUtils.findField(getJavaType(), "id");
    } else if (fields.size() == 1) {
        idField = fields.get(0);
    } else {
        throw new IllegalArgumentException("only one field with @Id annotation!");
    }

    if (idField != null && idField.getType() != String.class) {
        throw new IllegalArgumentException("type of id field must be String");
    }
    return idField;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public ID getId(T entity) {
	Class<?> domainClass = getJavaType();
	while (domainClass != Object.class) {
		for (Field field : domainClass.getDeclaredFields()) {
			if (field.getAnnotation(Id.class) != null) {
				try {
					return (ID) field.get(entity);
				}
				catch (IllegalArgumentException | IllegalAccessException e) {
					BeanWrapper beanWrapper = PropertyAccessorFactory
							.forBeanPropertyAccess(entity);
					return (ID) beanWrapper.getPropertyValue(field.getName());
				}
			}
		}
		domainClass = domainClass.getSuperclass();
	}
	throw new IllegalStateException("id not found");
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
private String getPkColumns() {
  Class<T> entityType = entityInfo.getJavaType();

  Field[] fields = entityType.getDeclaredFields();
  for (Field field : fields) {
    Id idAnnotation = field.getAnnotation(Id.class);
    if (idAnnotation != null) {
      String id = idAnnotation.name();
      if (StringUtils.isEmpty(id)) {
        return underscoreName(field.getName());
      } else {
        return id;
      }
    }
  }

  return "";
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
protected <T> T getBean(Class<T> clazz, Node node) {
    try {
        T instance = clazz.newInstance();
        Iterable<String> propertyKeys = node.getPropertyKeys();
        for (String key : propertyKeys) {
            if (!key.equals(clazz.getName() + ID_SUFFIX)) {
                BeanUtils.setProperty(instance, key, node.getProperty(key));
            } else {
                BeanProperty prop = ReflectionUtils.getAnnotatedProperty(instance, Id.class);
                BeanUtils.setProperty(instance, prop.getName(), node.getProperty(key));
            }
        }
        return instance;
    } catch (Exception e) {
        throw new DataAccessResourceFailureException("Problem obtainig bean from node", e);
    }
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@Override
public <T> T persist(T e) {
    BeanProperty id = ReflectionUtils.getAnnotatedProperty(e, Id.class);
    if (id == null) {
        throw new IllegalArgumentException("The bean must have an @Id field");
    }

    List<BeanProperty> persistentProperties = ReflectionUtils
            .getAnnotatedProperties(e, Persistent.class);
    Property[] properties = new Property[persistentProperties.size() + 1];
    properties[0] = new Property(e.getClass().getName() + ID_SUFFIX, id.getValue());
    int i = 1;
    for (BeanProperty property : persistentProperties) {
        properties[i] = new Property(property.getName(), property.getValue());
        i++;
    }

    Node node = template.createNode(properties);
    index.index(node, e.getClass().getName() + ID_SUFFIX, id.getValue());
    return e;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
public static Field getIdField(Class<?> clazz) {
	Field idField = null;

	for(Field f : ReflectionUtils.getDeclaredFieldsInHierarchy(clazz)) {
		// named id or annotated with Id
		if(f.getName().equals(FIELD_NAME_DEFAULT_ID) || f.getAnnotation(Id.class) != null) {
			if(idField != null) {
				throw new MappingException("Multiple id fields detected for class " + clazz.getName());
			}
			idField = f;
		}

	}

	return idField;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Class<ID> getIdType() {
	Class<?> domainClass = getJavaType();
	while (domainClass != Object.class) {
		for (Field field : domainClass.getDeclaredFields()) {
			if (field.getAnnotation(Id.class) != null) {
				return (Class<ID>) field.getType();
			}
		}
		domainClass = domainClass.getSuperclass();
	}
	throw new IllegalStateException("id not found");
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
public void doWith(Field field) throws IllegalArgumentException,
		IllegalAccessException {
	ReflectionUtils.makeAccessible(field);

	if (field.isAnnotationPresent(Id.class)) {
		idFound = true;
	}
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
/**
 * 除@Id字段外，其他字段则更新
 *
 * @param <T>
 * @param dto
 * @return
 * @throws SecurityException
 * @throws IllegalArgumentException
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws ClassNotFoundException
 * @throws InstantiationException
 */
public static <T extends AbstractNaviBaseDto> Update buildUpdate(T dto) throws SecurityException, IllegalArgumentException,
    NoSuchMethodException, IllegalAccessException,
    InvocationTargetException, InstantiationException,
    ClassNotFoundException {
    Field[] fields = dto.getClass().getDeclaredFields();
    AbstractNaviBaseDto initDto = (AbstractNaviBaseDto) Class.forName(
        dto.getClass().getName(), true, dto.getClass().getClassLoader()
    ).newInstance();
    Update up = new Update();
    for (Field field : fields) {
        String fnm = field.getName();
        int finalNo = field.getModifiers() & Modifier.FINAL;
        int staticNo = field.getModifiers() & Modifier.STATIC;
        int transitNo = field.getModifiers() & Modifier.TRANSIENT;
        if (finalNo != 0 || staticNo != 0 || transitNo != 0
            || field.isAnnotationPresent(Id.class)) {
            continue;
        }
        Object newValue = dto.getValue(fnm);
        if (newValue == null || newValue.equals(initDto.getValue(fnm))) {
            continue;
        }
        up.set(fnm, newValue);
    }
    return up;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
private Field getIdField(final Class<T> domainClass) {
    Field idField = null;
    for (final Field field : domainClass.getDeclaredFields()) {
        final Class type = field.getType();
        final String name = field.getName();
        if (field.isAnnotationPresent(Id.class)) {
            idField = field;
            idField.setAccessible(true);
            break;
        }
    }
    return idField;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
    ReflectionUtils.makeAccessible(field);

    if (field.isAnnotationPresent(Id.class)) {
        idFound = true;
    }
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@Override
protected Field findIdField(Class<?> clazz) {
	Field idField = getReferencedField(this.getClazz(), Id.class);
	if (idField == null) {
		idField = getReferencedField(this.getClazz(), javax.persistence.Id.class);
		if (idField == null) {
			idField = getReferencedField(this.getClazz(), EmbeddedId.class);
		}
	}
	return idField;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@Override
public boolean matches(Field field) {
    return field.getAnnotation(Id.class) == null;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
@Id
public String getCode() {
	return code;
}
 

import org.springframework.data.annotation.Id; //导入依赖的package包/类
public boolean isIdProperty() {
    return isAnnotationPresent(Id.class) 
           || isAnnotationPresent(com.googlecode.objectify.annotation.Id.class);
}