GRAN LIBRO DE KOTLIN PARA PROGRAMADORES DE BACK END

Prólogo .................................................................................................... xv
Sobre este libro ...................................................................................... xix
1. Introducción ......................................................................................... 1
2. Objetivo y estructura ............................................................................ 7
3. IDE para Kotlin ...................................................................................... 9
Experimentando con Kotlin en back end
4. Poco código y grandes resultados ....................................................... 13
El primer programa en Kotlin .................................................................................. 13
Programa para escribir varias líneas de un fichero de texto ................................... 15
Programa para leer líneas de un fichero de texto ................................................... 17
Programa para contar las líneas de un fichero ....................................................... 18
Programa para copiar un fichero ............................................................................ 19
Descargar un fichero ............................................................................................... 21
Acceso a un recurso desde código ........................................................................... 22
5. Funciones ................................................................................................25
Funciones que no requieren parámetros de entrada y salida ................................. 26
Funciones con parámetro de entrada y sin parámetro de salida ............................ 27
Funciones con parámetro de entrada y salida ........................................................ 28
Funciones con parámetro por defecto ..................................................................... 29
Funciones con parámetros variables ....................................................................... 30
Funciones con parámetros genéricos ...................................................................... 33
Funciones de extensión ............................................................................................ 34
Funciones infix ......................................................................................................... 36
Expresión y funciones lambda ................................................................................. 38
Funciones de orden superior .................................................................................... 40
6. Clases ................................................................................................. 41
6.1 Definición de una clase y compatibilidad con Java ............................................ 41
6.2 Experimentando con métodos ........................................................................... 45
6.2.1. Ejemplos de métodos sin parámetro de entrada y con parámetro de salida ... 45
6.2.2. Ejemplos de métodos privados, parámetros variables, con parámetro
de entrada y salida ............................................................................................ 46
6.3 Tipos de clases ................................................................................................... 49
6.3.1 Data: clases de datos .......................................................................................... 49
6.3.2 Enum: clases de valores enumerados ................................................................ 52
6.3.3 Clases heredables ............................................................................................... 56
6.3.4 tipo interfaz ........................................................................................................ 58
6.3.5 Clase abstracta ................................................................................................... 59
6.3.6 Clases anidadas: Inner ........................................................................................ 60
6.3.7 Objetos ............................................................................................................... 63
6.3.8 Clases selladas .................................................................................................... 68
6.4 Alias ................................................................................................................... 72
6.5 Visibilidad de los modificadores ........................................................................ 72
6.6 Retrasar la inicialización de propiedades .......................................................... 72
6.6.1 Inicialización tardía para: var ............................................................................. 72
6.6.2 Inicialización tardía para: val .............................................................................. 73
7. Ficheros .............................................................................................. 75
7.1 Trazas o logs: log4j2 .......................................................................................... 75
7.1.1 Configurando Log4j2 por consola ....................................................................... 77
7.1.2 Configurando Log4j2 por fichero........................................................................ 79
7.2 Ficheros de texto ................................................................................................ 81
7.3 Ficheros properties ............................................................................................ 84
7.4 XML .................................................................................................................... 86
7.5 RDF y OWL ......................................................................................................... 92
7.6 EXCEL y CSVs .................................................................................................... 101
7.7 JSON y GSON .................................................................................................... 104
7.7.1 Serialización/deserialización JSON ................................................................... 109
7.8 ePub ................................................................................................................. 110
7.9 Zip .................................................................................................................... 112
7.10 FASTA (fa) ...................................................................................................... 119
8. Bases de datos ...................................................................................123
8.1 Montar el entorno de pruebas ......................................................................... 124
8.2 Relational DBMS .............................................................................................. 125
8.2.1 SQLite ............................................................................................................... 130
8.2.2 MySQL .............................................................................................................. 134
8.2.3 MariaDB ............................................................................................................ 139
8.2.4 Oracle ............................................................................................................... 142
8.3 NoSQL .............................................................................................................. 146
8.3.1 Key-value Stores: Redis .................................................................................... 146
8.3.1.1 Redis ...................................................................................................... 147
8.3.2 Document Stores: MongoDB ............................................................................ 151
8.3.2.1 MongoDB .............................................................................................. 151
8.3.3 RDF Stores: Apache Jena, Virtuoso y AllegroGraph ......................................... 156
8.3.3.1 Apache Jena - TDB ................................................................................. 156
8.3.3.2 AllegroGraph ......................................................................................... 161
8.3.3.3 Virtuoso y la DBpedia ............................................................................ 165
9. Números ............................................................................................169
9.1 Los números árabes ......................................................................................... 169
9.2 Colecciones útiles para números ..................................................................... 170
9.3 Determinantes ................................................................................................. 173
9.4 Sistemas de ecuaciones lineales ...................................................................... 178
9.4.1 Regla de Cramer ............................................................................................... 180
9.4.2 Método de Gauss Jordan.................................................................................. 182
9.4.3 Método Gauss-Seidel ....................................................................................... 185
9.5 Fibonacci .......................................................................................................... 190
9.6 Números primos .............................................................................................. 191
9.7 Trigonometría .................................................................................................. 196
9.8 Cálculo de integrales........................................................................................ 200
9.9 Transformada rápida de Fourier ...................................................................... 203
10. Cadenas ...........................................................................................207
10.1 Cadenas ......................................................................................................... 207
10.2 Concatenar Strings ........................................................................................ 210
10.3 Acceso a los caracteres de un String ............................................................. 213
10.4 Sutil diferencia entre vacíos y/o espacios ...................................................... 213
10.5 Arrays de Strings ............................................................................................ 214
10.6 Maps .............................................................................................................. 215
10.7 Rellenando Strings ......................................................................................... 215
10.8 Quitando espacios de un Strings ................................................................... 216
10.9 Obtener términos de un Strings ..................................................................... 216
10.10 Subcadenas .................................................................................................. 217
10.11 Conversores ................................................................................................. 219
10.11.1 ASCII ............................................................................................................. 219
10.11.2 Hexadecimal ................................................................................................. 220
10.11.3 Binario .......................................................................................................... 221
10.12 Claves de acceso y funciones hash .............................................................. 222
11. Concurrencia ...................................................................................225
11.1 Thread ............................................................................................................ 226
11.1.1 Hilo principal y secundarios ........................................................................... 229
11.1.2 Sección crítica de código ................................................................................ 230
11.1.2.1 Semáforos ........................................................................................... 230
11.1.2.2 Monitores ............................................................................................ 233
11.1.2.3 El problema del productor-consumidor .............................................. 236
11.1.3 Comparativas de rendimiento ........................................................................ 240
11.2 Corrutinas ...................................................................................................... 246
11.2.1 Creación de corrutinas ................................................................................... 248
11.2.2 runBlocking() gestinando corrutinas .............................................................. 249
11.2.3 Funciones de suspensión................................................................................ 250
11.2.4 Canales (Channel) ........................................................................................... 252
11.2.5 Comparativas de rendimiento ........................................................................ 254
11.3 Recapitulando ideas ...................................................................................... 265
12. Despliegues en war de RESTful ........................................................267
12.1 Ktor ................................................................................................................ 268
12.2 Conceptos: API, REST, SOA y RESTful ............................................................. 269
12.3 Arquitectura en tres capas ............................................................................ 271
12.4 Capa de negocio ............................................................................................ 272
12.4.1 Acercamiento a Ktor ....................................................................................... 273
12.4.2 Configuraciones de servidores ....................................................................... 274
12.4.3 EL proyecto Ktor-cap12 .................................................................................. 276
12.4.3.1 Serialización y deserialización ............................................................. 278
12.4.3.2 Enrutamiento ...................................................................................... 280
12.4.3.3 Sesiones............................................................................................... 285
12.4.3.4 Autentificación .................................................................................... 291
12.4.3.5 Recomendación de mejora ................................................................. 293
12.5 Despliegues .................................................................................................... 293
12.5.1 War en Tomcat 9 ............................................................................................ 294
12.5.2 En docker, war en Tomcat 9 ........................................................................... 295
Anexos
Anexo 1. Docker ....................................................................................301
Anexo 2. Máquina virtual para descargar ..............................................305
Anexo 3. Referencia rápida de la sintaxis Kotlin ....................................307
Anexo 4. Maven y Gradle ......................................................................321
Anexo 5. Conceptos generales sobre Programación
Orientada a Objetos ..............................................................................323
Anexo 6. DBeaver ..................................................................................325
Bibliografía ............................................................................................327
Sobre el autor .......................................................................................329

Si como programador de back end quiere evolucionar al mismo tiempo que aprovechar todo su código en Java, sin duda, debe empezar por adoptar Kotlin, un nuevo lenguaje de programación, equiparado a Java en el mundo Android. Emplear profesionalmente un nuevo lenguaje de programación puede ser un problema en la empresa en la que trabaja, sobre todo si se tiene invertido mucho código. No obstante, Kotlin permite reutilizar todas las librerías Java que ya disponga y construir back ends de forma sencilla. Este libro será su gran aliado si quiere adentrarse en Kotlin, gracias a él: ' Tendrá ejemplos originales y estimulantes. ' Se acercará rápidamente al manejo del lenguaje mediante funciones y clases. ' Tratará una gran variedad de tipos de ficheros. ' Practicará con todo tipo de bases de datos utilizando dockers. ' Revisará el manejo de cadenas y sus posibilidades, y realizará conversiones de cualquier base y funciones hash. ' Explorará la programación asíncrona con dos enfoques: thread y corrutinas. ' Implementará y desplegará un servicio API REST, ayudado de ktor. Además, en la parte inferior de la primera página del libro encontrará el código que le permitirá acceder de forma gratuita a los contenidos adicionales del libro en www.marcombo.info. Con él, ahorrará mucho tiempo, pues podrá clonar el repositorio desde GitHub y mucho más. El autor es Luis Criado-Fernández, doctor e ingeniero en telecomunicaciones, cuyo talento sobresaliente es la programación. Siempre se ha mantenido cerca de los avances en este campo y ha prestado especial atención a los nuevos lenguajes. Cuando descubrió Kotlin, quedó fascinado y se vio envuelto en un devorador entusiasmo que lo instó a estudiarlo, experimentarlo y plasmarlo en esta obra. No se quede atrás, con este libro conocerá todo lo que necesita saber sobre Kotlin y estará a la última sin perder su código Java. Ser un programador actualizado, está en sus manos.