Unravel › Java concepts

Learn

Java concepts, explained

The 267 ideas that real Java code leans on, each with a mental model, how it works, the usual mistakes and what happens inside. These are the same pages Unravel shows when it finds the concept in your code.

🔎 Unravel some code 🗺️ Learning paths

New to this? Start here

The main method, arguments and console inputpublic static void main(String[] args) is where a Java program starts
Lambdas and functional interfacesA lambda is a short, nameless function you can pass around: x -> x * 2
StreamsA stream is a pipeline over a sequence of values: start from a source, chain steps such as filter and map, and finish with a terminal step such as collect

0 of 267
concepts learned

Popular right now

Consumer groupsA consumer group is a set of consumers that share one job @Transactional@Transactional makes a method run inside a database transaction: all its database changes commit together if it finishes normally and are rolled back together if it throws Lazy loading and the N+1 query problemRelations between entities are often loaded lazily, one extra query on first access StreamsA stream is a pipeline over a sequence of values: start from a source, chain steps such as filter and map, and finish with a terminal step such as collect Optional and null safetyOptional<T> is a box that holds a value or nothing How HashMap worksA HashMap stores each entry in a bucket chosen by the key's hashCode()CompletableFutureCompletableFuture represents a result that will arrive later Spring proxies (how annotations work)Annotations like @Transactional, @Async and @Cacheable work through a proxy: Spring wraps your bean in a stand-in object that adds behaviour before and after your method Lambdas and functional interfacesA lambda is a short, nameless function you can pass around: x -> x * 2 Exceptions: try, catch, throwAn exception is how Java reports that something went wrong Virtual threadsA virtual thread is a very cheap thread managed by the JVM instead of the operating system JSON Web Tokens (JWT)A JWT is a signed token that carries claims (who the user is, when it expires, what roles they have)

Learning map: 6 sections, 25 topics

Java language

Language basics11Program structure, control flow, var, text blocks, static members and the system class.0/11 learned OOP and types22Classes, inheritance, interfaces, records, enums, sealed types, annotations and reflection.0/22 learned Generics and functional5Generics, wildcards, lambdas, method references and Optional.0/5 learned Strings and text5String basics, builders, formatting, regular expressions and Unicode.0/5 learned Numbers and math7Floating point, overflow, boxing, BigDecimal, Math, random numbers and bit tricks.0/7 learned Time and dates4java.time, time zones, formatting and the legacy Date classes.0/4 learned

Language basics

Program structure, control flow, var, text blocks, static members and the system class.

Switch expressions and pattern matchingModern switch can be an expression that produces a value, with arrow cases that do not fall through static and final membersstatic means "belongs to the class, not to any object": one shared copy Initialisation order and init blocksA static { ..VarargsA parameter declared String..var and type inferencevar lets the compiler work out the type of a local variable from the right-hand side: var users = new ArrayList<User>();Text blocksA text block is a multi-line string literal between triple quotes (""")The main method, arguments and console inputpublic static void main(String[] args) is where a Java program starts System, Runtime and environmentSystem gives access to the clock, environment variables, system properties and standard streams Processes and shutdown hooksProcessBuilder starts another program from Java and lets you read its output; Runtime.addShutdownHook registers code that runs when the JVM shuts down ServiceLoader and plug-insServiceLoader.load(Plugin.class) finds every implementation of an interface that is registered on the class path, without the calling code naming any of them Loops, labels and do-whilebreak leaves the nearest loop, continue skips to the next round, and a label (outer:) lets either one target an outer loop

OOP and types

Classes, inheritance, interfaces, records, enums, sealed types, annotations and reflection.

RecordsA record is a compact class for plain data: you list the fields once and Java generates the constructor, getters, equals, hashCode and toString Interfaces, inheritance and polymorphismAn interface is a contract of methods that classes can promise to provide EnumsAn enum is a fixed set of named constants, such as order statuses Lombok annotationsLombok writes boilerplate for you at compile time equals() and hashCode()equals says when two objects count as the same; hashCode gives a number used to file objects into hash tables Classes, objects and constructorsA class is a blueprint; an object is one thing built from it with new Inheritance, extends and superclass Dog extends Animal makes Dog a specialised Animal: it inherits the fields and methods and may replace (override) some of them Abstract classesAn abstract class is an unfinished class: it can hold shared code and state, and declares abstract methods that every concrete subclass must fill in Nested and inner classesA class declared inside another class Anonymous classesAn anonymous class creates and defines a one-off subclass or implementation right where it is used: new Runnable() { public void run() { ..Sealed classes and interfacessealed restricts who may extend or implement a type: sealed interface Shape permits Circle, Square Pattern matching with instanceofif (o instanceof String s) tests the type and gives you a ready-cast variable s in one step Comparable and ComparatorSorting needs a rule for "which comes first"The Object class: toString, getClass, hashCodeEvery class extends Object and inherits toString, equals, hashCode and getClass Copying objects: clone and copy constructorsAssigning an object (b = a) copies the reference, not the object Custom annotationsAn annotation is a label you attach to code (@Deprecated, @Test)ReflectionReflection lets code look at classes, methods and fields by name at run time, and call or change them, without knowing them at compile time Dynamic proxiesProxy.newProxyInstance builds an object at run time that implements an interface and sends every call to one InvocationHandler Default and static interface methodsAn interface method marked default has a body, so implementing classes get it for free and may override it Immutability and final classesAn immutable object never changes after construction JavaBeans, POJOs and BeanUtilsA JavaBean (or POJO) is a plain class with a no-argument constructor, private fields and public getX/setX methods Enums with fields and behaviourA Java enum is a full class with a fixed set of instances

Generics and functional

Generics, wildcards, lambdas, method references and Optional.

Lambdas and functional interfacesA lambda is a short, nameless function you can pass around: x -> x * 2 Method referencesA method reference such as String::valueOf is a shorthand lambda that just calls an existing method: x -> String.valueOf(x)Optional and null safetyOptional<T> is a box that holds a value or nothing GenericsGenerics put a type in angle brackets, as in List<String>, so the compiler checks what a container holds and you need no casts Wildcards and bounded genericsList<? extends Number> means "a list of some kind of Number, I do not know which"; List<? super Integer> means "a list that accepts Integers". Bounds like <T extends Comparable<T>> limit what a type parameter may be

Strings and text

String basics, builders, formatting, regular expressions and Unicode.

Regular expressionsA regular expression describes a pattern of text StringBuilder and string buildingStrings in Java never change Strings: immutability, equality, common methodsA String is an immutable piece of text: no method ever changes it, every "change" returns a new String Formatting text and numbersString.format("%s has %d items (%.2f%%)", name, n, pct) builds text from a template with placeholders Characters, Unicode and encodingsA char is a 16-bit UTF-16 unit, not always a whole visible character

Numbers and math

Floating point, overflow, boxing, BigDecimal, Math, random numbers and bit tricks.

BigDecimal and moneyBigDecimal stores decimal numbers exactly, so it is used for money Primitive types and floating pointJava has eight primitive types (byte short int long float double char boolean)Integer overflow and exact arithmeticAn int that goes past 2,147,483,647 does not fail: it silently wraps around to a large negative number Autoboxing and wrapper typesEach primitive has an object twin (int and Integer)Math and number utilitiesMath is a toolbox of static methods: max, min, abs, pow, sqrt, round, floor, ceil, trigonometry and logarithms Random numbers and UUIDsRandom produces repeatable pseudo-random numbers from a seed, SecureRandom produces unpredictable ones for security, and UUID.randomUUID() creates a practically unique 128-bit identifier Bitwise operators and flagsBitwise operators work on the individual bits of a number: & and, | or, ^ xor, ~ not, << and >> shift

Time and dates

java.time, time zones, formatting and the legacy Date classes.

java.time dates and timesThe java.time classes separate a point on the timeline (Instant), a calendar date or time without a zone (LocalDate, LocalDateTime) and a zoned moment (ZonedDateTime)Time zones, DST and InstantAn Instant is one exact moment on the global timeline Formatting, parsing and date arithmeticDateTimeFormatter.ofPattern("dd.MM.yyyy") turns dates into text and back, and methods like plusDays, isBefore and ChronoUnit.DAYS.between do date arithmetic without the pitfalls of old Date code Legacy Date, Calendar and SimpleDateFormatjava.util.Date, Calendar and SimpleDateFormat are the pre-Java-8 date classes

Core library

Collections and streams17Lists, maps, sets, queues, iterators, streams and collectors.0/17 learned I/O and files13Files, streams, NIO, serialization, sockets, XML, JSON and spreadsheets.0/13 learned Errors and logging8Exceptions, try-with-resources, custom errors, assertions and logging.0/8 learned Testing13JUnit, Mockito, AssertJ, Spring slices, containers and fake services.0/13 learned

Collections and streams

Lists, maps, sets, queues, iterators, streams and collectors.

StreamsA stream is a pipeline over a sequence of values: start from a source, chain steps such as filter and map, and finish with a terminal step such as collect Collections: List, Set, MapCollections hold groups of objects Arrays and the Arrays utilitiesAn array is a fixed-size row of values of one type, indexed from 0: int[] a = new int[5]ArrayList vs LinkedListArrayList keeps its elements in a resizable array: fast to read by position, slow to insert in the middle How HashMap worksA HashMap stores each entry in a bucket chosen by the key's hashCode()Map idioms: merge, compute, entrySetA handful of Map methods replace the clumsy "check, get, put" dance: merge for counting, computeIfAbsent for grouping, getOrDefault for lookups with a default, and entrySet for looping over keys and values together Sets: HashSet, LinkedHashSet, EnumSetA Set holds each element at most once TreeMap, TreeSet and sorted collectionsTreeMap and TreeSet keep their elements sorted all the time and can answer range questions: the first key, the nearest key below or above a value, everything between two keys Queue, Deque and StackA queue is first-in-first-out (a line at the shop), a stack is last-in-first-out (a pile of plates)PriorityQueue and heapsA PriorityQueue always hands out the smallest element first (or the largest with a reversed comparator), whatever order you added them in Iterator and IterableAn Iterator walks through a collection one element at a time (hasNext, next, remove)ConcurrentModificationExceptionThis exception means a collection was changed while a loop was going through it The Collections utility classCollections has static helpers for lists and sets: sort, reverse, shuffle, max, min, frequency, swap, plus wrappers that make a collection read-only, synchronized or empty Collectors: groupingBy, toMap, joiningA Collector decides what a stream becomes at the end: a list, a map, a group per key, a count, a joined string Stream operations in depthIntermediate steps (filter, map, flatMap, sorted, distinct, limit) shape the data; terminal steps (reduce, collect, count, anyMatch, findFirst) produce the answer Parallel streamslist.parallelStream() splits the work across several threads of the common fork-join pool Legacy collections: Vector, Hashtable, EnumerationVector, Hashtable, Stack, Enumeration and StringTokenizer date from Java 1.0

I/O and files

Files, streams, NIO, serialization, sockets, XML, JSON and spreadsheets.

Files and I/OJava reads and writes files with Path and Files (modern) or stream classes (older)File upload and downloadUploads arrive as multipart form data and downloads are streams with a Content-Disposition header Java serialization and its risksJava can turn an object graph into bytes (Serializable) and back CSV and Excel file processingBusiness systems constantly import and export CSV and Excel files SFTP and file transfer clientsMany partners still exchange files over SFTP or FTP Properties files, Locale and resource bundlesProperties loads key=value text files into a map Byte streams, readers and writersJava has two families for moving data: byte streams (InputStream, OutputStream) for raw bytes, and character readers and writers (Reader, Writer) that decode bytes to text with a charset NIO.2: Path and Files in practicePath describes a location and Files does the work: read, write, copy, move, list and delete Java serializationSerialization turns an object graph into bytes (ObjectOutputStream) and back (ObjectInputStream)Sockets, URLs and networkingA Socket is one end of a TCP connection: you write bytes in and read bytes out XML parsing: DOM, SAX, StAXJava reads XML three ways: DOM loads the whole document into a tree you can query, SAX and StAX stream through it event by event, and JAXB or Jackson XML map elements onto classes Gson and other JSON APIsGson, org.json and JSON-B are other ways to turn JSON into Java objects and back ZIP and GZIP compressionGZIPOutputStream compresses a single stream; ZipOutputStream bundles many named entries into one archive

Errors and logging

Exceptions, try-with-resources, custom errors, assertions and logging.

Exceptions: try, catch, throwAn exception is how Java reports that something went wrong try-with-resourcestry-with-resources opens a resource in the parentheses after try and closes it automatically when the block ends, normally or by exception, so files, connections and streams are never leaked Logging with SLF4JA logger writes diagnostic messages at a level (trace, debug, info, warn, error)Custom exceptions: checked vs uncheckedA checked exception (extends Exception) must be caught or declared with throws; an unchecked one (extends RuntimeException) need not Exception causes and stack tracesWhen one exception is caused by another, pass the original as the "cause": throw new ServiceException("save failed", e)The exceptions you meet every dayA short list of exceptions causes most production errors: NullPointerException, IndexOutOfBoundsException, ClassCastException, NumberFormatException, IllegalArgumentException, IllegalStateException, UnsupportedOperationException, StackOverflowError and OutOfMemoryError Defensive checks: assert and preconditionsFail early and loudly: check arguments at the start of a method (Objects.requireNonNull, if (x < 0) throw new IllegalArgumentException(...))Other logging APIs: JUL, Log4j, System.outSLF4J is the usual facade, but code also uses java.util.logging (JUL, built into the JDK, with levels SEVERE to FINEST), Log4j 2 (LogManager.getLogger), Commons Logging, or plain System.out

Testing

JUnit, Mockito, AssertJ, Spring slices, containers and fake services.

JUnit testsA JUnit test is a method annotated with @Test that sets something up, runs the code under test and asserts the expected result Mockito mocksMockito creates fake versions of a class's collaborators so a test can control what they return and check how they were used, without a real database or network Testing Kafka codeKafka code is tested at three levels: unit tests with mock producers and consumers, topology tests for Kafka Streams without a broker, and integration tests against a real broker started by the test (embedded or in a container)Spring Boot test slices and test configurationA full @SpringBootTest starts the whole application, which is slow Testing HTTP endpoints (MockMvc, WebTestClient, REST Assured)These tools call your endpoints from a test and check status, headers and JSON body Testcontainers (real databases and brokers in tests)Testcontainers starts real services (PostgreSQL, Kafka, Redis, Elasticsearch) in Docker for the duration of a test Faking remote services (WireMock, MockWebServer, Pact)To test code that calls another service, you stand up a fake HTTP server that returns the answers you script: successes, errors, slow responses and broken connections Advanced JUnit 5 and async assertionsBeyond simple @Test methods, JUnit 5 supports parameterised tests, nested test groups, temporary directories, conditional execution and custom extensions Advanced Mockito (matchers, captors, static mocks)Mockito does more than when(...).thenReturn(...)AssertJ fluent assertionsAssertJ makes test assertions read like sentences: assertThat(orders).hasSize(2).extracting(Order::id).containsExactly(1, 2)JUnit 5: parameterized tests and lifecycleA @ParameterizedTest runs one test method many times with different inputs from @ValueSource, @CsvSource or @MethodSource Mockito: matchers, verification, spiesBeyond when(...).thenReturn(...): argument matchers (any(), eq()), verification modes (times(2), never()), inOrder, captured arguments, spies (real objects with some methods replaced) and doReturn().when(spy)JUnit 4 and HamcrestJUnit 4 is the older test framework still found in many projects: @Before/@After, @RunWith, @Rule, @Test(expected = ...) and org.junit.Assert

Runtime and design

Concurrency18Threads, locks, executors, futures, virtual threads and the memory model.0/18 learned JVM and performance7Memory, garbage collection, class loading, leaks and benchmarking.0/7 learned Design patterns and architecture16Classic patterns, SOLID, layering and distributed-system patterns.0/16 learned Algorithms and data structures11Big-O, recursion, searching, sorting, dynamic programming, trees and graphs.0/11 learned

Concurrency

Threads, locks, executors, futures, virtual threads and the memory model.

Threads and shared stateA thread is an independent path of execution synchronized and lockssynchronized lets only one thread at a time run a block of code on a given lock object, protecting shared data from interleaved access ReentrantLock and ReadWriteLockThe java.util.concurrent.locks classes are explicit versions of synchronized with extras: try without waiting, time out, separate read and write access, and more than one condition volatile and atomic classesAtomic classes update a single value as one indivisible step without a lock Executors and thread poolsAn executor runs tasks on a reusable pool of threads CompletableFutureCompletableFuture represents a result that will arrive later Concurrent collectionsConcurrent collections are safe to share between threads Distributed locks and job locking (ShedLock)When several copies of an application run at once, an ordinary synchronized or ReentrantLock only protects one copy Runnable, Callable and FutureA Runnable is a task that returns nothing; a Callable<V> returns a value and may throw Interruption and InterruptedExceptioninterrupt() is a polite request: "please stop what you are doing"Latches, barriers and semaphoresThese classes coordinate threads: CountDownLatch waits until N things have happened, CyclicBarrier makes threads wait for each other, Semaphore limits how many threads may enter at once Producer-consumer with blocking queuesOne group of threads produces work, another consumes it, and a BlockingQueue sits between them: put waits when the queue is full, take waits when it is empty ThreadLocal and scoped valuesA ThreadLocal<T> gives every thread its own private copy of a variable Virtual threadsA virtual thread is a very cheap thread managed by the JVM instead of the operating system Fork/Join and divide and conquerFork/Join splits a big job into smaller pieces recursively, runs the pieces on a pool of threads, and joins the results Timers and scheduled executorsScheduledExecutorService runs a task after a delay or repeatedly Visibility and the Java Memory ModelWithout synchronisation one thread may never see another thread's writes, or may see them in a surprising order Race conditions and deadlocksA race condition is a bug where the result depends on the timing of threads (two threads both do "check, then act")

JVM and performance

Memory, garbage collection, class loading, leaks and benchmarking.

JVM memory: heap, stack and limitsObjects live on the heap, shared by all threads and cleaned by the garbage collector Garbage collectionThe garbage collector frees objects that nothing can reach any more, so Java code never frees memory by hand Weak and soft referencesA normal reference keeps an object alive Memory leaks in JavaJava has a garbage collector, yet leaks happen: objects that are still reachable but never used again Class loading and the class pathA class loader finds the bytes of a class (from a jar or folder) and turns them into a Class object the first time the class is needed Measuring performance and JMHTiming code with a start and end clock is easy and often wrong: the JIT compiler needs time to warm up and may delete work whose result is unused Method handles, VarHandle and native codeMethod handles are fast, type-checked function pointers that the JIT can inline; VarHandle gives atomic and ordered access to fields; native methods and the Foreign Function & Memory API call code written in C

Design patterns and architecture

Classic patterns, SOLID, layering and distributed-system patterns.

Transactional outbox patternSaving to the database and publishing a message are two separate actions, and a crash between them loses or invents events Sagas and distributed transactionsA business process that spans several services cannot use one database transaction Idempotency and duplicate handlingNetworks and message brokers repeat things: a client retries, a broker redelivers CQRS and event sourcingCQRS separates writing (commands that change state) from reading (queries over a shape built for the screen)DTOs and object mapping (MapStruct, ModelMapper)A DTO (data transfer object) is a plain class that carries data across a boundary (API, message) and is shaped for that boundary Layered and hexagonal architectureEnterprise code is usually split into layers (controller, service, repository) so that each class has one job Singleton patternA singleton guarantees one shared instance of a class: a private constructor plus a static accessor Builder patternA builder creates a complex object step by step with readable, named steps (Pizza.builder().size(12).cheese(true).build()), instead of one constructor with many positional parameters Factory patternA factory creates objects for you, hiding which concrete class is chosen: PaymentFactory.create("card") returns a CardPayment behind a Payment interface Strategy patternThe strategy pattern puts interchangeable behaviours behind one interface and lets the caller pick one: a PricingStrategy for regular customers and another for members Observer and event listenersIn the observer pattern an object (the subject) keeps a list of listeners and tells all of them when something happens Decorator and wrapper classesA decorator wraps an object of the same interface and adds behaviour before or after delegating: new BufferedReader(new FileReader(f)) adds buffering to a plain reader Visitor patternThe visitor pattern lets you add new operations to a family of classes without changing them: each element has an accept(visitor) method that calls back visitor.visit(this), and the visitor decides what to do for each type Template method patternA base class defines the fixed skeleton of an algorithm in a final method and leaves some steps as abstract or overridable hooks that subclasses fill in DAO and repository patternA DAO (data access object) or repository hides how data is stored behind a small interface such as OrderRepository.findById(id)SOLID principlesSOLID is five guidelines for classes that are easy to change: single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion

Algorithms and data structures

Big-O, recursion, searching, sorting, dynamic programming, trees and graphs.

RecursionA recursive method calls itself on a smaller version of the problem until it reaches a base case it can answer directly Time complexity (Big O)Big O describes how the running time grows with the input size n Binary searchBinary search finds a value in a sorted array by repeatedly comparing with the middle element and discarding the half that cannot contain it Sorting algorithmsSorting puts items in order Dynamic programming and memoisationDynamic programming solves a problem by storing the answers to overlapping smaller problems so each is computed only once Linked listsA linked list is a chain of nodes, each holding a value and a reference to the next node Trees and tree traversalA tree is a hierarchy of nodes where each node has children (a binary tree has at most a left and a right child)Graphs: BFS and DFSA graph is nodes connected by edges (cities and roads, users and friendships)Two pointers and sliding windowTwo indexes moving through an array or string replace a nested loop: one from each end (sorted pair sums, palindromes) or one behind the other (a window of elements that grows and shrinks)Building your own stack or queueWriting your own stack or queue (push, pop, enqueue, dequeue) on an array or linked nodes is a standard exercise that shows how the library classes work: an array plus an index, or nodes plus head and tail references BacktrackingBacktracking builds a solution step by step, tries each choice, and undoes it (backtracks) when it leads to a dead end

Spring and frameworks

Spring and Boot13Beans, proxies, configuration, auto-configuration, events, async and validation.0/13 learned Scheduling and batch4Scheduled jobs, cron, Quartz, batch processing.0/4 learned Jakarta and other frameworks5CDI, EJB, Quarkus, Micronaut and Vert.x.0/5 learned

Spring and Boot

Beans, proxies, configuration, auto-configuration, events, async and validation.

Spring beans and dependency injectionSpring creates your objects (beans) and hands each one the other objects it needs, so classes declare their dependencies and never build them with new Spring proxies (how annotations work)Annotations like @Transactional, @Async and @Cacheable work through a proxy: Spring wraps your bean in a stand-in object that adds behaviour before and after your method @Transactional@Transactional makes a method run inside a database transaction: all its database changes commit together if it finishes normally and are rolled back together if it throws @Async@Async makes a call return immediately while the method body runs on another thread from a pool Spring application eventsEvents let one bean announce "something happened" without knowing who cares Spring configuration propertiesSpring reads settings from application.yml, environment variables and command-line flags, and injects them into beans with @Value or @ConfigurationProperties, so behaviour changes per environment without rebuilding Bean validation (@Valid)Bean validation lets you declare rules on fields (@NotBlank, @Size(max = 50), @Email) and have the framework check them Spring caching@Cacheable stores a method's result under a key built from its arguments Spring Boot auto-configuration and startersSpring Boot looks at the libraries on your classpath and your properties, and configures sensible beans for you (a web server, a data source, a JSON mapper) unless you define your own @Configuration, @Bean and bean wiringA @Configuration class is a recipe for creating beans in plain Java Bean lifecycle and startup hooksSpring runs code at fixed moments in a bean life: right after it is built and wired, when the application is ready, and just before it is thrown away Writing aspects (@Aspect, pointcuts, advice)An aspect is code that you attach to many methods at once (timing, audit logging, permission checks) without editing them Transaction propagation and isolationPropagation decides what happens when a transactional method calls another transactional method (join the current transaction or start a new one)

Scheduling and batch

Scheduled jobs, cron, Quartz, batch processing.

@Scheduled jobs@Scheduled runs a method repeatedly on a timer: at a fixed rate, with a fixed delay between runs, or on a cron schedule Quartz schedulerQuartz is a job scheduling library Spring Batch jobs, steps and chunksSpring Batch runs big, restartable jobs: read many records, process each, write them in chunks inside transactions, and remember how far it got so a failed run can resume Cron expressions in JavaA cron expression is a compact line that says when something repeats, such as every weekday at 02:30

Jakarta and other frameworks

CDI, EJB, Quarkus, Micronaut and Vert.x.

CDI: contexts and dependency injection (Jakarta EE)CDI is the standard dependency injection of Jakarta EE (and Quarkus)EJB session beans and container servicesEnterprise JavaBeans are the original Java EE components Quarkus applicationsQuarkus is a Java framework designed for containers and fast startup Micronaut applicationsMicronaut is a JVM framework with dependency injection and AOP done at compile time instead of runtime reflection Vert.x verticles and the event loopVert.x is a toolkit for non-blocking applications on the JVM

Data and messaging

Persistence and JPA13Entities, relationships, lazy loading, queries, locking and migrations.0/13 learned JDBC and SQL mappers6Prepared statements, connections, result sets, batching and jOOQ or MyBatis.0/6 learned NoSQL and caches6Redis, MongoDB, Elasticsearch, Cassandra, DynamoDB and local caches.0/6 learned Messaging and Kafka19Topics, consumers, offsets, streams, plus RabbitMQ, JMS and cloud queues.0/19 learned

Persistence and JPA

Entities, relationships, lazy loading, queries, locking and migrations.

Spring Data repositoriesA Spring Data repository is an interface only JPA entitiesAn entity is a Java class mapped to a database table: each instance is a row, each field a column Lazy loading and the N+1 query problemRelations between entities are often loaded lazily, one extra query on first access Reactive data access (R2DBC and reactive repositories)Reactive repositories return Mono and Flux instead of blocking until the database answers, so a few threads can serve many concurrent requests while the database is working Dynamic queries (Specifications, Example, Querydsl)When search filters are optional (name, status, date range), you cannot write one fixed query method JPA relationships, cascade and orphan removalRelationship mappings tell JPA how tables are linked Optimistic and pessimistic lockingTwo users editing the same record at the same time is the lost-update problem JPA inheritance mappingObject models have inheritance (a Payment is a CardPayment or a BankTransfer) but tables do not Persistence context, flush and dirty checkingInside a transaction, JPA keeps every entity it has loaded in a first-level cache and watches it for changes JPQL, native queries and the Criteria APIJPQL is SQL written against your entity classes and fields instead of tables and columns Auditing, lifecycle callbacks and soft deleteMany tables need "who and when": created and modified timestamps, the user who did it, and sometimes a flag instead of real deletion Database migrations (Flyway, Liquibase)A migration tool applies numbered SQL scripts to the database in order and remembers which ones ran, so every environment, from a laptop to production, ends up with exactly the same schema Connection pools (HikariCP)Opening a database connection is slow, so applications keep a small pool of open connections and lend them out

JDBC and SQL mappers

Prepared statements, connections, result sets, batching and jOOQ or MyBatis.

JDBC and prepared statementsJDBC is Java's low-level database API JDBC transactions, batching and JdbcTemplate mappingBy default each JDBC statement commits alone SQL mappers and builders (MyBatis, jOOQ)MyBatis and jOOQ sit between raw JDBC and a full ORM: you control the SQL, and the library handles parameters, result mapping and (in jOOQ) type-safe query building JDBC connections, DataSource and poolsA Connection is an expensive, stateful channel to the database JDBC transactions and batchingBy default each JDBC statement commits on its own ResultSet and mapping rows to objectsA ResultSet is a cursor over the rows a query returned: while (rs.next()) moves to the next row and rs.getString("name") reads a column

NoSQL and caches

Redis, MongoDB, Elasticsearch, Cassandra, DynamoDB and local caches.

MongoDB documents and queriesMongoDB stores JSON-like documents in collections instead of rows in tables Elasticsearch and OpenSearch searchElasticsearch is a search engine built on inverted indexes Cassandra and wide-column modellingCassandra spreads data over many nodes by a partition key and is built for huge write volumes and predictable reads Redis clients and data structuresRedis is an in-memory data store with simple structures (strings, hashes, lists, sets, sorted sets)In-memory caches (Caffeine, Guava, Ehcache)A local cache keeps results of expensive work (a database read, a remote call) in memory next to your code DynamoDB accessDynamoDB is a managed key-value and document database that stays fast at any size

Messaging and Kafka

Topics, consumers, offsets, streams, plus RabbitMQ, JMS and cloud queues.

Kafka topics, partitions and eventsKafka is a durable log of events Kafka producerA producer sends events to a topic Kafka consumer and the poll loopA consumer reads events from a topic in a loop Consumer groupsA consumer group is a set of consumers that share one job Offsets and commitsAn offset is a record's position in a partition RebalancingA rebalance is Kafka reshuffling which consumer owns which partition, triggered by a member joining, leaving, crashing or being too slow Serializers and deserializersKafka stores only bytes Spring Kafka @KafkaListenerSpring Kafka runs the poll loop for you Retries and dead-letter topicsWhen a record cannot be processed, a Kafka consumer must not block forever and must not silently drop it Spring Integration (channels and flows)Spring Integration implements classic enterprise integration patterns in-process: messages travel over channels, and small components filter, transform, route, split and aggregate them Kafka StreamsKafka Streams is a library for processing topics as continuous streams inside your own application: filter, transform, join and aggregate events, with state kept locally and backed up to Kafka Kafka idempotent producer and transactionsTwo features make Kafka writes safer: the idempotent producer removes duplicates caused by retries, and transactions write to several partitions and commit consumer offsets all-or-nothing Schema Registry, Avro and ProtobufA schema registry stores the structure of messages (Avro, Protobuf or JSON Schema) and checks that producers and consumers change it compatibly Kafka Connect connectorsKafka Connect moves data between Kafka and other systems (databases, search, object storage) using ready-made connectors that you configure instead of coding consumers and producers RabbitMQ and AMQP messagingRabbitMQ is a message broker JMS and ActiveMQ messagingJMS is the standard Java API for message brokers (ActiveMQ, IBM MQ, Artemis)AWS SQS and SNS messagingSQS is a managed queue and SNS is a managed publish-subscribe topic Azure Service Bus, Event Hubs and Google Pub/SubAzure and Google offer managed brokers (Service Bus and Event Hubs; Pub/Sub)Apache Camel integration routesApache Camel connects systems with routes: take a message from one endpoint (file, queue, HTTP, database), transform and route it, and deliver it to another

APIs, security and cloud

APIs and web19REST, JSON, OpenAPI, GraphQL, gRPC, WebSockets, filters and HTTP clients.0/19 learned Security11Spring Security, tokens, OAuth2, CORS, passwords, hashing, encryption and TLS.0/11 learned Cloud and operations11Cloud SDKs, containers, secrets, tracing, metrics, health and resilience.0/11 learned Libraries and tooling3Guava, Apache Commons and MapStruct.0/3 learned

APIs and web

REST, JSON, OpenAPI, GraphQL, gRPC, WebSockets, filters and HTTP clients.

Spring REST controllersA controller maps HTTP requests to Java methods Jackson JSONJackson converts between Java objects and JSON HTTP clientsAn HTTP client calls another service over the network Central error handling and ProblemDetailInstead of try/catch in every controller, one advice class maps each exception type to an HTTP status and a consistent error body, so clients always get the same shape of error Servlets, filters and interceptorsEvery Java web request passes through the servlet layer Declarative HTTP clients (Feign, HTTP interfaces)You write a Java interface describing a remote REST API with annotations, and the framework generates the HTTP client behind it Reactive programming (Reactor Mono and Flux)Reactive code describes a pipeline for data that arrives over time Streaming responses and Server-Sent EventsInstead of answering once, a streaming endpoint keeps the HTTP connection open and sends several pieces over time: progress updates, live events, or a big file written as it is generated WebSockets and STOMP messagingA WebSocket is a long-lived two-way connection between browser and server, so either side can send at any time Rate limiting and throttlingA rate limiter caps how many requests a client or operation may make per time window OpenAPI and Swagger documentationOpenAPI is a machine-readable description of a REST API gRPC services and clientsgRPC is a fast, typed way for services to call each other GraphQL serversGraphQL lets the client ask for exactly the fields it needs in one request JAX-RS (Jakarta REST) resourcesJAX-RS, now Jakarta REST, is the standard annotation model for REST in Java EE and Jakarta EE servers and in Quarkus Custom Jackson serialization and modulesWhen default JSON mapping is not enough (dates in a special format, money as a string, hiding fields per audience, circular references), Jackson can be tuned with annotations, features and custom serializers registered in modules XML, YAML, Gson and ProtobufEnterprise systems exchange data in many formats besides JSON: XML (SOAP, legacy and government feeds), YAML configuration, Gson in older code, and Protobuf for compact internal messages Sending email (JavaMail, Spring Mail)Applications send email for receipts, resets and alerts through an SMTP server SOAP and JAX-WS web servicesSOAP is an older, XML-based way for systems to call each other, still common in banking, insurance and government The built-in HTTP servercom.sun.net.httpserver.HttpServer is a tiny web server inside the JDK

Security

Spring Security, tokens, OAuth2, CORS, passwords, hashing, encryption and TLS.

Spring Security basicsSpring Security puts a chain of filters in front of your application LDAP and directory lookupsLDAP (and Active Directory) is the company address book that stores users, groups and credentials Spring Security filter chain and authorization rulesSpring Security is a chain of servlet filters in front of your controllers JSON Web Tokens (JWT)A JWT is a signed token that carries claims (who the user is, when it expires, what roles they have)OAuth 2.0 and OpenID Connect loginOAuth 2.0 lets users sign in or let one service call another without sharing a password CORS and CSRF protectionCORS decides which web pages from other origins may call your API from a browser Password hashing (BCrypt, Argon2, PBKDF2)Passwords must be stored as slow, salted hashes so that a stolen database does not reveal them Hashes, HMAC and secure randomA hash turns data of any size into a fixed fingerprint; an HMAC adds a secret key so that only parties who know it can create the fingerprint Symmetric encryption (AES-GCM) and key handlingEncryption makes data unreadable without a key TLS, keystores and certificatesTLS encrypts connections and proves the identity of the server (and optionally the client) with certificates Hashing, Base64 and encryptionMessageDigest hashes data (SHA-256), Mac signs it with a secret (HMAC), Cipher encrypts it, and Base64 turns bytes into safe text

Cloud and operations

Cloud SDKs, containers, secrets, tracing, metrics, health and resilience.

Retry and circuit breakerRemote calls fail for short moments Spring Boot Actuator and health checksActuator adds operational endpoints to a running Spring Boot app (health, metrics, environment, thread dump)Metrics with MicrometerMicrometer is the metrics facade of Spring Boot API gateways (Spring Cloud Gateway)A gateway is the single front door of a set of microservices Service discovery and central config (Spring Cloud)In a microservice system, instances start and stop all the time Object storage SDKs (S3, Azure Blob, GCS)Object storage (Amazon S3, Azure Blob Storage, Google Cloud Storage) keeps files as objects in buckets, addressed by a key Serverless function handlers (AWS Lambda, Azure, GCP)A serverless function is one handler method that the cloud runs on demand, in response to a request, a queue message, a file upload or a schedule Cloud credentials and secrets managementCode that calls cloud services needs credentials, and database passwords and API keys need a safe home Containers and Kubernetes in Java codeProduction Java services run in containers on Kubernetes, and that shapes the code: configuration comes from environment variables, the app must start and stop quickly and gracefully, and sometimes the code talks to the cluster API itself Distributed tracing (OpenTelemetry)A single user request can touch ten services Structured logging and correlation ids (MDC)In a busy service, plain log lines from different requests are mixed together

Libraries and tooling

Guava, Apache Commons and MapStruct.

Guava utilitiesGuava is Google's utility library: immutable collections (ImmutableList.of), richer collections (Multimap, BiMap, Table), string helpers (Joiner, Splitter), Preconditions and a simple in-memory cache Apache Commons helpersApache Commons (Lang, Collections, IO, CSV, Codec) offers small null-safe helpers: StringUtils.isBlank(s), CollectionUtils.isEmpty(list), FileUtils.readFileToString, IOUtils.copy, EqualsBuilder, and a CSV parser MapStruct and object mappingObject mapping copies data between similar classes, typically entity to DTO