Skip to content
Computese home
Utilities07Cloud01Website

Legacy Java, from Struts to Spring Boot

A utility’s core system for customers, field work and billing had run on premises for 15+ years on Struts 1, WebLogic and Oracle. Without access to the client’s environment, we assessed it, proved the move to Spring Boot in code and mapped the route to the cloud.

Industry
Utilities
Engagement
Assessment, proof of concept, cloud strategy
Starting point
Struts 1 on WebLogic, on premises
Target
Spring Boot on Java 21, containers, cloud
Access
None: source export and specifications

Where it started.

One codebase runs customers and contracts, field work, billing and collections, stock and equipment, a large set of printed forms and a nightly batch. The client asked what state it was in, whether modernizing it was feasible, what it would cost, in what order, and how it should reach the cloud.

  • Struts 1, a web framework past its end of life for more than a decade, with no security patches, on Java 8 and tied to WebLogic’s own logging and JNDI APIs.
  • No surviving design documents: the knowledge lived in the code and with the people maintaining it.
  • Heavy technical debt: a build full of warnings, raw SQL through a home-grown data access layer, and business logic inside JSPs and actions, so every change was slow and risky.
  • Ageing infrastructure, expensive Oracle and WebLogic licences and no clear route to the cloud.

The shape of the work.

Drawn new for this page. No screens or data from the client's systems.

The client sends only a source export and specifications; there is no access to its environment. We build a mirror of the legacy stack, move a slice from the old framework to Spring Boot, and compare every output with the old system: screens, database writes and report files must match.

Fig. 1 Working without the client’s environment. Drawn new; no client systems shown.

From legacy to target, layer by layer.

The as-is stack we assessed, and the target the proof of concept and the cloud strategy point to.

Language runtime
As is: Java 8
Target: Java 21
Web framework
As is: Struts 1, JSP with scriptlets
Target: Spring Boot, Spring MVC, Spring Security
Application server
As is: Oracle WebLogic
Target: Embedded server in a container, on Docker and Kubernetes
Database
As is: Oracle Database, raw SQL through a home-grown layer
Target: Oracle in the cloud, licence brought or managed; PostgreSQL evaluated
Build and source control
As is: Apache Ant, Subversion
Target: Maven, Git, a CI/CD pipeline
Batch
As is: Nightly jobs on premises
Target: A cloud scheduler
Character encoding
As is: A legacy encoding
Target: UTF-8, with a conversion plan
Infrastructure
As is: On premises, with a standby site
Target: AWS or Google Cloud, Multi-AZ, infrastructure as code

How it ran.

  1. 01

    Mirror

    Provisioned our own servers mirroring the client’s stack (Red Hat Enterprise Linux, WebLogic, Oracle) from the specifications and the source export, for analysis, performance baselines and regression tests.

  2. 02

    Assess

    Module inventory and dependency map (one core module carries most of the inbound references), static and security scans, a risk heatmap and priority matrix, and the client’s list of issues analysed alongside the hidden ones we found.

  3. 03

    Recover

    Rebuilt the missing design documents and extracted the business rules from the source code, accelerated with AI under an approved, masked-data process.

  4. 04

    Prove

    Moved a slice from Struts actions and JSP to Spring Boot and Spring MVC on a current Java release without changing behaviour, checked against a golden baseline of the old system’s screens, database writes and report files.

  5. 05

    Plan

    Current-state capture; functional, non-functional and migration requirements; a weighted AWS and Google Cloud comparison (Oracle licensing, total cost, data residency, compatibility with the Java estate); and a roadmap tied to the proof of concept.

Two steps, not a big bang.

Modernize the application where it runs today, then move it to the cloud.

Today the system runs on premises on Struts 1 and JSP, Java 8, Oracle WebLogic and Oracle Database, built with Ant from Subversion. Step one modernizes the application where it runs: Spring Boot on Java 21, a container image, Maven, Git and CI/CD, with a golden baseline proving the old and new behave the same. Step two moves it to the cloud: AWS or Google Cloud, Multi-AZ, infrastructure as code, Oracle with the licence brought or managed, and PostgreSQL evaluated.

Fig. 2 The route the roadmap recommends: two steps, each with its own checkpoint. Drawn new; no client systems shown.

The stack, by layer.

Every product and practice in this work, named so an engineer can check it.

01Legacy we analysed
  • Java 8
  • Struts 1
  • JSP
  • Oracle WebLogic
  • JNDI
  • Apache Ant
  • Subversion
02Target application
  • Java 21
  • Spring Boot
  • Spring MVC
  • Spring Security
  • Embedded server
03Data
  • Oracle Database
  • PostgreSQL (evaluated)
  • SQL
  • UTF-8
04Build and delivery
  • Maven
  • Git
  • CI/CD pipeline
  • Docker
  • Kubernetes
05Cloud
  • AWS
  • Google Cloud
  • Multi-AZ
  • Infrastructure as code
  • Red Hat Enterprise Linux
06Assessment
  • Dependency mapping
  • Static code analysis
  • Security scanning
  • Performance baselines
  • AI-assisted reverse engineering
  • Golden-baseline regression tests

Constraints we worked within.

No access to the client’s environment
A mirror built from specifications and source; every analysis and test ran there.
No design documents
The code is the only source of truth, so the documents were recovered from it.
Sensitive data
Masked data only, with an NDA and approval for AI use on the codebase before work began.
Behaviour must not change
Every change compared automatically with the old system: screens, database writes and report files.

What changed.

  • A clear picture of the system’s state, risks and priorities, reviewed by the client as each deliverable landed.
  • A repeatable Struts to Spring Boot pattern proven in code, with an effort model for the remaining modules.
  • The existing report engine confirmed on the new Java runtime.
  • A weighted cloud comparison and a roadmap that keeps modernizing the application and moving to the cloud as separate, lower-risk steps.

What we learned.

  1. 01When you cannot touch production, a faithful mirror is worth its setup cost. It made performance and regression testing possible.
  2. 02A golden baseline beats manual testing: compare screens, database writes and files with the old system automatically.
  3. 03Modernize the application and move to the cloud as two steps. Doing both at once multiplies the risk.

Questions this work answers.

How do you migrate Struts to Spring Boot without breaking behaviour?

Slice by slice. Each slice moves from Struts actions and JSP to Spring Boot and Spring MVC, and a golden baseline compares its screens, database writes and report files with the old system automatically before it is accepted.

Should we modernize the application and move to the cloud at the same time?

We advise two steps: modernize the application first, on infrastructure you already know, then move it to the cloud. Doing both at once multiplies the risk and blurs the cause of any problem.

Can a legacy system be assessed without access to its environment?

Yes. From a source export and specifications we build a mirror of the stack, then run the analysis, the performance baselines and the regression tests there.

Start with a conversation.

Tell us what you run and what is getting in the way. You get a reply within 24 hours.

Hours
Mon–Fri, 9:00–17:00 ET
Closed on statutory holidays
Office
110 Place d'Orléans Dr
Ottawa, ON K1C 2L9