摘自 《J2EE Best Practices 》

#1 Attack risk as early as possible. Using the ‘T’ approach defined in the
Overview chapter, you can combine the benefits of prototypes and proofs-of-
concept. In any case, you should attack risk as early as your development
process will allow.


#2 Design for change with DDM. Relational mapping tools can decouple your
application code from your database model, insulating each from change.

#3 Use a Common Modeling Language. UML allows for designers and
developers to speak the same language and understand one another. A
secondary benefit in code/model synchronization which increases developer
productivity.

#4 Recycle your resources. You can use object pools and caches to use
important data or resources more than once before you throw it away, often
dramatically improving performance.

#5 Use proven design patterns. The J2EE pattern catalog makes it easy to
learn about critical design patterns and there are a number of books and sites
dedicated to understanding and using Patterns.

#6 Automate the build process. An automated build should be simple,
include testing, and notify key stakeholders, such as developers, of the build
status.

#7 Integrate often. Continuous integration, a cornerstone of agile
methodologies, does not cost time: it saves time.

#8 Optimize communication costs. By batching, caching and using the other
techniques in this section, you can dramatically reduce communication costs.

#9 Build test cases first. This agile best practice is fast becoming a staple
among knowledgeable programmers across the industry.

#10 Create a testing framework. Tools like JUnit make it easy to create a
framework of both coarse and fine test cases.

#11 Automate testing. Test case automation is the key to integrating testing
into short development cycles. Automation should fully integrate test cases into
the build.

#12 Use J2EE standard package specification. For the first time, Java
applications have a specification that defines exactly what elements should be
deployed, how they should be packaged, and where it should go. You should
stay well within the bounds of this specification as you deploy your application.

#13 Use tools to help in deployment. You can deploy smaller projects and
development systems with IDE tools, but larger, production deployments
demand a scripted approach, like Ant.

#14 Back up production data and environment. Before deploying any
changes, it’s critical to back up the production environment.

#15 Build a performance plan. For modern Internet applications, the
complexity demands a full performance plan. In it, you should set criteria for
completion, and have all stakeholders sign off.

#16 Manage and plug memory leaks. Java can have memory leaks too, but
good tools can simplify identifying and fixing them.

#17 Focus on priorities. Good developers frequently spend too much time
optimizing code fragments that are not on the critical path. If you focus on top
priorities first, you’ve got a much greater chance of success.

#18 Do not restrict deployment options at design time. By making
intelligent design decisions about how you cache, manage session state, and
handle local and remote interfaces, you can maintain flexibility to deploy
clustered or standalone, based on changing business needs.

#19 Create a Responsive Environment. Make a development environment
that maximizes developer’s productivity and independence.