Engineering With Java: Digest #30

Curated and Hand Picked Java and Spring Blogs

In this Engineering With Java newsletter edition, we have hand-picked some interesting Java and Spring articles worth reading.Topics include Http Clients, PostgreSQL JSON Type, Functional Programming, Java stream, Jakarta Data With Spring and Hibernate etc.

🚀 Grokking the Java Interview 🚀

Crack your Java interview by preparing important topics and mastering key concepts in a guided and structured way in a short time. 

>> Grab it while its hot.

Spring HTTP Clients: RestClient, WebClient, RestTemplate

This article compares three HTTP clients in Spring: RestClient, WebClient, and RestTemplate.

1. RestTemplate: An older, synchronous client that has been widely used but is being phased out in favor of newer, non-blocking solutions. It’s simple to use but not ideal for modern applications needing non-blocking operations.

2. WebClient: The recommended, non-blocking, asynchronous client introduced in Spring 5. It provides more flexibility and supports a reactive programming model, making it suitable for modern applications that require efficient handling of multiple requests.

3. RestClient: A newer HTTP client introduced in Spring 6, designed to replace RestTemplate and provide a more modern, easy-to-use API. It aims to simplify development while offering performance improvements and features from WebClient.

The article highlights that while RestTemplate is still usable, WebClient and RestClient are better suited for current and future needs due to their support for asynchronous and reactive programming.

Read the full article.

Resolving PostgreSQL JSON Type Mismatch Errors in JPA

This article explores how to resolve JSON type mismatch errors when using PostgreSQL with Java Persistence API (JPA). It provides practical solutions for handling JSON data types in JPA entities and ensuring compatibility with PostgreSQL.

Key points include:

1. Understanding JSON Types in PostgreSQL: PostgreSQL supports json and jsonb data types. jsonb is generally preferred due to its performance benefits and additional functionalities.

2. Mapping JSON Data: When mapping PostgreSQL JSON data to Java objects, it’s crucial to use appropriate data types. Typically, map JSON columns to String or a custom class, depending on the complexity of the JSON structure.

3. Using @Type Annotation: The article recommends using the @Type annotation from Hibernate or similar JPA providers to explicitly specify how JSON data should be handled.

4. Custom Converters: For more complex scenarios, creating custom JPA converters allows for fine-grained control over JSON data conversion between the database and Java objects.

5. Handling Errors: Common JSON type mismatch errors and their solutions are outlined, such as ensuring data consistency between the database and application code.

The article provides actionable advice to handle JSON data effectively in JPA when working with PostgreSQL, ensuring proper data mapping and minimizing type mismatch errors.

Read the full article.

Functional First: Rethinking Programming Education

This article explores the benefits of introducing functional programming concepts early in programming education. Key points include:

1. Functional Programming Advantages: Functional programming (FP) emphasizes immutability, higher-order functions, and pure functions, which can lead to more predictable and maintainable code. These concepts help students develop a deeper understanding of programming principles.

2. Educational Approach: The article argues for a shift towards teaching functional programming as a foundational approach, rather than as an advanced topic. It suggests that starting with FP can enhance students' problem-solving skills and overall coding proficiency.

3. Benefits for Students: By learning FP principles early, students can develop a stronger grasp of concepts like recursion, data transformation, and declarative programming. This can make transitioning to other programming paradigms easier and improve their ability to reason about code.

4. Curriculum Integration: The article proposes integrating functional programming into existing curricula, highlighting practical strategies for educators to incorporate FP concepts without overwhelming students.

5. Long-term Impact: Embracing a functional-first approach can better prepare students for modern software development challenges and improve their adaptability to various programming languages and paradigms.

Overall, the article advocates for a functional-first approach in programming education to foster a deeper understanding of programming concepts and better prepare students for diverse coding environments.

Read the full article.

---

If you're preparing for interviews, I have some good news! I started a LinkedIn page called "Interview Prep 101," last week, where I post intriguing interview questions related to DSA, Java, Spring Boot, and SQL. If you're interested, feel free to follow the page!

---

Following the flow of a Java Stream

This article provides a detailed guide on understanding and using Java Streams. Key points include:

1. Stream Basics: Java Streams represent a sequence of elements that can be processed in parallel or sequentially. They offer a high-level abstraction for processing collections of data.

2. Stream Pipeline: Streams use a pipeline pattern consisting of a source (like a collection), intermediate operations (like filter, map), and a terminal operation (like collect, forEach). The article explains how data flows through these stages.

3. Intermediate Operations: These operations, such as filter and map, are lazy and build a chain of operations that are executed when a terminal operation is invoked.

4. Terminal Operations: Terminal operations, like collect and reduce, trigger the processing of the stream and produce a result or side-effect.

5. Parallel Streams: The article discusses how to leverage parallel streams to improve performance by processing elements concurrently, and provides guidelines on when to use them effectively.

6. Practical Examples: It includes practical code examples to illustrate common operations and patterns in Java Streams, making it easier to understand their application in real-world scenarios.

Overall, the article serves as a comprehensive overview of how Java Streams work, including their structure, operation flow, and practical usage tips.

Read the full article.

How to integrate Jakarta Data with Spring and Hibernate

This article provides an in-depth look at integrating Jakarta Data with Spring and Hibernate. Key points include:

1. Jakarta Data Overview: Jakarta Data (formerly known as Jakarta Persistence or JPA) is a specification for object-relational mapping in Java. It helps manage database operations through entities and repositories.

2. Spring Integration: Spring Data simplifies working with databases by providing a repository abstraction. It builds on Jakarta Data to offer a more developer-friendly approach, allowing for automatic query generation and reducing boilerplate code.

3. Hibernate: Hibernate is a popular implementation of Jakarta Data. It provides additional features and optimizations on top of the standard specification, such as caching and lazy loading.

4. Setting Up: The article details how to configure Jakarta Data, Spring, and Hibernate together, including dependencies and configuration files.

5. Best Practices: It includes best practices for using these technologies, such as how to efficiently handle transactions, manage entity states, and optimize performance.

6. Examples and Code: Practical examples and code snippets demonstrate how to use Jakarta Data with Spring and Hibernate effectively, covering common scenarios like querying and managing entities.

Overall, the article serves as a comprehensive guide for developers looking to understand and effectively use Jakarta Data in conjunction with Spring and Hibernate for robust data management in Java applications.

Read the full article.

Dynamic Client Registration in Spring Authorization Server

This article explores how to dynamically register clients with an OAuth2 Authorization Server using Spring Security. Here’s a summary of the key points:

1. Dynamic Client Registration: This refers to the process where OAuth2 clients are registered or updated at runtime rather than statically configuring them. This is useful for applications that require flexible client management.

2. Spring Security: The article outlines how Spring Security can be used to implement dynamic client registration. It focuses on configuring OAuth2 clients dynamically, which can be beneficial in microservices architectures or scenarios where clients are frequently added or modified.

3. Configuration: The dynamic registration process is demonstrated through code examples. It involves using Spring Security’s OAuth2ClientRegistrationRepository to manage and store client registrations dynamically.

4. Custom Implementations: The article explains how to create custom implementations to handle the registration and storage of clients. This allows for flexibility in how client information is managed and accessed.

5. Use Cases: Scenarios where dynamic client registration is particularly useful include environments where clients are created and destroyed frequently or where there’s a need for on-the-fly updates to client configurations.

The article provides practical guidance and code samples for integrating dynamic client registration into a Spring Security-based application, emphasizing how this approach can enhance the flexibility and manageability of OAuth2 client

Read the full article

Integrate OpenAPI With Spring Cloud Gateway

This article discusses how to integrate OpenAPI documentation with Spring Cloud Gateway. Here’s a summary:

1. Introduction: It introduces the concept of Spring Cloud Gateway as a tool for routing and filtering requests in a microservices architecture. OpenAPI (formerly Swagger) is a specification for defining APIs.

2. Setup: The guide details how to set up a Spring Cloud Gateway project with the necessary dependencies. It includes adding Spring Boot and Spring Cloud Gateway dependencies to pom.xml or build.gradle file.

3. Integrating OpenAPI:

   • Dependencies: Add dependencies for Springdoc OpenAPI to project to generate OpenAPI documentation.

   • Configuration: Configure Springdoc OpenAPI by setting up properties in application.yml or application.properties. This configuration allows the gateway to generate and expose the OpenAPI documentation.

4. Testing and Verification: Instructions on how to run the application and access the OpenAPI documentation endpoint to ensure it is properly integrated.

5. Conclusion: Summarizes the benefits of integrating OpenAPI with Spring Cloud Gateway, such as improved API documentation and easier client interaction with microservices.

Read the full article.

A Guide to Fallback Beans in Spring Framework

This article provides a guide to using fallback beans in the Spring Framework. Here’s a summary of the key points:

1. Fallback Beans Concept: Fallback beans are used in Spring applications to provide default behavior or alternative implementations when a primary bean fails or is unavailable. They are particularly useful in scenarios involving external services or complex systems where failure is a possibility.

2. Spring’s @Primary and @Qualifier Annotations: The guide explains how to use @Primary to designate a default bean and @Qualifier to specify which bean to use when multiple candidates are available. This allows for a fallback mechanism if the primary bean is not available.

3. Profile-based Configuration: The article discusses how Spring profiles can be used to define different sets of beans for different environments (e.g., development, production). Fallback beans can be configured based on the active profile to ensure that a sensible default is used in each environment.

4. Customizing Bean Initialization: The guide also covers how to customize the initialization of beans to handle failures gracefully. This involves implementing error-handling logic during bean creation to ensure the application remains stable even if some beans cannot be initialized properly.

5. Practical Example: The article provides a practical example demonstrating how to set up fallback beans using Spring's dependency injection and bean management features. This helps illustrate the concepts and shows how to implement fallback behavior effectively in a real-world scenario.

Overall, the guide offers a detailed look at how to implement fallback strategies using Spring Framework's features to ensure robustness and flexibility in application design.

Creating cloud-native Java applications with the 12-factor app methodology

This article discusses how to create cloud-native Java applications using the 12-Factor App methodology. Here’s a summary of the key points:

1. Overview of the 12-Factor App Methodology: The 12-Factor App methodology is a set of best practices for building applications that are designed to be scalable, maintainable, and deployable in a cloud environment. It helps ensure that applications are portable and can run efficiently in a variety of cloud platforms.

2. The 12 Factors:

   • Codebase: Keep a single codebase for each application, tracked in version control.

   • Dependencies: Explicitly declare and isolate dependencies using dependency management tools.

   • Config: Store configuration in environment variables to keep it separate from the codebase.

   • Backing Services: Treat backing services (like databases) as attached resources, not part of the application.

   • Build, Release, Run: Separate the build, release, and run stages of deployment to manage changes and rollbacks more effectively.

   • Processes: Execute the application as one or more stateless processes, managing state through external storage.

   • Port Binding: Export services via port binding, making them available over the network.

   • Concurrency: Scale out the application by deploying multiple instances or processes.

   • Disposability: Design the application for fast startup and graceful shutdown to handle changes and failures.

   • Dev/Prod Parity: Keep development, staging, and production environments as similar as possible to reduce bugs and inconsistencies.

   • Logs: Treat logs as event streams, and use logging to track the application’s behavior and issues.

   • Admin Processes: Run administrative or management tasks as one-off processes, separate from the main application processes.

3. Benefits of the 12-Factor Methodology: Applying these principles helps ensure that Java applications are easier to deploy, manage, and scale in cloud environments. It also promotes better practices for maintaining application quality and operational efficiency.

4. Implementation in Java: The article touches on how Java developers can apply these principles using various tools and frameworks, such as Spring Boot for dependency management and configuration, and cloud platforms for deployment and scaling.

Overall, the guide highlights how adopting the 12-Factor App methodology can lead to more robust and cloud-ready Java applications.

Read the full article.

How To Change PDF Paper Sizes With an API in Java

This article provides a tutorial on changing the paper size of a PDF using an API in Java. Here’s a summary of the key points:

1. Objective: The goal is to modify the paper size of a PDF document programmatically using Java, which is useful for adjusting document layouts and ensuring they fit specific print or display requirements.

2. Tools and Libraries:

   • iText Library: The article uses the iText library, a popular Java library for creating and manipulating PDF documents.

   • PDFBox: Another option mentioned for handling PDF manipulations in Java.

3. Steps to Change Paper Size:

   • Load the PDF: Open the existing PDF document using the library’s API.

   • Modify the Page Size: Adjust the paper size by setting new dimensions for each page. This involves accessing and altering the page size properties.

   • Save the Modified PDF: Save the document with the new paper size settings.

4. Example Code: The article includes example code snippets demonstrating how to use iText to change the paper size. This typically involves:

   • Creating a new Document object with the desired page size.

   • Iterating through the existing pages and adjusting their size.

   • Writing the modified document to a new file.

5. Considerations:

   • Page Content: When changing the paper size, consider how the existing content will fit on the new page dimensions.

   • Compatibility: Ensure the chosen library and methods are compatible with the specific version of the PDF are working with.

Overall, the article provides a practical guide for Java developers to change the paper size of PDFs using available APIs, with a focus on using iText for implementation.

Read the full article.

If you like this newsletter, consider liking, restacking, and sharing with others to promote this newsletter, thanks for your help!