soudmaijer

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public class OrderRepository {
    private static final RowMapper<Order> rowMapper = (rs, i) -> new Order(rs.getLong("id"));

soudmaijer

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.jdbc.core.RowMapper
import org.springframework.stereotype.Repository
import java.util.*

@Repository
class OrderRepository(private val jdbcTemplate: JdbcTemplate) {
    private val rowMapper: RowMapper<Order> = RowMapper { rs, i -> Order(rs.getLong("id")) }

    fun findOrderById(id: Long): Optional<Order> {

soudmaijer

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.jdbc.core.RowMapper
import org.springframework.stereotype.Repository

@Repository
class OrderRepository(private val jdbcTemplate: JdbcTemplate) {
    private val rowMapper: RowMapper<Order> = RowMapper { rs, i -> Order(rs.getLong("id")) }

    fun findOrderById(id: Long): Order? {
        val result = jdbcTemplate.query<Order>("select * from orders where id=:id", rowMapper, id)

soudmaijer

public void doStuffWithOrder(Long id) {
    Optional<Order> orderById = orderRepository.findOrderById(id);

    orderById.ifPresent( order -> {
        // do stuff with order
    });
}

soudmaijer

fun doStuffWithOrder(id: Long) {
    val orderById: Order? = orderRepository.findOrderById(id)

    orderById?.run {
        // do stuff with order
    }

    orderById.id // Compiler error: Only safe ?. or non-null asserted calls are allowed on a nullable receiver of type Order?
}

soudmaijer

val orderOrElse: Order = orderById?.apply {
    // do stuff with order
} ?: Order() // orElse with default

val orderOrElseThrow: Order = orderById?.apply {
    // do stuff with order
} ?: throw RuntimeException("orElseThrow") // orElseThrow

val orderId: Long? = orderById?.let {
    // do stuff with order

soudmaijer

import kotlinx.coroutines.experimental.GlobalScope
import kotlinx.coroutines.experimental.async
import kotlinx.coroutines.experimental.runBlocking
import java.util.*

data class GiftCard(val id: Int, val code: String)

class GiftCardService {

    /**

soudmaijer

import org.slf4j.LoggerFactory
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Component
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import java.time.Duration

interface LockManager {
    fun <T> tryWithLock(key: Long, timeout: Duration, function: () -> T): T
}

soudmaijer

<project>
    ...
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>9</source>

soudmaijer

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>process-sources</phase>