Java 17 Backend Development. Design backend systems.2025 (Drevyn, Elara) (Z-Library)

Java 17 Backend Development Design backend systems using Spring Boot, Docker, Kafka, Eureka, Redis, and Tomcat Elara Drevyn

Preface This book offers beginners and backend developers with practical guidance on developing robust server-side applications with Java 17. Each chapter is structured around hands-on examples, real- world challenges, and step-by-step solutions tailored to Java professionals aiming to elevate their expertise in backend systems. It seamlessly transitions through essential development phases, covering everything from foundational elements like object-oriented design and basic REST endpoints to advanced microservices architecture and container orchestration. It covers everything from wiring up databases with Hibernate to managing asynchronous communication with Apache Kafka and securing endpoints with Spring Security. You will gain insight into caching strategies with Redis and diving into techniques to boost performance and reduce database load. It also covers Spring Cloud concepts like Eureka for service discovery and Config Server for centralized management, showing how microservices function cohesively. The book also covers testing and debugging topics, highlighting modern tools and practices such as JUnit, Mockito, integration tests, and distributed tracing. The book clearly encourages consistent coding standards, efficient concurrency patterns, and a

layered approach for verifying logic. As the book moves forward, it clearly illustrates how to maintain code quality and automate deployment workflows using continuous integration and delivery pipelines. Towards the book's end, you will know how to run Java 17 backend applications in production environments, and you will be applying best practices for logging, monitoring, security, and scalability. You will witness how all of these pieces fit together in a coherent ecosystem, whether they are deploying on Tomcat or containerizing with Docker. In this book you will learn to: Set up RESTful APIs and data mappings. Use Spring Security for robust user authentication and role-based access control. Employ Redis caching techniques to offload databases and enhance performance. Integrate Kafka to establish asynchronous, high-throughput communication among microservices. Adopt Spring Cloud tools for configuration, discovery, and gateway-based microservice architectures. Employ Docker containerization for portable deployments across environments. Construct CI/CD pipelines to automate testing, building, and delivery of microservices. Conduct thorough integration testing with real databases, brokers, and external dependencies. Use debugging tools, logs, and distributed tracing to isolate

production issues. Optimize concurrency, resource usage, and monitoring to handle large-scale backend demands.

Prologue I know many Java professionals who struggle with bridging the gap between knowing the language fundamentals and writing a production-ready backend. They often find themselves grappling with configuration headaches, performance bottlenecks, and advanced frameworks that appear daunting. I decided to write this book because I've seen these problems time and again. Time and again, I saw talented developers trying to figure out how to adopt microservices, orchestrate containers, or integrate messaging systems, all while staying within deadlines and avoiding excessive complexity. As I worked on various enterprise projects, I realized that certain patterns repeatedly emerged—connecting to databases with JPA or Hibernate, caching data, deploying with Tomcat or containers, managing configurations in dynamic environments, and ensuring proper testing strategies. There was a clear demand for concrete, step-by-step explanations. Colleagues expressed a clear need for guidance on handling concurrency, implementing security measures, and debugging errors in distributed services. Many felt overwhelmed by the number of libraries and the fast-paced changes in the ecosystem.

I'm sharing my experiences in a direct manner, focusing on how developers can utilize Java 17 effectively for server-side tasks. Each chapter tackles a specific need, from building REST endpoints to handling microservices communications. I show realistic tasks like setting up continuous integration, orchestrating containers, or installing caching solutions. I don't just present theoretical knowledge. I blend real application code with relevant concepts, not ignore them. My background in client-facing platforms convinced me that pushing code to production safely is just as important as writing elegant logic. I devote significant time to explaining testing, debugging, and the final mile of deployment. While writing, I imagined a Java developer who has wrestled with half-baked solutions or incomplete instructions. I wanted them to see a cohesive path from the first lines of code to a reliable production environment. Throughout this book, I've deliberately chosen language that is accessible and real-world examples that are easy to understand. You will gain the confidence to piece everything together, no matter the size of the system they are creating. Java 17's new features enhance maintainability and performance, and this book shows how they seamlessly integrate into modern backend practices. “Approach backend development with renewed enthusiasm and ability to tackle emerging challenges head-on”

- Elara Drevyn Copyright © 2024 by GitforGits All rights reserved. This book is protected under copyright laws and no part of it may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage and retrieval system, without the prior written permission of the publisher. Any unauthorized reproduction, distribution, or transmission of this work may result in civil and criminal penalties and will be dealt with in the respective jurisdiction at anywhere in India, in accordance with the applicable copyright laws. Published by: GitforGits Publisher: Sonal Dhandre www.gitforgits.com

support@gitforgits.com Printed in India First Printing: December 2024 Cover Design by: Kitten Publishing For permission to use material from this book, please contact GitforGits at support@gitforgits.com.

Content Preface GitforGits Acknowledgement Chapter 1: Introduction to Java 17 and Backend Development Understanding Java 17 Features Role of Backend Development Overview of Backend Technologies Spring and Spring Boot Hibernate ORM RESTful APIs Security, Caching, Messaging, and Microservices Introduction to Book Application Overview of GitforGits Project Tools and Concepts

Summary Chapter 2: Setting up Development Environment Installing Java Development Kit (JDK) 17 Setting up Eclipse IDE Managing Dependencies with Maven Project Structure and Version Control Summary Chapter 3: Introduction to Spring and Spring Boot Up and Running with Spring Getting Started with Spring Boot Dependency Injection and Inversion of Control Creating GitforGits Base Application

Summary Chapter 4: Building RESTful APIs with Spring Boot Understanding RESTful Web Services Creating Controllers and Request Mapping Understanding Controllers Mapping URLs to Methods Sample Program: Building a Sample Controller Handling HTTP Methods and Responses Role of CRUD Operations Implementing GET Implementing POST Implementing PUT Implementing DELETE Handling Errors and Status Codes Testing Endpoints Integration with Services and Repositories Consistency and Documentation Summary

Chapter 5: Data Persistence with Hibernate ORM and JPA Configuring Hibernate with Spring Boot Introducing Hibernate and JPA Setting up Dependencies and Configuration Entity Modeling with JPA Annotations Using Spring Data JPA Repositories Integrating Repositories into Services Testing Integration Handling Schema Evolution and Environments Advanced JPA Features Transactions and Consistency Logging and Monitoring Defining Entities and Relationships Implementing Repositories Summary Chapter 6: Managing Database Interactions Database Configuration and Connectivity Setting Data Source Properties Verifying Connections

Profile-specific Configurations Using YAML for Configuration Adapting to Different Environments Connection Pooling and Advanced Settings Testing Connectivity and Queries Considering Migrations and Environments Adapting to Other Databases CRUD Operations with Repositories Transaction Management Introduction to @Transactional Default Transactional Behavior Controlling Transaction Scope and Isolation Rollback Rules Testing Transactions Performance and Transaction Handling Combining Transactions with Other Features Querying with JPQL and Criteria API Using JPQL for Complex Queries Criteria API for Dynamic Queries Summary Chapter 7: User Authentication and Authorization with Spring Security

Introduction to Spring Security Implementing Authentication Mechanisms Role-Based Access Control Understanding Roles and Authorities Defining Roles in User Store Configuring Authorization Rules Method-Level Security Evolving Roles and Permissions Summary Chapter 8: Caching with Redis Understanding Caching Concepts Integrating Redis with Spring Boot Implementing Caching Identifying What to Cache Applying Caching Annotations Choosing TTL Strategy

Handling Stale Data and Invalidation Caching Complex Queries and Result Sets Monitoring and Adjusting Cache Usage Integrate Caching into CI/CD and Tests Scaling and Enhancing the Caching Strategy Summary Chapter 9: Messaging with Apache Kafka Setting up Kafka Installing and Configuring Kafka Integrating Kafka with Docker Configuration Considerations and Tuning Securing and Networking Linking Kafka to App Producing and Consuming Messages Setting up Spring-Kafka Dependency Creating a Kafka Producer Creating a Kafka Consumer Handling Complex Data Formats Observing Offsets and Consumer Groups Reliability and Error Handling

Integrating Kafka into App Defining Event Model Publishing a BookEvent Consuming the Event Logging and Auditing with Kafka Handling Errors and Retries Summary Chapter 10: Microservices Architecture with Spring Cloud Spring Cloud Overview Why Microservices? Key Components of Spring Cloud Benefits of Integrated Microservices Setting up a Config Server Purpose of a Config Server Creating a Config Server Connecting to a Configuration Repository Running the Config Server and Testing Integrating Microservices with the Config Server Handling Environment Profiles and Overrides Registering Microservices with Eureka Role of Eureka Installing a Eureka Server

Registering the Microservices Configuring a Gateway Service Need of Gateway Setting up Spring Cloud Gateway Configuring Routes Testing and Observability Summary Chapter 11: Testing and Debugging Backend Applications Unit Testing with JUnit and Mockito Why Unit Testing? Installing JUnit and Mockito Writing a Simple JUnit Test Using Mockito to Mock Dependencies Advanced Mockito Patterns Test Organization and Best Practices Debugging Failures Integration Testing Why Integration Testing? Setting up Testing Environment Using MockMvc for HTTP-Level Tests

Testcontainers for External Services Multi-Service Integration Debugging Techniques Debugging with Logs and Correlation IDs Using IDE Debugger Leveraging Trace Tools for Distributed Systems Sample Program: Logging Exception with Extra Data Performance or Memory Profiling Sample Program: Debugging a Failing Integration Test Continuous Integration and Delivery Setting up CI Pipeline Adding Integration Tests to Pipeline Implementing CD for Automated Deployments Managing Environment-specific Config Monitoring and Rollbacks Sample Program: Jenkinsfile for a Microservice Summary Chapter 12: Deploying Java Backend Applications Preparing App for Deploy Choosing Right Build Artifacts

Optimizing Configuration Preparing Database and External Dependencies Logging and Monitoring Security Considerations Deployment Options Final Verification before Launch Deploying to Application Servers Understanding Tomcat Building WAR for GitforGits Deploying WAR to Tomcat Testing and Managing Deployment Containerization with Docker Installing Docker and Basic Commands Creating Dockerfile Persisting Data and Volumes Building Minimal Images Deploying Containers Logging and Monitoring in Containers Summary Index