Kotlin + SpringBoot + JPA(Hibernate) + Repository自定义方法 Spring

[TOC]

### Kotlin + SpringBoot + JPA(Hibernate) + Repository自定义方法
```
JPA是java为整合对数据库操作定义的一系列接口方案, 操作非常简单方便. 但有时需要自定义复杂sql操作的时候, 则可能需要对JPA方法扩展. 但若直接实现JPARepository接口, 则需实现它一系列方法, 这显然是不可取的.本文则记录如何简单的扩展自定义方法
```

#### `pom.xml`
```
<project>
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>

<properties>
        <druid.version>1.0.22</druid.version>
        <jackson-module-kotlin.version>2.9.3</jackson-module-kotlin.version>
        <java.version>1.8</java.version>
        <junit.version>4.12</junit.version>
        <kotlin.version>1.2.10</kotlin.version>
        <mysql.version>5.1.29</mysql.version>
        <mybatis-spring-boot-starter.version>1.3.1</mybatis-spring-boot-starter.version>        <org.springframework.boot.version>1.5.9.RELEASE</org.springframework.boot.version>
        <spring-boot-starter-log4j.version>1.3.8.RELEASE</spring-boot-starter-log4j.version>

<kotlin.compiler.incremental>true</kotlin.compiler.incremental>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

<dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-kotlin</artifactId>
            <version>${jackson-module-kotlin}</version>
        </dependency>

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>${spring-boot-starter-log4j.version}</version>
        </dependency>

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

<dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib-jre8</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
		
		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

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

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
    </dependencies>

<build>
        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
        <plugins>
            <plugin>
                <artifactId>kotlin-maven-plugin</artifactId>
                <groupId>org.jetbrains.kotlin</groupId>
                <version>${kotlin.version}</version>
                <configuration>
                    <compilerPlugins>
                        <plugin>spring</plugin>
                    </compilerPlugins>
                    <jvmTarget>1.8</jvmTarget>
                </configuration>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-allopen</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project
```

#### `application-jpa.properties`
```
spring.datasource.url=jdbc:mysql://localhost:3306/vanki2?characterEncoding=utf8&characterSetResults=utf8
spring.datasource.username=root
spring.datasource.password=zoufanqi

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.name=mysqldb

# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
#spring.datasource.useGlobalDataSourceStat=true

spring.jpa.database=MYSQL
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
```

#### 类
##### 目录结构
```
com.qiqinote.repository.base.BaseRepository

com.qiqinote.repository.customize.UserCustomizeRepository
com.qiqinote.repository.customize.impl.UserRepository

com.qiqinote.repository.UserRepository
```

##### `BaseRepository.kt`
```
package com.qiqinote.repository.base

import org.springframework.data.repository.NoRepositoryBean
import org.springframework.data.repository.PagingAndSortingRepository
import java.io.Serializable

/**
 * Created by vanki on 2018/1/23 14:49.
 */
@NoRepositoryBean
interface BaseRepository<T, ID : Serializable?> : PagingAndSortingRepository<T, ID> {
}
```

##### `UserRepositoryImpl.kt`
```
package com.qiqinote.repository.customize

import com.qiqinote.entity.User

/**
 * Created by vanki on 2018/1/23 14:44.
 */
interface UserCustomizeRepository {
    fun test(name: String): MutableList<User?>?
}
```

##### `UserRepositoryImpl.kt`
> ***注意***
>> 1. 实现 `UserCustomizeRepository`
>> 2. 名称必须与对外接口名对应(加上`Impl`), 或者注解加上bean名称 `@Repository("userRepositoryImpl")`

```
package com.qiqinote.repository.customize.impl

import com.qiqinote.entity.User
import com.qiqinote.repository.customize.UserCustomizeRepository
import org.springframework.stereotype.Repository
import javax.persistence.EntityManager
import javax.persistence.PersistenceContext

/**
 * Created by vanki on 2018/1/23 14:38.
 */
@Repository
class UserRepositoryImpl : UserCustomizeRepository {

@PersistenceContext
    private lateinit var entityManager: EntityManager

override fun test(name: String): MutableList<User?>? {
        val sql = "select * from user where alias=?1"
        val query = this.entityManager.createNativeQuery(sql, User::class.java)
        query.setParameter(1, name)
        return query.resultList as MutableList<User?>?
    }
}
```

##### `UserRepository`
> 对外的接口

```
package com.qiqinote.repository

import com.qiqinote.entity.User
import com.qiqinote.repository.base.BaseRepository
import com.qiqinote.repository.customize.UserCustomizeRepository

/**
 * Created by vanki on 2018/1/23 14:04.
 */
interface UserRepository : BaseRepository<User, Long>, UserCustomizeRepository {
}
```

#### Application.kt
```
package com.qiqinote

import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.PropertySource

/**
 * Created by vanki on 2018/1/17 21:46.
 */
@SpringBootApplication
@ComponentScan(basePackages = arrayOf("com.qiqinote.repository"))
@PropertySource(value = "classpath:application-jpa.properties")
class Application

fun main(args: Array<String>) {
    SpringApplication.run(Application::class.java, *args);
}
```

#### 测试类
```
package com.qiqinote.repository

import org.junit.Test
import org.junit.runner.RunWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.junit4.SpringRunner

/**
 * Created by vanki on 2018/1/18 18:00.
 */
@RunWith(SpringRunner::class)
@SpringBootTest
class TestUserRepository {
    @Autowired
    private lateinit var userRepository: UserRepository

@Test
    fun t1() {
        val test = this.userRepository.test("name2")
    }
}
```

vanki

相传胜利者肯定手持正义,那仅是因为正义可以被胜利者定义

创建： 2018-01-24 04:55:38

更新： 2018-09-15 09:09:01

Kotlin + SpringBoot + JPA(Hibernate) + Repository自定义方法 Spring

TA的最新笔记

TA的最热笔记

欢 迎

登录

新朋友 注册

注册

老朋友 登录

Kotlin + SpringBoot + JPA(Hibernate) + Repository自定义方法 Spring

TA的最新笔记

TA的最热笔记

欢迎

新朋友注册

老朋友登录