Engineering With Java: Digest #28

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 Spring Boot 3.3 performance updates, creating beans, command line with Jbang, java 8 predicates, Convo AI with Apache camel, etc.

---

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!

---

1. Spring Boot 3.3 Boosts Performance, Security, and Observability

The article discusses the release of Spring Boot 3.3, which introduces several new features and improvements. Here are the key highlights:

1. Support for Java 21: Spring Boot 3.3 is compatible with Java 21, leveraging new language features and improvements.

2. Improved Configuration Management: Enhancements in configuration management make it easier to manage and override settings, with better support for YAML and properties files.

3. Enhanced Observability: There are updates to observability tools, including improved support for tracing and metrics, helping developers monitor and troubleshoot applications more effectively.

4. Native Image Support: The new version includes better support for native image generation with GraalVM, improving startup times and reducing memory usage.

5. Dependency Upgrades: Spring Boot 3.3 upgrades its core dependencies, including Spring Framework 6.1, which brings additional features and fixes.

6. Developer Experience Improvements: Various enhancements aim to improve the overall developer experience, including better error messages and more intuitive configuration options.

Read the article.

2. Creating Beans: Do’s, Don’ts and Nice-To-Do’s

This article on creating beans in Spring Framework provides guidelines on best practices and common pitfalls. Here’s a summary of the key points:

Dos:

1. Use Constructor Injection: Prefer constructor injection over field injection for better immutability and easier testing.

2. Annotate Properly: Use @Component, @Service, @Repository, or @Controller to define beans clearly, which improves readability and maintains the intended roles of the components.

3. Leverage Configuration Classes: Use @Configuration classes and @Bean methods to define beans when we need more control over bean creation.

4. Understand Scopes: Be aware of bean scopes (singleton, prototype, etc.) and use them appropriately based on needs.

Don’ts:

1. Avoid Field Injection: It can lead to hidden dependencies and makes unit testing difficult.

2. Don’t Use @Autowired on Fields: Instead, use constructor-based injection or setter injection where appropriate.

3. Avoid Overusing @Bean: Use @Bean methods in configuration classes sparingly and only when necessary for creating complex beans.

Nice-to-Do’s:

1. Use @PostConstruct for Initialization: Utilize @PostConstruct to handle initialization logic after the bean’s properties have been set.

2. Consider @Profile for Conditional Beans: Use @Profile to define beans that should only be active in specific environments or conditions.

3. Document Bean Dependencies: Clearly document the dependencies and purposes of the beans to improve maintainability and clarity.

The article emphasizes the importance of using Spring's features correctly to ensure that the application is maintainable, testable, and follows best practices.

Read the article.

3. Creating a Command Line Tool With JBang and PicoCLI To Generate Release Notes

• This article provides a guide on creating a command-line tool using JBang and Picocli. Here's a summary of the key points:

• JBang is a tool for running Java code directly from scripts, which simplifies the development and execution of Java-based CLI applications.

• Picocli is a Java library for building command-line interfaces with features like argument parsing, subcommands, and more.

• JBang simplifies the setup and execution of Java-based scripts without needing a full project setup.

• Picocli provides a powerful and flexible way to handle command-line arguments and build robust CLI tools.

Read the article

🚀 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.

4. Optimizing Data Filtering with Java 8 Predicates

• This article discusses optimizing data filtering in Java using Java 8's Predicate interface. Here's a summary of the key points:

• Predicates are functional interfaces that represent a single argument function that returns a boolean value. They are used extensively in Java 8 for filtering and matching data in streams.

1. Using Predicate for Filtering:

   • Predicate can be used to define conditions for filtering data in collections or streams.

   • It provides methods like test() to evaluate the condition, and and(), or(), and negate() for combining multiple predicates.

2. Combining Predicates:

   • and(Predicate other): Combines two predicates with a logical AND.

   • or(Predicate other): Combines two predicates with a logical OR.

   • negate(): Inverts the result of the predicate.

3. Examples and Best Practices:

   • Use Predicate to create reusable conditions for filtering.

   • Combine multiple predicates to create complex filters in a clean and readable manner.

   • Leverage built-in methods for common conditions to avoid redundant code.

Read the article

5. Configuring gRPC Retry Policies in Java Applications

• This article explores configuring gRPC retry policies in Java applications to handle transient failures and improve reliability.

• gRPC is a high-performance RPC framework that allows clients and servers to communicate over HTTP/2. Configuring retry policies is crucial for handling network issues and improving application resilience.

1. Understanding gRPC Retries:

   • gRPC supports retry policies to automatically retry failed requests under specific conditions.

   • Retries are useful for handling transient failures such as network timeouts or temporary unavailability of services.

2. Configuring Retry Policies:

   • Client-Side Configuration: Use RetryPolicy in client configurations to specify when and how retries should be attempted.

   • Server-Side Configuration: Servers can also configure retry behavior to handle retries from clients.

3. Retry Policy Parameters:

   • Retry Conditions: Define which types of failures should trigger a retry, such as UNAVAILABLE or DEADLINE_EXCEEDED status codes.

   • Retry Delay: Configure how long to wait before retrying a request, which can include fixed delays or exponential backoff strategies.

   • Retry Limits: Set the maximum number of retry attempts to avoid infinite retry loops.

Read the article

6. Service Layers in Spring Boot: Simplified vs. Structured — Which Should You Choose?

• This article discusses the different approaches to implementing service layers in Spring Boot applications, focusing on the "Simplified" and "Structured" approaches.

- Simplified Approach:

• Characteristics: This approach integrates business logic and data access into fewer classes, often combining these responsibilities in a single class. It minimizes the amount of boilerplate code and often involves direct interactions between service and repository layers.

• Pros: The simplified approach accelerates development by reducing the number of classes and simplifying the codebase. It's especially useful for small projects or prototypes where rapid development is prioritized.

• Cons: The main drawback is reduced flexibility and maintainability. Combining multiple responsibilities into a single class can lead to tightly coupled code, making it harder to test, maintain, and scale. As the project grows, this approach can result in a cluttered and difficult-to-manage codebase.

Structured Approach:

• Characteristics: This approach advocates for a clear separation of concerns by using distinct layers for business logic, data access, and other functionalities. It typically involves multiple layers or components, such as service layers, repository layers, and DTOs (Data Transfer Objects).

• Pros: The structured approach enhances maintainability and scalability by clearly defining responsibilities and interactions between layers. This separation makes the application easier to test, extend, and refactor, which is beneficial for larger projects or applications expected to evolve over time.

• Cons: The primary downside is the increased amount of boilerplate code and complexity. Additional layers can introduce overhead and might slow down initial development. However, this is often outweighed by the benefits of better organization and easier future modifications.

Choosing the Right Approach:

For smaller projects or rapid prototyping, the simplified approach may suffice. For larger, more complex applications where long-term maintainability and scalability are critical, the structured approach is generally preferred.

Read the article.

7. Build a Conversational AI With Apache Camel, LangChain4j, and WhatsApp

The article explores integrating conversational AI into Spring Boot applications using LangChain4j and Ollama, two tools that enhance the development of sophisticated chatbots and conversational interfaces.

LangChain4j:

• Functionality: LangChain4j is a Java library designed to manage chains of language models. It facilitates the integration of multiple AI models into a cohesive system, allowing for complex conversational flows and interactions. The library helps developers build systems where different models handle various aspects of conversation, such as intent recognition and response generation.

• Integration: To use LangChain4j in a Spring Boot application, we need to set up the necessary dependencies and configure the library to chain models effectively. This setup allows for the creation of dynamic and context-aware conversational systems by leveraging the strengths of different language models.

Ollama:

• Functionality: Ollama provides a platform with pre-trained language models and conversational agents. It simplifies the creation of chatbots and AI-driven conversational systems by offering models that can handle intent recognition, entity extraction, and dialogue management out of the box.

• Integration: Integrating Ollama into a Spring Boot application involves configuring the platform to interact with our application’s services. This setup enables developers to deploy sophisticated conversational agents without extensive machine learning knowledge, as Ollama’s pre-trained models manage much of the conversational complexity.

Integration with Spring Boot:

• Configuration: The article details how to integrate both LangChain4j and Ollama within a Spring Boot application, including managing dependencies and setting up configurations. It provides insights into creating services that utilize these tools to build and manage conversational AI features.

• Advantages: Combining LangChain4j and Ollama in Spring applications allows developers to quickly build advanced conversational interfaces. The tools provide a framework for handling complex interactions and improve the overall user experience with minimal development effort.

Overall, the article emphasizes how these tools streamline the development of conversational AI, enabling more sophisticated and scalable chatbot solutions in Spring Boot applications.

Read the article.

8. Java 8 — Frequently Used Stream Methods

• This article provides an overview of frequently used Stream methods in Java 8, highlighting their utility in processing collections in a functional and declarative manner. Here’s a summary:

• Java 8 introduced the Stream API, which allows for functional-style operations on sequences of elements. Streams provide a way to process collections of data in a more readable and efficient manner.

1. filter(): This method is used to exclude elements from a stream based on a predicate. It returns a new stream that contains only the elements that satisfy the specified condition. For example, stream.filter(e -> e.startsWith("A")) filters elements starting with "A".

2. map(): This method transforms each element of the stream using a given function. It returns a new stream consisting of the results of applying the function. For instance, stream.map(String::toUpperCase) converts all elements to uppercase.

3. flatMap(): Used to flatten a stream of collections into a single stream. It maps each element to a stream and then flattens those streams into a single stream. For example, stream.flatMap(List::stream) converts a stream of lists into a single stream of elements.

4. collect(): This terminal operation gathers the elements of a stream into a collection or other data structure. Common collectors include Collectors.toList(), Collectors.toSet(), and Collectors.joining().

5. reduce(): This method performs a reduction on the elements of the stream using an associative accumulation function and returns an Optional. It is useful for aggregating results, such as summing up numbers or concatenating strings.

6. sorted(): It sorts the elements of the stream based on their natural order or a specified comparator. For example, stream.sorted() sorts elements in ascending order.

In summary, Java 8 Stream methods like filter, map, flatMap, collect, reduce, and sorted offer powerful ways to handle collections of data efficiently and in a more functional style.

9. Enhancing Java Application Logging: A Comprehensive Guide

This article explores techniques for enhancing logging in Java applications to improve visibility, troubleshooting, and maintenance. It covers best practices and tools for effective logging strategies.

1. Choose the Right Logging Framework:

   • SLF4J with Logback or Log4j2: SLF4J (Simple Logging Facade for Java) is a popular facade that allows us to plug in various logging implementations like Logback or Log4j2. Logback is known for its performance and advanced configuration options, while Log4j2 offers asynchronous logging for high-performance scenarios.

2. Effective Logging Practices:

   • Log Levels: Use appropriate log levels (DEBUG, INFO, WARN, ERROR) to categorize messages. Avoid excessive logging at INFO and DEBUG levels in production environments to reduce log volume.

   • Structured Logging: Implement structured logging to include context and metadata with log entries. This can be achieved using tools like Logback’s MDC (Mapped Diagnostic Context) or custom log formats.

   • Log Rotation and Archiving: Configure log rotation to manage file sizes and archiving to keep historical logs. This helps in managing disk space and ensuring that logs are available for analysis over time.

3. Centralized Logging:

   • Use Log Aggregation Tools: Implement centralized logging solutions such as ELK Stack (Elasticsearch, Logstash, Kibana) or tools like Splunk. These tools aggregate logs from multiple sources, provide powerful search capabilities, and facilitate visualization and alerting.

4. Performance Considerations:

   • Asynchronous Logging: Use asynchronous logging to reduce the performance overhead of synchronous logging operations. This ensures that logging does not impact application performance.

   • Logging Best Practices: Avoid logging sensitive information and be mindful of the performance impact of logging operations. Configure logging frameworks to balance between logging detail and performance impact.

Effective logging is crucial for monitoring, troubleshooting, and maintaining Java applications. By choosing the right framework, following best practices for logging levels and formats, using centralized logging tools, and considering performance implications, developers can significantly enhance the logging capabilities of their Java applications.

Read the article.

10. How To Solve OutOfMemoryError: Java Heap Space

article provides strategies for addressing OutOfMemoryError: Java heap space issues in Java applications, which occur when the JVM cannot allocate more memory for objects.

• OutOfMemoryError: Java heap space: This error indicates that the Java Virtual Machine (JVM) has exhausted the heap memory, which is used for object allocation. This can be caused by various factors, including memory leaks, improper memory management, or insufficient heap size.

1. Increase Heap Size:

   • Adjust JVM Options: Increase the maximum heap size using the -Xmx option in JVM settings. For example, -Xmx4G sets the maximum heap size to 4 GB. Ensure that the allocated heap size is sufficient for the application’s needs but within the limits of the system's resources.

2. Optimize Memory Usage:

   • Review Object Lifecycles: Analyze and optimize the usage of objects to ensure they are being created and destroyed efficiently. Avoid unnecessary object creation and consider reusing objects when possible.

   • Use Profiling Tools: Employ memory profiling tools like VisualVM, YourKit, or Eclipse MAT to identify memory usage patterns and detect memory leaks. Profiling helps in pinpointing objects that consume excessive memory or are not being garbage collected.

3. Fix Memory Leaks:

   • Identify Leaks: Investigate potential memory leaks where objects are retained longer than necessary, preventing garbage collection. Common sources include static references, unclosed resources, or collections that grow indefinitely.

   • Code Review and Testing: Conduct thorough code reviews and perform stress testing to uncover and resolve memory leaks. Use tools to analyze heap dumps and track down problematic areas in the code.

4. Optimize Garbage Collection:

   • Tune GC Parameters: Adjust garbage collection settings to improve performance and memory management. JVM options like -XX:+UseG1GC enable the G1 Garbage Collector, which can be more efficient for applications with large heaps.

Java heap space involves a combination of increasing heap size, optimizing memory usage, fixing memory leaks, and tuning garbage collection. By implementing these strategies, developers can enhance the stability and performance of Java applications, preventing heap space errors and improving overall efficiency.

Read the article.

🚀 Ace Your Next System Design Interview 🚀

Taught by a best-selling author, everything you need to take your system design skills to the next level.

>> Grab it while its hot.