Goals of an Enterprise Architecture (J2EE)

Awell-designed Enterprise Architecture should meet the following goals.

Be robust

Enterprise software is important to anorganization. Its users expect it to be reliable and bug-free. Hence we mustunderstand and take advantage of those parts of J2EE that can help us buildrobust solutions and must ensure that we write quality code.

Be performing and scalable

Enterprise applications must meet theperformance expectations of their users. They must also exhibit sufficientscalability - the potential for an application to support increased load, givenappropriate hardware. Scalability is a particularly important consideration forInternet applications, for which it is difficult to predict user numbers andbehavior. Understanding the J2EE infrastructure is essential for meeting boththese goals. Scalability will typically require deploying multiple serverinstances in a cluster. Clustering is a complex problem requiring sophisticatedapplication server functionality. We must ensure that our applications aredesigned so that operation in a cluster is efficient.

Take advantage of OO designprinciples

OO designprinciples offer proven benefits for complex systems. Good OO design practiceis promoted by the use of proven design patterns - recurring solutions tocommon problems. It's vital that we use J2EE to implement OO designs, ratherthan let our use of J2EE dictate object design. Today there's a whole"J2EE patterns" industry. While many "J2EE patterns" arevaluable, classic (non-technology-specific) design patterns are more so, andstill highly relevant to J2EE.

Avoid unnecessary complexity

Practitionersof Extreme Programming (XP) advocate doing "the simplest thing that couldpossibly work". We should be wary of excessive complexity that mayindicate that application architecture isn't working. Due to the range ofcomponents on offer, it's tempting to over-engineer J2EE solutions, acceptinggreater complexity for capabilities irrelevant to the business requirements.Complexity adds to costs throughout the software lifecycle and thus can be aserious problem. On the other hand, thorough analysis must ensure that we don'thave a naïve and simplistic view of requirements.

Be maintainable and extensible

Maintenanceis by far the most expensive phase of the software lifecycle. It's particularlyimportant to consider maintainability when designing J2EE solutions, becauseadopting J2EE is a strategic choice. J2EE applications are likely to be a keypart of an organization's software mix for years, and must be able toaccommodate new business needs.

Maintainability and extensibility depend largely on clean design. We need toensure that each component of the application has a clear responsibility, andthat maintenance is not hindered by tightly-coupled components.

Be delivered on time

Productivityis a vital consideration, which is too often neglected when approaching J2EE.

Be easy to test

Testingis an essential activity throughout the software lifecycle. We should considerthe implications of design decisions for ease of testing.

Promote reuse

Enterprise software must fit into anorganization's long term strategy. Thus it's important to foster reuse, so thatcode duplication is minimized (within and across projects) and investmentleveraged to the full. Code reuse usually results from good OO design practice,while we should also consistently use valuable infrastructure provided by theapplication server where it simplifies application code.

Support for multiple client types

There'san implicit assumption that J2EE applications always need to support multipleJ2EE-technology client types, such as web applications, standalone Java GUIsusing Swing or other windowing systems or Java applets. However, such supportis often unnecessary, as "thin" web interfaces are being more andmore widely used, even for applications intended for use within an organization(ease of deployment is one of the major reasons for this).

Portability