jpa: database: MYSQL show-sql: true #Hibernate ddl auto (validate|create|create-drop|update) hibernate: ddl-auto: update naming: physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl properties: hibernate: dialect: org.hibernate.dialect.MySQL5InnoDBDialect enable_lazy_load_no_trans: true
啓動項目時,系統就會自動建立實體類中的定義的表,建立完以後你會發現數據庫裏的字段和實體類裏的字段順序是不同的 是亂序的 這是爲何呢?html
翻了翻源碼才發現,不少地方都是使用LinkedHashMap或者是List來傳輸Entity裏面的fields,因而感受Hibernate應該是考慮到使用Entity裏面定義的fields的順序來實現建表語句裏的表字段順序的。
因而就一步步跟蹤下去,終於在一個地方發現了一個問題:org.hibernate.cfg包下的PropertyContainer類在取fields的時候是使用TreeMap來保存的,因而試着改了下,將這個裏面的全部TreeMap改爲了LinkedHashMap,編譯經過,打包,測試。
終於,咱們期待已久的結果出來了:建表語句裏面的字段順序和Entity裏面的fields的順序一致了。java
**/sql
這裏附上修改後的代碼,僅供參考(這裏的Hibernate版本爲hibernate5)數據庫
package org.hibernate.cfg; import java.util.*; import javax.persistence.Access; import javax.persistence.ManyToMany; import javax.persistence.ManyToOne; import javax.persistence.OneToMany; import javax.persistence.OneToOne; import javax.persistence.Transient; import org.hibernate.AnnotationException; import org.hibernate.annotations.Any; import org.hibernate.annotations.ManyToAny; import org.hibernate.annotations.Target; import org.hibernate.annotations.Type; import org.hibernate.annotations.common.reflection.XClass; import org.hibernate.annotations.common.reflection.XProperty; import org.hibernate.boot.MappingException; import org.hibernate.boot.jaxb.Origin; import org.hibernate.boot.jaxb.SourceType; import org.hibernate.cfg.annotations.HCANNHelper; import org.hibernate.internal.CoreMessageLogger; import org.hibernate.internal.util.StringHelper; import org.jboss.logging.Logger; /** * 解決SpringDataJpa實體類中屬性順序與數據庫中生成字段順序不一致的問題
*/ 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()); } }
至此,又能夠愉快的玩耍啦。。。。。。。。。。。。app
原文出處:https://www.cnblogs.com/cndarren/p/11911204.html測試