Jpa自动建表浅谈,造一个轮子

最新推荐文章于 2024-04-06 19:53:40 发布
最新推荐文章于 2024-04-06 19:53:40 发布
阅读量1.3k 收藏 2
点赞数
文章标签： hibernate java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dinl_vin/article/details/121290019
版权

在Spring项目中,偷懒的话可能需要用到jpa去自动建表,一张遵循阿里巴巴Java开发规范的表,应该具备(主键ID,创建时间,修改时间)这三个通用属性.

也就是说,所有的表都应该有如下sql:

create table xxx if not exists (
    id int not null auto_increment,
    created_at timestamp default current_timetamp,
    updated_at timestamp default current_timetamp on update current_timestamp,
    .....
)

那么,如何让我们用jpa建的entity表都有如下的开头模板呢?

EntityBase.java

import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import java.time.LocalDateTime;


@Getter
@Setter
@MappedSuperclass
public class EntityBase {
    @Id
    @GeneratedValue
    private Long id;

    @CreationTimestamp
    @Column(columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
    private LocalDateTime createdAt;

    @UpdateTimestamp
    @Column(columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
    private LocalDateTime updatedAt;

}

所有的entity只需要继承该类即可,无须重复造轮子.

import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import java.time.LocalDateTime;


@Getter
@Setter
@MappedSuperclass
public class TableEntity {
    @Id
    @GeneratedValue
    private Long id;

    @CreationTimestamp
    @Column(columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
    private LocalDateTime createdAt;

    @UpdateTimestamp
    @Column(columnDefinition = "TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
    private LocalDateTime updatedAt;

}

另一个问题,jpa建表的时候字段顺序如何与代码顺序相同?

jpa建表的字段顺序是按照字母序排列的,其原因是因为源码在保存字段顺序的时候使用了TreeMap(org.hibernate.cfg.PropertyContainer第89行).所以只需要覆盖此类,使用LinkedHashMap即可,不清楚map区别的可以看:

Java中各种Map的区别

所以保证字段顺序的步骤,

在包里新建一个类 org.hibernate.cfg.PropertyContainer

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */

// $Id$

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.MappingException;
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.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.hibernate.internal.util.collections.CollectionHelper;

import org.jboss.logging.Logger;

/**
 * A helper class to keep the {@code XProperty}s of a class ordered by access type.
 *
 * @author Hardy Ferentschik
 */
class PropertyContainer {
//
//    static {
//        System.setProperty("jboss.i18n.generate-proxies", "true");
//    }

    private static final CoreMessageLogger LOG = Logger.getMessageLogger(CoreMessageLogger.class, PropertyContainer.class.getName());

    /**
     * The class for which this container is created.
     */
    private final XClass xClass;
    private final XClass entityAtStake;

    /**
     * Holds the AccessType indicated for use at the class/container-level for cases where persistent attribute
     * did not specify.
     */
    private final AccessType classLevelAccessType;

    private final List<XProperty> persistentAttributes;

    PropertyContainer(XClass clazz, XClass entityAtStake, AccessType defaultClassLevelAccessType) {
        this.xClass = clazz;
        this.entityAtStake = entityAtStake;

        if ( defaultClassLevelAccessType == AccessType.DEFAULT ) {
            // this is effectively what the old code did when AccessType.DEFAULT was passed in
            // to getProperties(AccessType) from AnnotationBinder and InheritanceState
            defaultClassLevelAccessType = AccessType.PROPERTY;
        }

        AccessType localClassLevelAccessType = determineLocalClassDefinedAccessStrategy();
        assert localClassLevelAccessType != null;

        this.classLevelAccessType = localClassLevelAccessType != AccessType.DEFAULT
                ? localClassLevelAccessType
                : defaultClassLevelAccessType;
        assert classLevelAccessType == AccessType.FIELD || classLevelAccessType == AccessType.PROPERTY;


        final List<XProperty> fields = xClass.getDeclaredProperties( AccessType.FIELD.getType() );
        final List<XProperty> getters = xClass.getDeclaredProperties( AccessType.PROPERTY.getType() );

        preFilter( fields, getters );

        final Map<String,XProperty> persistentAttributesFromGetters = new HashMap<String, XProperty>();

        final LinkedHashMap<String, XProperty> localAttributeMap = new LinkedHashMap<>();
        collectPersistentAttributesUsingLocalAccessType(
                xClass,
                localAttributeMap,
                persistentAttributesFromGetters,
                fields,
                getters
        );
        collectPersistentAttributesUsingClassLevelAccessType(
                xClass,
                classLevelAccessType,
                localAttributeMap,
                persistentAttributesFromGetters,
                fields,
                getters
        );
        this.persistentAttributes = verifyAndInitializePersistentAttributes( xClass, localAttributeMap );
    }

    private void preFilter(List<XProperty> fields, List<XProperty> getters) {
        Iterator<XProperty> propertyIterator = fields.iterator();
        while ( propertyIterator.hasNext() ) {
            final XProperty property = propertyIterator.next();
            if ( mustBeSkipped( property ) ) {
                propertyIterator.remove();
            }
        }

        propertyIterator = getters.iterator();
        while ( propertyIterator.hasNext() ) {
            final XProperty property = propertyIterator.next();
            if ( mustBeSkipped( property ) ) {
                propertyIterator.remove();
            }
        }
    }

    private static void collectPersistentAttributesUsingLocalAccessType(
            XClass xClass,
            LinkedHashMap<String, XProperty> persistentAttributeMap,
            Map<String,XProperty> persistentAttributesFromGetters,
            List<XProperty> fields,
            List<XProperty> getters) {

        // Check fields...
        Iterator<XProperty> propertyIterator = fields.iterator();
        while ( propertyIterator.hasNext() ) {
            final XProperty xProperty = propertyIterator.next();
            final Access localAccessAnnotation = xProperty.getAnnotation( Access.class );
            if ( localAccessAnnotation == null
                    || localAccessAnnotation.value() != javax.persistence.AccessType.FIELD ) {
                continue;
            }

            propertyIterator.remove();
            persistentAttributeMap.put( xProperty.getName(), xProperty );
        }

        // Check getters...
        propertyIterator = getters.iterator();
        while ( propertyIterator.hasNext() ) {
            final XProperty xProperty = propertyIterator.next();
            final Access localAccessAnnotation = xProperty.getAnnotation( Access.class );
            if ( localAccessAnnotation == null
                    || localAccessAnnotation.value() != javax.persistence.AccessType.PROPERTY ) {
                continue;
            }

            propertyIterator.remove();

            final String name = xProperty.getName();

            // HHH-10242 detect registration of the same property getter twice - eg boolean isId() + UUID getId()
            final XProperty previous = persistentAttributesFromGetters.get( name );
            if ( previous != null ) {
                throw new org.hibernate.boot.MappingException(
                        LOG.ambiguousPropertyMethods(
                                xClass.getName(),
                                HCANNHelper.annotatedElementSignature( previous ),
                                HCANNHelper.annotatedElementSignature( xProperty )
                        ),
                        new Origin( SourceType.ANNOTATION, xClass.getName() )
                );
            }

            persistentAttributeMap.put( name, xProperty );
            persistentAttributesFromGetters.put( name, xProperty );
        }
    }

    private static void collectPersistentAttributesUsingClassLevelAccessType(
            XClass xClass,
            AccessType classLevelAccessType,
            LinkedHashMap<String, XProperty> persistentAttributeMap,
            Map<String,XProperty> persistentAttributesFromGetters,
            List<XProperty> fields,
            List<XProperty> getters) {
        if ( classLevelAccessType == AccessType.FIELD ) {
            for ( XProperty field : fields ) {
                if ( persistentAttributeMap.containsKey( field.getName() ) ) {
                    continue;
                }

                persistentAttributeMap.put( field.getName(), field );
            }
        }
        else {
            for ( XProperty getter : getters ) {
                final String name = getter.getName();

                // HHH-10242 detect registration of the same property getter twice - eg boolean isId() + UUID getId()
                final XProperty previous = persistentAttributesFromGetters.get( name );
                if ( previous != null ) {
                    throw new org.hibernate.boot.MappingException(
                            LOG.ambiguousPropertyMethods(
                                    xClass.getName(),
                                    HCANNHelper.annotatedElementSignature( previous ),
                                    HCANNHelper.annotatedElementSignature( getter )
                            ),
                            new Origin( SourceType.ANNOTATION, xClass.getName() )
                    );
                }

                if ( persistentAttributeMap.containsKey( name ) ) {
                    continue;
                }

                persistentAttributeMap.put( getter.getName(), getter );
                persistentAttributesFromGetters.put( name, getter );
            }
        }
    }

    public XClass getEntityAtStake() {
        return entityAtStake;
    }

    public XClass getDeclaringClass() {
        return xClass;
    }

    public AccessType getClassLevelAccessType() {
        return classLevelAccessType;
    }

    /**
     * @deprecated Use the {@link #propertyIterator()} method instead.
     */
    @Deprecated
    public Collection<XProperty> getProperties() {
        return Collections.unmodifiableCollection( this.persistentAttributes );
    }

    public Iterable<XProperty> propertyIterator() {
        return persistentAttributes;
    }

    private static List<XProperty> verifyAndInitializePersistentAttributes(XClass xClass, Map<String, XProperty> localAttributeMap) {
        ArrayList<XProperty> output = new ArrayList( localAttributeMap.size() );
        for ( XProperty xProperty : localAttributeMap.values() ) {
            if ( !xProperty.isTypeResolved() && !discoverTypeWithoutReflection( xProperty ) ) {
                String msg = "Property " + StringHelper.qualify( 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 );
            }
            output.add( xProperty );
        }
        return CollectionHelper.toSmallList( output );
    }
//
//	private void considerExplicitFieldAndPropertyAccess() {
//		for ( XProperty property : fieldAccessMap.values() ) {
//			Access access = property.getAnnotation( Access.class );
//			if ( access == null ) {
//				continue;
//			}
//
//			// see "2.3.2 Explicit Access Type" of JPA 2 spec
//			// the access type for this property is explicitly set to AccessType.FIELD, hence we have to
//			// use field access for this property even if the default access type for the class is AccessType.PROPERTY
//			AccessType accessType = AccessType.getAccessStrategy( access.value() );
//            if (accessType == AccessType.FIELD) {
//				propertyAccessMap.put(property.getName(), property);
//			}
//            else {
//				LOG.debug( "Placing @Access(AccessType.FIELD) on a field does not have any effect." );
//			}
//		}
//
//		for ( XProperty property : propertyAccessMap.values() ) {
//			Access access = property.getAnnotation( Access.class );
//			if ( access == null ) {
//				continue;
//			}
//
//			AccessType accessType = AccessType.getAccessStrategy( access.value() );
//
//			// see "2.3.2 Explicit Access Type" of JPA 2 spec
//			// the access type for this property is explicitly set to AccessType.PROPERTY, hence we have to
//			// return use method access even if the default class access type is AccessType.FIELD
//            if (accessType == AccessType.PROPERTY) {
//				fieldAccessMap.put(property.getName(), property);
//			}
//            else {
//				LOG.debug( "Placing @Access(AccessType.PROPERTY) on a field does not have any effect." );
//			}
//		}
//	}

//	/**
//	 * Retrieves all properties from the {@code xClass} with the specified access type. This method does not take
//	 * any jpa access rules/annotations into account yet.
//	 *
//	 * @param access The access type - {@code AccessType.FIELD}  or {@code AccessType.Property}
//	 *
//	 * @return A maps of the properties with the given access type keyed against their property name
//	 */
//	private TreeMap<String, XProperty> initProperties(AccessType access) {
//		if ( !( AccessType.PROPERTY.equals( access ) || AccessType.FIELD.equals( access ) ) ) {
//			throw new IllegalArgumentException( "Access type has to be AccessType.FIELD or AccessType.Property" );
//		}
//
//		//order so that property are used in the same order when binding native query
//		TreeMap<String, XProperty> propertiesMap = new TreeMap<String, XProperty>();
//		List<XProperty> properties = xClass.getDeclaredProperties( access.getType() );
//		for ( XProperty property : properties ) {
//			if ( mustBeSkipped( property ) ) {
//				continue;
//			}
//			// HHH-10242 detect registration of the same property twice eg boolean isId() + UUID getId()
//			XProperty oldProperty = propertiesMap.get( property.getName() );
//			if ( oldProperty != null ) {
//				throw new org.hibernate.boot.MappingException(
//						LOG.ambiguousPropertyMethods(
//								xClass.getName(),
//								HCANNHelper.annotatedElementSignature( oldProperty ),
//								HCANNHelper.annotatedElementSignature( property )
//						),
//						new Origin( SourceType.ANNOTATION, xClass.getName() )
//				);
//			}
//
//			propertiesMap.put( property.getName(), property );
//		}
//		return propertiesMap;
//	}

    private AccessType determineLocalClassDefinedAccessStrategy() {
        AccessType classDefinedAccessType;

        AccessType hibernateDefinedAccessType = AccessType.DEFAULT;
        AccessType jpaDefinedAccessType = AccessType.DEFAULT;

        org.hibernate.annotations.AccessType accessType = xClass.getAnnotation( org.hibernate.annotations.AccessType.class );
        if ( accessType != null ) {
            hibernateDefinedAccessType = AccessType.getAccessStrategy( accessType.value() );
        }

        Access access = xClass.getAnnotation( Access.class );
        if ( access != null ) {
            jpaDefinedAccessType = AccessType.getAccessStrategy( access.value() );
        }

        if ( hibernateDefinedAccessType != AccessType.DEFAULT
                && jpaDefinedAccessType != AccessType.DEFAULT
                && hibernateDefinedAccessType != jpaDefinedAccessType ) {
            throw new MappingException(
                    "@AccessType and @Access specified with contradicting values. Use of @Access only is recommended. "
            );
        }

        if ( hibernateDefinedAccessType != AccessType.DEFAULT ) {
            classDefinedAccessType = hibernateDefinedAccessType;
        }
        else {
            classDefinedAccessType = jpaDefinedAccessType;
        }
        return classDefinedAccessType;
    }

    private static boolean discoverTypeWithoutReflection(XProperty p) {
        if ( p.isAnnotationPresent( OneToOne.class ) && !p.getAnnotation( OneToOne.class )
                .targetEntity()
                .equals( void.class ) ) {
            return true;
        }
        else if ( p.isAnnotationPresent( OneToMany.class ) && !p.getAnnotation( OneToMany.class )
                .targetEntity()
                .equals( void.class ) ) {
            return true;
        }
        else if ( p.isAnnotationPresent( ManyToOne.class ) && !p.getAnnotation( ManyToOne.class )
                .targetEntity()
                .equals( void.class ) ) {
            return true;
        }
        else if ( p.isAnnotationPresent( ManyToMany.class ) && !p.getAnnotation( ManyToMany.class )
                .targetEntity()
                .equals( void.class ) ) {
            return true;
        }
        else if ( p.isAnnotationPresent( org.hibernate.annotations.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() );
            }
            return true;
        }
        else if ( p.isAnnotationPresent( Type.class ) ) {
            return true;
        }
        else if ( p.isAnnotationPresent( Target.class ) ) {
            return true;
        }
        return false;
    }

    private static boolean mustBeSkipped(XProperty property) {
        //TODO make those hardcoded tests more portable (through the bytecode provider?)
        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() );
    }
}
dinl_vin
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
springBoot的jpa（自动建表）
weixin_43689176的博客
03-03 2802
springBoot的jpa，自动根据实体对象建表
springboot+mybatisplus自动建表案例
05-08
springboot+mybatisplus自动建表案例
解决 Springboot Jpa 自动创建表 和字段乱序问题[凤凰小哥哥]
09-20
产生原因：因为使用 jpa 自动创建表的时候，采用的是TreeMap的，我们要变成LinkedHashMap 的结构。 解决方案：在项目下java文件夹下创建包名为： org.hibernate.cfg  ，创建类： PropertyContainer [包名，类名一定要相同哦]
Spring Boot JPA MySQL 多租户系统 Part2 - 自动建表
PeterGamp的博客
09-03 1259
本文介绍了 Spring Data JPA 集成 Hibernate 在应用启动时创建数据表的过程。使用 DriverManager 为每个租户创建数据库，SchemaExport 工具为每个租户创建数据表。这些工作均在应用启动时完成，不同租户的请求到来时，可以无缝切换数据源，实现租户的数据隔离。
【spring boot 系列】spring data jpa 全面解析（实践 + 源码分析）
weixin_33882452的博客
05-27 344
前言 本文将从示例、原理、应用3个方面介绍spring data jpa。 以下分析基于spring boot 2.0 + spring 5.0.4版本源码 概述 JPA是什么？ JPA (Java Persistence API) 是 Sun 官方提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具来管理 ...
Spring Data JPA之自动创建数据库表
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
11-19 5976
由于在项目中使用到了Spring Data JPA（Java Persistent API）进行项目开发，并且自己对JPA比较感兴趣想进行学习和了解。首先学习和了解的是JPA自动创建数据库表，通过JPA能够让软件工程师们不用再去手动创建数据表，能够减轻软件工程师们的工作量。通过本篇博客可以实现使用Spring Data JPA自动创建数据库表，并且可以使表与表之间具有关联性（一对多，多对多，一对一）最后可以通过可视化工具Navicat进行表关系的查看。
手写jpa自动创建数据库表
蜗牛也需要奔跑
02-22 1483
jpa自动创建数据库表
jpa学习(一）通过jpa创建数据库表
qq_41842356的博客
08-06 2641
jpa创建数据库表 一对多关系 1、创建实体类user以及department，一个department里面有多个user，代码如下 package com.example.springbootjpatest.entity; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import lombok.Data; import lombok.ToString; import lombok.Value; import javax.m
JPA自动生成数据库表教程
m0_52174905的博客
09-05 5044
简单的来说，Jpa就是一个和mybatis-plus功能类似的一个持久层框架，也是将所有基本的CRUD操作封装好了，下面来介绍一下自动生成数据库表的操作。 JPA常用注解 1、常用基本注解 @Entity @Table @Basic @Column @GeneratedValue @Id @OneToMany @ManyToOne @ManyToMany 具体用法可以自...
SpringBoot jpa 自动建表的配置方法
tfish的专栏
05-23 1309
在 application.properties 文件中配置如下: spring.jpa.hibernate.ddl-auto=update
SpringBoot整合JPA实现自动创建数据库表自动建表，JPA逆向生成数据库表.zip
11-10
新建一个test的数据库即可，表在springboot启动后自动新建 依赖包文件(可选) Maven管理jar包依赖，编译工程自动下载 链接：https://pan.baidu.com/s/1QYVjX-0FeWquWz9zY87oVQ?pwd=ilah 提取码：ilah
jpa自动代码生成工具
08-16
本工具可以根据数据库表自动生成JPA开发所需的实体JavaBean（带有jpa主注解）、repository及service类，提高开发效率；目前支持数据库：MYSQL；并提供配合演示使用的demo项目。
springboot jpa 自动生成实体类的 文件 Generate POJOs.groovy
06-01
springboot jpa 自动生成实体类的 文件 可以拿走直接用 Generate POJOs.groovy
jpa 建表 以及 自我理解
qq_58979565的博客
07-26 397
首先 是 创建 entity 拉取 jpa 的 依赖 <dependencies> <!-- data-jpa --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> ...
Mybatis加入JPA的自动建表功能
weixin_34248118的博客
08-30 1053
Mybatis是一个自由度很高的ORM框架,关于Mybatis和Hibernate孰优孰劣的争论从来就没有停止过.但是Mybatis不支持自动建表确实是一大硬伤,在需要快速修改的小项目或者小bug中非常麻烦. 本文引入JPA自动建表和Mybatis共存,既满足了Mybatis的自由度又使用了JPA的便利性 此处假定各位看官已经配置好了Mybatis的整体环境,如果没有可以看我的另一篇文章Sprin...
SpringDataJPA 源码解析
m0_37561303的博客
03-25 1107
SpringDataJPA是什么
springboot+jpa自动建表
m0_56463670的博客
08-13 8371
原文：https://blog.csdn.net/NMZLduiduidui/article/details/105536644?utm_source=app&app_version=4.13.0&code=app_1562916241&uLinkId=usr1mkqgl919blen jpa自动建表 1.pom.xml添加依赖 <dependency> <groupId>org.springframework.boot</groupId
5.3.3 表生成器@ TableGenerator
05-09 5789
将当前主键的值单独保存到一个数据库的表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式也是很常用的。这种方法生成主键的策略可以适用于任何的数据库，不必担心不同数据库不兼容造成的问题。使用以下SQL脚本创建一个表“tb_generator”，并插入两条数据，SQL脚本如下所示。CREATE TABLE  tb_generator (  id int(20) unsign
web安全学习笔记（6）
最新发布
m0_58875569的博客
04-06 790
记一下第十节课的内容。
jpa自动建表的好处
12-08
JPA自动建表的好处在于，它可以根据实体类的定义自动创建对应的数据库表，省去了手动创建表的繁琐过程。此外，JPA还可以根据实体类中的注解自动创建表的约束条件，例如主键、外键、唯一性约束等。这样可以大大提高开发效率，减少出错的可能性。 举个例子，如果我们有一个名为User的实体类，其中包含了id、name、age等属性，我们可以通过如下的代码来让JPA自动创建对应的数据库表： ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "name") private String name; @Column(name = "age") private Integer age; // 省略getter和setter方法 } ``` 在这个例子中，@Entity注解表示这是一个实体类，@Table注解表示对应的数据库表名为"user"，@Id注解表示id属性为主键，@GeneratedValue注解表示主键自动生成，@Column注解表示对应的数据库列名为"name"和"age"。 通过以上的定义，我们可以让JPA自动创建对应的数据库表，而不需要手动创建。这样可以大大提高开发效率，减少出错的可能性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值