Previous    Next

Summary

In this chapter, we've taken a high-level look at J2EE architecture. We've considered:

• The advantages and disadvantages of adopting a distributed architecture. Distributed apps are more complex, harder to implement, test, and maintain than apps in which all components are collocated. Distributed apps can also exhibit disappointing performance, unless designed carefully. However, distributed apps can be more robust and scalable in some cases and a distributed architecture may be the only way to meet some business requirements. Thus deciding whether to use a distributed architecture is an important decision that should be made early in the project lifecycle. It's best to avoid a distributed architecture unless it delivers real advantages.

• The implications for J2EE architecture of the enhancements in the EJB 2.0 specification and the emergence of web services. EJB 2.0 allows us to access EJBs running in the same JVM using call-by-reference, through local interfaces. Thus EJB 2.0 allows us to use EJB without forcing us to adopt a distributed architecture. Web services protocols enable us to support remote clients without using EJB, as RMI-based remoting protocols are no longer the only choice for J2EE apps. Which of these approaches to remoting is preferable depends on the needs of any remote clients the app must support.
• Deciding when to use EJB. EJB is a complex, powerful technology that solves some problems very well, but is inappropriate in many apps. In particular, we should not let desire to use EJB make an app distributed when it is not otherwise necessary.
• Some of the major issues in data access in J2EE apps, notably:

  • Database portability. While J2EE can deliver portability between target databases, this does not always produce business value. Thus database portability may not justify any sacrifices in terms of performance or productivity.

  • Major data access strategies. We've discussed the choice between O/R mapping strategies such as entity beans and JDO, and SQL-oriented, JDBC-based persistence. Choosing the correct data access strategy for an app can have a huge impact on performance and ease of implementation.
  • The importance of concealing the details of data access from business objects via an abstraction layer. If this abstraction layer will consist of ordinary Java interfaces, we are free to use any data access strategy and able to leverage proprietary capabilities of any target database without compromising the portability of our overall design.
• The importance of a tiered architecture, in which each architectural tier depends only on the tier immediately beneath it. This ensures clean separation of concerns and ensures that changes to one tier do not cascade into other tiers.
• Four J2EE architectures, their strengths and disadvantages:

  • Web app with business component interfaces
    This is a simple, performant architecture that meets the requirements of many projects. Although it does not use EJB, it still delivers a clean separation between business objects and web-tier components. A layer of business component interfaces exposes all the app's business logic to web-tier components.

  • Web app accessing local EJBs
    This is a slightly more complex architecture that allows us to use EJB container services to provide thread and transaction management without making the app distributed or suffering the performance overhead of remote method invocation.
  • Distributed app with remote EJBs
    This is a significantly more complex architecture that is ideal for meeting the needs of remote J2EE-technology clients. This architecture is more scalable and robust than the other architectures in some cases. However, it is harder to implement, maintain, and test than the simpler architectures we've discussed, and usually delivers inferior performance, compared to a non-distributed architecture meeting the same requirements.
  • Web app exposing web services interface
    This architecture enables us to support non J2EE-technology clients by adding a web services layer to an app that is not distributed internally. This architecture is normally a variant of the first or second architectures discussed above.
• Web-tier design issues, and the importance of using the MVC architectural pattern. Within the web tier, separation between presentation and logic is vital to the delivery of maintainable web apps that can respond to changing presentational requirements. It's also vital that the web tier should be a thin layer on top of a J2EE app's business interfaces and that as little of an app as possible should depend on the Servlet API.

Previous    Next