Java

Java java-core

Understand OOP concepts Know language syntax and constructions Understand visibility modifiers, exception handling Be aware of java.lang.*classes

Optional class New Date/Time API

New default methods in JDK Static methods in interfaces Lambda expressions syntax Method references Purpose of @FunctionalInterface API support for functional style (java.util.function)

collections

Know all basic interfaces (List, Set, Map) and understand their differences Know implementations of these interfaces from JDK and their behavior

Understand implementation details of concrete classes

streams

Standard streams (map, filter, sum, etc) Intermediate and terminal operations

Classes from java.util.stream (Stream, StreamSupport, Spliterator), streams of primitives Sequential and parallel streams

Classes from java.util.stream (Stream, StreamSupport, Spliterator), streams of primitives Sequential and parallel streams

exceptions

exception handling mechanism difference between error and exception try, catch and finally blocks hierarchy of exceptions

Chained Exceptions Throwable Class

algorithms

Why design patterns are important (common language)? Ability to describe some pattern. Ability to categorize them (structural, behavioral, creational) Ability to recognize them in others code. Ability to use them in practice (name a pattern for a given problem) SOLID: The Single Responsibility (a class should have only a single responsibility (i.e. only one reason to change) The Open Closed Principle (A component should be open for extension but closed for modification) The Liskov Substitution Principle (Subclasses should be substitutable for their super classes) The Interface Segregation Principle (Many client specific interfaces are better than one general purpose interface) The Dependency Inversion Principle (Depend upon Abstractions. Do not depend upon concretions.)

Reactive Manifesto: Reactive Systems are: - responsive: The system responds in a timely manner if at all possible - resilient: The system stays responsive in the face of failure. - elastic: The system stays responsive under varying workload. - message driven: Reactive Systems rely on asynchronous message-passing to establish a boundary between components that ensures loose coupling, isolation, location transparency. Role of supervision. Implementations: RxJava, React, Akka Ability to apply/know the various implementation patterns, for example: - Simple Component - Let it crash - Error Kernel - Circuit Breaker Ability to design a system keeping in mind these characteristics

memory model

synchronized keyword semantics volatile keyword semantics final fields visibility

Synchronizes-With rule Happens-Before rule

multithreading

Synchronized keyword (static vs non-static method, synchronized block) wait/notify/notifyAll, sleep, yeild Starting new thread (start vs run), Runnable interface Daemon Threads + JVM shutdown Shutdown Hooks Thread Groups Standard Executors (Single-Thread, Fixed, Pooled) Scheduled executor Callable/Future interface ReentrantLock, ReentrantReadWriteLock Atomic* (Integer, Boolean, etc) Concurrent collections: CopyOnWriteArrayList/Set, ConcurrentSkipListMap/Set, ConcurrentHashMap Thread States BlockingQueues/Dequeues (Linked*, Array*, Priority*,etc…)

volatile keyword, gotchas with 64-bit values

Semaphore, Phaser, CountdownLatch, CyclicBarrier Fork/Join pool Self-Monitoring, Deadlock detection, long wait detection (over JMX) CompletableFuture StampedLock LongAdder, DoubleAdder Parallel sorting

Spring REST Implementation

Creating REST Controllers RestTemplate usage HTTP Message Conversion Async RestTemplate

Creating asynchronous controller

Spring MVC Framework

The DispatcherServlet Implementing Controllers Handler mappings Building URIs Spring’s multipart (file upload) support Handling exceptions Web Security Convention over configuration support Configuring Spring MVC

Resolving views HTTP caching support

Beans, IoC Container

Container and Beans overview Dependencies Annotation-based container configuration Java-based container configuration

Bean scopes Classpath scanning and managed components Using JSR 330 Standard Annotations Additional Capabilities of the ApplicationContext

The BeanFactory

JMS

Using Spring JMS Sending a Message Receiving a message

Resources files handling

Application contexts and Resource paths

The Resource interface The ResourceLoader Resources as dependencies

Introduction to Spring Testing

Unit Testing Integration Testing

Introduction to Spring Testing MVC Test Framework

Validation, Data Binding, and Type Conversion

Resolving codes to error messages Spring Type Conversion Spring Field Formatting Configuring a global date & time format Spring Validation

Bean manipulation and the BeanWrapper Customizing the nature of a bean Bean definition inheritance Container Extension Points

spring-cache

Declarative annotation-based caching Configuring the cache storage

Plugging-in different back-end caches

scheduling

The Spring TaskScheduler Annotation Support

The Spring TaskExecutor

The Task Namespace Using the Quartz Scheduler

spring boot

Differences Between Spring and Spring Boot Spring Initializr Basic Annotations

Available Spring Boot Starters Auto-Configuration management External Configuration

Devtools Actuator

Java Data Persistence Hibernate and JPA

Hibernate relation to JPA Difference between Hibernate and JPA

Hibernate. Multitenance

Cache levels, unique ids

JPA. Object/Relational concept

Object/Relational Mismatch Function of Entity Manager Entity, Annotations Configuration and persistence.xml

JPA. Object/Relational Mapping and Entity Relationships

Property, Field, Table and Column Mapping, Primary Keys and Generation Type Mappings, Temporal and Enumerated Types, Embedded Types @ManyToOne Relationships, @OneToOne Relationships, @OneToMany Relationships, @ManyToMany Relationships Eager and Lazy Loading

Inheritance, Single-Table and Joined-Table, Table-Per-Concrete-Class Strategy Composite Primary Keys, @IdClass and @EmbeddedId, Derived Identifiers

JPA. Object/Relational Operations

Fetching and Inserting Detachment and Merging Cascading and Orphan Removal Lifecycle and Validation (JSR-303)

JPA. Object/Relational Optimisation

Optimistic Read and Write Locking, Pessimistic Locking Persistence Context as Transactional Cache Shared Cache, Locking vs. Caching, Persistence Context as Transactional Cache Lifecycle Events, Entity Listeners

JPA. Object/Relational Quering (JPA and native SQL)

Java Persistence Query Language (JPQL) Query builder with Criteria API Named Queries, Native Queries Mapping

MyBatis

Difference between iBATIS / MyBatis and others ORMs

MyBatis. Configuration Parts of configuration (Configuration XML or Configuration class)

MyBatis. Mappers

Purpose of mappers, and their basic parts Primary Key generation (useGeneratedKeys vs selectKey) SQL Injections (String Substitution) Caching Dynamic queries DB vendor specific queries Annotation based mappers

Result type vs result map Advanced Result mapping (compound objects, result type selection, nested queries)

Database rdbms

Create, Drop, Alter Insert, Update, Delete Simple selections, Joins Tables, Columns, Rows, Relations (Primary key, Foreign key), Views

Database normalization forms Merge / Upsert Unions, Aggregations (Group By, Distinct, Window Functions, etc.), Subqueries Transaction isolation levels Cursors, Stored Procedures & Functions, Indexes, Triggers Atomicity, Consistency, Isolation levels (can name and explain how they work), Durability, CAP theorem

Database denormalization Understanding of partitioning Explain Plans