Matthew Hawkins

You change a value somewhere in your Java code, and you want the screen to follow without hand-writing refresh calls for every label and every table. That is what most developers mean when they search for a Java reactive UI framework, and it rarely has anything to do with reactive streams.

webforJ, the full-stack Java framework, is a Java reactive UI framework in the sense that matters for screens: the UI reacts to events, to bound data and to repository commits, and background work can push changes to the page. It does this with event listeners and data binding, not with a streams library, and this post shows how those pieces fit together.

Some tools are easier to use with a prompt than with forms: an admin console, a log viewer, a way to run a quick command against a live server. Building one in the browser usually means a JavaScript terminal library and the code to wire it to your backend.

A Java web terminal in webforJ skips that wiring. The Terminal component is a full console you place in a view like any other component, and every keystroke reaches your Java code as an event.

A combo box in Java lets users pick an option from a list or type a value of their own. In webforJ, the ComboBox component handles both in one control, and you build it entirely in Java. This guide builds a country picker step by step. You will add preset items, set a placeholder, cap the dropdown height, turn custom input off for a field that needs a fixed answer, and read what the user chose.

Maybe you've heard it in a meeting already: the app feels outdated, users want it in a browser and on their phones, and every upgrade feels slow and risky. If you need to move a Java app to the web and mobile, the answer in this webinar is to stay in Java. You run the existing app in the browser first, then rebuild it one piece at a time with webforJ, the full-stack Java framework, while the business logic keeps working.

The webforJ 25.x cycle covered a lot of ground: new components, a fresh design language, smarter AI tooling, and plenty of polish, and it all wrapped up with the 26.00 release. Rather than a long recap, here's a short video that walks through the highlights.

Data is the lifeblood of business applications, and displaying it properly can make or break someone's experience using your app. In order to visualize data, most developers quickly turn to tables for displaying that data. Here's the problem: just throwing information into rows and columns doesn't always tell the story clearly enough.

When users glance at a table, the idea is that they immediately understand what matters. Is that price change good or bad? Which items need attention? What's trending up versus down? If your users have to pause and think, squint at numbers, or do mental math to understand their data, your interface isn't working hard enough for them. Perhaps your first instinct is to say that tables aren't the answer, but that isn't the case.

This is where renderers come in. In webforJ, cell renderers let you transform raw data into visual, instantly understandable information. Earlier this year, I built a mock cryptocurrency dashboard, which is a perfect example of an app that needs quick, understandable information at a glance, since crypto data is fast-moving, emotionally charged, and needs to be digested within seconds. Green numbers for gains, red for losses, formatted prices, inline charts—all rendered dynamically to tell the story your data is trying to communicate.

The fun part was using renderers to contain all of this information inside a tidy table, and in this post, we'll explore when and how to use these renderers to build tables that don't just display data, but actually communicate with your users.

When building web applications that consume REST APIs, one of the most important decisions you'll make is how to load and manage your data. Load everything at once for snappy client-side operations, or fetch data on-demand to keep memory usage low? The answer, as with most things in software development, is: it depends.

In this post, we'll explore two distinct approaches to loading data from REST APIs in webforJ applications, examining the trade-offs of each and showing you exactly how to implement them using Spring Boot and webforJ's repository patterns.

Remember learning about Model-View-Controller (MVC) in university? For most, at least from what I hear when speaking to others, they had to actually create an app following this design paradigm, which greatly helps any future use of this pattern in the "real world."

For me, that class was right in the middle of COVID. Our instructor was a nice enough guy, but between the Zoom fatigue and lack of experience (I'm fairly sure it was his first or second term teaching), not only did we not end up actually building anything, but we spent time doing theoretical explorations of the various design patterns out there, with MVC only receiving a few days of review.

All this to say that when I started working with webforJ, I saw it as the perfect opportunity to finally get hands-on with MVC—not just to understand the pattern properly this time, but also to learn how webforJ fits into this paradigm. Building a stereotypical todo app seemed like the ideal way to explore both.

As I went through my computer science education at Oregon State, I realized pretty quickly that I enjoyed the UI side of things. Messing around with CSS (yes, even trying to center a div) and making pages that looked nice appealed to me way more than databases and business logic.

Somehow, I ended up working at a company that primarily used Java. Lucky for me, the project I ended up on was a Java web framework - back in my comfort zone!

I've been able to keep myself pretty much in UI land since then, in my comfort zone and happy to let my colleagues deal with all that back end stuff.

Recently our framework, webforJ, released Spring integration, and with that, my blissful isolation in UI land came to an end. As my first foray into full-stack development, I was asked to build a (very, very simple) CRUD application using Spring and webforJ both so I could learn more about the back end, and also showcase webforJ and Spring together in one project.

TLDR: It went well.