無法容忍的問題
今天一時興起，搭建了一個Spring Boot 2.0整合Spring Data Jpa的小項目，其實主要目的就是用來給朋友練手的，他接觸Java時間不久，寫代碼的機會少之又少，所以就搭建一個讓他來寫邏輯玩玩。對于我而言一直都是在用MyBatis，可以說我是MyBatis的死忠粉也不為過，所以今天玩Jpa就遇到了一個問題。使用Jpa創(chuàng)建出來的表字段竟然是亂序的，強迫癥怎么能忍?。?！
數據表字段順序亂序
新建了一個User實體類，大概如下：
@Data
@Entity
@Table(name = "user")
@ApiModel(value = "用戶信息")
public class User implements Serializable {
private static final long serialVersionUID = 2936388663101830713L;
@Id
@TableGenerator(name = "AppSeqStore", initialValue = 10000, allocationSize = 1)
@GeneratedValue(strategy = GenerationType.IDENTITY, generator = "AppSeqStore")
@Column(name = "id", columnDefinition = "bigint(20) comment '主鍵ID'")
@ApiModelProperty(value = "自增長主鍵ID", required = false)
private Long id;
/**
* 用戶名
*/
@Column(name = "user_name", columnDefinition = "varchar(100) comment '用戶名'")
@ApiModelProperty(value = "用戶名", required = true)
private String userName;
/**
* 密碼
*/
@Column(name = "password", columnDefinition = "varchar(100) comment '用戶密碼'")
@ApiModelProperty(value = "用戶密碼", required = true)
private String password;
/**
* 鹽值
*/
@Column(name = "salt", columnDefinition = "varchar(100) comment '鹽值'")
@ApiModelProperty(value = "鹽值", required = true)
private String salt;
/**
* 昵稱
*/
@Column(name = "nick_name", columnDefinition = "varchar(100) comment '昵稱'")
@ApiModelProperty(value = "昵稱", required = true)
private String nickName;
/**
* 頭像
*/
@Column(name = "avatar", columnDefinition = "varchar(255) comment '頭像url'")
@ApiModelProperty(value = "頭像url", required = true)
private String avatar;
/**
* 創(chuàng)建人
*/
@Column(name = "create_id", columnDefinition = "bigint(20) comment '創(chuàng)建人ID'")
@ApiModelProperty(value = "創(chuàng)建人ID", required = true)
private Long createId;
/**
* 創(chuàng)建時間
*/
@Column(name = "create_time", columnDefinition = "datetime comment '創(chuàng)建時間'")
@ApiModelProperty(value = "創(chuàng)建時間", required = true)
private Date createTime;
/**
* 修改人
*/
@Column(name = "modify_id", columnDefinition = "bigint(20) comment '修改人ID'")
@ApiModelProperty(value = "修改人ID", required = true)
private Long modifyId;
/**
* 修改時間
*/
@Column(name = "modify_time", columnDefinition = "datetime comment '修改時間'")
@ApiModelProperty(value = "修改時間", required = true)
private Date modifyTime;
/**
* 是否刪除標志
*/
@Column(name = "is_delete", columnDefinition = "int(1) comment '刪除標識[0：正常；1：刪除；]'")
@ApiModelProperty(value = "刪除標識[0：正常；1：刪除；]", required = true)
private Integer isDelete;
}
啟動項目后創(chuàng)建出來的表效果是這樣的：
Jpa創(chuàng)建表亂序
原因
經過一頓源碼的亂翻，最終剛找到類PropertyContainer下，發(fā)下這里面存放的時候竟然用的TreeMap，TreeMap應該是除了HashMap之外最常用的了，TreeMap是一個能比較元素大小的Map集合，而且會根據傳入key的大小自動進行排序，所以就導致了，Jpa創(chuàng)建數據表的時候，沒有跟實體中的字段順序相對應。
Jpa容器
解決方案
既然它使用的是TreeMap，那么就把它換成hashMap就可以變成有序的了。
新建一個包，包路徑是org.hibernate.cfg，然后新建一個類，類名與源碼相同PropertyContainer，將源碼復制出來修改一下即可。
新建包
代碼如下，將其改成LinkedHashMap：
public class PropertyContainer {
private static final CoreMessageLogger LOG = (CoreMessageLogger) Logger.getMessageLogger(CoreMessageLogger.class, PropertyContainer.class.getName());
private final XClass xClass;
private final XClass entityAtStake;
private final AccessType classLevelAccessType;
private final LinkedHashMap<String, XProperty> persistentAttributeMap;
PropertyContainer(XClass clazz, XClass entityAtStake, AccessType defaultClassLevelAccessType) {
this.xClass = clazz;
this.entityAtStake = entityAtStake;
if (defaultClassLevelAccessType == AccessType.DEFAULT) {
defaultClassLevelAccessType = AccessType.PROPERTY;
}
AccessType localClassLevelAccessType = this.determineLocalClassDefinedAccessStrategy();
assert localClassLevelAccessType != null;
this.classLevelAccessType = localClassLevelAccessType != AccessType.DEFAULT ? localClassLevelAccessType : defaultClassLevelAccessType;
assert this.classLevelAccessType == AccessType.FIELD || this.classLevelAccessType == AccessType.PROPERTY;
this.persistentAttributeMap = new LinkedHashMap();
List<XProperty> fields = this.xClass.getDeclaredProperties(AccessType.FIELD.getType());
List<XProperty> getters = this.xClass.getDeclaredProperties(AccessType.PROPERTY.getType());
this.preFilter(fields, getters);
Map<String, XProperty> persistentAttributesFromGetters = new HashMap();
this.collectPersistentAttributesUsingLocalAccessType(this.persistentAttributeMap, persistentAttributesFromGetters, fields, getters);
this.collectPersistentAttributesUsingClassLevelAccessType(this.persistentAttributeMap, persistentAttributesFromGetters, fields, getters);
}
private void preFilter(List<XProperty> fields, List<XProperty> getters) {
Iterator propertyIterator = fields.iterator();
XProperty property;
while(propertyIterator.hasNext()) {
property = (XProperty)propertyIterator.next();
if (mustBeSkipped(property)) {
propertyIterator.remove();
}
}
propertyIterator = getters.iterator();
while(propertyIterator.hasNext()) {
property = (XProperty)propertyIterator.next();
if (mustBeSkipped(property)) {
propertyIterator.remove();
}
}
}
private void collectPersistentAttributesUsingLocalAccessType(LinkedHashMap<String, XProperty> persistentAttributeMap, Map<String, XProperty> persistentAttributesFromGetters, List<XProperty> fields, List<XProperty> getters) {
Iterator propertyIterator = fields.iterator();
XProperty xProperty;
Access localAccessAnnotation;
while(propertyIterator.hasNext()) {
xProperty = (XProperty)propertyIterator.next();
localAccessAnnotation = (Access)xProperty.getAnnotation(Access.class);
if (localAccessAnnotation != null && localAccessAnnotation.value() == javax.persistence.AccessType.FIELD) {
propertyIterator.remove();
persistentAttributeMap.put(xProperty.getName(), xProperty);
}
}
propertyIterator = getters.iterator();
while(propertyIterator.hasNext()) {
xProperty = (XProperty)propertyIterator.next();
localAccessAnnotation = (Access)xProperty.getAnnotation(Access.class);
if (localAccessAnnotation != null && localAccessAnnotation.value() == javax.persistence.AccessType.PROPERTY) {
propertyIterator.remove();
String name = xProperty.getName();
XProperty previous = (XProperty)persistentAttributesFromGetters.get(name);
if (previous != null) {
throw new MappingException(LOG.ambiguousPropertyMethods(this.xClass.getName(), HCANNHelper.annotatedElementSignature(previous), HCANNHelper.annotatedElementSignature(xProperty)), new Origin(SourceType.ANNOTATION, this.xClass.getName()));
}
persistentAttributeMap.put(name, xProperty);
persistentAttributesFromGetters.put(name, xProperty);
}
}
}
private void collectPersistentAttributesUsingClassLevelAccessType(LinkedHashMap<String, XProperty> persistentAttributeMap, Map<String, XProperty> persistentAttributesFromGetters, List<XProperty> fields, List<XProperty> getters) {
Iterator var5;
XProperty getter;
if (this.classLevelAccessType == AccessType.FIELD) {
var5 = fields.iterator();
while(var5.hasNext()) {
getter = (XProperty)var5.next();
if (!persistentAttributeMap.containsKey(getter.getName())) {
persistentAttributeMap.put(getter.getName(), getter);
}
}
} else {
var5 = getters.iterator();
while(var5.hasNext()) {
getter = (XProperty)var5.next();
String name = getter.getName();
XProperty previous = (XProperty)persistentAttributesFromGetters.get(name);
if (previous != null) {
throw new MappingException(LOG.ambiguousPropertyMethods(this.xClass.getName(), HCANNHelper.annotatedElementSignature(previous), HCANNHelper.annotatedElementSignature(getter)), new Origin(SourceType.ANNOTATION, this.xClass.getName()));
}
if (!persistentAttributeMap.containsKey(name)) {
persistentAttributeMap.put(getter.getName(), getter);
persistentAttributesFromGetters.put(name, getter);
}
}
}
}
public XClass getEntityAtStake() {
return this.entityAtStake;
}
public XClass getDeclaringClass() {
return this.xClass;
}
public AccessType getClassLevelAccessType() {
return this.classLevelAccessType;
}
public Collection<XProperty> getProperties() {
this.assertTypesAreResolvable();
return Collections.unmodifiableCollection(this.persistentAttributeMap.values());
}
private void assertTypesAreResolvable() {
Iterator var1 = this.persistentAttributeMap.values().iterator();
XProperty xProperty;
do {
if (!var1.hasNext()) {
return;
}
xProperty = (XProperty)var1.next();
} while(xProperty.isTypeResolved() || discoverTypeWithoutReflection(xProperty));
String msg = "Property " + StringHelper.qualify(this.xClass.getName(), xProperty.getName()) + " has an unbound type and no explicit target entity. Resolve this Generic usage issue or set an explicit target attribute (eg @OneToMany(target=) or use an explicit @Type";
throw new AnnotationException(msg);
}
private AccessType determineLocalClassDefinedAccessStrategy() {
AccessType hibernateDefinedAccessType = AccessType.DEFAULT;
AccessType jpaDefinedAccessType = AccessType.DEFAULT;
org.hibernate.annotations.AccessType accessType = (org.hibernate.annotations.AccessType)this.xClass.getAnnotation(org.hibernate.annotations.AccessType.class);
if (accessType != null) {
hibernateDefinedAccessType = AccessType.getAccessStrategy(accessType.value());
}
Access access = (Access)this.xClass.getAnnotation(Access.class);
if (access != null) {
jpaDefinedAccessType = AccessType.getAccessStrategy(access.value());
}
if (hibernateDefinedAccessType != AccessType.DEFAULT && jpaDefinedAccessType != AccessType.DEFAULT && hibernateDefinedAccessType != jpaDefinedAccessType) {
throw new org.hibernate.MappingException("@AccessType and @Access specified with contradicting values. Use of @Access only is recommended. ");
} else {
AccessType classDefinedAccessType;
if (hibernateDefinedAccessType != AccessType.DEFAULT) {
classDefinedAccessType = hibernateDefinedAccessType;
} else {
classDefinedAccessType = jpaDefinedAccessType;
}
return classDefinedAccessType;
}
}
private static boolean discoverTypeWithoutReflection(XProperty p) {
if (p.isAnnotationPresent(OneToOne.class) && !((OneToOne)p.getAnnotation(OneToOne.class)).targetEntity().equals(Void.TYPE)) {
return true;
} else if (p.isAnnotationPresent(OneToMany.class) && !((OneToMany)p.getAnnotation(OneToMany.class)).targetEntity().equals(Void.TYPE)) {
return true;
} else if (p.isAnnotationPresent(ManyToOne.class) && !((ManyToOne)p.getAnnotation(ManyToOne.class)).targetEntity().equals(Void.TYPE)) {
return true;
} else if (p.isAnnotationPresent(ManyToMany.class) && !((ManyToMany)p.getAnnotation(ManyToMany.class)).targetEntity().equals(Void.TYPE)) {
return true;
} else if (p.isAnnotationPresent(Any.class)) {
return true;
} else if (p.isAnnotationPresent(ManyToAny.class)) {
if (!p.isCollection() && !p.isArray()) {
throw new AnnotationException("@ManyToAny used on a non collection non array property: " + p.getName());
} else {
return true;
}
} else if (p.isAnnotationPresent(Type.class)) {
return true;
} else {
return p.isAnnotationPresent(Target.class);
}
}
private static boolean mustBeSkipped(XProperty property) {
return property.isAnnotationPresent(Transient.class) || "net.sf.cglib.transform.impl.InterceptFieldCallback".equals(property.getType().getName()) || "org.hibernate.bytecode.internal.javassist.FieldHandler".equals(property.getType().getName());
}
}
效果
修改后刪除原來的表，重新啟動項目，效果如下：
修改Jpa建表亂序問題
原文地址：傳送門
