ONJava.com -- The Independent Source for Enterprise Java
oreilly.comSafari Books Online.Conferences.


AddThis Social Bookmark Button

Topic: Java EE (Enterprise)

Java 2 Enterprise Edition (Java EE) is the server-side, enterprise Java application development platform and framework, which includes EJB, JTA/JTS, JMS, JMX, JCA and more.

O'Reilly Network articles about this topic:

Designing Messaging Applications with Temporary Queues (ONJava.com)
Most JMS destinations are created administratively and treated as static resources, but you can dynamically create your own topics and queues at runtime. In this article, Thribhuvan Thakur shows us how to create temporary JMS topics and queues, and discusses architectural reasons why we might want to do so.

Review/Preview: 2006 and 2007 in Java (ONJava.com)
2006 will be remembered as the year that Sun open-sourced Java under the GPL, that EJB 3.0 finally shipped, and that Google surprised everyone with its Google Web Toolkit. But how will history record the results of these events? For the 2006 year-ender, ONJava editor Chris Adamson looks at the year's events through the lens of how they may play out in 2007.

Scaling Enterprise Java on 64-bit Multi-Core X86-Based Servers (ONJava.com)
Today's enterprise server--indeed, the environment--isn't what it was when Java was born. Slow networked machines have been replaced by fast, 64-bit multi-core servers that can house all your tiers in one box or even virtualize servers within the server. This has a significant effect on the design and deployment of your Java enterprise application, and Michael Yuan and Dave Jaffe show you how to get the most out of your hardware.

Don't Let Hibernate Steal Your Identity (ONJava.com)
Hibernate has one set of ideas about how to make something unique, such as using a database sequence number as an ID. But this clashes with Java's need for implementations of equals() and hashCode() that determine identity for objects, even those that haven't yet made a trip to the database and thus can't have a sequence number. James Brundege has an option that should satisfy both Hibernate and Java.

How to Publish Multiple Websites Using a Single Tomcat Web Application (ONJava.com)
While the idea of mapping several names onto one Apache instance with VirtualHost directives is well known, what do you do when you're serving web apps with Tomcat? Satya Komatineni has both the code and the configs that you'll need to make this work.

What Is Geronimo? (ONJava.com)
Geronimo is Apache's open source, Java EE-compatible application server, based on a flexible system of interchangeable components. This makes it ideal for a wide range of enterprise deployments. In this article, Kunal Jaggi shows you how to get started with Geronimo.

Standardizing Java Persistence with the EJB3 Java Persistence API (ONJava.com)
Dissatisfaction with entity beans as an "official" means of persisting Java objects to databases has prompted a number of "unofficial" approaches, such as the very popular Hibernate. Now EJB3 seems to have learned its lesson: its new Java Persistence API allows you to persist plain old Java objects (POJOs) with a minimum of fuss and just a few annotations. Debu Panda looks at how to put this new standard to work.

Configuration Management in Java EE Applications Using Subversion (ONJava.com)
Does your enterprise Java application need to store not only complex objects or documents but a history of changes to them? Many developers try to solve this problem with database wizardry, but it's probably a better option to hand the job over to a configuration management system that is built for the task. In this article, Swaminathan Radhakrishnan shows how you can implement requirements for change tracking by using a Subversion repository from your Java application, by way of the JavaSVN library.


JBoss Seam (ONJava.com)
Many frameworks are perfectly sensible and well-designed on their own, but don't work particularly well when you try to combine them. Combining, for example, JSF and EJB 3.0 requires a lot of glue code, and adding another framework like JBoss BPM confuses things further. JBoss Seam is designed to provide common context for frameworks to share objects. Project leader Thomas Heute introduces Seam and what you can do with it.

Using Spring with JDO and Hibernate (ONJava.com)
Everyone knows about Hibernate, but what about Java Data Objects? Both of these object-relational persistence frameworks are well supported by Spring, and in this excerpt from Spring: A Developer's Notebook, Bruce Tate and Justin Gehtland show you the advantages of each and how to integrate them with Spring.

J2EE Without the Application Server (ONJava.com)
J2EE apps sound big because they usually are big, running on big enterprise-class application servers--servers that often provide a lot of functionality that you don't really want or need. In this article, Guy Pardon advocates a mix-and-match approach to combining Spring with best-of-breed persistence and transaction frameworks to build enterprise applications without a traditional J2EE app server.

Twelve Best Practices For Spring XML Configurations (ONJava.com)
Spring is powerful and popular, but in practice, the configuration files it needs for beans, dependencies, and services can quickly become confusing and hard to maintain. Jason Zhicheng Li offers some real-world advice on how to keep control of your configs.

Spring: Integrating iBATIS (ONJava.com)
iBATIS is one of the object-relational (OR) frameworks embraced by the Spring framework, and it's an ideal choice for those seeking a middle ground between full-blown OR and hand-written JDBC. In this excerpt from Spring: A Developer's Notebook, Bruce Tate and Justin Gehtland show how to integrate iBATIS with Spring.

An Exception Handling Framework for J2EE Applications (ONJava.com)
One common hassle in J2EE development is exception handling: many apps devolve into a mess of inconsistent and unreliable handling of errors. In this article, ShriKant Vashishtha introduces a strategy for predictably collecting your exception handling in one place.

Using Dependency Injection in Java EE 5.0 (ONJava.com)
Dependency injection, also known as inversion of control, is a programming technique being adopted by many programmers and frameworks, including the popular Spring framework. But using it in J2EE 1.4 requires a burdensome deployment-descriptor-based approach. Debu Panda shows how Java EE 5.0 provides relief in the form of annotations-based dependency injection.

Using Global/Distributed Transactions in Java/JDBC with Oracle Real Application Clusters (ONJava.com)
Maintaining transaction integrity, and rolling back failed steps, becomes more difficult on a cluster. One option is to move some of the load balancing decisions to your code, and accounting for which cluster nodes you're using. Sachin Shetty shows how this works in the context of an Oracle Real Application Cluster.

Hibernate for Java SE (ONJava.com)
For many, Hibernate goes hand in hand with Java EE as part of their enterprise development strategy. But what if you need access to your data access objects outside of the EE container? Jason Lee offers some strategy for getting and using a Hibernate session from Java SE code.

JBoss Cache as a POJO Cache (ONJava.com)
Typical in-memory cache systems can trip you up in ways you don't expect, from mangled object relationships to overly expensive serialization operations. A POJO cache offers a simpler, lower-maintenance alternative. Ben Wang uses JBoss Cache to show how POJO caches work.

Test-Driven Development Using StrutsTestCase (ONJava.com)
JUnit and DbUnit can help test your web application, but they're not ideal for testing Struts Actions. Fortunately, the StrutsTestCase framework exists to help you close this gap in your testing coverage. John Ferguson Smart looks at how it works and what it can do for you.

Constructing Web Services with the Globus Toolkit Version 4 (ONJava.com)
Grid computing allows you to combine processing, storage, databases, and other resources across a network, hiding the details from callers. As Birali Hakizumwami shows, the Globus Toolkit makes this easier by exposing the grid as a normal web service.

Eclipse Web Tools (ONJava.com)
The Eclipse Web Tools Platform (WTP) project aims to make web application development easier by attacking the problem from the tool side, providing Eclipse-based tools for creating and manipulating EJBs (optionally exposed as web services), data stores, and JSPs. Committers Jeffrey Liu and Lawrence Mandel introduce this new toolset.

iBatis DAO (ONJava.com)
The J2EE Data Access Object pattern calls for encapsulating access to a data source behind an API, giving you the freedom to change implementations or use different persistence strategies for different operations. As Sunil Patil shows, the Apache iBatis DAO framework helps you develop such a strategy.

POJO Application Frameworks: Spring Vs. EJB 3.0 (ONJava.com)
Spring and EJB 3.0 are both reactions, in their own ways, to the complexity of EJB 2.1 and the complaints piled upon it. Both support developing with Plain Old Java Objects (POJOs) and give the framework responsibility for handling transactions, security, persistence, etc. But the two use substantially different approaches. In this article, Michael Yuan puts the two frameworks up against one another to see how they stack up.

An Ant Modular Build Environment for Enterprise Applications (ONJava.com)
Most Java developers already use Ant for their builds, but are you getting everything you could out of this tool? With a complex enterprise application, in which classes may be used in several tiers, it's important to control where the code lives and how it gets built, so you can build .jars with just the code needed for each tier. Les Hazlewood shows how this approach leads to faster builds and downloads, and even catches errant dependencies.

Constructing Services with J2EE (ONJava.com)
Web services are a popular means of deploying service-oriented applications, and the standards in J2EE 1.4 make it easier to develop services that are portable and interoperable. Debu Panda shows you how, and takes a look at how things will get easier in J2EE 5.0.

WS-Security in the Enterprise, Part 2: The Framework (ONJava.com)
Denis Pilupchuk continues his series on developing a WS-Security toolkit by developing a general framework to match the needs identified in part one and by starting to map WSSE features to Java objects.

Migrating a WebLogic EJB Application to JBoss (ONJava.com)
WebLogic and JBoss both offer powerful and popular EJB servers, but they're not completely compatible: an application deployed on one won't immediately deploy on the other. In this article, Deepak Vohra shows how to alter the deployment descriptors to make the migration.

Welcome to a New World: JBoss World 2005 (ONJava.com)
JBoss World, held in Atlanta on March 1-2, kicked off with announcements of new directions for the company and a roundtable of customers discussing the popular application server. This article offers a recap of the opening presentations.

Introducing JBoss Remoting (ONJava.com)
With JBoss World 2005 a week away, JBoss has introduced a new remoting framework. Before you say "another one?" John Mazzitelli hopes you'll take a look at JBoss Remoting, which rids you of RMI-style skeletons and stubs, and offers flexibility and extensibility on both the client and server sides.

Designing a Fully Scalable Application (ONJava.com)
It's difficult, maybe impossible, to know up front how much or in what ways your application will need to scale. But by decoupling parts of the application, you can at least ensure that the scaling process can be kept modular. Amir Shevat shows how some sharable pieces of the MantaRay messaging system can allow your app to grow beyond one box.

An Introduction to Service-Oriented Architecture from a Java Developer Perspective (ONJava.com)
Service-oriented architectures offer a new way to think about building software applications, with coarse-grained pieces of functionality split out into "services" that communicate with standardized, widely understood interfaces like XML and SOAP. In this article, Debu Panda shows you how to design and connect SOAs.

Software Infrastructure Bottlenecks in J2EE (ONJava.com)
Sometimes you can throw more CPUs and memory in a box and your web application doesn't get any faster. This can happen when the bottleneck is not in the hardware but the software; specifically, your application server. Deepak Goel looks at what this looks like in terms of performance characteristics and what you can do about it.

Distributed Enterprise Messaging with MantaRay (ONJava.com)
Java Messaging Service (JMS) is a much-used system for distributed enterprise applications, but many implementations use a "broker" approach that creates bottlenecks. MantaRay implements the JMS API through a peer-to-peer approach that, as Amir Shevat reports, provides some significant advantages.

Session Replication in Tomcat 5 Clusters, Part 1 (ONJava.com)
A web application running on a single server is completely lost if the server goes down. But with a cluster, user sessions can be replicated across servers, so that the system stays up even if one server fails. Srini Penchikala presents Tomcat 5's handling of this feature.

Memory Contention in J2EE Applications for Multiprocessor Platforms (ONJava.com)
You can scale an enterprise app on a single box by adding CPUs, right? Yes--to a point. As Deepak Goel and Ramchandar Krishnamurthy have discovered and documented, the battle for access to memory from threads on the different CPUs creates a memory contention that, in time, becomes a bottleneck. In this article, they document the phenomenon and suggest some ways to improve the situation.

Extending Struts (ONJava.com)
With so many web application frameworks available, there's little point reinventing the wheel, especially when Struts offers remarkable extensibility. Sunil Patil introduces the three basic means of extending Struts to achieve custom web application behavior.

How to Use JMS with PHP (ONJava.com)
Java Messaging Service (JMS) is a great enterprise messaging architecture, but what if you have have a web application written in a non-Java language that wants to participate in JMS? Amir Shevat shows how PHP can be made to work with JMS.

Using Timers in J2EE Applications (ONJava.com)
J2SE gained support for scheduled tasks in 1.3, and J2EE 1.4 provides an enterprise equivalent, with transactional, scheduled callbacks provided by application containers. Debu Panda introduces J2EE timers by way of an EJB that gets scheduled services.

XML Messaging Using JBoss (ONJava.com)
Simple communication in an enterprise system is possible through various schemes, but not all of them answer the question of coordination. Benoit Aumars presents a hypothetical case study that shows how generating and sharing information in XML is made easier with Java Messaging Service (JMS) and Java Management Extensions (JMX).

Monitoring Session Replication in J2EE Clusters (ONJava.com)
Session replication is critical for running enterprise-class application servers, but tracking down problems in J2EE clusters can be difficult. Fermin Castro introduces techniques for monitoring and measuring how well your cluster is replicating sessions.

Designing J2EE Applications for Real-Life Clustered Environments (ONJava.com)
What works on a single server can crash and burn in a cluster. In this article, the authors draw from their practical experience to list and discuss some critical considerations when building J2EE applications so that they can be deployed in a clustered environment without requiring any code changes.

Using a JMS Provider with MDBs via the J2EE Connector Architecture (ONJava.com)
Message-Driven Beans (MDBs) get a big boost in J2EE 1.4 via integration with the J2EE Connector Architecture (JCA), which opens up interesting possibilities to use messaging to and from legacy systems. Debu Panda shows how this can be accomplished.

Performance Analysis of J2EE Applications Using AOP Techniques (ONJava.com)
It's tricky to profile a J2EE application to find performance bottlenecks; it's even trickier to do this with a production system, without introducing instability or new slowdowns. Aspect-Oriented Programming (AOP) offers a means of injecting new code, such as performance metrics, into existing code, without re-compiling. Ramchandar Krishnamurthy shows how this can be done.

Clustering and Load Balancing in Tomcat 5, Part 2 (ONJava.com)
The latest version of Tomcat provides clustering and load-balancing capabilities for scalable, high-available systems. In part two of this series, Srini Penchikala sets up a Tomcat cluster and assesses its performance.

Bug Prevention with Code Generation: A J2EE Case Study (ONJava.com)
If you had to drill 12,000 holes, would you prefer a manual drill, or its automated equivalent? Francesco Aliverti-Piuri describes using code generation for discovering bugs in a J2EE example.

Clustering and Load Balancing in Tomcat 5, Part 1 (ONJava.com)
The latest version of Tomcat provides clustering and load balancing capabilities for scalable, highly available systems. In part one of this series, Srini Penchikala looks at architectural factors to consider in such a system and how Tomcat implements them.

J2EE Connector Architecture (ONJava.com)
This article looks at some of the challenges of legacy system integration, then introduces the J2EE Connector Architecture (J2EE CA) and explains how it can significantly reduce the problems of integrating your legacy system. It also offers a comprehensive example of how to use the current version of J2EE CA to access a common transaction-processing platform from a Java 2 Enterprise Edition (J2EE) platform application.

MVC Heresy with SQLTags (ONJava.com)
When the "right" way is more than you need, is it wrong to do what works? Steve A. Olson introduces the SQLTags toolkit, which takes database access out of its traditional tier and puts it directly into JSP tags.

Configuring JBoss 4.0 JDBC Connectivity (ONJava.com)
JBoss uses the HypersonicDB by default, but with a few configuration changes, it can use any JDBC-equipped database. Deepak Vohra shows how to use Oracle, Sybase, MySQL and other databases with JBoss.

Security in Struts: User Delegation Made Possible (ONJava.com)
Struts may not have an all-encompassing security scheme, but what it does offer is extensibility. Werner Raemakers looks at how to extend Struts' security by allowing one group of users to delegate permissions to others.

Object Caching in a Web Portal Application Using JCS (ONJava.com)
One way to improve server-side performance is to cache data instead of generating it over and over again. Srini Penchikala takes a look at how the Java Caching System makes this possible.

Page Navigation in JavaServer Faces (ONJava.com)
Any web application with more than one page needs some sort of navigation. Where does the user go when he logs in? Where does he go if his password is incorrect? JSF provides an easy-to-update page navigation model in its Application Configuration file. Budi Kurniawan explains how it works.

Web and Enterprise Architecture Design Patterns for J2EE, Part 2 (ONJava.com)
From their experience as Web-era application designers, Ganesh Prasad, Rajat Taneja, and Vikrant Todankar saw a need for a set of named ways of doing things at the application or subsystem level, in the same manner that the original design patterns fulfilled a need for standardization of lower-level functionality. In this second part of a two-part series, the authors discuss their Web and Enterprise Architecture Design Patterns in the Security, Navigation, and Data Volume Control categories.

Web and Enterprise Architecture Design Patterns for J2EE, Part 1 (ONJava.com)
From their experience as web-era application designers, Ganesh Prasad, Rajat Taneja, and Vikrant Todankar saw a need for a set of named ways of doing things at the application or subsystem level, in the same manner that the original design patterns fulfilled a need for standardization of lower-level functionality. In part one of a two-part series, the authors discuss their Web and Enterprise Architecture Design Patterns in the Partitioning and Scope categories.

Adding Transactions to Servlets with JOTM (ONJava.com)
Some operations are too important to happen in stages. If you're dealing with money, for example, you need robust code and assurance that everything will go according to plan. That's where transactions come in. Jeff Mesnil explains what transactions are and how you can use JOTM to provide them.

J2EE Application Deployment Considerations (ONJava.com)
The J2EE specification describes many things, but curiously leaves application deployment up to vendors. This means that you, the developer, have to consider architecture, maintainability, scalability, and other concerns. Allen Chan explores the issues to consider when packaging a J2EE app for deployment.

JBoss Optimizations 101 (ONJava.com)
"First make it work, then make it fast." Your J2EE application works, but it's slower than you'd like under peak load. Before you rush out for new hardware, check out your configuration. Sacha Labourey and Juha Lindfors demonstrate a few simple techniques to improve JBoss performance without spending money.

Aspect-Oriented Programming and JBoss (ONJava.com)
Is aspect-oriented programming (AOP) the OOP of the oughts? It promises to apply common behavior across different object models. Bill Burke and Adrian Brock explore AOP by example in a JBoss application.

Understanding Classloaders: log4j in a J2EE Environment (ONJava.com)
EJBs are a little different from the normal J2EE world. Part of that difference lies in the app server's classloaders. While demonstrating how to use log4j with EJB applications, Vikram Goyal explains how classloaders work and how to use them.

Space-Based Programming (ONJava.com)
Distributed applications promise better scalability and reliability, but the standard models of building them on Remote Procedure Calls are often difficult and slow. Sun and IBM are taking steps to adopt a different approach: space-based programming. Bernhard Angerer explores this idea and what it could mean for J2EE.

Flash Remoting for J2EE Developers (ONJava.com)
Rich Internet Applications are slowly becoming more popular, with web services gluing desktop clients to more traditional back ends. Macromedia's Flash Remoting MX for J2EE is one way to connect a Flash client to a J2EE back end. Alon Salant reveals the tricky details of using Flash Remoting for J2EE and outlines a simple architecture for creating the interfaces that make this possible.

Building Dependency Webs in J2EE (ONJava.com)
J2EE applications are complex. Good programming means managing complexity, especially if you're making changes to a stable system. In this article, Alex Iskold and Daniel Kogan introduce Dependency Webs, a technique for visualizing and analyzing source code dependencies.

Object-Relational Mapping with Apache Jakarta OJB (ONJava.com)
Object persistence is important in enterprise applications, but mapping class hierarchies to relational databases can be tricky. Enter OJB, an open source persistence framework. Charles Chan demonstrates nearly-painless techniques for saving your objects.

Local Invocation for CORBA (ONJava.com)
CORBA 2.2 or less does not enable applications to transfer objects from the server to the client by copying. This article explains how to simulate the pass-by-value strategy in CORBA so that a client virtual machine can locally invoke methods implemented on a remote CORBA server.

Resin: The Instant Application Server (ONJava.com)
Could you use a Java app server that's easy to set up, offers rapid development, and supports EJB/CMP and other standard Java features? Meet Resin. This article gets you installed and running a database-querying app in short order.

JSR 109: Web Services Inside of J2EE Apps (ONJava.com)
Over the past few years, J2EE has emerged as the dominant standard for serving up information on the Web. JSR 109 is one of the latest specifications to expand J2EE support into new areas, effectively defining how a J2EE application server could be expanded to provide native support for deploying, managing, and accessing Web services in a standard fashion.

Clustering with JBoss 3.0 (ONJava.com)
For scalability and reliability, many Java developers look to their app server's clustering features. This article takes a look at clustering in the open source JBoss app server.

Enhancing Web Services Infrastructures with JMS (ONJava.com)
JMS is a leading candidate for providing robust enterprise messaging to Web services. This article demonstrates a loosely coupled Web service with JMS.

J2EE Form-based Authentication (ONJava.com)
J2EE Web containers support form-based authentication mechanisms, but how do you integrate application-based security with that in other realms? This article explains.

Bringing the J2EE Cathedral to the Bazaar (ONJava.com)
While Sun is busy building a beautiful cathedral around J2EE, average programmers will abandon Java for .NET in droves unless J2EE development is vastly simplified. The author offers a tool that leverages J2EE in an accessible way.

J2EE Design Patterns: CMP-to-BMP Pattern (ONJava.com)
In EJB 2.0, Sun delivered a revamped container-based persistence model. This article explains how to write a CMP in EJB 2.0 and how to go from CMP to BMP when needed.

Six Common Enterprise Programming Mistakes (ONJava.com)
Most programmers use the good things from programming books and then leave their mistakes in the very same programs. Brett McLaughlin looks at six common errors in enterprise programming.

Introducing A New Vendor-Neutral J2EE Management API (ONJava.com)
JBoss contributor Andreas Shaefer introduces you to JSR-77, a new vendor-neutral approach to J2EE management.

JBoss: Sun Needs Us (ONJava.com)
In this interview, JBoss leaders Marc Fleury and Nathalie Mason argue that Sun should certify this open source J2EE project for the health of the platform: "We are seeing the beginning of market-share loss to .NET. We urge Sun to certify us and give us the backing and credibility to be succesful in competing against Microsoft as the entry-level J2EE offering."

Java API Map (ONJava.com)
Is the world of Java getting a little unweildy for you? Use our Java API map and directory to track all significant Java platforms and respective Java APIs. Includes the JAX Pack and MIDlets.

Business Logic, Part 3 (ONJava.com)
In Part 3 of our excerpt from Building Java Enterprise Applications (Vol. 1, Architecture), Brett McLaughlin addresses issues of statelessness and statefulness.

Business Logic, Part 2 (ONJava.com)
In Part 2 of our excerpt from Chapter 8 of Building Java Enterprise Applications, Vol I: Architecture, Brett McLaughlin builds a UserManager component, and illustrates why managers are a good thing.

Business Logic, Part 1 (ONJava.com)
In this excerpt from Chapter 8 of Building Java Enterprise Applications, Vol I: Architecture, Brett McLaughlin discusses the fašade pattern, in which you use session beans to access entity beans. This access method is used instead of allowing direct access to entity beans, and is key to a sound strategy in building enterprise applications.

Will You See Open Source J2EE Implementations? Not Likely. (ONJava.com)
O'Reilly & Associates' senior Java editor Mike Loukides revisits the latest on Sun's positioning regarding open source J2EE and the hurdles open source projects like JBoss experience.

Atomic File Transactions, Part 2 (ONJava.com)
In Part 2 of this series, Jonathan Amsterdam provides more detail on his algorithm for atomic file transactions, walks through the design of his system, and provides a justification for the correctness of the algorithm.

Oracle Containers for J2EE (OC4J) (ONJava.com)
OC4J is a J2EE-1.2-certified application server, which provides performance, scalability and features like HTTP clustering and load balancing.

J2EE Design Patterns (ONJava.com)
Design patterns are a way of bringing clarity to a system architecture; they allow for the possibility of better systems being built. This article covers how to identify and use design patterns in J2EE apps, specifically for the presentation layer.

JMS and CORBA Notification Interworking (ONJava.com)
The CORBA Notification Service is being expanded to support JMS. This article explains how to internetwork between JMS and CORBA Notification products.

Cat Fight in a Pet Store: J2EE vs. .NET (ONJava.com)
What's nastier than a cat fight? It can only be a Sun-Microsoft showdown. This time the claws are bared over the Java Pet Store app, which Microsoft recently remade with .NET, claiming huge performance gains. Dean Wampler takes a hard look at these claims and finds their bark is worse than their bite.

Atomic File Transactions, Part 1 (ONJava.com)
Databases provide atomicity for data stored within them, but filesystems are not atomic with respect to their files. This article series explains how to achieve atomicity for standard filesystem actions in transactions.

Extending J2EE for Mobile Application Development (ONJava.com)
Learn to extend J2EE for use in developing mobile, wireless Java applications through the use of a new server-side component model.

Learning EJB QL (ONJava.com)
Learn how the addition of EJB QL to EJB 2 justifies the distributed component architecture as the standard way of defining queries, which allows database applications to be more portable.

Clustering with JBoss/Jetty (ONJava.com)
A project manager recounts his experiences on clustering with JBoss/Jetty, as well as having the source code to this open source J2EE container and server.

EJB 2 and J2EE Packaging, Part II (ONJava.com)
Tyler Jewell continues his coverage of J2EE packaging issues by focusing on the approaches that vendors can use for implementing EAR classloaders and their ambiguities.

Using JBoss Web Application Server (ONJava.com)
If you don't need clustering, use this highly-scalable open source Web application server.

EJB 2 and J2EE Packaging (ONJava.com)
Tyler Jewell is back to discuss some of the nuances associated with J2EE packaging and provides some hints to make you more productive.

Developing a Simple JMS Example (ONJava.com)
This excerpt from Chapter 2 of Java Message Service provides a gentle introduction to JMS using the publish-and-subscribe messaging model.

J2EE Transaction Frameworks, Part 3 (ONJava.com)
This series concludes with descriptions of declarative transaction management of session, entity and message driven beans; global transaction guidelines; and local transaction management.

J2EE Transaction Frameworks: Distributed Transaction Primer (ONJava.com)
In Part II of this series, JTA/XA and RM/Local Transactions in a J2EE configuration are described as well as issues of isolation and serialization of resource managers.

EJB 2 Message-Driven Beans (ONJava.com)
This article will talk about the new EJB 2.0 Message Driven Beans. I will walk through an example of using this new bean, along with the corresponding JMS infrastructure that surrounds it.

Developing A White Pages Service with LDAP and JNDI (ONJava.com)
You will learn what you can do with LDAP and how Java answers the need to handle LDAP with the JNDI API in building a white pages service.

Enterprise Servlets and J2EE (ONJava.com)
Jason Hunter demonstrates how the robust Servlets API and its containers are used and integrated with other J2EE API on a growing number of enterprise-based Web sites in this excerpt from O'Reilly's Java Servlet Programming, 2nd Edition.

A Java Message Service Primer (ONJava.com)
Tonia Flores gives us a primer on the latest JMS API.

J2EE Blueprints Unrolled (ONJava.com)
Sun Microsystem's J2EE Blueprints Architect Vijay Ramachandran defines J2EE Blueprints program, and shows its benefits.

J2EE Transaction Frameworks: Building the Framework (ONJava.com)
Dibyendu Baksi describes the emergence of distributed component-based systems, including the role of transactions within J2EE.

Designing JSP Custom Tag Libraries (ONJava.com)
In this article, you'll learn what a JSP custom tag library is, why you'd want to use it, and how to build and use a complete tag library.

Sorting Out the EJB 2.0 Rumors (ONJava.com)
Tyler Jewell examines the latest rumors about the changing EJB 2.0 specification.

Servlet 2.3 API Features Exposed (ONJava.com)
Stephanie Fesler unveils the latest features and tricks of the new Java Servlet 2.3 API.

Pseudo Sessions for JSP, Servlets and HTTP (ONJava.com)
Kurniawan discusses pseudo sessions and using them to overcome drawbacks in JSP and Servlet applications.

What's Wrong with the EJB 2 Specification? (ONJava.com)
Tyler Jewell points out errors in the latest EJB 2.0 API specification.

JSP vs. XSP (ONJava.com)
Sue Spielman looks at JSP and XSP to help you decide which is right for your development needs.

JMS and XML (ONJava.com)
TA Flores describes JMS as an XML data transport model for B2B content exchange.

Enabling Component Architectures with JMX (ONJava.com)
An explanation of the role of JMX components in J2EE platforms and how JMX boosted productivity in an open source project.

Clustering Stateless Session Beans (ONJava.com)
Adding to last month's article, Jewell demonstrates other techniques for load balanced and fault tolerant EJBs.

Advanced Features of JSP Custom Tag Libraries (ONJava.com)
In part two of Sue Spielman's JSP Custom Tag Libraries series, she covers advanced features: JSP container interaction with tags, tags with bodies, nested tags, tag extra info, and cooperating tags.

Macworld Java Update (ONJava.com)
Steve Anglin's Macworld Java conference report includes the good, the bad, and the ugly news for Mac OS X developers.

EJB 2 Clustering with Application Servers (ONJava.com)
Tyler Jewell, BEA Systems Java Trainer, teaches clustering with EJB 2, including a systematic breakdown of the different possibilities that application server vendors may incorporate.

Developing, Applying and Optimizing XSLT with Java Servlets (ONJava.com)
O'Reilly's upcoming Java and XSLT book author, Eric Burke, explains the fundamental patterns and techniques commonly used when XSLT and Java Servlets are combined.

Other documents about this topic:

Below are other references available on the web for this topic. Since other sites may change their links, please if you find any that may need to be updated.

Microsoft .NET vs. J2EE:
Even if you don't write code dedicated to Microsoft platforms, you have probably heard by now about Microsoft .NET, Microsoft's latest volley in their campaign against all things non-Windows. If you've read the media spin from Microsoft, or browsed through the scant technical material available on the MSDN site, or even if you attended the Microsoft Professional Developers' Conference (where the .NET platform was officially "launched"), you're probably still left with at least two big questions: What exactly is the .NET platform? How does the .NET architecture measure up against J2EE? And, if you think more long-term, you might have a third question rattling around your head: What can we learn from the .NET architecture about pushing the envelope of enterprise software development? The .NET framework is at a very early stage in its lifecycle, and deep details are still being eked out by the Microsoft .NET team. But we can, nevertheless, get fairly decent answers to these questions from the information that's already out there. [Source: O'Reilly]

O'Reilly's Top 10 JSP Tips by Hans Bergsten
JavaServer Pages (JSP) is an integral API for Java-based Web application development. A JSP page contains regular markup code plus special JSP elements. When the page is requested, the static markup code and the dynamic content produced by the JSP elements are combined to form the complete response to the request. It's impossible to tell you everything you need to know to use JSP effectively in a short article like this (that's why I wrote JavaServer Pages). Instead, this article focuses on the frequently asked questions that I've heard from people who have just started to play around with JSP. [Source: O'Reilly]

Enterprise Applications in Java
Perhaps the most difficult problem in building enterprise applications today is the blurring of the line between what is wanted and what is needed. All too often, people go overboard with their applications. In geek talk, this is called "buzzmania." Buzzmania is the tendency to buy more, get more, and use more, simply because more "buzzwords" are in a product. This is a large part of the J2EE problem. With the J2EE product descriptions and specifications reading like a meeting of exotic 12-step programs--JSP, XML, JMS, EJB, CMP, BMP, OR, JDBC--it's no wonder managers' eyes light up at sales presentations. [Source: O'Reilly]

Top 8 Architecture Tips for Distributed Computing
1.Use a relational database. 2.Normalize the relational database. 3.Buy, don't build, a reporting system. 4.HTML is the preferred user interface 5.Flexibility vs. performance 6.Understand technology 7.Hire an experienced architect 8.There's no panacea [Source: O'Reilly]

Enterprising Java Development Tools
Meta Trend: During 2000/01, ongoing consolidation of application server, component framework, and development tool environments will drive evolution to more complete, integrated development and deployment platforms.

Getting Started with EJB, Part 3
In this lesson, Richard Baldwin begins walking you through the detailed steps necessary to deploy a simple Enterprise Bean in the J2EE server. You'll learn about jar files and ear files, the deployment descriptor, J2EE applications, and the three steps required for deployment of an Enterprise Bean in the J2EE server. For Parts 1 and 2, click on previous link below the tutorial. [Source: Earthweb]

Java as a Teaching Language
One measure of the success of a programming language is how readily it is embraced by academia. Java has come a long way since its introduction by Sun Microsystems in 1995, and it is now proving itself in the halls of colleges and universities around the world. Java is well on the way to becoming the predominate instructional programming language. The significance of this cannot be overstated--training our future computer scientists, programmers, and IT (information technology) executives in Java will lead to even more acceptance of the language in society at large, putting Java solidly at the forefront of many IT efforts. [Source: O'Reilly & Associates]

EJB Design Forum
This is a great forum for expressing and solving EJB design issues and problems, including design patterns, clustering and more. [Source: theserverside.com]

EJB Troubleshooting Forum
This is an EJB troubleshooting Forum, which should be useful for solving many of your problems and issues. [Source: theserverside.com]

Servlets and JSP Forum
Great resource for learning, developing and troubleshooting JSP and Servlet issues. [Source: theserverside.com]

Coarse Grained BMP beans with Dependent Value Objects
Coarse Grained BMP beans with Dependent Value Objects is a draft pattern. The pattern describes how to properly implement the equivalent of Dependent Objects in BMP, and provides a fully resuable implementation as an example. The pattern does not describe the motivation for dependent objects, that is a separate pattern and you can learn more about it by reading the EJB 2.0 specs or Sun's ejb-interest archives. [Source: Middleware]

Integrating SOAP and EJB
SOAP is basically an XML marshalling mechanism for RPC calls. It doesn't specify a transport although it is most commonly used with HTTP. It could also be used to encode an RPC call over a simple TCP/IP socket or a JMS message. People have a tendency to use the latest technology for no other reason than 'just because'. This article gives the reasons why SOAP may be appropriate in conjunction with session beans and when it makes little sense. See more in this article by Billy Newport on theserverside.com.

Sybase White Papers/Tech Papers
Sybase White Papers, containing info on projects related to Java, JDBC, SQLJ and development for their Web Application Server. [Source: Sybase]

A few tips on deciding between EJB and COM
Recently, there's been much said about Enterprise JavaBeans (EJB) and Microsoft's COM+ technologies. Some assert that EJB is new, and is therefore not ready for prime-time. Others question the historical scalability of Windows, and are uneasy about using Windows 2000 in their mission-critical deployments. So what's a development lead to do when deciding between these two environments? In this article, Ed Roman, CEO of The Recently, there's been much said about Enterprise JavaBeans (EJB) and Microsoft's COM+ technologies. Some assert that EJB is new, and is therefore not ready for prime-time. Others question the historical scalability of Windows, and are uneasy about using Windows 2000 in their mission-critical deployments. So what's a development lead to do when deciding between these two environments?Middleware Company will raise some questions that you should be asking yourself to help you decide on the technology that's right for your business. This article will not answer all of your questions, but it will get you asking the right ones. [Source: Middleware]

Java 2EE API Documents
Java 2EE 1.3 defines the standard for developing and deploying enterprise applications. With the latest versions of Enterprise JavaBeansTM (EJBTM), JavaServer PagesTM (JSPTM) and Java Servlet API component technologies, it enhances the existing J2EE platform. In addition, J2EE 1.3 adds support for J2EE Connector Architecture, the Java API for XML Parsing (JAXP), and the Java Authentication and Authorization Service (JAAS) API. J2EE 1.3 also increases the level of support from optional to required of the Java Message Service (JMS) API. [Source: Sun]

The Java API for XML Messaging (JAXM), Java API for XML Parsing (JAXP), and Java API for XML Data Binding (JAXB) form the core of XML support in the Java 2EE. These API will likely be open sourced through Apache's Jakarta project. These along with the recently announced JXTA networking application API make up JAX (Java, Apache and XML). Others could soon be announced and available. [Source: Sun]

EJB/JavaBeans Repository
Component Source has all the available JavaBean and Enterprise JavaBean (EJB)components and tools. To find a product choose one of the "Browse by" options listed on the web page or use the Product Search box provided. Please note that the Product Search facility works within the selected filter.

The CORBA Component Model (CCM)is written to address these and other complexities in the CORBA object model. The CCM is part of the CORBA 3.0 specification, which is due to be released this year. The CCM is a server-side component model for building and deploying CORBA applications. It is very similar to Enterprise Java Beans (EJB) because it uses accepted design patterns and facilitates their usage, enabling a large amounts of code to be generated. This also allows system services to be implemented by the container provider rather than the application developer. The benefit and need for these types of containers can be observed through the growth of Application Server software. The CCM extends the CORBA object model by defining features and services in a standard environment that enable application developers to implement, manage, configure and deploy components that integrate with commonly used CORBA Services. These server-side services include transactions, security, persistence, and events. [Source: IBM Developer Works]

J2EE Pattern Language E++
E++, an Alexandrian pattern language, describes the process for creating a J2EE framework. Compared with a loose pattern collection, E++ provides rules for design patterns to work together in solving a set of related problems. Building or migrating to an n-tier J2EE application becomes as easy as following the E++ tree network from root to leaves. Bin Yang, in this first article of two, introduces the pattern language concept and three architectural patterns, saving detailed design patterns for Part 2. [Source: JavaWorld.com]

JMS and Legacy Tutorial
This is Krishna Chigante's JMS and Legacy tutorial session at the 2001 O'Reilly Enterprise Java Conference. [Source: O'Reilly]

JMX Tutorial
This is a JMX tutorial session as presented at the 2001 O'Reilly Enterprise Java Conference by Kreger. [Source: O'Reilly & Associates]

J2EE Component Patterns Tutorial
Liou presents J2EE component design patterns in a tutorial session at the 2001 O'Reilly Enterprise Java Conference. [Source: O'Reilly & Associates]

JMX Tutorial
This is another JMX tutorial sesssion as presented at the 2001 O'Reilly Enterprise Java Conference. [Source: O'Reilly]

J2EE Connectors Tutorial
This tutorial session was presented at the 2001 O'Reilly Enterprise Java Conference. [Source: O'Reilly]

Java OSS
The members of the OSS through JavaTM Initiative are convinced that the fastest and most flexible way to develop OSS solutions is to embrace a multi-tier architecture, based on reusable components and container technology, with client access either by tightly or loosely coupled mechanisms. [Source: Sun]

OSS Trouble Ticket API
JSR-91 OSS Trouble Ticket API The OSS Trouble Ticket API will provide interfaces for creating, querying, updating, and deleting trouble tickets (trouble reports). [Source: Sun]

OSS Quality of Service API
JSR-90 OSS Quality of Service API Provide an API that allows telecom management applications to be developed and integrated with Java-enabled Quality of Service systems. [Source: Sun]

Java OSS Service Activation API
JSR-89 OSS Service Activation API Provide an API that allows telecom management applications to be developed and integrated with Java-enabled Service Activation systems. [Source: Sun]

J2EE 1.3 Tutorial
A beginner's guide to developing enterprise applications on the Java 2 Platform, Enterprise Edition SDK version 1.3 [Source: java.sun.com]

Web Development with JSP
Web applications developed using JavaServer Pages (JSP) may require some interaction with J2EE services. For example, a web-based inventory control system may need to access J2EE's directory services to gain access to a database. Or you may want to use Enterprise JavaBeans (EJB) in your application. This article presents a brief overview of J2EE, then it shows how to: Describe J2EE services in a Web Deployment Descriptor (web.xml) Reference J2EE services Access and use J2EE services from JSPs [Source: java.sun.com]