基于Kotlin的 Spring Boot JPA应用

最新推荐文章于 2024-05-27 09:36:43 发布
原创 最新推荐文章于 2024-05-27 09:36:43 发布 · 2.6k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JPA

本文通过实例介绍如何使用Kotlin与SpringBoot JPA进行应用开发，涵盖依赖引入、实体类定义、存储库使用及JUnit5测试。

基于Kotlin的 Spring Boot JPA应用

1. 简介

本文主要讲解如何在Kotlin中使用JPA。为了便于讲解，本文使用了一个Spring Boot JPA应用，其特征如下 :

  • 基于Spring Data JPA
  • 没有使用Web层
  • 所有类通过Kotlin定义
  • 使用JUnit 5
  • 使用内嵌数据库H2用于演示

2. pom.xml

2.1 依赖

首先，我们要在pom.xml中引入依赖，声明使用Spring Boot 和JPA :

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

然后，我们使用H2内嵌式数据库支持数据保存 :

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>

接下来，是跟Kotlin相关的依赖 , 这里kotlin.version在pom.xml属性定义区域定义 :

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

单元测试有关的依赖 :

        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>

2.2. JPA编译插件

要使用JPA,实体类需要一个无参构造函数。

缺省情况下,Kotlin数据类是没有无参构造函数的，为了产生无参构造函数，我们需要如下JPA插件:


            <plugin>
                <artifactId>kotlin-maven-plugin</artifactId>
                <groupId>org.jetbrains.kotlin</groupId>
                <version>${kotlin.version}</version>
                <configuration>
                    <compilerPlugins>
                        <!--注意插件 jpa 不能缺少，非则会提示Entity缺少缺省构造函数-->
                        <plugin>jpa</plugin>
                    </compilerPlugins>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-noarg</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
            </plugin>

2.3 完整的 pom.xml 文件内容

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>andy.kotlin.jpa</groupId>
    <artifactId>zero</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <kotlin.version>1.3.50</kotlin.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <dependencies>
        <!-- 使用 Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- 使用 Spring Data JPA -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <!-- 排除 JUnit 4 -->
                <exclusion>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 使用 JUnit 5 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>kotlin-maven-plugin</artifactId>
                <groupId>org.jetbrains.kotlin</groupId>
                <version>${kotlin.version}</version>
                <configuration>
                    <compilerPlugins>
                        <!--注意插件 jpa 不能缺少，非则会提示Entity缺少缺省构造函数-->
                        <plugin>jpa</plugin>
                    </compilerPlugins>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-noarg</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

3. 使用Kotlin数据类定义JPA实体

以上步骤完成后，现在可以通过Kotlin数据类定义JPA实体。在本文的例子中，我们定义了两个JPA实体：员工Employee和电话号码PhoneNumber , 如下所示 :

3.1 实体类

员工实体Employee定义在文件Employee.kt中 :

package andy

import javax.persistence.*

@Entity
data class Employee(
        /**
         * 员工记录 id，自动生成
         */
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        val id: Int,

        /**
         * 员工姓名,不可为空
         */
        @Column(nullable = false)
        val name: String,

        /**
         * 员工电子邮箱，可以为空
         */
        @Column(nullable = true)
        val email: String? = null,

        /**
         * 员工电话号码，可以有多个，关联存储在另外一张表中
         */
        @OneToMany(cascade = [CascadeType.ALL], fetch = FetchType.EAGER)
        val phoneNumbers: List<PhoneNumber>? = null
)

电话号码PhoneNumber实体定义在PhoneNumber.kt中 :

package andy

import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id

/**
 * 电话号码
 */
@Entity
data class PhoneNumber(
        /**
         * 电话号码记录 id，自动生成
         */
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        val id: Int,

        /**
         * 电话号码字符串值，不能为空
         */
        @Column(nullable = false)
        val number: String
)

从实体类定义可以看到，JPA提供的注解,比如@Entity,@Column和@Id等等在这里可以随意使用。

3.2. 存储库类

有了JPA实体，我们来定义相应的存储库类。

首先是员工Employee实体对应的存储库类EmployeeRepository,定义在文件EmployeeRepository.kt中:

package andy

import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.JpaSpecificationExecutor
import org.springframework.stereotype.Repository

@Repository
interface EmployeeRepository : JpaRepository<Employee, Long>, JpaSpecificationExecutor<Employee> {
   fun findByNameLike(pattern: String): List<Employee>;
}

然后是电话号码PhoneNumber实体对应的PhoneNumberRepository存储库类，定义在文件PhoneNumberRepository.kt中:

package andy

import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.JpaSpecificationExecutor
import org.springframework.stereotype.Repository

@Repository
interface PhoneNumberRepository : JpaRepository<PhoneNumber, Long>, JpaSpecificationExecutor<PhoneNumber> {
}

4. 应用程序入口

有了上面的实体类和相应的存储库，我们定义一个Spring Boot应用在文件Application.kt中,如下所示 :

package andy

import org.springframework.boot.CommandLineRunner
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Bean

@SpringBootApplication
open class Application {
    // 另外一种注入 EmployeeRepository bean 的方法
    //@Autowired
    //lateinit var repository: EmployeeRepository;

    /**
     * 定义一个 CommandLineRunner bean,
     * 它会在应用启动时运行
     */
    @Bean
    open fun init(repository: EmployeeRepository): CommandLineRunner {
        return CommandLineRunner {
            // 这段逻辑对应接口 CommandLineRunner 约定的方法  void run(String... args)
             
            // 注意下面定义的 Employee 实例的第三个参数设置为了 null,
            // 这里可以设置为 null 是因为 Employee 实体定义中相应 phoneNumber 属性定义中的问号
            repository.save(Employee(0, "张三", "zhang.san@test.com", null))
            repository.save(Employee(0, "李四", "li.si@test.com", null))
            repository.save(Employee(0, "王五", "wang.wu@test.com", null))

            /**
             * 上面的添加了一个Employee 王五，所以下面输出语句肯定能搜索到一条记录
             */
            val entity = repository.findByNameLike("王五")[0];
            println("查询到的记录应该是 王五 : $entity");
        }
    }
}


fun main(args: Array<String>) {
    runApplication<Application>(*args)
}

在该文件中:

  1. 我们使用注解@SpringBootApplication定义了一个Spring Boot应用类Application；
  2. 又定义了一个Spring Boot CommandLineRunner bean,接口CommandLineRunner约定了该bean的run方法会在容器启动时被执行;
  3. 定义方法main启动应用Application;

该文件中重点的部分是CommandLineRunner bean的定义。它有如下特征 :

  1. 以一个Kotlin函数的形式存在，接受一个参数repository: EmployeeRepository以接收注入的EmployeeRepository bean;
  2. 返回值是一个CommandLineRunner实例，表明其run方法会在应用启动时被调用;

另外，我们在CommandLineRunner#run方法逻辑中往数据库插入三条员工记录，但是每个员工的电话号码都未设置，使用了null值。这里主要是用来演示数据库插入动作和null值的使用的。运行该程序，你可以看到如下输出 :

查询到的记录应该是 王五 : Employee(id=3, name=王五, email=wang.wu@test.com, phoneNumbers=[])

5. 单元测试

这里我们制作一个基于JUnit 5的单元测试来观察一下Kotlin中使用JPA :

package andy

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.context.SpringBootTest
import java.util.*


@DataJpaTest
@DisplayName("Test JPA in Kotlin using JUnit 5")
open class KotlinJPATest @Autowired constructor(val employeeRepository: EmployeeRepository) {

    // 另外一种注入方式，属性注入
    @Autowired
    lateinit var phoneNumberRepository: PhoneNumberRepository;

    @Test
    fun testJPAInKotlin() {
        /**
         * 以下语句添加三个员工，使用六个电话号码
         */

        val tom = Employee(0, "Tom", "tom@test.com", Arrays.asList(PhoneNumber(0, "110"), PhoneNumber(0, "120")));
        employeeRepository.save(tom);

        val jerry = Employee(0, "Jerry", "jerry@test.com", Arrays.asList(PhoneNumber(0, "119"), PhoneNumber(0, "911")));
        employeeRepository.save(jerry);

        val andy = Employee(0, "Andy", "andy@test.com", Arrays.asList(PhoneNumber(0, "114"), PhoneNumber(0, "10080")));
        employeeRepository.save(andy);


        /**
         * 下面查询语句能匹配到一条记录，是关于 Jerry 的
         */
        val employees: List<Employee> = employeeRepository.findByNameLike("%rr%");
        println("查询得到的员工记录是 : $employees ");
        assertEquals(1,employees.size,"查询得到的员工记录数量应该是1")
        assertEquals("Jerry",employees[0].name,"查询得到的员工记录应该是Jerry")

        /**
         * 下面输出电话号码的数量，应该是 6，也就是上面创建员工记录时所使用的电话号码信息
         */
        val countPhoneNumbers = phoneNumberRepository.count();
        println("电话号码记录数量 : $countPhoneNumbers");
        assertEquals(6,countPhoneNumbers,"电话号码数量 [应该是 6]")
    }
}

该单元测试我们主要演示以下几个要点 :

  1. 通过构造函数注入组件;
  2. 使用@Autowired注入组件;
  3. 在Kotlin中像在Java中一样操作JPA实体和存储库组件；

运行该测试，在控制台上，你应该可以看到如下输出 :

Hibernate: insert into employee (id, email, name) values (null, ?, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: insert into employee (id, email, name) values (null, ?, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: insert into employee (id, email, name) values (null, ?, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: insert into phone_number (id, number) values (null, ?)
Hibernate: select employee0_.id as id1_0_, employee0_.email as email2_0_, employee0_.name as name3_0_ from employee employee0_ where employee0_.name like ? escape ?
查询得到的员工记录是 : [Employee(id=5, name=Jerry, email=jerry@test.com, phoneNumbers=[PhoneNumber(id=3, number=119), PhoneNumber(id=4, number=911)])] 
Hibernate: select count(*) as col_0_0_ from phone_number phonenumbe0_
电话号码记录数量 : 6

6. 总结

本文通过一个例子应用讲解了如何使用Kotlin制作一个Spring Boot JPA应用，演示了如下要点 :

  1. 依赖的引入
  2. 插件的引入
  3. JPA实体的定义
  4. JPA存储库组件的定义
  5. SpringApplication入口应用程序的定义
  6. 基于JUnit 5的单元测试
  7. 基于构造函数的依赖注入
  8. 基于属性的依赖注入@Autowired
  9. JPA实体对象的创建
  10. 通过JPA存储库插入或者查询实体对象

参考文章

JPA之Specification多条件搜索
li_tiantian的博客
08-22 2220
import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root; import org.spr...
精选资源
kotlin-spring-boot-jpa-rest-api-demo：使用Kotlin，Spring Boot，Mysql，Jpa和Hibernate构建一个Restful API
01-30
Spring Boot是Spring框架的一个模块，简化了创建独立的、生产级别的基于Spring的应用程序。它通过自动配置、内嵌Web服务器（如Tomcat）以及“起步依赖”（Starter POMs）来加速开发过程。 MySQL是一个流行的开源...
spring boot + jpa + kotlin入门实例详解
08-29
主要介绍了spring boot + jpa + kotlin入门实例详解 ,需要的朋友可以参考下
kotlin-jpa-specification-dsl：该库提供了流利的DSL，用于使用spring数据规范（即JPA Criteria API）查询spring数据JPA存储库，而无需样板代码或生成的元模型
02-03
kotlin-jpa-specification-dsl：该库提供了流利的DSL，用于使用spring数据规范（即JPA Criteria API）查询spring数据JPA存储库，而无需样板代码或生成的元模型
用 Kotlin 开发 SpringBoot 之 Data JPA
孙亖的专栏
02-01 280
Kotlin 是一个基于 JVM 的新的编程语言，Kotlin 可以编译成 Java 字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。 Kotlin 已经成为 Android 原生开发的推荐首选语言，但传统领域的使用还存在着一定的争议，这次我们就感受下用 Kotlin 来开发一个 SpringBoot 是什么感觉。有 Java...
使用Kotlin打造的Spring Data JPA Specification DSL：高效查询新体验
gitblog_00036的博客
05-27 629
使用Kotlin打造的Spring Data JPA Specification DSL：高效查询新体验 项目介绍 Spring Data JPA Specification DSL for Kotlin 是一个专门面向Kotlin开发者的库，它提供了一个流式DSL，用于在Spring Data JPA仓库中通过Specifications（即JPA Criteria API）进行查询，无需编写繁...
DMeista:带有REST WebService和Spring Data JPA的Spring Boot Kotlin项目
04-12
本教程将介绍如何使用Kotlin、Spring Boot和Spring Data JPA构建一个包含RESTful Web Service的应用程序。这个项目名为"DMeista"，旨在提供一个基于Kotlin的后端解决方案，结合了Spring框架的强大功能，包括对数据库...
使用Spring Boot和Kotlin构建Web应用程序.pdf
最新发布
11-18
### Spring Boot和Kotlin构建Web应用程序知识点 #### Kotlin语言入门 - Kotlin是一门静态类型的编程语言，用于运行在Java虚拟机上。它由JetBrains公司开发，旨在解决实际应用开发中的痛点，比如简洁性和安全。 - ...
精选资源
spring-boot-kotlin-starter:Spring Boot和Kotlin入门
04-29
使用Spring Boot配置应用程序。 写在Kotlin。 如何使用 生成并运行。 ./gradlew bootRun 在浏览器中打开 。 发出发布请求以添加一个项目，如下所示。 curl ...
kotlin使用spring data jpa（一）
weixin_33966365的博客
11-01 683
2019独角兽企业重金招聘Python工程师标准>>> ...
kotlin-jpa-jooq:Kotlin，JPA，JOOQ
03-15
프로젝트 JOOQ，JPA，Kotlin，Spring Boot 2.4.3 를이를를JPA를네이네션과리로JOOQ로다이다。 JOOQ的代码生成，数据库实体，Schema，JPA实体，SQL和Java实体。이일고고고들었들었들었。 在CI / CD上运行的CI / CD上的所有内容。 를를인메모인메모인메모리DB를사용한로컬에서트는지힘들지않을까다。 H2니니니니블블블블에러에러에러났났다났。。。。。。。。。。。 DB정DBMS。... CREATE OR REPLACE TABLE USR_USER ( USER_KEY BIGINT NOT NULL PRIMARY KEY , USER_ID VARCHAR ( 256 ) NOT NULL UNIQUE, EMAIL VARCHAR ( 256 ) NOT NULL UNIQUE,
Springboot+Kotlin+Jpa集成项目
weixin_34324081的博客
11-09 531
2019独角兽企业重金招聘Python工程师标准>>> ...
Kotlin + SpringBoot + JPA 服务端开发
qq_34285557的博客
12-17 1269
Kotlin + SpringBoot + JPA 服务端开发 本篇主要介绍一下 kotlin + springboot的服务端开发环境搭建 1.概述 Kotlin 是一个基于JVM的编程语言, 是IDEA开发工具 jetbrains 公司开发的语言,也被google选为android开发的首选语言, 因为它是完全兼容Java的 所以也可以做后端开发 比如集成我们在使用Java的一些技术框架 ,本篇就来简单介绍一下和SpringBoot的集成 下面我用Gradle init 的方式从头开始搭建Kot
Kotlin日记——Kotlin+SpringBoot+Jpa入门
饥渴计科极客杰铿的博客
03-13 6669
Kotlin是一门很新的语言，它的设计和一些语法糖使它开发起来比Java要简洁很多，效率自然也提高了不少，性能方面，跟java也是不相上下的。 没有接触过Kotlin的朋友可以先到官网看详细教程 https://www.kotlincn.net/docs/reference/server-overview.html 众所周知SpringBoot是一个对新手极其友好的框架，它使开发者省
Kotlin + Jpa + Querydsl
qq_34285557的博客
12-21 784
Kotlin + Jpa + Querydsl 本篇主要介绍一下 kotlin + jpa + querydsl . jpa + querydsl 是我很喜欢的一种搭配,它能够让你写sql语句一样的去写代码 , 以前我也写过关于 java版本的, 本篇就来看看kotlin中如何去使用 1.引入插件 主要引入jpa插件 和 kapt Kotlin annotation processing tool（Kotlin 注解处理工具） plugins { // Apply the org.jetbra
SpringBoot2.x 集成 SpringDataJpa 基于Kotlin
RtxTitanV的博客
05-24 3165
SpringDataJpa简介：Spring Data JPA是Spring Data家族的一员，可以轻松实现基于JPA的存储库。该模块处理对基于JPA的数据访问层的增强支持。这使得构建使用数据访问技术的Spring应用程序变得更加容易。 在相当长的一段时间内，实现应用程序的数据访问层一直很麻烦。必须编写太多样板代码来执行简单查询以及执行分页和审计。Spring Data JPA旨在通过减少实际需要的工作量来显著改善数据访问层的实现。作为开发人员，你编写repository接口，包括自定义查询器方法，Spr
代码发布：用 Kotlin 开发 SpringBoot 之 Data JPA
孙亖的专栏
02-09 370
今天已经把分享的文章提交发布了，把代码也通过码云发布（地址看下面），分享内容目录如下，有兴趣的朋友欢迎参加： 1. 项目初始化 1.1 IDE选择 1.2 新建项目 1.3 代码组织 1.4 数据库配置 2. 编写实体类 2.1 Kotlin Data Classes 2.2 Kotlin Proerties And Fields 2.3 实...
《翻译》将 JPA (Hibernate) 与 Kotlin 结合使用的最佳实践和常见陷阱
圆师傅的博客
07-31 823
JPA与Kotlin组合使用的最佳实践
spring boot kotlin jpa的使用
weixin_43113795的博客
12-13 443
实体类 @Entity @Table(name = &quot;user&quot;) class User { @Id var host: String? = null @Column(name=&quot;user&quot;) var user: String? = null @Column(name=&quot;selectPriv&quot;) var selectPriv: String? = nu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值