Java Web Development (JSP/Servlets) Services

In this blog, we will take a closer look at Spring Security, specifically in combination with Keycloak using OpenID Connect, all supported with examples and unit tests. Enjoy!

Introduction

Many applications are supported by means of authentication and authorization. However, it is also something software developers find difficult to grasp. In this blog, Spring Security is introduced, which is Spring's solution for adding security to your Spring applications. By means of examples and unit tests, you will learn the annotations and Spring classes. The end goal is to set up an application using OpenID Connect in combination with Keycloak. An introduction to OpenID Connect and Keycloak can be found in a previous blog. It is advised to read this blog if you are not yet familiar with the concepts.

Amazon EKS makes running containerized applications easier, but it doesn’t give you automatic visibility into JVM internals like memory usage or garbage collection. For Java applications, observability requires two levels of integration:

• Cluster-level monitoring for pods, nodes, and deployments
• JVM-level APM instrumentation for heap, GC, threads, latency, etc.

New Relic provides both via Helm for infrastructure metrics, and a lightweight Java agent for full JVM observability.

Many times, while developing at work, I needed a template for a simple application from which to start adding specific code for the project at hand.

In this article, I will create a simple Java application that connects to a database, exposes a few rest endpoints and secures those endpoints with role based access.

I recently experimented with QtJambi, a Java wrapper for the well-known Qt C++ library used to build GUIs. Here are some initial thoughts, remarks and observations:

• Building a QtJambi project can be somewhat challenging. It requires installing the Qt framework, configuring system paths to Qt’s native libraries, and setting proper JVM options. Although it is possible to bundle native libraries within the wrapper JARs, I haven’t tried this yet.
• The overall development approach is clean and straightforward. You create windows or dialogs, add layouts, place widgets (components or controls) into those layouts, configure widgets and then display the window or dialog to the user. This model should feel familiar to anyone with GUI experience.
• Diving deeper, QtJambi can become quite complex, comparable to usual Java Swing development. The API sometimes feels overly abstracted with many layers that could potentially be simplified.
• There is an abundance of overloaded methods and constructors, which can make it difficult to decide which ones to use. For example, the QShortcut class has 34 different constructors. This likely comes from a direct and not fully optimized mapping from the C++ Qt API.
• Like Swing, QtJambi is not thread-safe. All GUI updates must occur on the QtJambi UI thread only. Ignoring this can cause crashes, not just improper UI refresh like in Swing.
• There is no code reuse between Java Swing and QtJambi. Even concepts that appear close and reusable are not shared. QtJambi is essentially a projection of C++ Qt’s architecture and design patterns into Java, so learning it from scratch is necessary even for experienced Swing developers.
• Using AI tools to learn QtJambi can be tricky. AI often mixes Java Swing concepts with QtJambi, resulting in code that won’t compile. It can also confuse Qt’s C++ idioms when translating them directly to Java, which doesn’t always fit.
• Despite being a native wrapper, QtJambi has some integration challenges, especially on macOS. For example, handling the application Quit event works differently and only catching window-close events behaves properly out of the box. In contrast, native Java QuitHandler support is easier and more reliable there, but it doesn't work with QtJambi.
• Mixing Java AWT with QtJambi is problematic. This may leads to odd behaviors or crashes. The java.awt.Desktop class also does not function in this context.
• If you want a some times challenging Java GUI framework with crashes and quirks, QtJambi fits the bill! It brings a lot of power but also some of complexity and instability compared to standard Java UI options.
• There is a GUI builder that works with Qt, but it is possible to use its designs in QtJambi, generating source code or loading designs at runtime. The only issue: the cost starts from $600 per year for small businesses to >$5,000 per year for larger companies.

Notable Applications Built With QtJambi

Notable applications built with QtJambi are few. One example is the Interactive Brokers desktop trading platform (IBKR Desktop), which uses QtJambi for its user interface. 

Introduction

Concurrent programming remains a crucial part of building scalable, responsive Java applications. Over the years, Java has steadily enhanced its multithreaded programming capabilities. This article reviews the evolution of concurrency from Java 8 through Java 21, highlighting important improvements and the impactful addition of virtual threads introduced in Java 21.

Starting with Java 8, the concurrency API saw significant enhancements such as Atomic Variables, Concurrent Maps, and the integration of lambda expressions to enable more expressive parallel programming.