Developing large-scale enterprise applications involve several processes and technologies for creating a truly extensible, maintainable, and resilient object-oriented architecture. To be able to deliver an application that both completely meets the business goals set forth, and is able to evolve over the years without requiring significant redesign, warrants an open, flexible, and standards-friendly architecture. Careful articulation of the problem domain, and the requirements of its consumers, is just one aspect of ensuring that an architecture is created for supporting the current and future needs of the business. The problem domain definition must also become a means of driving the design, and development process. We should be able to trace the design and development artifacts to the original requirements to ensure consistency between the stated requirements and what is being delivered. This traceability between requirements and other project related artifacts ensure that the design view of the system is consistent with its use-case view.
Creating a use case view of the system is a meticulous process in which Information Architecture also plays a significant role. Translating the use case view into a corresponding design view for a multi-tiered architecture entails using the incremental and iterative process of domain modeling, business-tier process modeling, implementing presentation semantics—all within the context of a design that will allow maximum reuse within all tiers of the application. When you add to this compendium the need to understand the underlying component technologies, and the need to follow development methodologies and processes for managing project life-cycle, you can see that we are faced with a huge learning curve for creating a prototypical application that validates our approach for a large-scale solution. While the processes and technologies required to address all of the varied disciplines we just discussed are well-documented in several books, it is not practical for all J2EE enthusiasts to pour through each several-hundred page book before they're able to create a real world end-to-end solution. Serially learning each of the disciplines of software development is not efficient either, since it takes a lot more time, and is further compounded by our inability to retain unused information for long time. This book offers a "what you learn is what you use" approach that provides a blueprint for establishing a base-line architecture for most Web-based applications. This approach gives J2EE enthusiasts the opportunity for a fast ramp-up by allowing them to immediately apply the concepts they've learned to solve a real-world problem. It also provides both developers, and students aspiring to become architects, a one-stop source for the following:
Use case driven modeling and development
Role of Information Architecture in use case elaboration
Formulating the security strategy of the application
Understanding the need for presentation framework in the context of an MVC architecture
Using the Struts framework
Identifying implementation patterns for enabling Struts adoption in a consistent manner
Capturing static aspects of the Design View of the system using class diagrams, and dynamic aspects using sequence diagrams
Modeling interactions between the presentation tier components, interactions between the business tier components, and interactions between inter-tier components (between presentation and business tiers) using best practice design patterns
Implementing the Design View using J2EE component technologies
Implementing Web services using J2EE component technologies
Part I of this book is helpful for architects, developers, project managers, quality assurance teams, information architects, and anybody else who cares to understand the process of requirements analysis. The rest of the book is for budding architects, corporate developers, and students who are planning to build enterprise-class business applications for the J2EE platform. For Part II of this book, it is expected that the readers are familiar with object-oriented principles and concepts, and familiarity with UML is essential. This book assumes that the readers have familiarity with basic J2EE concepts, and the development and deployment of simple J2EE components.
Technology teams who will be creating a reference architecture or a prototypical programming model for upcoming projects will be able to harvest design templates from the accompanying material for their baseline architecture. Several best-practice J2EE design patterns, and their interactions and dependencies, have been captured in the accompanying sample application. The sample application provides a good place to start evolving the programming model based on your unique project requirements. Technology teams wanting to understand the architecture and adoption of presentation tier frameworks will benefit from the discussion on Struts.
The book's emphasis in on architecture and design and less on programming aspects, and as such, this book is not a complete coverage of the J2EE platform or Struts framework. Readers are provided with references to resources and books for completing their understanding of the material covered in this book. Also, this book is not exhaustive in its coverage of design patterns, as the subject of design patterns is vast and covered by large number of books, and there are several sites dedicated to discussing design patterns. The Web service implementation in this book is based on BEA WebLogic Workshop, which provides an abstraction over JAX-RPC API, as such programming with JAX-RPC API is not covered in this book.