Springboot JPA 的简单使用和字段排序问题

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

简单使用

在Springboot项目中引入 jpa

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

定义公共字段

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

@MappedSuperclass //告诉 jpa 这是公用字段
public class CommonModel {
	@Id
	@Column(columnDefinition = "bigint(64) COMMENT 'ID'")
	private Long id;

	@Column(columnDefinition = "varchar(32) COMMENT '创建者'")
	private String createBy;

	@Column(columnDefinition = "datetime COMMENT '创建时间'")
	private Date createTime;

	@Column(columnDefinition = "datetime COMMENT '更新者'")
	private String updateBy;

	@Column(columnDefinition = "datetime COMMENT '更新时间'")
	private Date updateTime;

	@Column(columnDefinition = "datetime COMMENT '备注'")
	private String remark;
}

定义表字段

import lombok.Data;
import javax.persistence.*;

@Entity
@Table(name = "data_catalog")
@Data
@org.hibernate.annotations.Table(appliesTo = "data_catalog",comment="数据目录") //告诉数据库这是表注释
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class DataCatalog extends CommonModel {
	@Column(columnDefinition = "varchar(32) COMMENT '目录名称'")
	private String name; // 目录名称
	@Column(columnDefinition = "bigint(64) DEFAULT 0 COMMENT '上级目录'")
	private Long parentId; // 上级目录
	@Column(columnDefinition = "varchar(32) COMMENT '目录描述'")
	private String description; // 目录描述
	@Column(columnDefinition = "int COMMENT '排序'")
	private Integer sort; // 排序
}

通过以上步骤就可以简单实现自动建表了！
当然配置文件上记得配置 spring.jpa.hibernate.ddl-auto = update
下面说一下排序问题

排序

需要重写jpa的排序逻辑
这里我们直接在java目录下新建两个类
原理就是修改最终的字段属性返回值实现重新排序
在这里插入图片描述
要记得这个报名和下面的类名完全一致！
这个是为了覆盖jap的源码，利用了jvm的加载类文件的原理实现的，不需要动jar包里面的类！

InheritanceState 代码

这里是修改这部分的代码，对 properties 的顺序进行了 改变
在这里插入图片描述

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.hibernate.cfg;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.persistence.Access;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.MappedSuperclass;
import org.hibernate.AnnotationException;
import org.hibernate.annotations.common.reflection.XAnnotatedElement;
import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.annotations.common.reflection.XProperty;
import org.hibernate.boot.spi.MetadataBuildingContext;
import org.hibernate.cfg.annotations.EntityBinder;
import org.hibernate.mapping.PersistentClass;

public class InheritanceState {
    private XClass clazz;
    private boolean hasSiblings = false;
    private boolean hasParents = false;
    private InheritanceType type;
    private boolean isEmbeddableSuperclass = false;
    private Map<XClass, InheritanceState> inheritanceStatePerClass;
    private List<XClass> classesToProcessForMappedSuperclass = new ArrayList();
    private MetadataBuildingContext buildingContext;
    private AccessType accessType;
    private InheritanceState.ElementsToProcess elementsToProcess;
    private Boolean hasIdClassOrEmbeddedId;

    public InheritanceState(XClass clazz, Map<XClass, InheritanceState> inheritanceStatePerClass, MetadataBuildingContext buildingContext) {
        this.setClazz(clazz);
        this.buildingContext = buildingContext;
        this.inheritanceStatePerClass = inheritanceStatePerClass;
        this.extractInheritanceType();
    }

    private void extractInheritanceType() {
        XAnnotatedElement element = this.getClazz();
        Inheritance inhAnn = (Inheritance)element.getAnnotation(Inheritance.class);
        MappedSuperclass mappedSuperClass = (MappedSuperclass)element.getAnnotation(MappedSuperclass.class);
        if (mappedSuperClass != null) {
            this.setEmbeddableSuperclass(true);
            this.setType(inhAnn == null ? null : inhAnn.strategy());
        } else {
            this.setType(inhAnn == null ? InheritanceType.SINGLE_TABLE : inhAnn.strategy());
        }

    }

    boolean hasTable() {
        return !this.hasParents() || !InheritanceType.SINGLE_TABLE.equals(this.getType());
    }

    boolean hasDenormalizedTable() {
        return this.hasParents() && InheritanceType.TABLE_PER_CLASS.equals(this.getType());
    }

    public static InheritanceState getInheritanceStateOfSuperEntity(XClass clazz, Map<XClass, InheritanceState> states) {
        XClass superclass = clazz;

        do {
            superclass = superclass.getSuperclass();
            InheritanceState currentState = (InheritanceState)states.get(superclass);
            if (currentState != null && !currentState.isEmbeddableSuperclass()) {
                return currentState;
            }
        } while(superclass != null && !Object.class.getName().equals(superclass.getName()));

        return null;
    }

    public static InheritanceState getSuperclassInheritanceState(XClass clazz, Map<XClass, InheritanceState> states) {
        XClass superclass = clazz;

        do {
            superclass = superclass.getSuperclass();
            InheritanceState currentState = (InheritanceState)states.get(superclass);
            if (currentState != null) {
                return currentState;
            }
        } while(superclass != null && !Object.class.getName().equals(superclass.getName()));

        return null;
    }

    public XClass getClazz() {
        return this.clazz;
    }

    public void setClazz(XClass clazz) {
        this.clazz = clazz;
    }

    public boolean hasSiblings() {
        return this.hasSiblings;
    }

    public void setHasSiblings(boolean hasSiblings) {
        this.hasSiblings = hasSiblings;
    }

    public boolean hasParents() {
        return this.hasParents;
    }

    public void setHasParents(boolean hasParents) {
        this.hasParents = hasParents;
    }

    public InheritanceType getType() {
        return this.type;
    }

    public void setType(InheritanceType type) {
        this.type = type;
    }

    public boolean isEmbeddableSuperclass() {
        return this.isEmbeddableSuperclass;
    }

    public void setEmbeddableSuperclass(boolean embeddableSuperclass) {
        this.isEmbeddableSuperclass = embeddableSuperclass;
    }

    void postProcess(PersistentClass persistenceClass, EntityBinder entityBinder) {
        this.getElementsToProcess();
        this.addMappedSuperClassInMetadata(persistenceClass);
        entityBinder.setPropertyAccessType(this.accessType);
    }

    public XClass getClassWithIdClass(boolean evenIfSubclass) {
        if (!evenIfSubclass && this.hasParents()) {
            return null;
        } else if (this.clazz.isAnnotationPresent(IdClass.class)) {
            return this.clazz;
        } else {
            InheritanceState state = getSuperclassInheritanceState(this.clazz, this.inheritanceStatePerClass);
            return state != null ? state.getClassWithIdClass(true) : null;
        }
    }

    public Boolean hasIdClassOrEmbeddedId() {
        if (this.hasIdClassOrEmbeddedId == null) {
            this.hasIdClassOrEmbeddedId = false;
            if (this.getClassWithIdClass(true) != null) {
                this.hasIdClassOrEmbeddedId = true;
            } else {
                InheritanceState.ElementsToProcess process = this.getElementsToProcess();
                Iterator var2 = process.getElements().iterator();

                while(var2.hasNext()) {
                    PropertyData property = (PropertyData)var2.next();
                    if (property.getProperty().isAnnotationPresent(EmbeddedId.class)) {
                        this.hasIdClassOrEmbeddedId = true;
                        break;
                    }
                }
            }
        }

        return this.hasIdClassOrEmbeddedId;
    }

    public InheritanceState.ElementsToProcess getElementsToProcess() {
        if (this.elementsToProcess == null) {
            InheritanceState inheritanceState = (InheritanceState)this.inheritanceStatePerClass.get(this.clazz);

            assert !inheritanceState.isEmbeddableSuperclass();

            this.getMappedSuperclassesTillNextEntityOrdered();
            this.accessType = this.determineDefaultAccessType();
            ArrayList<PropertyData> elements = new ArrayList();
            int idPropertyCount = 0;

            int currentIdPropertyCount;
            for(Iterator var4 = this.classesToProcessForMappedSuperclass.iterator(); var4.hasNext(); idPropertyCount += currentIdPropertyCount) {
                XClass classToProcessForMappedSuperclass = (XClass)var4.next();
                PropertyContainer propertyContainer = new PropertyContainer(classToProcessForMappedSuperclass, this.clazz, this.accessType);
                currentIdPropertyCount = AnnotationBinder.addElementsOfClass(elements, propertyContainer, this.buildingContext);
            }

            if (idPropertyCount == 0 && !inheritanceState.hasParents()) {
                throw new AnnotationException("No identifier specified for entity: " + this.clazz.getName());
            }

            elements.trimToSize();
            this.elementsToProcess = new InheritanceState.ElementsToProcess(elements, idPropertyCount);
        }

        return this.elementsToProcess;
    }

    private AccessType determineDefaultAccessType() {
        XClass xclass;
        for(xclass = this.clazz; xclass != null; xclass = xclass.getSuperclass()) {
            if ((xclass.getSuperclass() == null || Object.class.getName().equals(xclass.getSuperclass().getName())) && (xclass.isAnnotationPresent(Entity.class) || xclass.isAnnotationPresent(MappedSuperclass.class)) && xclass.isAnnotationPresent(Access.class)) {
                return AccessType.getAccessStrategy(((Access)xclass.getAnnotation(Access.class)).value());
            }
        }

        label62:
        for(xclass = this.clazz; xclass != null && !Object.class.getName().equals(xclass.getName()); xclass = xclass.getSuperclass()) {
            if (xclass.isAnnotationPresent(Entity.class) || xclass.isAnnotationPresent(MappedSuperclass.class)) {
                Iterator var2 = xclass.getDeclaredProperties(AccessType.PROPERTY.getType()).iterator();

                XProperty prop;
                boolean isEmbeddedId;
                do {
                    if (!var2.hasNext()) {
                        var2 = xclass.getDeclaredProperties(AccessType.FIELD.getType()).iterator();

                        do {
                            if (!var2.hasNext()) {
                                continue label62;
                            }

                            prop = (XProperty)var2.next();
                            isEmbeddedId = prop.isAnnotationPresent(EmbeddedId.class);
                        } while(!prop.isAnnotationPresent(Id.class) && !isEmbeddedId);

                        return AccessType.FIELD;
                    }

                    prop = (XProperty)var2.next();
                    isEmbeddedId = prop.isAnnotationPresent(EmbeddedId.class);
                } while(!prop.isAnnotationPresent(Id.class) && !isEmbeddedId);

                return AccessType.PROPERTY;
            }
        }

        throw new AnnotationException("No identifier specified for entity: " + this.clazz);
    }

    private void getMappedSuperclassesTillNextEntityOrdered() {
        XClass currentClassInHierarchy = this.clazz;

        InheritanceState superclassState;
        do {
            this.classesToProcessForMappedSuperclass.add(0, currentClassInHierarchy);
            XClass superClass = currentClassInHierarchy;

            do {
                superClass = superClass.getSuperclass();
                superclassState = (InheritanceState)this.inheritanceStatePerClass.get(superClass);
            } while(superClass != null && !this.buildingContext.getBuildingOptions().getReflectionManager().equals(superClass, Object.class) && superclassState == null);

            currentClassInHierarchy = superClass;
        } while(superclassState != null && superclassState.isEmbeddableSuperclass());

    }

    private void addMappedSuperClassInMetadata(PersistentClass persistentClass) {
        org.hibernate.mapping.MappedSuperclass mappedSuperclass = null;
        InheritanceState superEntityState = getInheritanceStateOfSuperEntity(this.clazz, this.inheritanceStatePerClass);
        PersistentClass superEntity = superEntityState != null ? this.buildingContext.getMetadataCollector().getEntityBinding(superEntityState.getClazz().getName()) : null;
        int lastMappedSuperclass = this.classesToProcessForMappedSuperclass.size() - 1;

        for(int index = 0; index < lastMappedSuperclass; ++index) {
            org.hibernate.mapping.MappedSuperclass parentSuperclass = mappedSuperclass;
            Class<?> type = this.buildingContext.getBuildingOptions().getReflectionManager().toClass((XClass)this.classesToProcessForMappedSuperclass.get(index));
            mappedSuperclass = this.buildingContext.getMetadataCollector().getMappedSuperclass(type);
            if (mappedSuperclass == null) {
                mappedSuperclass = new org.hibernate.mapping.MappedSuperclass(parentSuperclass, superEntity);
                mappedSuperclass.setMappedClass(type);
                this.buildingContext.getMetadataCollector().addMappedSuperclass(type, mappedSuperclass);
            }
        }

        if (mappedSuperclass != null) {
            persistentClass.setSuperMappedSuperclass(mappedSuperclass);
        }

    }

    static final class ElementsToProcess {
        private final List<PropertyData> properties;
        private final int idPropertyCount;

        public List<PropertyData> getElements() {
            return this.properties;
        }

        public int getIdPropertyCount() {
            return this.idPropertyCount;
        }

        private ElementsToProcess(List<PropertyData> properties, int idPropertyCount) {
            List<PropertyData> perList = new ArrayList<>();
            List<PropertyData> finalList = new ArrayList<>();
            properties.forEach(item->{
                XClass last = properties.get(properties.size()-1).getDeclaringClass();
                String name = item.getProperty().getName();
                if(item.getDeclaringClass()!=last && !name.equals("id") ){
                    finalList.add(item);
                }else{
                    perList.add(item);
                }
            });
            perList.addAll(finalList);
            this.properties = perList;
            this.idPropertyCount = idPropertyCount;
        }
    }
}

PropertyContainer 代码

这部分代码是改变了 属性存储对象的类型 把Map 改成 LinkedHashMap 实现有序！

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.*;

/**
 * @Author: 凤凰[小哥哥]
 * @Date: 2019/9/20 16:12
 * @Email: 15290810931@163.com
 */
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);
        int i=0;
    }

    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());
    }
}

好了，最后篇幅有限，如果有问题的朋友可以私信我或者评论区讨论哈

梁三思
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
解决 Springboot Jpa 自动创建表 和字段乱序问题[凤凰小哥哥]
09-20
产生原因：因为使用 jpa 自动创建表的时候，采用的是TreeMap的，我们要变成LinkedHashMap 的结构。 解决方案：在项目下java文件夹下创建包名为： org.hibernate.cfg  ，创建类： PropertyContainer [包名，类名一定要相同哦]
Jpa 根据字段排序
Don-Talk的博客
01-10 7517
方法一：Pageable /** * 查询所有，根据"xh"字段升序排序 */ @RequestMapping(value = "/cVendorListUI") public String cvendorList(Model model, @PageableDefault(value = 20, sort = {"xh"}, direction ...
Spring Data JPA分页与排序
热门推荐
pan_junbiao的博客
04-17 1万+
1、认识JPA的分页接口和排序类 在项目的开发中，需要经常对数据表进行分页和排序查询。下面将介绍如何使用Spring Data JPA对数据进行分页和排序。 1.1 分页排序接口 PagingAndSortingRepository PagingAndSortingRepository 接口继承自CrudRepository 接口提供的分页和排序方法。其关键代码如下： @NoRepos...
解决 Springboot Jpa 自动创建表 和字段乱序问题
m0_53925153的博客
06-20 1222
解决 Springboot Jpa 自动创建表 和字段乱序问题。
jpa ---排序
iteye_4585的博客
12-14 415
ORDER BY 允许你对查询结果进行排序。数据库排序比应用程序更有效。要依据集合的顺序，可以使用ORDER BY 操作符。(更多信息参见第三章Entities Part II中@OrderBy 注释) 这是一个JPQL 查询语句中Order By 操作符的所在位置。 select from [where] [group by] [having] [order by] Ord...
jpa生成字段顺序和实体类保持一致
weixin_43826336的博客
07-23 685
已经新建生成的字段顺序不会被改变！！！ 在java目录下新建一个包：org.hibernate.cfg 上代码，复制进去就能用： package org.hibernate.cfg; import org.hibernate.AnnotationException; import org.hibernate.MappingException; import org.hibernate.annotations.ManyToAny; import org.hibernate.annotations.Targ
spring jap多个属性，不同排序方式
ClaireCheney的博客
08-12 135
List orders=new ArrayList(); Sort.Order order1 = new Sort.Order(Sort.Direction.DESC, "status"); Sort.Order order2 = new Sort.Order(Sort.Direction.ASC, "endTime"); orders.add(order1); orders.add(order2); Pageable pageable = PageReque
SpringBoot JPA 表关联查询实例
08-30
本文将深入探讨如何使用Spring Boot JPA进行表关联查询，以一对多关系为例，展示如何通过JPA的`findBy`方法实现。 首先，我们有两个实体类：`Floor`（商品楼层类）和`FloorContent`（商品楼层内容表）。在JPA中，...
SpringBoot Jpa分页查询配置方式解析
08-25
Sort 是 SpringBoot Jpa 中用于实现排序的接口，该接口提供了多种方法来实现排序。Sort 接口的主要方法包括： * Sort by(Sort.Direction direction, String... properties)：根据指定的方向和字段进行排序 Jpa...
springboot-jpa
11-16
**SpringBoot整合JPA详解** 在现代Java开发中，Spring Boot框架因其简洁高效的特性而备受青睐，而JPA（Java Persistence API）则是Java领域中广泛使用的对象关系映射（ORM）框架之一。本文将深入探讨如何在Spring ...
java springboot+jpa
08-06
通过这个"springboot-jpa"项目，你可以深入了解 Spring Boot 如何与 JPA 结合，实践各种 JPA 和 Spring Data JPA 的用法，以及如何在实际项目中进行数据库操作。这个 v1 版本应该包含了基本的示例和实践，对于理解和...
spring jpa 自动建表 字段乱序 字段 顺序
weixin_34321753的博客
04-11 6484
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Boot中JPA实现Sort排序的三种方式
HD243608836的博客
01-24 8809
引言： 在Spring Boot应用中，基于数据某个字段进行排序是一个非常常用的需求，这里将给出Sort的三种常用用法，基于分页的应用，大家可以各取所需，择机使用。 环境说明 Spring 4.2 Spring Boot 1.5.11 Java 8 前置说明 ECardEntity.java的定义： import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Table;
Spring -Data-Jpa 多条件排序
Likeisnotexist的博客
03-23 1477
简单的常用的就不多说了，这里纪录下项目中用到的几种排序场景 1. 多条件同序排序（全是正序/全是倒序） Sort sort = isSnapshot ? new Sort(Sort.Direction.DESC, "isTop", "createTime"):new Sort(Sort.Direction.ASC, "state","createTime"); 2. 不同顺序多条件排序（有正序有...
springboot中JPA的各种排序方式+分页+关键字查询
wangshao5122的博客
10-26 3050
1、非原生语句排序，在Dao接口Repositorie中编写非原生SQL语句 /** * 用户管理的Dao接口 */ public interface UserRepositories extends JpaRepository<User, Integer>,JpaSpecificationExecutor<User>{ /** * 查询全部，倒序 * @return */ @Query(value = "select u from User u order b
SpringBoot JPA sort多属性排序
stonezealot_zjr的博客
08-07 5137
在开发JPA中，遇见需要对数据进行多属性排序的情况，例如 select * from MldmasView order by vslName ASC,custName ASC,docDate DESC; 导入jar包 import org.springframework.data.domain.Sort.Order; 代码示例 List<Sort.Order> list = new...
堆排序（非递归）
japinli
03-18 746
堆排序非递归算法及通用形式
JPA（order, or, like, left join, 时间筛选,when case,find_in_set ）
放开那个桃子的博客
05-30 4424
多字段排序 List&lt;Order&gt; orders=new ArrayList&lt;&gt;(); orders.add(builder.asc(root.join("provider").&lt;String&gt; get("providerCode"))); orders.add(builder.asc(root.&lt;Str...
springboot JPA
最新发布
09-15
SpringBoot JPA 是指在 SpringBoot 框架中集成了 Spring Data JPA 技术。Spring Data JPA 是对 JPA 规范的进一步封装和抽象，底层使用了 Hibernate 的 JPA 技术实现。 通过 SpringBoot JPA，我们可以实现对数据库的增删改查操作。在 SpringBoot 中，我们可以通过编写 Controller、Model、DAO、Service 等代码来实现这些功能，并且可以通过配置文件进行相应的配置。同时，SpringBoot JPA 还提供了事务控制的支持，可以确保数据库操作的一致性和完整性。 在 SpringBoot JPA 中，我们可以使用一些常见的功能，如高级查询、预先生成方法、自定义简单查询、复杂查询、分页查询和限制查询等。这些功能可以帮助我们更方便地操作数据库，提高开发效率。 总结来说，SpringBoot JPA 是一种在 SpringBoot 框架中集成的 JPA 技术，可以帮助我们简化数据库操作的开发过程，并提供了事务控制的支持。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值