quarkus数据库篇之一：比官方demo更简单的基础操作

发布时间：2023-07-25

浏览次数：0

项目源码仓库地址，https合约

Git仓库地址（ssh）

git@.com:/.git

项目源码、ssh合约的仓库地址

确认数据库已准备好

docker run \\
--name quarkus_test \\
-e POSTGRES_USER=quarkus \\
-e POSTGRES_PASSWORD=123456 \\
-e POSTGRES_DB=quarkus_test \\
-p 5432:5432 \\
-v /xxx:/var/lib/postgresql/data \\
postgres:13.3

关系库的标准语言_intellij idea 数据库关系图_数据库关系图在哪

创建一个新的maven子项目basic-db



    
        quarkus-tutorials
        com.bolingcavalry
        1.0-SNAPSHOT
    
    4.0.0
    basic-db
    
        
            io.quarkus
            quarkus-arc
        
        
        
            io.quarkus
            quarkus-agroal
        
        
        
            io.quarkus
            quarkus-hibernate-orm
        
        
        
            io.quarkus
            quarkus-jdbc-postgresql
        
        
        
            io.quarkus
            quarkus-junit5
            test
        
        
            io.rest-assured
            rest-assured
            test
        
    
    
        
            
                ${quarkus.platform.group-id}
                quarkus-maven-plugin
                true
                
                    
                        
                            build
                            generate-code
                            generate-code-tests
                        
                    
                
            
            
                maven-compiler-plugin
                
                    
                        -parameters
                    
                
            
            
                maven-surefire-plugin
                
                    
                        org.jboss.logmanager.LogManager
                        ${maven.home}

配置文件

quarkus.datasource.db-kind=postgresql
quarkus.hibernate-orm.log.sql=true
quarkus.datasource.jdbc.max-size=8
quarkus.datasource.jdbc.min-size=2

quarkus.datasource.username=quarkus
quarkus.datasource.password=123456
quarkus.datasource.jdbc.url=jdbc:postgresql://192.168.50.43:15432/quarkus_test
quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.hibernate-orm.sql-load-script=import.sql

.-orm..：有六个值，如下表

价值

意义

没有任何

没做什么

第一次启动会建表，之后启动不会改变

跌落-

每次启动应用的时候删除表（数据没了），然后建表，然后执行.sql导出数据

降低

启动应用程序时删除表，但不删除数据库

保留数据，升级表结构

检查表结构是否匹配

数据库关系图在哪_intellij idea 数据库关系图_关系库的标准语言

.-orm.sql-load-：指定sql文件。当配置项.-orm..等于drop-and-时，执行此sql文件，可用于生成初始化数据SQL文件

INSERT INTO known_fruits(id, name) VALUES (1, 'Cherry');
INSERT INTO known_fruits(id, name) VALUES (2, 'Apple');
INSERT INTO known_fruits(id, name) VALUES (3, 'Banana');

编码：实体类

package com.bolingcavalry.db.entity;
import javax.persistence.Cacheable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.QueryHint;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity
@Table(name = "known_fruits")
@NamedQuery(name = "Fruits.findAll", query = "SELECT f FROM Fruit f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
@Cacheable
public class Fruit {
    @Id
    @SequenceGenerator(name = "fruitsSequence", sequenceName = "known_fruits_id_seq", allocationSize = 1, initialValue = 10)
    @GeneratedValue(generator = "fruitsSequence")
    private Integer id;
    @Column(length = 40, unique = true)
    private String name;
    public Fruit() {
    }
    public Fruit(String name) {
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

注解Table确定通过一条名为.的自定义SQL来减少表名，旁边会使用该注解定义的自增字段的信息。初始值为10，也就是说当前应用添加的第一条记录的ID等于表。只有两个数组：id和layer

package com.bolingcavalry.db.service;
import com.bolingcavalry.db.entity.Fruit;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.transaction.Transactional;
import java.util.List;
@ApplicationScoped
public class FruitService {
    @Inject
    EntityManager entityManager;
    public List get() {
        return entityManager.createNamedQuery("Fruits.findAll", Fruit.class)
                .getResultList();
    }
    public Fruit getSingle(Integer id) {
        return entityManager.find(Fruit.class, id);
    }
    @Transactional
    public void create(Fruit fruit) {
        entityManager.persist(fruit);
    }
    @Transactional
    public void update(Integer id, Fruit fruit) {
        Fruit entity = entityManager.find(Fruit.class, id);
        if (null!=entity) {
            entity.setName(fruit.getName());
        }
    }
    @Transactional
    public void delete(Integer id) {
        Fruit entity = entityManager.getReference(Fruit.class, id);
        if (null!=entity) {
            entityManager.remove(entity);
        }
    }
}

单元测试类

package com.bolingcavalry;
import com.bolingcavalry.db.entity.Fruit;
import com.bolingcavalry.db.service.FruitService;
import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.*;
import javax.inject.Inject;
import java.util.List;
@QuarkusTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class FruitServiceTest {
    /**
     * import.sql中导入的记录数量，这些是应用启动是导入的
     */
    private static final int EXIST_RECORDS_SIZE = 3;
    /**
     * import.sql中，第一条记录的id
     */
    private static final int EXIST_FIRST_ID = 1;
    /**
     * 在Fruit.java中，id字段的SequenceGenerator指定了initialValue等于10，
     * 表示自增ID从10开始
     */
    private static final int ID_SEQUENCE_INIT_VALUE = 10;
    @Inject
    FruitService fruitService;
    @Test
    @DisplayName("list")
    @Order(1)
    public void testGet() {
        List list = fruitService.get();
        // 判定非空
        Assertions.assertNotNull(list);
        // import.sql中新增3条记录
        Assertions.assertEquals(EXIST_RECORDS_SIZE, list.size());
    }
    @Test
    @DisplayName("getSingle")
    @Order(2)
    public void testGetSingle() {
        Fruit fruit = fruitService.getSingle(EXIST_FIRST_ID);
        // 判定非空
        Assertions.assertNotNull(fruit);
        // import.sql中的第一条记录
        Assertions.assertEquals("Cherry", fruit.getName());
    }
    @Test
    @DisplayName("update")
    @Order(3)
    public void testUpdate() {
        String newName = "ShanDongBigCherry";
        fruitService.update(EXIST_FIRST_ID, new Fruit(newName));
        Fruit fruit = fruitService.getSingle(EXIST_FIRST_ID);
        // 从数据库取出的对象，其名称应该等于修改的名称
        Assertions.assertEquals(newName, fruit.getName());
    }
    @Test
    @DisplayName("create")
    @Order(4)
    public void testCreate() {
        Fruit fruit = new Fruit("Orange");
        fruitService.create(fruit);
        // 由于是第一次新增，所以ID应该等于自增ID的起始值
        Assertions.assertEquals(ID_SEQUENCE_INIT_VALUE, fruit.getId());
        // 记录总数应该等于已有记录数+1
        Assertions.assertEquals(EXIST_RECORDS_SIZE+1, fruitService.get().size());
    }
    @Test
    @DisplayName("delete")
    @Order(5)
    public void testDelete() {
        // 先记删除前的总数
        int numBeforeDelete = fruitService.get().size();
        // 删除第一条记录
        fruitService.delete(EXIST_FIRST_ID);
        // 记录数应该应该等于删除前的数量减一
        Assertions.assertEquals(numBeforeDelete-1, fruitService.get().size());
    }
}

共有五种测试方法。为了对它们进行排序，您需要使用注释来修改类，并将值设置为..class。然后用Order注解修改每个方法intellij idea 数据库关系图，就可以使用该值来执行测试订单。测试方法有很多种。为了便于观察，使用注释为每个测试方法命名。同名intellij idea 数据库关系图，在IDEA上测试结果如下

intellij idea 数据库关系图_数据库关系图在哪_关系库的标准语言