Interest in J2EE is growing in leaps and bounds. But it’s easy to get stranded in a sea of marketing material. How can you put J2EE into perspective so you can learn to use it in an orderly, productive fashion? In this article, I’ll discuss how technology benefits of the J2EE platform combined with Extreme Programming best practices will make your Java shop more efficient.

From front-end clients to back-end data management
J2EE is a middleware framework for building scalable distributed enterprise applications. The platform divides applications into front-end clients, middleware business rules processing, and back-end data model management.

J2EE applications comprise independent components that are assembled into loosely coupled, self-managed containers. Containers are coupled by higher-level containers as proxy facades to clients, hiding the underlying complexity of detail in combined container interfaces—much like a manufacturing product Bill of Materials. To keep containers simple, J2EE lets you delegate supporting services shared across clients, facilitating the productivity paradigm of “write once—use many times.” And you can optimize data access services for network traffic by placing them next to the data sources they access.

Business rule processing is developed through incremental refinement and the use of automated tools, such as Ant, JUnit, httpUnit, Cactus, JUnitPerf and JMeter, that check application performance and help you catch problems early in the development process.

Best practices in the development process
Leveraging hundreds of years in engineering architecture history and best practices, design patterns provide developers a way to manage, optimize, and leverage what works from past experiences—avoiding what doesn’t—when assembling the detailed designs of large enterprise applications. Design patterns are organized by named metaphors, such as Structural and Behavioral, providing an easy way to associate design solutions to problem categories and streamlining the development process.

By allowing for reusable application components that can easily be assembled into independent and meaningful business containers, J2EE enables large enterprise systems development to move out of the dark ages of black magic, past the enlightened era of engineering architecture discipline, and into the modern era of intelligent, self-configurable software components. These components operate intuitively, like Lego assemblies, putting domain experts in control of successful business application deployment.

Through Java’s concept of reflection, developers can further abstract application logic into declarative predicate scripts, increasing the reuse and flexibility of common application logic. This, in turn, provides users with a prescriptive way to drive application functionality from the outside through declarative properties.

An ancillary benefit of adopting design patterns is that they provide an opportunity for code to be refactored. Paired programming is a great vehicle to drive this, especially when a senior engineer teams up with a junior one. Paired programming results not only in cleaner code but also in the transmission of expertise.

J2EE in the big picture
J2EE architecture covers the broad and deep landscape of enterprise business application technology. By appreciating the essence of J2EE’s rules, you can get a high-level grasp of what J2EE is all about. By adopting J2EE design patterns, your team can make J2EE work for them to facilitate code reuse faster and avoid reinventing the wheel for every application they build. And, perhaps, software engineering can move one step closer to self-assembling, self-optimizing applications that are built like Lego systems, intuitively assembled to solve the problem at hand or leverage an opportunity before it disappears.

J2EE on the brain

Thinking of making the switch to J2EE, or are you smitten with the promise of .NET? Drop us an e-mail or post a comment below.