Enterprise Backend Microservices Development

Trace a transfer request through the standalone service’s controller, application service, PostgreSQL transaction, and audit-event path.

Compare the standalone training boundary with the production payment, account, identity, and notification service boundaries.

Verify JDK 17, Maven, Git, Docker, and an HTTP client from the command line.

Build and run a supplied Java 17 Maven application containing one automated test.

Use Maven lifecycle commands to compile, test, package, and run a Java application.

Create a feature branch, make an atomic commit, rebase it onto an updated main branch, and inspect the resulting history.

Declare Java variables using suitable types for identifiers, text, status flags, timestamps, and monetary values.

Define and instantiate a Java class with fields, a constructor, and behavior methods.

Write a typed method that uses conditional logic to enforce one payment rule.

Represent immutable request and response data with Java 17 records.

Model account and transfer states with enums and switch expressions.

Perform monetary addition, subtraction, comparison, rounding, and scale handling with BigDecimal.

Use Optional to handle a potentially absent account without returning null.

Define and throw an unchecked domain exception for a violated payment rule.

Model Account as an aggregate that permits balance changes only through invariant-enforcing debit and credit methods.

Represent an IBAN or transaction reference as an immutable, validated value object.

Separate HTTP, application-service, domain, and persistence responsibilities in a transfer feature.

Define a transfer service interface and inject its implementation through constructor-based dependency inversion.

Start PostgreSQL with Docker Compose, connect to it, and verify container and database health.

Create account and transfer tables with primary keys, foreign keys, NOT NULL constraints, CHECK constraints, and uniqueness rules.

Execute parameterized SQL statements to insert, retrieve, and update account data.

Update two balances and insert a transfer record within one explicit PostgreSQL transaction.

Demonstrate rollback after a failure between debit and credit operations and relate the result to ACID atomicity.

Reproduce a lost update with concurrent sessions and compare isolation, pessimistic locking, and optimistic locking as countermeasures.

Generate a Spring Boot 3.2 project with web, validation, JPA, PostgreSQL, Flyway, security, and test dependencies.

Explain how component scanning creates Spring beans and inject a service into a controller through its constructor.

Load database and application settings from profile-specific configuration and environment variables.

Serialize and deserialize Java record DTOs in Spring MVC requests and responses.

Select HTTP methods and status codes for transfer operations using safety and idempotency semantics.

Implement a POST transfer endpoint that delegates business execution to an application service.

Map Account and Transfer classes to PostgreSQL tables using JPA identifiers and explicit table mappings.

Map BigDecimal amounts, currency codes, account status, version numbers, and audit timestamps to suitable column types.

Create Spring Data repositories and a query that retrieves an account eligible for transfer processing.

Manage the account and transfer schema with versioned Flyway migrations instead of automatic production schema creation.

Add a @Version field to Account and demonstrate how JPA detects a stale update.

Translate an empty repository result into an account-not-found domain exception.

Reject a transfer whose amount is zero or negative before changing persistent state.

Reject a transfer whose source and target account identifiers are identical.

Reject a transfer involving a locked, closed, or otherwise ineligible account.

Reject a transfer whose currencies violate the service’s supported same-currency rule.

Reject a transfer when the source account has insufficient available balance.

Apply the debit and credit within one Spring @Transactional application-service method.

Persist the completed transfer record in the same database transaction as both balance updates.

Convert an optimistic-lock conflict into a non-success response without blindly repeating the debit.

Apply Bean Validation constraints to the transfer request record and activate validation at the controller boundary.

Map validation and domain failures to consistent RFC 7807 Problem Details responses with a centralized exception handler.

Define an OpenAPI 3 contract for the transfer endpoint, including authorization, idempotency headers, and success and error responses.

Generate and persist a unique transaction reference that remains stable after the transfer is accepted.

Claim an idempotency key transactionally using a database uniqueness rule before applying a debit.

Return the stored result for an identical replay and reject reuse of the key with a different request payload.

Explain the resource owner, client, authorization server, resource server, access token, role, and scope in the training authentication flow.

Configure a Keycloak training realm with a client, user, banking role, and payment-write scope.

Obtain a signed access token from Keycloak and inspect its issuer, audience, expiry, roles, and scopes.

Configure Spring Security 6 as an OAuth2 resource server that validates Keycloak JWT signatures and claims.

Map Keycloak roles and scopes to Spring authorities and protect the transfer operation with request rules and @PreAuthorize.

Verify missing-token, insufficient-authority, and authorized requests as distinct 401, 403, and successful cases.

Explain the consistency failure that can occur when Kafka publication is performed directly inside a database transaction.

Define a versioned payment-completed event containing stable identifiers and no unnecessary sensitive account data.

Insert an outbox record in the same PostgreSQL transaction as the balance updates and transfer record.

Publish pending outbox records to Kafka with a stable message key and mark them published only after broker confirmation.

Implement an idempotent notification consumer that records processed event identifiers and acknowledges progress only after successful handling.

Write JUnit 5 tests for successful debit behavior and rejected domain operations.

Use Mockito to isolate persistence collaborators while testing transfer-service orchestration.

Use parameterized tests for invalid amounts, insufficient funds, locked accounts, and unsupported currency combinations.

Use MockMvc to verify the transfer endpoint’s JSON contract, Problem Details responses, and security outcomes.

Use PostgreSQL Testcontainers to prove that a failure rolls back the debit, credit, transfer, and outbox record.

Write an integration test proving that replaying an idempotency key cannot create a second debit or transfer.

Expose Actuator health information for the application and its PostgreSQL and Kafka dependencies.

Emit structured logs containing correlation and transaction references while excluding tokens, balances, and sensitive account data.

Externalize credentials and environment-specific settings so they are not committed to source control.

Build a Docker image for the payment service and run it with PostgreSQL, Keycloak, and Kafka through Docker Compose.

Run Maven verification and demonstrate the secured transfer flow, rollback behavior, idempotent replay, audit-event publication, and pull-request evidence.