JPA自动创建表实体类和数据库表字段顺序不对应问题(已解决)

最新推荐文章于 2022-06-12 17:06:05 发布
最新推荐文章于 2022-06-12 17:06:05 发布
阅读量1.3k 收藏 1
点赞数 1
文章标签： hibernate java jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42651201/article/details/116943694
版权

1.在jar包中找到如下地址
在这里插入图片描述
在cfg文件下找到PropertyContainer类
在这里插入图片描述
2.在src目录下创建一样的包结构和类
在这里插入图片描述
3.复制以下全部代码到PropertyContainer类中，如果包位置和类名没没有错的话，复制下面的代码不用做任何改动即可使用，如果有错，请仔细检查。当然你也可以复制jar包中的源码，自己改。

package org.hibernate.cfg;

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;

import javax.persistence.*;
import java.util.*;

class PropertyContainer {
    private static final CoreMessageLogger LOG = (CoreMessageLogger)Logger.getMessageLogger(CoreMessageLogger.class, org.hibernate.cfg.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());
    }
}

4.删除数据库中原有的表，重新运行项目即可。如果有数据，记得提前备份。
参考文章地址

风度啊
关注
spring jpa 自动建表 字段乱序 字段 顺序
weixin_34321753的博客
04-11 6509
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Data JPA
qq_15513905的博客
10-28 377
配置实体类 使用 JPA 的注解，来配置实体类，指定实体类和数据库表之间的关系，指定实体类中的属性名和数据库表中的字段之间的关系。 指定实体类的数据库表之间的关系 @Entity 注解和 @Table 注解，加在实体类的上面 @Entity 指定当前类是一个实体类 @Table(name = '''') 指定当前实体类对应数据库中的哪个表 指定实体类中的属性名和数据库表中的字段之间的关系 @Id、@Colum、@GeneratedValue、@JsonFormat 加在实体类中的属性上 @I
解决 Springboot Jpa 自动创建表 和字段乱序问题[凤凰小哥哥]
09-20
产生原因：因为使用 jpa 自动创建表的时候，采用的是TreeMap的，我们要变成LinkedHashMap 的结构。 解决方案：在项目下java文件夹下创建包名为： org.hibernate.cfg  ，创建类： PropertyContainer [包名，类名一定要相同哦]
Java jpa自动建表 危害,SpringDataJPA自动建表字段顺序优化
weixin_32801895的博客
03-11 924
JPA 自动建表字段顺序优化1、表字段顺序和实体类定义字段顺序一致原理：复制一个 hibernate 包下的 PropertyContainer 类，修改其中 persistentAttributeMap 的类型，TreeMap 修改为有序的 LinkedHashMap，在下次类加载时，会优先加载我们定义的类。2、自定义继承类字段顺序原理同上就不说了。一般我们的实体类会继承一个父类，父类中有 id...
spring data jpa 实体类中字段不与数据库表映射 ORA-00904 标识符无效
小楼一夜听春雨
10-31 2万+
当我们使用spring data jpa开发的时候，会将实体类中的成员变量与表中的字段一一对应，当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时会报错，例如： Caused by: java.sql.SQLSyntaxErrorException: ORA-00904: "BOOK0_"."TYPENAMES": 标识符无效 此时我们只要在这个成员变量上加上注解@Tr
03. Spring Security 之前后端分离
明月燃雨
12-27 442
1. 登录交互 1.1 登录成功回调 代码如下： .and() .formLogin() .loginPage("/login.html") .loginProcessingUrl("/login") .usernameParameter("name") .passwordParameter("pwd") .successHandler((request, response, authentication) -> { Object principal = authentication.getPrin
springboot整合security、jpa
qq_37705525的博客
06-12 566
springboot整合security、jpa
SpringBoot学习（五）操作数据库Spring-Data-JPA
ncfl
08-06 3502
JPA JPA数据增删改查 JPA事务管理 JPA缓存
实体类映射与表结构设计原则
ORM框架会根据事先定义好的映射规则，自动将实体类的属性映射到相应的数据库表的字段上。这样，我们就可以通过操作实体类的对象来实现对数据库的操作，而不需要直接编写SQL语句。 实体类映射的作用不仅仅局限于简化...
整合Spring Data JPA 和 Spring
Ashley_Peng的博客
09-10 257
pom.xml 使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等 (可能存在版本冲突的问题) <properties> <spring.version>4.2.4.RELEASE<...
JPA注解 和hibernate 建表
07-07
JPA注解创建数据库表 和hibernate.cfg.xml 建表
JPA中的事务管理与乐观锁
在JPA中，实体（Entity）是指映射到数据库表的Java类，每个实体类对应一个表。实体通过注解的方式描述其与表的映射关系，并定义了实体属性与表字段之间的对应关系。 实体管理（Entity Manager）负责对实体的管理和...
spring data jpa 实体类中字段不与数据库表映射
weixin_44423144的博客
02-03 2504
当我们使用spring data jpa开发的时候，当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时我们只要在这个成员变量上加上注解@Transient 注意是javax.persistence.Transient 　 而不是spring annotation包下的注解类。 @Transient private List<GrantedAuthority> autho...
使用Spring Security、Spring Data Jpa实现的RBAC权限控制
热门推荐
tanghuanyou---的博客
05-18 2万+
使用Spring Security、Spring Data Jpa做RBAC的权限控制。
Hibernate（JPA）中实体类变量与表中字段顺序不一致问题
cauchy6317的博客
08-27 3458
在使用JPA的过程，当使用spring.jpa.hibernate.ddl-auto=update属性时，我们是能在数据库中创建实体类所对应的表，但是却发现表中字段的顺序和实体类中变量的顺序不一致。作为一名爱思考（装b）的程序猿，我觉得是时候展现我真正的实力了。作为一名爱读源码的程序猿，我先打开了hibernate的源码包位置，如图： 接下来，就开始思考（Google），这么多我读个锤子哦。...
@NamedEntityGraphs --JPA按实体类对象参数中的字段排序问题得解决方法
weixin_30920513的博客
09-07 2153
JPA按实体类对象参数中的字段排序问题得解决方法@Entity @Table(name="complaints") @NamedEntityGraphs({ @NamedEntityGraph(name="allJoinsButMessages", attributeNodes = { @NamedAttributeNode("customer"), ...
Java@注解-JPA实体类与数据库对应
weixin_44177447的博客
06-11 2316
Springboot+Hibernate+JPA 1. 数据库和实体类同步： @Entity 只有一个属性name @Table 属性name 属性catalog 和 schema 用于设置表所属的数据库目录或模式，基本上用不到 2. @Id 设置主键 3. @GeneratedValue(strategy = GenerationType.AUTO) ，设置自增长，一般与@Id搭配使用 4. @Column： 当实体类的属性和数据库中的字段名称不一样时使用 如： @Column（name=“uid”
spring data jpa 实体类中字段不与数据库表映射,使用@Transient 注解无效的解决方法
java123_PB的博客
04-25 6965
我们在使用jpa来操作数据库时，会需要在实体类中添加额外的属性，这个属性在表中又不存在，此时就会报错，提示添加的这个属性在表中找不到 蓝线标注就是表中没有的属性，我在属性上添加@Transient 这个注解，发现任然报相同的错，我又检测这个注解是否引用错误， 发现也没有引用错误，import javax.persistence.Transient; 我参试了很多次，任然没有解决，最好我试...
使用JPA映射数据库表字段部分字段映射失败问题
深思熟虑的博客
06-23 3792
最近使用Spring、Spring MVC、Mybatis搭建一个工程，然后有一个查询，查询所有的用户列表，发现数据库用户表字段user_name无法映射到实体类对应的userName字段，但是其他字段没有问题。 1、表 CREATE TABLE `tb_user` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `user_name` varc...
在idea里面怎么更改数据库表字段的名字并且不出错，数据库表使用jpa
最新发布
05-23
在使用JPA的情况下，更改数据库表字段名字可以通过以下步骤： 1. 首先，在实体类中更改对应属性的名字，例如： ``` @Column(name = "new_name") private String oldName; ``` 在`@Column`注解中指定新的字段名。 2. 在`application.properties`或`application.yml`配置文件中添加以下配置： ``` spring.jpa.hibernate.ddl-auto=update ``` 这个配置会在应用启动时自动更新数据库表结构。 3. 启动应用，等待JPA自动更新数据库表结构。 如果以上步骤都正确执行，那么更改数据库表字段名字就不会出错了。注意，如果已经有数据存在于表中，更改字段名字后需要手动迁移数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值