Šálek Javy, který zachutná


Leoš Přikryl
@leos_prikryl

commity.cz, GDG Jihlava

Kotlin

  • Jazyk nad JVM od JetBrains
  • 100% interoperabilní s Javou
  • Staticky typovaný

Proč potřebujeme další jazyk nad JVM?

  • Java se dlouhá léta prakticky nevyvíjela
  • Bude trvat, než dožene moderní jazyky
  • Boilerplate code
  • ... ale má skvělý ekosystém

Proč Kotlin

  • Snadno pochopitelný pro Java vývojáře
  • Navržen vývojáři
  • Stručný a pragmatický
  • Kombinace funkcionálního a objektového přístupu
  • Zpětná kompatibilita
  • Stejně rychlý jako Java
  • Skvělá podpora v IntelliJ IDEA

Kotlin je brán vážně

  • Od léta 2017 oficiální jazyk pro Android
  • Podpora Kotlinu ve Springu 5
  • Gradle build scripts v Kotlinu
  • Kotlin Foundation (JetBrains + Google)

Github

Základy

Deklarace proměnné

val a: Int = 2           //immutable
var b: String = "Hello"  //mutable
Type inference
val a = 2
var b = "Hello"
val myClass = MyClass()

var a = 2;
Další postřehy - chybí klíčové slovo "new", středníky jsou nepovinné

Imutabilní kolekce

val list = listOf(1, 2, 3)          //immutable
val list = mutableListOf(1, 2, 3)   //mutable

val map = mapOf(1 to "one", 2 to "two")         //immutable
val map = mutableMapOf(1 to "one", 2 to "two")  //mutable
List<Integer> list = List.of(1, 2, 3);   //immutable :-o

If conditions

var max: Int
if (a > b) {
    max = a
} else {
    max = b
}
If je výraz
val max = if (a > b) a else b
Kotlin nemá ternární operátor ? :

When

var text: String
when (x) {
    1 -> text = "jedna"
    2 -> text = "dvě"
    else -> {
        text = "mnoho"
    }
}
When je výraz
val text = when (x) {
    1 -> "jedna"
    2 -> "dvě"
    else -> {
        "mnoho"
    }
}

When podruhé

val text = when (x) {
    1, 2 -> "jedna nebo dvě"
    in 3..10 -> "tři až deset"
    else -> "mnoho"
}

var text = switch (x) {
    case 1, 2 -> "jedna nebo dvě";
    case 3, 4, 5, 6, 7, 8, 9, 10 -> "tři až deset";
    default -> "mnoho";
};

When potřetí

when {
    x.isOdd() -> println("x je liché")
    x.isEven() -> println("x je sudé")
    else -> throw IllegalNumberException()
}

if (x.isOdd()) {
    System.out.println("x je liché");
} else if (x.isEven()) {
    System.out.println("x je sudé");
} else {
    throw new IllegalNumberException();
}

Defaultní parametry funkcí

fun sum(a: Int, b: Int = 0): Int {
    return a + b
}
Defaultní parametry mohou nahradit přetěžování funkcí
public int sum(int a, int b) {
    return a + b;
}

public int sum(int a) {
    return sum(a, 0);
}
Pojmenované parametry
val c = sum(a = 5, b = 10)

First-class functions

public inline fun measureTimeMillis(block: () -> Unit) : Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}
Lambda funkce
val doubled = ints.map({ value -> value * 2 })
val doubled = ints.map { it * 2 }
val elapsedTime = measureTimeMillis {
    doSomeWork()
}

Problémy, které Kotlin řeší

Properties, primary constructor

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class User (var name: String)

Data classes

public class User {

    private String name;

    public User(String name) {...}

    public String getName() {...}

    public void setName(String name) {...}

    @Override
    public boolean equals(Object o) {...}

    @Override
    public int hashCode() {...}

    @Override
    public String toString() {...}

    public User copy(String name) {...}
}

data class User (var name: String)

Data classes - immutability

data class User(val name: String = "", val email: String = "")

val user = User(name = "Petr")
val user2 = user.copy(email = "petr@gmail.com")

Intuitivní equals

val person1 = Person("Petr")
val person2 = Person("Petr")
person1 == person2   //true - automaticky volá .equals()
person1 === person2  //false - porovnává reference

String interpolation

String s = "Rozměry: " + width + " x " + height + " metrů";String s = String.format("Rozměry: %d x %d metrů", width, height);

val s = "Rozměry: $width x $height metrů"

Multiline strings

String sql =
    "SELECT\n" +
    "    fist_name,\n" +
    "    last_name,\n" +
    "    email\n" +
    "FROM users\n" +
    "WHERE id = ?";

val sql =
    """SELECT
            fist_name,
            last_name,
            email
       FROM users
       WHERE id = ?"""

var sql =
    `SELECT
            fist_name,
            last_name,
            email
       FROM users
       WHERE id = ?`

Smart casts

if (obj instanceof String) {
    System.out.println(((String) obj).toLowerCase());
}

if (obj is String) {
    println(obj.toLowerCase());
}

Smart casts - when

if (value instanceof Number) {
    cell.setDoubleValue(((Number)value).toDouble());
} else if (value instanceof Date) {
    cell.setDateValue((Date)value);
} else {
    cell.setStringValue(value.toString());
}

when (value) {
    is Number -> cell.setDoubleValue(value.toDouble())
    is Date -> cell.setDateValue(value)
    else -> cell.setStringValue(value.toString())
}

Singleton

public class Singleton {

    private static Singleton instance = null;

    private Singleton(){
    }

    private static void getInstance() {
        if(instance == null){
            synchronized (Singleton.class) {
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

object Singleton

Lazy initialization

private ExpensiveObject expensiveObject;

public ExpensiveObject getExpensiveObject() {
    if(expensiveObject == null) {
        synchronized(this) {
            if(expensiveObject == null) {
                expensiveObject = new ExpensiveObject();
            }
        }
    }

    return expensiveObject;
}

val expensiveObject by lazy  { ExpensiveObject() }

Null safety

var notNullString: String = "Hello"
notNullString = null  //compilation error
var nullableString: String? = "Hello"
notNullString = null  //OK

Null safe operator

fun getZipForUser(user: User?): String? {
    return user?.address?.zip
}

public String getZipForUser(User user) {
    if (user != null && user.getAddress() != null) {
        return user.getAddress().getZip();
    } else {
        return null;
    }
}

Safe calls

val locationService = getLocationService()
val location = locationService?.findLocation()
if (location != null) {
    println("${location.longitude}, ${location.latitude}")
}

LocationService locationService = getLocationService();
if (locationService != null) {
    Location location = locationService.findLocation();
    if (location != null) {
        println(location.longitude + ", " + location.latitude);
    }
}

Elvis operator

val displayName = username ?: "N/A"

String displayName = username != null ? username : "N/A";

Elvis operator

fun getUserById(id: Long) : User {
    return userRepository.findOne(id) ?: throw UserNotFoundException()
}

User getUserById(long id) {
    User user = userRepository.findOne(id);
    if (user == null) {
        throw new UserNotFoundException();
    }
    return user;
}

Smart casts for null checks

val user: User? = findUserById(42)
if (user != null) {
    println(user.address)  //user is not null
}

Even smarter casts - contracts

val text: String? = getText()
if (!text.isNullOrBlank()) {
    println(text.length)  //text is not null
}

Contracts - calls in place

val lock = Object()

val x: Int
synchronized(lock) {
    x = 42
}
println(x)

Rozšíření API

Extension funkce

public fun String.capitalize(): String {
    return if (isNotEmpty()) {
        substring(0, 1).toUpperCase() + substring(1)
    } else {
        this
    }
}
Nahrazují *Utils (StringUtils, FileUtils, ...) třídy
StringUtils.capitalize(string);
string.capitalize()
Extension funkce se importují

Extension funkce ve standardní knihovně

  • String - substringBefore, isNullOrEmpty, removePrefix, ...
  • Collections - filter, map, sum, min, max, groupBy, ...
  • I/O - String.byteInputStream(), InputStream.readBytes()

Ukázka Collections extensions

List<String> oldList =
    Arrays.asList("a1", "a2", "b1", "c2", "c1");

List<String> transformedList = oldList
    .stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

val oldList = listOf("a1", "a2", "b1", "c2", "c1")

val transformedList = oldList
    .filter { it.startsWith("c") }
    .map { it.toUpperCase() }
    .sorted()
Vyhodnocování není lazy

Coroutines

Coroutines

  • operace, která může být pozastavena bez zablokání vlákna
  • light-weight threads
  • asynchronní, neblokující zpracování

Blokující kód

fun postItem(item: Item) {
    val token = login()
    val post = submitPost(token, item)
    processPost(post)
}

fun login(): Token {
    // a blocking code
    return token
}

Asynchronní kód - callbacks

fun postItem(item: Item) {
    loginAsync { token ->
        submitPostAsync(token, item) { post ->
            processPost(post)
        }
    }
}

fun loginAsync(callback: () -> Token) {
    // make request and return immediately
    // arrange callback to be invoked later
}

Asynchronní kód - coroutines

suspend fun postItem(item: Item) {
    val token = login()
    val post = submitPost(token, item)
    processPost(post)
}

suspend fun login(): Token {

}
  • Klíčové slovo suspend
  • Suspend funkce jdou volat pouze z coroutines

Spouštění coroutines

GlobalScope.launch {
    syncData()
}

val deferredData : Deferred<Data> = GlobalScope.async {
    retrieveData()
}

Coroutines jdou zrušit

val job = GlobalScope.launch {
    syncData()
}
job.cancel();

Standarní ošetření výjimek

try {
    GlobalScope.launch {
        syncData()
    }
} catch (e: DataSynchronizationException) {
    //handle exception
}

Defaultně sekveční zpracování

suspend fun loadImage(url: String): Image {
    // blocking load
}

suspend fun getCombinedImage(url1: String, url2: String): Image {
    val image1 = loadImage(url1)
    val image2 = loadImage(url2)
    return combineImages(image1, image2)
}

Paralelní zpracování

suspend fun loadImage(url: String): Image {
    // blocking load
}

suspend fun getCombinedImage(url1: String, url2: String): Image {
    val image1 = GlobalScope.async { loadImage(url1) }
    val image2 = GlobalScope.async { loadImage(url2) }
    return combineImages(image1.await(), image2.await())
}

Structured concurrency

suspend fun loadImage(url: String): Image {
    // blocking load
}

suspend fun getCombinedImage(url1: String, url2: String): Image {
    return coroutineScope {
        val image1 = async { loadImage(url1) }
        val image2 = async { loadImage(url2) }
        combineImages(image1.await(), image2.await())
    }
}

Interoperabilita s Javou

Seamless

Prakticky nerozpoznáte Java třídu od Kotlinu
val file = File("temp.tmp")
if (file.exists()) {
    println("File exists")
}

POJO → Properties

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

val user = User("John")
println(user.name)

SAM konverze

//Executor.java
void execute(Runnable command) { ... }
executor.execute { println("runnable") }

Platform types

public class Generator {

    public String generateString() {
        return ...;
    }

}

val s = Generator().generateString()
 // String!

val s: String? = Generator().generateString()
// vždy projde

val s: String = Generator().generateString()
// může vyhodit NPE v runtime

Platform types

public class Generator {

    @NotNull
    public String generateString() {
        return ...;
    }

}
val s = Generator().generateString()
// String

public class Generator {

    @Nullable
    public String generateString() {
        return ...;
    }

}
val s = Generator().generateString()
// String?

Jak začít

Hned ;-)

Stávající projekt

  • Lze bez problémů míchat Javu a Kotlin
    • Konvertor Javy do Kotlinu v IntelliJ IDEA

 

  • Případně rovnou konverze celého projektu
    • Spring aplikace, cca 400 souborů ~ 4 hodiny
    • 18 476 řádků redukováno na 11 530

Odkazy

Dotazy