Leanpub Header

Skip to main content
Go to Leanpub.com

Fullstack Dev 2027 for Java Tech

Practical Java, Spring, Architecture, Security, AI and Modern Backend Engineering

This book is 100% completeLast updated on 2026-08-10
Vincent VAUBAN

A practical 2027 guide for Java developers who want to go beyond syntax. Explore Spring Boot, Jakarta EE, REST, security, JVM performance, gRPC, AI, DDD, testing and architecture through concise, real-world chapters designed to help you build better fullstack systems.

Minimum price

$29.99

$39.99

You pay

Author earns

$

Also available for 2 book credits with a Reader Membership

PDF
EPUB
WEB
APP
About

About

About the Book

Fullstack Dev 2027 for Java Tech is a practical guide for Java developers who want to understand the modern Java ecosystem beyond the language itself.

Through concise, hands-on chapters, the book explores Java, Spring Boot, Jakarta EE, REST APIs, security, testing, JVM performance, databases, DDD, gRPC, distributed systems, AI agents and software architecture.

The goal is not to memorize frameworks. It is to understand how modern Java applications are designed, connected, secured, tested, optimized and operated in production.

Whether you are moving from backend development toward fullstack engineering or from feature development toward system design, this book gives you practical concepts, code examples and engineering principles you can apply directly to real projects.

Share this book

Categories

FullstackJava

Feedback

Email the Author

Author

About the Author

Vincent VAUBAN

Vincent Vauban is a Senior Software Engineer and Java/Spring specialist with more than 15 years of experience building enterprise software and backend systems. He currently works as a Senior Engineer in the financial-services industry, where he contributes to large-scale business applications, software architecture, engineering practices, and the delivery of production systems under real-world constraints.

Vincent is an Oracle ACE Associate and a VMware vExpert, and holds several industry certifications across the Java and cloud-native ecosystem, including Oracle Java certifications, the Kubernetes and Cloud Native Associate (KCNA) certification, and the Confluent Certified Developer for Apache Kafka (CCDAK) certification. His interests span Java, Spring, Jakarta EE, distributed systems, cloud-native engineering, software architecture, security, messaging, and the growing role of AI in enterprise development.

Beyond his day-to-day engineering work, Vincent is an author, instructor, and technical content creator. He has created multiple online courses covering Java certification, Spring certification, Kubernetes, Kafka, software design, and modern development practices, helping developers prepare for certifications while strengthening the engineering knowledge behind them. He is also the author of several books, including TeamBOK: Team Body Of Knowledge, Study Guide for Spring and the Java Developers Roadmap series.

Vincent also publishes the Java Fullstack newsletter and regularly shares practical Java and software-engineering content with a community of more than 10,000 followers on LinkedIn. His articles explore not only frameworks and APIs, but also the engineering decisions behind production systems: architecture, performance, security, testing, distributed systems, developer productivity, and technical leadership.

With Java Fullstack 2027, Vincent brings those ideas together into a practical guide for developers who want to move beyond learning isolated technologies. The goal is to understand how modern Java systems fit together - from the JVM and Spring ecosystem to APIs, security, data, messaging, AI, architecture, and production engineering - and ultimately to move from simply building features to engineering systems.

Contents

Table of Contents

Chapter 1 - TESTING SPRING SECURITY: Verify access rules, NOT JUST happy paths

  1. TLDR
  2. WHAT IS A SECURITY INTEGRATION TEST?
  3. WHY INTEGRATION TESTING MATTERS FOR SECURITY
  4. HAPPY PATHS ARE NOT ENOUGH
  5. 1. TEST WITH A MOCK USER
  6. HOW @WITHMOCKUSER WORKS
  7. ROLES BECOME AUTHORITIES
  8. MOCK USER DOES NOT TEST REAL LOGIN
  9. WHEN @WITHMOCKUSER IS A GOOD FIT
  10. SPRING DOCUMENTATION REFERENCE
  11. 2. USE A MOCK SECURITY CONTEXT
  12. WHY BUILD A CUSTOM SECURITY CONTEXT?
  13. TESTSECURITYCONTEXTHOLDER
  14. CUSTOM PRINCIPALS
  15. SPRING DOCUMENTATION REFERENCE
  16. 3. VERIFY 401 AND 403 RESPONSES
  17. 401 VS 403
  18. WHY THE DISTINCTION MATTERS
  19. EXACT 401 BEHAVIOR CAN DEPEND ON CONFIGURATION
  20. TEST DENIED PATHS AS CAREFULLY AS ALLOWED PATHS
  21. 4. TEST A SECURED CONTROLLER WRITE
  22. WHAT THIS TEST VERIFIES
  23. WHY CSRF MATTERS
  24. TESTING CSRF IS PART OF TESTING SECURITY
  25. SECURITY TESTS SHOULD MATCH THE REAL RULES
  26. PRINCIPAL TESTING
  27. WHY PRINCIPAL SHAPE MATTERS
  28. SECURITYFILTERCHAIN IS PART OF THE CONTRACT
  29. METHOD SECURITY SHOULD ALSO BE TESTED
  30. TEST AUTHENTICATION AND AUTHORIZATION SEPARATELY
  31. WHY MOCK SECURITY IS USEFUL
  32. WHAT MOCK SECURITY DOES NOT PROVE
  33. A PRACTICAL SECURITY TEST MATRIX
  34. EXAMPLE TEST STRUCTURE
  35. SECURITY TESTS AS EXECUTABLE DOCUMENTATION
  36. TAKEAWAYS

Chapter 2 - SPRING BOOT gRPC IN 5 STEPS: A BEGINNER-FRIENDLY PATH

  1. TLDR
  2. WHAT IS gRPC?
  3. WHAT IS PROTOCOL BUFFERS?
  4. STEP 1 - ADD THE STARTER
  5. WHY THE STARTER HELPS
  6. STEP 2 - DEFINE THE CONTRACT
  7. UNARY RPC
  8. SERVER STREAMING
  9. STEP 3 - GENERATE THE JAVA API
  10. GENERATED CODE IS CENTRAL TO gRPC
  11. WHY CODE GENERATION MATTERS
  12. STEP 4 - IMPLEMENT THE SERVICE
  13. WHAT THE GENERATED BASE CLASS DOES
  14. WHAT @GRPCSERVICE DOES
  15. BUSINESS LOGIC STAYS NORMAL JAVA
  16. STREAMOBSERVER
  17. STEP 5 - IMPORT THE CLIENT
  18. CLIENT STUB MENTAL MODEL
  19. BLOCKING STUB
  20. TEST THE SERVICE WITH grpcurl
  21. WHAT grpcurl IS USEFUL FOR
  22. OTHER TESTING TOOLS
  23. gRPC IS CONTRACT-FIRST
  24. STRONGLY TYPED COMMUNICATION
  25. STREAMING IS A FIRST-CLASS FEATURE
  26. SPRING BOOT REDUCES THE WIRING
  27. gRPC IS NOT AUTOMATICALLY BETTER THAN REST
  28. REST AND gRPC CAN COEXIST
  29. PRODUCTION CONCERNS
  30. TLS
  31. MTLS
  32. DEADLINES
  33. RETRIES
  34. MESSAGE LIMITS
  35. TRACING
  36. HEALTH CHECKS
  37. A SIMPLE BEGINNER RECAP
  38. THE MAIN MENTAL MODEL
  39. TAKEAWAYS

Chapter 3 - JAVA “MAGIC” TYPES: THE ONES YOU CAN’T NAME (NON-DENOTABLE TYPES)

  1. TLDR
  2. THE “NULL TYPE”
  3. VAR + ANONYMOUS CLASS
  4. NO STRUCTURAL TYPES IN JAVA
  5. GENERICS
  6. TAKEAWAYS

Chapter 4 - EMBABEL 1.0.0 GA: 5 STEPS TO YOUR FIRST JAVA AGENT APP

  1. TLDR
  2. 1. ADD EMBABEL TO YOUR APPLICATION
  3. MODEL PROVIDERS
  4. 2. CREATE THE SPRING BOOT APPLICATION
  5. AGENTIC CODE INSIDE THE JVM APPLICATION
  6. 3. DEFINE A STRONGLY TYPED DOMAIN MODEL
  7. MORE THAN SIMPLE DTOS
  8. WHY STRONG TYPING MATTERS
  9. 4. EXTRACT THE REQUEST AND CALL TOOLS
  10. ACTION 1 - UNDERSTAND THE REQUEST
  11. CREATEOBJECTIFPOSSIBLE
  12. ACTION 2 - RESEARCH WITH TOOLS
  13. ACTIONS CAN MIX DIFFERENT KINDS OF WORK
  14. 5. DECLARE THE GOAL
  15. WHAT @ACHIEVESGOAL MEANS
  16. SCRIPTED PIPELINE VS GOAL-ORIENTED AGENT
  17. GOAP PLANNING
  18. REPLANNING
  19. NORMAL APPLICATION CODE STILL MATTERS
  20. STRUCTURED OUTPUT
  21. WHY STRUCTURED OUTPUT IS IMPORTANT
  22. EMBABEL AND SPRING AI
  23. THE LAYERS MENTAL MODEL
  24. WHAT ELSE 1.0.0 EXPANDS
  25. MODULE MATURITY STILL MATTERS
  26. GA DOES NOT REMOVE ARCHITECTURAL JUDGMENT
  27. A SIMPLE FIVE-STEP RECAP
  28. THE CORE DESIGN IDEA
  29. WHEN THIS MODEL IS USEFUL
  30. TAKEAWAYS

Chapter 5 - 10 JAVA DESIGN PATTERNS EVERY DEVELOPER SHOULD RECOGNIZE

  1. TLDR
  2. 1. STRATEGY
  3. WHEN STRATEGY IS USEFUL
  4. WHY STRATEGY HELPS
  5. 2. SIMPLE FACTORY
  6. FACTORY MENTAL MODEL
  7. WHEN SIMPLE FACTORY IS USEFUL
  8. FACTORY VS DIRECT CONSTRUCTION
  9. 3. BUILDER
  10. WHY BUILDER IS USEFUL
  11. WHEN BUILDER IS A GOOD FIT
  12. BUILDER MENTAL MODEL
  13. 4. ADAPTER
  14. ADAPTER MENTAL MODEL
  15. WHEN ADAPTER IS USEFUL
  16. WHY ADAPTER REDUCES COUPLING
  17. 5. DECORATOR
  18. DECORATOR MENTAL MODEL
  19. COMMON DECORATOR USE CASES
  20. WHY DECORATOR IS POWERFUL
  21. DECORATOR VS INHERITANCE
  22. 6. OBSERVER
  23. OBSERVER MENTAL MODEL
  24. WHEN OBSERVER IS USEFUL
  25. THE OBSERVER TRADE-OFF
  26. USE OBSERVER WITH DISCIPLINE
  27. 7. TEMPLATE METHOD
  28. TEMPLATE METHOD MENTAL MODEL
  29. WHEN TEMPLATE METHOD IS USEFUL
  30. TEMPLATE METHOD TRADE-OFF
  31. 8. COMMAND
  32. COMMAND MENTAL MODEL
  33. WHEN COMMAND IS USEFUL
  34. COMMAND AND ASYNCHRONOUS EXECUTION
  35. 9. FACADE
  36. WHAT THE FACADE MAY HIDE
  37. WHEN FACADE IS USEFUL
  38. FACADE VS ADAPTER
  39. 10. PROXY
  40. PROXY MENTAL MODEL
  41. COMMON PROXY USE CASES
  42. PROXY IN SPRING
  43. PROXY IN HIBERNATE
  44. DECORATOR VS PROXY
  45. HOW THE 10 PATTERNS GROUP TOGETHER
  46. DO NOT START WITH THE PATTERN NAME
  47. PATTERNS ARE A SHARED VOCABULARY
  48. PATTERNS IN FRAMEWORKS
  49. THE OVER-ENGINEERING TRAP
  50. A PATTERN SHOULD EARN ITS COMPLEXITY
  51. A SIMPLE RECOGNITION CHECKLIST
  52. TAKEAWAYS

Chapter 6 - ZGC means “Z Garbage Collector,” not “Zero Garbage Collector.”

  1. TLDR
  2. A BRIEF HISTORY OF ZGC
  3. WHAT ZGC IS TRYING TO OPTIMIZE
  4. CONCURRENT DOES NOT MEAN PAUSE-FREE
  5. WHY ZGC PAUSES CAN STAY SHORT
  6. COLORED POINTERS
  7. LOAD AND STORE BARRIERS
  8. RELOCATING OBJECTS CONCURRENTLY
  9. WHY COMPACTION MATTERS
  10. WHY GENERATIONAL ZGC MATTERS
  11. WHY THE YOUNG GENERATION IS CHEAPER TO COLLECT
  12. ENABLING ZGC ON JDK 25
  13. ENABLING GENERATIONAL ZGC ON JDK 21
  14. ZGC VS G1
  15. G1’S GENERAL-PURPOSE STRENGTH
  16. ZGC’S LATENCY FOCUS
  17. HEAP HEADROOM MATTERS
  18. WHAT IS AN ALLOCATION STALL?
  19. CONCURRENT GC STILL USES CPU
  20. WHAT TO CHECK WHEN ZGC STRUGGLES
  21. LIVE SET SIZE
  22. ALLOCATION RATE
  23. LARGE ALLOCATIONS
  24. ZGC REQUIRES MINIMAL TUNING, NOT ZERO TUNING
  25. WHAT COMES NEXT?
  26. THE LONG-TERM VISION
  27. A SIMPLE ZGC MENTAL MODEL
  28. WHEN ZGC IS A GOOD FIT
  29. WHEN G1 MAY STILL BE BETTER
  30. TEST WITH REAL WORKLOADS
  31. TAKEAWAYS

Chapter 7 - REST API DESIGN: MAKE YOUR API EASY TO USE BEFORE MAKING IT PERFECT

  1. TLDR
  2. 1. START WITH RESOURCES, NOT ACTIONS
  3. LET HTTP PROVIDE THE VERBS
  4. RESOURCE RELATIONSHIPS
  5. 2. FILTERING IS PART OF THE API DESIGN
  6. CONSISTENT FILTER SYNTAX
  7. SORTING SHOULD SUPPORT REAL USE CASES
  8. PAGINATION IS NOT AN AFTERTHOUGHT
  9. KEYSET OR SEEK PAGINATION
  10. WHY PAGINATION DESIGN MATTERS
  11. 3. BULK OPERATIONS NEED CLEAR SEMANTICS
  12. BULK CREATE
  13. BULK UPDATE
  14. BULK GET OR DELETE
  15. PARTIAL FAILURE IS THE HARD PART
  16. MULTI-STATUS STYLE RESPONSES
  17. 4. RETURN USEFUL RESPONSES
  18. DELETE RESPONSES
  19. STRUCTURED ERRORS
  20. WHY STRUCTURED ERRORS MATTER
  21. 5. USE HTTP STATUS CODES PROPERLY
  22. STATUS CODES HELP CLIENTS DECIDE WHAT TO DO
  23. 6. THINK ABOUT FIELDS AND PAYLOAD SIZE
  24. EMBEDDING RELATED DATA
  25. THE EMBEDDING TRAP
  26. 7. SECURITY IS NOT OPTIONAL
  27. CACHING HEADERS
  28. RATE-LIMIT FEEDBACK
  29. 8. VERSIONING: CHOOSE A RULE AND STICK TO IT
  30. CONSISTENCY MATTERS MORE THAN ARGUMENTS
  31. 9. REST PURITY VS PRAGMATISM
  32. HATEOAS AS A REST IDEA
  33. PRAGMATISM DOES NOT MEAN IGNORANCE
  34. AN API IS NOT GOOD BECAUSE SWAGGER LOOKS CLEAN
  35. DESIGN FOR DEVELOPER EXPERIENCE
  36. BORING CONSISTENCY IS A FEATURE
  37. A SIMPLE REST API DESIGN CHECKLIST
  38. TAKEAWAYS

Chapter 8 - FIVE JAPANESE MINDSET PRINCIPLES FOR CLEANER CODE

  1. TLDR
  2. 1. KAIZEN - CONTINUOUS IMPROVEMENT
  3. BEFORE
  4. AFTER
  5. KAIZEN AS A CODING HABIT
  6. WHY SMALL REFACTORINGS MATTER
  7. 2. GANBARU - PERSEVERE THROUGH DIFFICULTY
  8. EXAMPLE
  9. PERSEVERANCE DOES NOT MEAN COMPLEXITY
  10. SMALL FUNCTIONS REDUCE COGNITIVE LOAD
  11. 3. SHOSHIN - BEGINNER’S MIND
  12. BAD NAME
  13. BETTER NAME
  14. MEANINGFUL NAMES ARE DOCUMENTATION
  15. SHOSHIN IN CODE REVIEW
  16. 4. WABI-SABI - THE BEAUTY OF IMPERFECTION
  17. SIMPLE CODE FIRST
  18. THE OVER-ENGINEERING TRAP
  19. SIMPLE DOES NOT MEAN CARELESS
  20. WABI-SABI AND “PERFECT” ARCHITECTURE
  21. 5. MUSHIN - CLEAR MIND, NO DISTRACTION
  22. MAGIC VALUE EXAMPLE
  23. WHY MAGIC VALUES BREAK FOCUS
  24. DUPLICATION ALSO BREAKS FLOW
  25. MUSHIN AS CODE CLARITY
  26. THE FIVE PRINCIPLES TOGETHER
  27. CLEAN CODE IS NOT PERFECT CODE
  28. SENIORITY AND CODE QUALITY
  29. A SIMPLE REVIEW CHECKLIST
  30. TAKEAWAYS

Chapter 9 - SPRING BOOT 4.1.0: LAZY JDBC CONNECTIONS + gRPC

  1. TLDR
  2. 1. FETCH JDBC CONNECTIONS LAZILY
  3. THE TRADITIONAL BEHAVIOR
  4. WHY THIS CAN WASTE CONNECTIONS
  5. WHAT LAZY JDBC FETCHING CHANGES
  6. WHAT COUNTS AS FIRST JDBC USAGE?
  7. WHEN LAZY FETCHING HELPS MOST
  8. CONNECTION-POOL BENEFITS
  9. DO NOT ENABLE IT BLINDLY
  10. 2. WHAT SPRING BOOT 4.1 ADDS FOR gRPC
  11. EXPOSE A gRPC SERVICE AS A SPRING BEAN
  12. DEFAULT SERVER MODEL
  13. IMPORT A GENERATED gRPC CLIENT
  14. CHANNEL AND CLIENT INFRASTRUCTURE
  15. WHY THIS MATTERS
  16. OTHER SPRING BOOT 4.1.0 IMPROVEMENTS
  17. SSRF MITIGATION SUPPORT
  18. ASYNC OBSERVABILITY CONTEXT
  19. UPGRADE NOTES
  20. REVIEW REMOVALS BEFORE UPGRADING
  21. LAZY JDBC AND gRPC SOLVE DIFFERENT PROBLEMS
  22. WHEN TO USE LAZY JDBC FETCHING
  23. WHEN TO USE gRPC
  24. TAKEAWAYS

Chapter 10 - APACHE SHIRO 2.2.0: JAVA SECURITY WITHOUT THE HEAVY NOISE

  1. TLDR
  2. WHAT IS APACHE SHIRO?
  3. THE SHIRO SUBJECT
  4. FEATURE 1 - AUTHENTICATION
  5. THE REALM CONCEPT
  6. FEATURE 2 - AUTHORIZATION
  7. ROLES VS PERMISSIONS
  8. FEATURE 3 - SESSION MANAGEMENT
  9. WHY SESSION MANAGEMENT MATTERS
  10. WHAT APACHE SHIRO 2.2.0 BRINGS
  11. WHEN APACHE SHIRO CAN MAKE SENSE
  12. SHIRO IS NOT “BETTER THAN SPRING SECURITY”
  13. THE SPRING ECOSYSTEM EQUIVALENTS
  14. CAN SHIRO BE USED WITH SPRING BOOT?
  15. WHEN SHIRO WITH SPRING BOOT MAY BE REASONABLE
  16. IMPORTANT SECURITY NOTE
  17. WHY PATCH LEVELS MATTER MORE FOR SECURITY LIBRARIES
  18. A SIMPLE SHIRO MENTAL MODEL
  19. WHY SOME TEAMS LIKE SHIRO
  20. WHEN SPRING SECURITY IS THE BETTER DEFAULT
  21. TAKEAWAYS

Chapter 11 - MASTERING OAUTH 2.0 AND OPENID CONNECT WITH SPRING BOOT

  1. TLDR
  2. KEY POINT 1 - TURN A SPRING APP INTO AN OAUTH 2.0 RESOURCE SERVER
  3. CONFIGURE THE TOKEN ISSUER
  4. WHAT THE ISSUER URI REPRESENTS
  5. RESOURCE SERVER RESPONSIBILITY
  6. KEY POINT 2 - SECURE ENDPOINTS WITH ROUTE RULES
  7. METHOD-LEVEL SECURITY
  8. HOW SPRING MAPS SCOPES
  9. ROUTE SECURITY VS METHOD SECURITY
  10. KEY POINT 3 - OIDC LOGIN WITHOUT STORING PASSWORDS
  11. THE OIDC LOGIN FLOW
  12. WHERE THE PASSWORD LIVES
  13. OIDC CLIENT CONFIGURATION
  14. THE OPENID SCOPE
  15. ID TOKEN VS ACCESS TOKEN
  16. AUTHORIZATION CODE FLOW
  17. ACCESS THE LOGGED-IN USER
  18. WHAT OIDCUSER CONTAINS
  19. SESSION-BASED AUTHENTICATED USER
  20. OAUTH 2.0 VS OPENID CONNECT
  21. WHAT ABOUT PKCE?
  22. WHY PKCE MATTERS
  23. SPRING AND PKCE
  24. CLIENT SECRETS
  25. RESOURCE SERVER VS OIDC LOGIN
  26. AUTHORIZATION SERVER VS RESOURCE SERVER
  27. SIMPLE ARCHITECTURE FOR API SECURITY
  28. SIMPLE ARCHITECTURE FOR USER LOGIN
  29. THE BIG RESPONSIBILITY SPLIT
  30. TAKEAWAYS

Chapter 12 - OPENAPI 3.1 WITH SPRING BOOT 4: DOCUMENT YOUR API CONTRACT, NOT JUST YOUR CODE

  1. TLDR
  2. WHAT IS OPENAPI?
  3. OPENAPI IS A CONTRACT
  4. SPRINGDOC OPENAPI
  5. 1. ADD OPENAPI AND SWAGGER UI
  6. 2. DESCRIBE API METADATA
  7. 3. DOCUMENT AN ENDPOINT OPERATION
  8. TAGS HELP ORGANIZE OPERATIONS
  9. 4. DOCUMENT SCHEMAS WITH VALIDATION
  10. VALIDATION AND DOCUMENTATION SHOULD AGREE
  11. DTO AS CODE AND DOCUMENTATION
  12. 5. DOCUMENT RESPONSES CLEARLY
  13. WHY ERROR DOCUMENTATION MATTERS
  14. 6. DOCUMENT SECURITY
  15. OPENAPI DOES NOT SECURE THE API
  16. 7. SPLIT THE API INTO GROUPS
  17. ONE CODEBASE, MULTIPLE CONTRACTS
  18. OPENAPI VS SWAGGER
  19. GENERATED CONTRACTS ARE MACHINE-READABLE
  20. CODE-FIRST CONTRACT GENERATION
  21. THE CONTRACT CAN DRIFT
  22. WHAT TO DOCUMENT FIRST
  23. API CONTRACT VS IMPLEMENTATION
  24. A SIMPLE ARCHITECTURE
  25. WHY GOOD OPENAPI DOCUMENTATION MATTERS
  26. TAKEAWAYS

Chapter 13 - KEYCLOAK FOR JAVA DEVELOPERS: IDENTITY WITHOUT REINVENTING LOGIN

  1. TLDR
  2. WHAT IS KEYCLOAK?
  3. IDENTITY PROVIDER VS APPLICATION
  4. 1. PROTECT A SPRING BOOT API WITH KEYCLOAK TOKENS
  5. WHAT SPRING SECURITY VALIDATES
  6. AUTHENTICATION VS AUTHORIZATION
  7. 2. MAP KEYCLOAK ROLES TO SPRING SECURITY AUTHORITIES
  8. METHOD SECURITY
  9. 3. CREATE USERS WITH THE KEYCLOAK ADMIN CLIENT
  10. WHAT THE ADMIN API CAN AUTOMATE
  11. KEYCLOAK REALMS
  12. CLIENTS
  13. TOKENS
  14. OPENID CONNECT, OAUTH 2.0, AND SAML
  15. WHERE KEYCLOAK SITS ON THE TECH RADAR
  16. WHY KEYCLOAK IS INTERESTING
  17. CONTROL COMES WITH OPERATIONAL RESPONSIBILITY
  18. SPRING SECURITY VS KEYCLOAK
  19. THE COMMON ARCHITECTURE
  20. WHY NOT BUILD LOGIN YOURSELF?
  21. KEYCLOAK AS INFRASTRUCTURE
  22. WHEN KEYCLOAK IS A GOOD FIT
  23. WHEN A MANAGED SERVICE MAY BE BETTER
  24. TAKEAWAYS

Chapter 14 - JAVA 26 & 27: WHAT DEVELOPERS SHOULD REALLY WATCH

  1. TLDR
  2. LANGUAGE: PRIMITIVE PATTERNS GET MORE NATURAL
  3. WHY EXACT CONVERSION MATTERS
  4. LIBRARIES: MORE MODERN APIS FOR REAL USE CASES
  5. HTTP/3 FOR HTTPCLIENT
  6. PEM ENCODING AND DECODING
  7. STRUCTURED CONCURRENCY
  8. WHY STRUCTURE HELPS
  9. LAZY CONSTANTS
  10. PERFORMANCE: THE VECTOR API
  11. WHERE THE VECTOR API CAN HELP
  12. RUNTIME IMPROVEMENTS
  13. AOT OBJECT CACHING
  14. G1 IMPROVEMENTS
  15. COMPACT OBJECT HEADERS
  16. SECURITY: POST-QUANTUM TLS
  17. WHAT JAVA DEVELOPERS SHOULD UNDERSTAND
  18. POST-QUANTUM DOES NOT MEAN PERFECT SECURITY
  19. TOOLING: FINAL SHOULD REALLY MEAN FINAL
  20. WHY REFLECTIVE FINAL-FIELD MUTATION MATTERS
  21. DEVELOPER ACTION ITEMS FOR JEP 500
  22. PREVIEW AND INCUBATOR FEATURES
  23. A SIMPLE WAY TO GROUP THE CHANGES
  24. WHAT DEVELOPERS SHOULD REALLY WATCH
  25. THE BIGGER DIRECTION
  26. TAKEAWAYS

Chapter 15 - THE 12 LABOURS OF PRIMEFACES 15.0.15

  1. TLDR
  2. WHAT PRIMEFACES IS
  3. 1. SCHEDULE TOOLTIP ESCAPING
  4. 2. SCHEDULE TOOLTIP WITH TRUSTED HTML
  5. 3. SELECTONEMENU ACCESSIBILITY
  6. 4. PANEL TOGGLE HEADER BEHAVIOR
  7. 5. CONFIRM BEFORE SHOW CALLBACK
  8. 6. INPUTNUMBER AND AUTONUMERIC UPDATE
  9. 7. TEXTEDITOR PASTE CLEANUP
  10. 8. PANELMENU STATEFULNESS
  11. 9. AJAX ERROR HANDLING
  12. 10. BLOCKUI CLEANUP
  13. 11. AUTOCOMPLETE MORETEXT FIX
  14. 12. SLIDER PRECISION
  15. WHAT THIS RELEASE SAYS ABOUT PRIMEFACES
  16. WHY PRIMEFACES STILL MATTERS
  17. IMPORTANT CONCEPT FOR NEW DEVELOPERS
  18. TAKEAWAYS

Chapter 16 - PLUG JAVA INTO PGVECTOR

  1. TLDR
  2. WHAT IS A VECTOR HERE?
  3. WHAT IS PGVECTOR?
  4. DATABASE SETUP
  5. SPRING AI DEPENDENCIES
  6. APPLICATION CONFIGURATION
  7. ADD DOCUMENTS FROM JAVA
  8. SEARCH BY MEANING
  9. SIMPLE REST ENDPOINT
  10. HOW THE FULL FLOW WORKS
  11. WHY JAVA DEVELOPERS SHOULD CARE
  12. PGVECTOR AS A FOUNDATION FOR RAG
  13. WHY MODEL DIMENSION MATTERS
  14. INDEXING MATTERS TOO
  15. METADATA FILTERING
  16. PRODUCTION CONCERNS
  17. A SIMPLE MENTAL MODEL
  18. TAKEAWAYS

Chapter 17 - 10 JAVA RED FLAGS THAT REVEAL A BAD JAVA DEVELOPER

  1. TLDR
  2. 1. RELIES ON FRAMEWORK MAGIC WITHOUT UNDERSTANDING JAVA
  3. 2. STARTS CODING BEFORE CLARIFYING THE PROBLEM
  4. 3. OVERUSES PATTERNS FOR SIMPLE PROBLEMS
  5. 4. WRITES DENSE OR FLASHY CODE THAT NOBODY WANTS TO READ
  6. 5. CANNOT EXPLAIN TRADE-OFFS
  7. 6. BLAMES OTHERS OR “THE INFRA” FOR EVERY FAILURE
  8. 7. DISMISSES TESTING, CODE REVIEW, OR DOCUMENTATION
  9. 8. CONFUSES CONFIDENCE WITH COMPETENCE
  10. 9. REINVENTS WHAT JAVA ALREADY PROVIDES
  11. 10. IGNORES NULLS, EDGE CASES, AND FAILURE PATHS
  12. THE PATTERN BEHIND THE RED FLAGS
  13. WHAT GOOD JAVA DEVELOPERS DO DIFFERENTLY
  14. TAKEAWAYS

Chapter 18 - SPRING CLOUD STREAM: A PRACTICAL INTRO TO EVENT-DRIVEN APPS

  1. TLDR
  2. WHAT SPRING CLOUD STREAM REALLY IS
  3. PROS
  4. CONS
  5. CREATE A SIMPLE MESSAGE CONSUMER
  6. FUNCTIONAL BINDING NAMES
  7. BINDER SPI
  8. CHANGE THE BROKER, KEEP THE BUSINESS CODE
  9. BINDING API
  10. CONNECT A FUNCTION INPUT AND OUTPUT
  11. THE PUB/SUB MODEL
  12. PUBLISH ONE EVENT TO MULTIPLE APPLICATIONS
  13. SPRING KAFKA VS SPRING CLOUD STREAM
  14. WHEN TO CHOOSE SPRING KAFKA
  15. SPRING KAFKA EXAMPLE
  16. WHEN TO CHOOSE SPRING CLOUD STREAM
  17. SPRING CLOUD STREAM VERSION OF THE SAME CONSUMER
  18. THE PRACTICAL RULE OF THUMB
  19. ABSTRACTION DOES NOT REMOVE BROKER KNOWLEDGE
  20. TAKEAWAYS

Chapter 19 - SPRING BATCH VS @SCHEDULED: THEY DO NOT SOLVE THE SAME PROBLEM

  1. TLDR
  2. THE KEY DIFFERENCE
  3. WHEN @SCHEDULED IS ENOUGH
  4. WHEN SPRING BATCH IS THE RIGHT TOOL
  5. WHAT SPRING BATCH ADDS
  6. CHUNK PROCESSING
  7. RESTARTABILITY
  8. SKIP AND RETRY LOGIC
  9. THE COMMON MISTAKE
  10. THE IMPORTANT NUANCE
  11. USING BOTH TOGETHER
  12. SIMPLE DECISION GUIDE
  13. TAKEAWAYS

Chapter 20 - CLAWRUNR SHOWS WHAT A JAVA AI AGENT RUNTIME CAN LOOK LIKE

  1. TLDR
  2. WHY THIS PROJECT MATTERS
  3. WHAT JOBRUNR ACTUALLY IS
  4. WHY JOBRUNR CHANGES THE AGENT STORY
  5. RUNTIME-LOADED SKILLS
  6. MODEL PROVIDERS
  7. MCP CONNECTIVITY
  8. HOW CLAWRUNR DIFFERS FROM SPRING AI OR EMBABEL
  9. SPRING AI
  10. EMBABEL
  11. CLAWRUNR
  12. CLAWRUNR IS BUILT ON SPRING AI, NOT AGAINST IT
  13. A SIMPLIFIED CLAWRUNR ARCHITECTURE
  14. WHY RELIABLE SCHEDULING MATTERS FOR AGENTS
  15. LOCAL-FIRST EXECUTION
  16. TAKEAWAYS

Chapter 21 - SPRING WEB SERVICES: SPRING’S SOAP STACK, CLEARLY EXPLAINED

  1. TLDR
  2. SPRING-WS IN ONE SENTENCE
  3. WHEN TO THINK ABOUT SPRING-WS
  4. THE FOUR CORE BUILDING BLOCKS
  5. CODE SNIPPET 1 - THE XSD
  6. CODE SNIPPET 2 - THE ENDPOINT CLASS
  7. CODE SNIPPET 3 - DYNAMIC WSDL CONFIGURATION
  8. CODE SNIPPET 4 - WEBSERVICETEMPLATE
  9. WHY CONTRACT-FIRST MATTERS
  10. RELEASE CONTEXT - MARCH 2026
  11. TAKEAWAYS

Chapter 22 - JAKARTA AGENTIC AI: STANDARDIZING AI AGENTS FOR JAVA ENTERPRISE

  1. TLDR
  2. WHAT IS JAKARTA AGENTIC AI?
  3. WHY THIS MATTERS FOR JAVA DEVELOPERS
  4. HOW AN AGENT WORKFLOW LOOKS
  5. THE CORE ANNOTATIONS
  6. LLM INTEGRATION WITHOUT LOCK-IN
  7. INTEGRATION WITH THE JAKARTA STACK
  8. TAKEAWAYS

Chapter 23 - SKINNY JAR VS FAT JAR: REDUCING REPEATED DEPENDENCY TRANSFERS

  1. TLDR
  2. WHAT IS A FAT JAR?
  3. THE LIMITATION OF FAT JARS
  4. WHAT IS A SKINNY JAR?
  5. WHY SOME TEAMS PREFER SKINNY JARS
  6. FAT JAR VS SKINNY JAR
  7. TOOLS THAT SUPPORT THIS APPROACH
  8. DEPLOYMENT MENTAL MODEL
  9. TAKEAWAYS

Chapter 24 - SERVLET DEVELOPMENT: THE FOUNDATIONS OF JAVA WEB APPLICATIONS

  1. TLDR
  2. WRITING A SERVLET
  3. REQUEST FORWARDING VS RESPONSE REDIRECTION
  4. REQUEST FORWARDING
  5. RESPONSE REDIRECTION
  6. PERSISTING DATA ACROSS REQUESTS
  7. COMMON PERSISTENCE SCOPES
  8. SERVLET FILTERS
  9. SERVLET LISTENERS
  10. TAKEAWAYS

Chapter 25 - SPRING CLOUD (WITHOUT THE HYPE)

  1. TLDR
  2. DEFINE SPRING CLOUD
  3. SPRING VS SPRING BOOT VS SPRING CLOUD
  4. PROS
  5. CONS
  6. RELEASE CONTEXT - JUNE 2026
  7. MINI SPRING CLOUD SETUP
  8. 1. CONFIG SERVER
  9. 2. CONFIG CLIENT
  10. 3. API GATEWAY
  11. BOM: DEPENDENCY MANAGEMENT
  12. SPRING CLOUD FEATURES
  13. TAKEAWAYS

Chapter 26 - RESTFUL WEB SERVICES WITH JAX-RS (JAKARTA REST)

  1. TLDR
  2. SIMPLE RESTFUL WEB SERVICE
  3. CONVERTING DATA BETWEEN JAVA AND XML WITH JAXB
  4. RESTFUL WEB SERVICE CLIENT
  5. QUERY AND PATH PARAMETERS
  6. SERVER-SENT EVENTS
  7. SSE SERVER
  8. SSE CLIENT
  9. TAKEAWAYS

Chapter 27 - JAVA VS CLOJURE: SAME JVM, VERY DIFFERENT MINDSET

  1. TLDR
  2. HELLO WORLD: TASTE THE SYNTAX
  3. DATA MODELING: CLASSES VS PLAIN DATA
  4. TRANSFORMATIONS: STREAMS VS SEQUENCES
  5. IMMUTABILITY: OPTIONAL VS DEFAULT
  6. CONCURRENCY: LOCKS/THREADS VS REDUCED SHARED MUTABLE STATE
  7. INTEROP: CLOJURE CALLS JAVA
  8. WHERE JAVA SHINES
  9. WHERE CLOJURE SHINES
  10. TAKEAWAYS

Chapter 28 - SECURING JAKARTA EE APPLICATIONS: IDENTITY STORES + AUTH MECHANISMS

  1. TLDR
  2. THE TWO BUILDING BLOCKS
  3. IDENTITY STORES: DATABASE
  4. IDENTITY STORES: LDAP DIRECTORY
  5. IDENTITY STORES: CUSTOM
  6. AUTHENTICATION MECHANISMS: BASIC
  7. AUTHENTICATION MECHANISMS: FORM
  8. CUSTOM FORM AUTHENTICATION
  9. TAKEAWAYS

Chapter 29 - JAKARTA MESSAGING (JMS) - QUEUES VS TOPICS

  1. TLDR
  2. CONTEXT: WHAT JMS IS, WITHOUT THE HYPE
  3. MESSAGE QUEUES: POINT-TO-POINT
  4. MESSAGE TOPICS: PUBLISH / SUBSCRIBE
  5. QUEUE VS TOPIC
  6. DURABLE SUBSCRIPTIONS
  7. TAKEAWAYS

Chapter 30 - JAKARTA EE WEBSOCKET: REAL-TIME SERVER + JAVA CLIENT (NO MAGIC, JUST API)

  1. TLDR
  2. WHY WEBSOCKETS?
  3. DEVELOPING AN ANNOTATED WEBSOCKET SERVER ENDPOINT
  4. DEVELOPING WEBSOCKET CLIENTS IN JAVA
  5. TYRUS: EXTRA TOOLING AND IMPLEMENTATION FEATURES
  6. TAKEAWAYS

Chapter 31 - STRATEGIC DDD: ALIGN BUSINESS + SOFTWARE (WITHOUT OVERCOMPLICATING IT)

  1. TLDR
  2. WHAT IS “STRATEGIC DDD” (IN ONE LINE)
  3. HOW TO APPROACH IT
  4. WHAT YOU GET OUT OF IT
  5. DOMAINS & SUBDOMAINS
  6. BOUNDED CONTEXTS: THE GAME CHANGER
  7. HOW CONTEXTS TALK
  8. BUSINESS NEEDS ANSWERS
  9. TAKEAWAYS

Chapter 32 - OBJECT-RELATIONAL MAPPING (ORM) WITH JPA / JAKARTA PERSISTENCE

  1. TLDR
  2. DEFINE ORM + JPA
  3. ENTITY RELATIONSHIPS (THE BIG 3)
  4. COMPOSITE PRIMARY KEYS (WHEN 1 COLUMN IS NOT ENOUGH)
  5. JPQL (QUERY THE MODEL, NOT THE TABLES)
  6. CRITERIA API (TYPE-SAFE… BUT VERBOSE)
  7. BEAN VALIDATION SUPPORT (VALIDATE BEFORE YOU HIT THE DB)
  8. TAKEAWAYS

Chapter 33 - AFTER JAVA FULLSTACK: from building features to engineering systems

  1. TLDR
  2. THE STARTING POINT: SOLID JAVA FOUNDATIONS
  3. THEN COMES THE JAVA FULLSTACK JOURNEY
  4. FULLSTACK GIVES BREADTH
  5. WHAT COMES AFTER FULLSTACK?
  6. THE NEXT STEP IS ENGINEERING DEPTH
  7. FROM FEATURE CORRECTNESS TO SYSTEM RELIABILITY
  8. DISTRIBUTED SYSTEMS CHANGE THE RULES
  9. CONSISTENCY BECOMES A DESIGN DECISION
  10. RESILIENCE BECOMES PART OF APPLICATION DESIGN
  11. OBSERVABILITY BECOMES ESSENTIAL
  12. SECURITY BECOMES SYSTEMIC
  13. PERFORMANCE IS MORE THAN FAST CODE
  14. CLOUD COST IS ALSO AN ENGINEERING CONCERN
  15. THE NEXT STEP IS ARCHITECTURAL JUDGMENT
  16. WHEN A MODULAR MONOLITH IS ENOUGH
  17. WHEN ASYNCHRONOUS COMMUNICATION ADDS VALUE
  18. WHEN EVENTUAL CONSISTENCY IS ACCEPTABLE
  19. COMPLEXITY HAS A COST
  20. ARCHITECTURE IS ABOUT TRADE-OFFS
  21. THE NEXT STEP IS DOMAIN UNDERSTANDING
  22. UNDERSTAND THE BUSINESS DOMAIN
  23. USERS HAVE CONSTRAINTS
  24. CRITICAL WORKFLOWS DESERVE SPECIAL ATTENTION
  25. THE COST OF FAILURE CHANGES DESIGN
  26. CONNECT CODE TO BUSINESS VALUE
  27. THE NEXT STEP IS ORGANIZATIONAL IMPACT
  28. FROM PERSONAL OUTPUT TO TEAM OUTPUT
  29. IMPROVE ENGINEERING STANDARDS
  30. MENTORING MULTIPLIES KNOWLEDGE
  31. SIMPLIFY DEVELOPMENT WORKFLOWS
  32. REDUCE RECURRING INCIDENTS
  33. HELP TEAMS MAKE BETTER DECISIONS
  34. CREATE PLATFORMS THAT MULTIPLY PRODUCTIVITY
  35. POSSIBLE CAREER DIRECTIONS
  36. TECH LEAD
  37. SOFTWARE ARCHITECT
  38. PLATFORM ENGINEER
  39. STAFF OR PRINCIPAL ENGINEER
  40. ENGINEERING MANAGER
  41. DIFFERENT PATHS, NOT ONE LADDER
  42. FROM FEATURES TO SYSTEMS
  43. FROM SYSTEMS TO OUTCOMES
  44. A SIMPLE MATURITY MODEL
  45. WHAT “SENIOR” REALLY STARTS TO MEAN
  46. KNOWING EVERYTHING IS NOT THE GOAL
  47. TAKEAWAYS

Chapter 34 - GO FURTHER WITH JAVA AND SPRING

  1. JAVA CERTIFICATION
  2. SPRING CERTIFICATION
  3. SPRING STUDY GUIDE
  4. JAVA DEVELOPER ROADMAP
  5. HOW TO USE THESE RESOURCES
  6. KEEP BUILDING
  7. RESOURCES
  8. FINAL WORD

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub