"Even though we all face similar issues in most of our projects, we still lack defined ways of tackling them. Throughout my years in software development, I have used some solutions to the recurring problems that plague most of my development projects, solutions that have really helped me effectively execute projects. In this article, I share with you three best practices for project execution, some of which could be considered full-fledged patterns:"
"The Java Enterprise Edition 5 release (Java EE 5), billed by Sun as the most significant update in six years, supports a number of important Web services standards and is designed to be easier to use than its predecessor, called J2EE."
"Thanks for sharing article and source code application-wide user session for J2EE...By indoto on December 8, 2008, 1:27 amThanks for sharing article and source code application-wide user session for J2EE.When I downloaded "DemoServiceDelegate" java file is missing in the zip. Please..."
"This book is about implementing enterprise applications using design patterns and lightweight frameworks. To enable you to use them effectively in your application, it provides a decision-making framework that consists of five key questions that must be answered when designing an application or implementing the business logic for an individual use-case. By consciously addressing each of these design issues and understanding the consequences of your decisions, you will vastly improve the quality of your application."
"In much the same way, I spend the first day of a tuning engagement interviewing my clients. During this interview, I look for known problems as well as architectural decisions that may negatively affect the performance of the application. With an understanding of the application architecture and the symptoms of the problem, I greatly increase my chances of resolving the problem. In this chapter, I share some of the common problems that I have encountered in the field and their symptoms. Hopefully, this article can serve as a troubleshooting manual for your Java EE environment."
"Many people incorrectly judge Java/J2EE-based systems on problems associated with maintaining the codebase, the number of bugs or inconsistencies in functionality, or poor performance. Fortunately, these problems have less to do with the Java/J2EE technology itself and more to do with the lack of a process focused on the quality of the system. To ensure success of large-scale Java/J2EE projects developed by a sizeable team, or across multiple teams, a team lead must:"
"This article presents yet another framework for exception handling, which extends the enterprise-wide application session facility presented in "Create an Application-Wide User Session for J2EE" (JavaWorld, March 2005). J2EE applications that use this framework will:"
"Scalability is one of the most important non-functional requirements of a system. But there could be several bottlenecks within a system, which might prevent it from being scalable. In this article, we try to analyze the case in which the software infrastructure becomes a bottleneck, long before any of the hardware resources (such as CPU, memory, disk space, and network speed) are fully consumed. This is a tricky problem whose solution is explored below."
"J2EE-based applications have become very successful in the enterprise market, despite the notorious complexity of both the J2EE platform (the application server) and its proposed programming model (Enterprise JavaBeans, or EJB). Thanks to modern notions like inversion-of-control (IoC) and aspect-oriented programming (AOP) represented in lightweight containers like the Spring framework, the programming model for J2EE can be made a lot simpler and more elegant. Nevertheless, even with these tools, the application server still remains an important source of complexity and cost. This article proposes a further simplification of J2EE, by showing a way to eliminate the overhead of the runtime platform: the application server. In particular, this article shows that many applications no longer need an application server to run. As a result, J2EE applications become:"
"The most critical asset of any enterprise application is the data that it stores. Today's enterprise applications are often required to not just store data, but also keep track of all the changes that are made. This expectation also permeates into an associated set of requirements, such as tracking the reason for each change, the time of the change etc. In many cases, the data tracking requirements apply to data that applications store in the form of documents. Using Subversion can help satisfy these complicated, albeit common, requirements."
"This article discusses 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, version 1.0, to access a common transaction-processing platform from a Java 2 Enterprise Edition (J2EE) platform application. This article concludes with an overview of the upcoming new release of J2EE CA, version 1.5, and explains some of the additional features and benefits introduced in this new version. This article assumes that you have a working knowledge of Java and J2EE."
"Dependency injection is the inverse of JNDI. It lets you declare dependencies and lets the Java EE container handle the complexities of service or resource instantiation and initialization when the resource is required. Based on the declaration of resources using annotations or deployment descriptors, the Java EE 5.0 container injects an instance of the resource when it's required. Figure 1 compares JNDI with dependency injection:"
"Blueprints is a developer outreach program from Sun Microsystems' Java Software division. This program provides architectural recommendations and design guidelines that help Java developers most effectively use the J2EE platform and its various technologies. This article will explain"
"At its heart [fleXive] is a pure Java EE 5 application, the core is made up of EJB3 beans, sharing common states and configuration using a clustered cache (including out-of-the-box support for JBoss Cache 2.x with pluggable interfaces that could be used for other providers like GigaSpaces or Coherence), while the web layer is based on JSF using Facelets, Richfaces/Ajax4JSF, and the Dojo toolkit. As a persistence alternative to JPA/Hibernate (which can be used as well of course) [fleXive] comes with its own persistence implementation offering some advantages like integrated ACL based security, versioning, support for multilingual data types, inheritance, and reuse. The persistence framework is not intended as an object-to-relational mapper, but rather as generic objects with all instance data accessible using XPath-like statements or traversing object graphs."
"In most Java projects, a large percentage of the code is boilerplate code. Exception handling comes under this category. Even though the business logic may be just three or four lines of code, exception handling might go on for ten to 20 lines. This article talks about how to keep exception handling simple and straightforward, keeping the developer's plate clean for him to concentrate on business logic rather than devoting time to writing exception-handling boilerplate code. It also gives the basis and guidelines to create and deal with exceptions in the J2EE environment and targets some of the business problems, in which exceptions could be used to resolve them. This article uses the Struts framework as the presentation implementation, though the approach is applicable to any presentation implementation."
"Web services are now a popular technology for implementing service-oriented applications. J2EE has become a popular platform to deploy web services applications. And J2EE 1.4 standardized building and deploying web services applications for the Java platform."
"So the big question for architects and developers of J2EE applications is: "Is there nothing we can do to ensure that the J2EE application being developed and tested on a standalone server will run on a cluster without any code changes?" The answer is that you can write cluster-ready J2EE applications; however, you need to be aware of the differences between standalone and clustered environments and ensure that you do not make any assumption about the single-process nature of an application. 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."
"Each application server allows you to customize different aspects of a cluster. Two examples are the replication scope ("How many nodes do I want to share my session across?") and the replication trigger ("When do I want to replicate the information?"). However, once a cluster is up and running, it is usually difficult to analyze its behavior. The reason for this is that application servers use low-level APIs to implement their clusters and do not expose any metrics about what's going on underneath the application's code."
"More and more mission-critical and large scale applications are now running on Java 2, Enterprise Edition (J2EE). Those mission-critical applications such as banking and billing ask for more high availability (HA), while those large scale systems such as Google and Yahoo ask for more scalability. The importance of high availability and scalability in today's increasingly inter-connected world can be proved by a well known incident: a 22-hour service outage of eBay in June 1999, caused an interruption of around 2.3 million auctions, and made a 9.2 percent drop in eBay's stock value."
"The details of Java EE 6 have been getting hashed out for quite a few months in the JSR 316 expert group, which I am part of. The goal of this article is to give you an overview of the changes in Java EE 6 as well as encourage your feedback. Besides the work of the JSR 316 expert group itself, I?ll also discuss the JSRs that are likely to comprise this release of the platform. Java EE 6 has now released its public review draft and is well on the road to be finalized after the official public review date is over on February 23. This means that this is the best time to provide feedback but providing feedback soon is very important."
"Many J2EE solutions exist, the EJB-SIG located at http://www.mgm-edv.de/ejbsig/bm_ejb.html provides a comprehensive list of those that at least support Enterprise Java Beans, a significant component of J2EE and this should be reviewed by an organisation before taking any further steps - to at least ensure that a decent representation of vendors is taken into consideration. Another site dedicated to J2EE solutions exists at http://www.theserverside.com."
"As an example, take a J2EE app that requires a particular version of Xerces. The application server may already load another version of Xerces and provide this to the J2EE apps as part of the JAXP requirement. In the case the J2EE app does not want to use the JAXP parser provided by the application server, but rather use its own, this can be problematic. The standard Java classloading mechanism will normally serve the version of Xerces loaded by the application server, because the application server classloader exists higher in the classloading hierarchy."
"This article describes a design strategy that accelerates development and improves reusability by structuring the domain model into two levels - a Plain Old Java Objects (POJO) [FOWLER] level that implements the business logic and an entity bean level that implements the persistence."
"?The J2EE Architect's Handbook can justifiably be considered to be the "bible" for J2EE based application designers and project managers.? -- The Midwest Book Review (7/2/2004)."
"This document is a living reference document for anyone involved in the design and architecture for organizations to transform their legacy systems to Java 2 Enterprise Edition (J2EE) based applications."
"Microsoft.NET8 is product suite that enables organizations to build smart, enterprise-class web services. Note the important difference: .NET is a product strategy, whereas J2EE is a standard to which products are written."
"JavaSpacse-based architectures continued to gain attention in recent years as clusters of rack-mounted servers brought some commoditization to a type of computer architecture that was once the province of only the best-funded computer shops."
"Once upon a time there was a dream. The dream was of creating cross platform products. Ones that transcended the boundaries imposed upon us by entities known as Intel or DEC or even Silicon Graphics. From that dream, two technologies were inevitably born: those of Java and CORBA."
"This whitepaper will teach you the best practices that will help you get the most reliability and scalability out of your J2EE based application and the most productivity out of your developers. It covers all elements of the software development cycle, from design through deployment."
"From its inception more than a decade ago, the Java platform has matured considerably making it the preferred choice of many professionals & organizations for developing applications. In its most recent version for the enterprise -- dubbed Java EE 5 -- its designers have placed a special emphasis on doing more with less, so whether you're a seasoned expert or just starting out, it's likely you will find some fresh approaches that will simplify and ease your development efforts ? this article takes a closer look."
"Wonderland is an interesting 3D collaboration application. It uses the darkstar server as backend. Project Underworld's goal is porting the Wonderland's communication and persistence layer to Glassfish v2 (later v3) to leverage its non-functional capabilities like monitoring, management, deployment and scaleability. In this shorttalk, especially the architecture and design, as well as, challenges, hacks, and workarounds will be discussed."
"Dependency injection is a mechanism in which a component's dependencies are supplied by the container. The dependency on a resource is marked using annotations or declared in the deployment descriptor file. Dependency injection (aka "resource injection") is nothing but the inverse of JNDI. Instead of the component explicitly requesting a resource, now the Java EE 5.0 container injects an instance of the resource when it's required. The injection could be at the field level or at the method level (typically on a setter method). The Java EE 5 platform defines annotations to support a variety of injections."
"The annotation facility is widely used in Java EE 5 and other frameworks, but it needs a validation facility to check the semantic constraints. apt is a great tool for creating annotation processors to validate EE annotations at build time. The apt-based, build-time annotation validation is complementary to run-time reflection-based validation. It is especially useful when the annotations are not available at run time. The upcoming JSR-269 defines a standardized annotation process API to supersede the apt API. The new annotation processing API is easy to use and preferred, even though apt remains supported in the next release of Java."
"This talks presents hints and tips on using the refactoring core J2EE functionalities with the Spring Framework. In particular Peter will talk about refactoring legacy EJBs into Spring-EJB, whilst through 10 days of staged new employment activity. He will advise how to manage those multiple application context files. He will describe the best probably avenues to get your IT workshop and management teams to think about using and/or doing more Agile development techniques. You have had some knowledge of Spring Framework beforehand, but don't worry if you are not very familiar, because it will be fun experience regardless."
"One of the hardest parts about J2EE development is getting started. There is an immense amount of open source tools for web app development. Making a decision on which technologies to use can be tough -- actually beginning to use them can be even more difficult. Once you've decided to use Struts and Hibernate, how do you go about implementing them? If you look on the Hibernate site or the Struts site, you'll probably have a hard time finding any information on integrating the two. What if you want to throw Spring into the mix? As a developer, the best way for me to learn is by viewing sample apps and tutorials that explain how to extend those applications. In order for me to learn (and remember) how to integrate open source technologies such as Hibernate, Spring, Struts, and Ant/XDoclet, I created AppFuse. The beauty of AppFuse is you can actually get started with Hibernate, Spring, and Struts without even knowing much about them. Using test-driven development, AppFuse and its tutorials will show you how to develop a J2EE web application quickly and efficiently."
"Wrap it all up This article has given you an applied understanding of clustering. You've learned how to set up, program for, and maintain J2EE clusters. You've seen the issues related to clustering, as well as possible solutions. With this practical knowledge, you can set up a working J2EE cluster."
"In this article, the focus shifts to client-side mashups. You'll learn how a client-side mashup works, see an example of a client-side mashup in Pet Store -- as is the case in the previous article, this article refers to the Java Pet Store 2.0 application simply as Pet Store -- and explore some of the onsiderations related to the client-side mashup style. In addition, you'll learn how to make services and content on your site available to others for use in client-side mashups."
"No official definition exists for a J2EE platform-based cluster, and each vendor of products for this platform has a different implementation. In this article, we are referring to a set of J2EE platform-based application servers working together to provide high availability and scalability for enterprise applications."
"Adam Bien Adam Bien's Blog From Java Platform Improvements to Better Teaching: A Conversation With Java Champion Cay Horstmann Java Champions NetBeans Dream Team Becoming a Better Programmer: A Conversation With Java Champion Heinz Kabutz Java Champion Geert Bevin and His Work With JavaScript Java EE at a Glance Writing Javadocs"
"Multitiered J2EE applications consist of components communicating across tiers to access/change data. This often leads to remote calls between application clients/JSPs/servlets and EJBs or between EJBs. Such remote calls are costly and affect the performance of the application as a whole. An increase in the number of such remote calls increases network traffic too. Moreover, for all the advantages that EJBs offer, they come with a small price. The following three design patterns suggest good solutions to minimize some of the performance costs in typical J2EE applications."
"This white paper is based on the article "Introduction to the Java EE 5 Platform," which originally appeared on the java.sun.com site in February 2006. This version includes data from two studies that compared development on Java 2 Platform, Enterprise Edition (J2EE) 1.4 with Java Platform, Enterprise Edition (Java EE) 5 and a new section on packaging Java EE 5 platform applications. The sections on web service support and JavaServer Faces technology have been greatly expanded, with two new JAXB 2.0 examples and an extensive JavaServer Faces example."
"To understand how resource injection makes life easier for developers, let's look at how applications accessed resources prior to support for resource injection and how the Java EE 5 platform has simplified this access. In the past, accessing data sources, web services, environment entries, and EJB software references required the use of boilerplate code. For example, the code required to access the container-managed data source javax.sql.DataSource would look like this:"
"The application used in these articles is derived from the Duke's Bookstore application, included in the Java EE 5 Tutorial. The application has been extracted from the tutorial for use in these articles."
"This paper is intended for EIS vendors and developers that want to learn more about the resource adapter component of the connector architecture before delving into the Java 2 Platform, Enterprise Edition (J2EE) Connector Architecture specification. While the connector architecture is mentioned to illustrate how the resource adapter component fits into the overall scheme, most of the paper concentrates on the resource adapter. Benefits of implementing a resource adapter, as well as implementation details and specification requirements, are discussed. Pseudo-code is given to illustrate how an EIS vendor might implement a resource adapter."
"As part of the official J2EE launch in December, the APM has been renamed the "Sun BluePrints Design Guidelines for J2EE." The new name reflects its inclusion in Sun's BluePrints best-practices series of articles and whitepapers. But because "Sun BluePrints Design Guidelines for J2EE" is too long to write over and over, I'll continue to refer to the document as the APM. The final version of the J2EE BluePrint document will be published by Addison-Wesley sometime this year."
"In this series of articles, web-tier proponents at Sun introduce the new concepts that every web-application developer should be familiar with to get the most out of the Java EE 5 web-tier technologies. This first article in the series gives an overview of the new features introduced in version 2.1 of JSP technology."
"This article is a digest of the J2EE Blueprints to introduce you to the programming model and help you get started. You can go to the J2EE downloads page for a PostScript or PDF version of the book or to download the example pet store application. The printed book will be available in June 2000."
"This article describes the J2EE Connector architecture Common Client Interface (CCI) API. The CCI provides the access from J2EE clients, such as enterprise beans, JavaServer Pages (JSP) technology, and servlets, to an underlying enterprise information system (EIS). The J2EE Connector architecture, and the CCI API, are currently available as a beta release."
"Web Tier to Go With Java EE 5: Summary of New Features in JSP 2.1 Technology, Part 1 in the series Web Tier to Go With Java EE 5: Summary of New Features in JSTL 1.2 Technology, Part 2 in the series JavaServer Faces Technology JSR 252: JavaServer Faces 1.2 JavaServer Pages Technology Hans Bergsten's article on the incompatibilities between the JSP and JavaServer Faces technologies Unified Expression Language Java Forums -- JavaServer Faces Technology Public IRC chat room: See Community heading"
"The Java 2 Enterprise Edition (J2EE) reference implementation provides a way for you to write, test, and deploy application clients. A J2EE application client is a standalone program launched from the command line or desktop, and typically accesses Enterprise JavaBean programs running on the J2EE application server."
"The first article in the "Web Tier to Go With Java EE 5" series, "Summary of New Features in JavaServer Pages (JSP) 2.1 Technology," introduced the new unified expression language. This fifth article of the series explains"
"To get an update on the Java EE 5 platform, we met with Java EE specification lead Bill Shannon, a Distinguished Engineer at Sun Microsystems. Shannon has been with Sun since 1982 and previously worked on the JavaMail API, the HotJava Views product, the Common Desktop Environment (CDE), the Solaris Operating Environment, and all versions of SunOS. He graduated from Case Western Reserve University with an MS in Computer Engineering."
"This article is intended for EIS vendors, messaging providers, and developers who want to learn more about the Message Inflow and Transaction Inflow contracts that were introduced in the latest version of the Java 2, Enterprise Edition (J2EE) Connector Architecture (Connector 1.5). Since this article is the second in a two-part series, the resource adapter and system-level contracts will not be discussed in detail. This information can be found in Part 1 of this article, which was published in March 2003. Instead, I'll focus solely on the two new contracts. Implementation details and specification requirements will be covered, and pseudo-code will be examined to see how an EIS vendor or messaging provider might implement the new contracts for a Connector 1.5-compatible resource adapter. The new Connectors v 1.5 can be found in the J2EE 1.4 SDK or in the J2EE 1.4 Application Server. Download it for free at http://java.sun.com/j2ee/1.4/download-dr.html."
"But how good is it as an enterprise application server platform? Judge for yourself: This article gives you five reasons why the J2EE platform continues to be the application-server platform of choice."
"In version 1.5 of the J2EE Connector Architecture, there are more contracts that a resource adapter must support, as new functionality and features made their way into the specification. A resource adapter can support these four new contracts by implementing the required interfaces defined in the specification for each contract."
"With COR, you can fast-track your J2EE development so that your developers spend less time building infrastructure (Beans, facades, facade implementations, and service locators) and more time solving real business problems."
"Until recently, performing parallel processing directly within a managed environment (J2EE container) was not advisable. Thankfully, IBM and BEA came up with a joint specification that resolves this problem. This JSR is named "JSR-237: Work Manager for Application Servers". JSR-237 specifies the Work Manager API, which provides abstraction from the lower-level APIs that enable an application to access a container-managed thread. Work Manager API also provides a mechanism to join various concurrent work items, so an application can programmatically add the dependency of work completion as a condition for starting other tasks. This can be useful for implementing workflow types of application. These features were difficult to implement prior to Work Manager."
"One of the main goals of the upcoming Java EE 5.0 release is to keep the power of J2EE, while making common development tasks simpler. To accomplish this, Java EE 5.0 aims to provide better default behavior and configuration by allowing most containers to get what they want from the application without using deployment descriptors. Java EE 5.0 puts annotations to great use for this purpose. Although developers don't need to know the implementation details (the containers do the bulk of the implementation work), these new features will make enterprise Java applications lighter and faster."
"This article introduces an alternative approach for J2EE concurrency that takes advantage of the inherent thread pool management of EJB timers. This approach is portable across application servers and does not require a messaging provider and resources such as queues and connection factories. Furthermore, since EJB timers are transactional and recoverable, this approach enables robust and reliable concurrency solutions."
"Commercial build tools are available that can automate your J2EE build process including the creation of multiple deployment descriptors. In some cases a commercial solution is best as it can be easily repeated for any J2EE application, not just custom-written for a single J2EE application. If a commercial tool is not an option, consider a scripted solution that builds all .wars and .ears needed for the lifecycle in a single build pass. This ensures that the same source is used to create each unique .war and .ear."
"Design with Performance in Mind Unless you consider and factor performance into your user interfaces, designs, and development processes up front (including testing early and often), you'll likely hit problems sooner or later. The key to good performance is to understand your performance goals up front. Understand the number of concurrent users, target response times, usage patterns, and data growth. Know how your application is going to be used: which parts of the system are session-based and which are non-session or batch-based. That way you can structure your architecture to meet your needs."
"This article discusses two data management strategies available with the J2EE: Java object serialization and Java Database Connectivity (JDBC). We'll look at the strengths and weaknesses of both of these approaches. No data management strategy is inherently superior or inferior to others. The applicability of a strategy in a particular implementation depends on the scope (the spectrum of activities occurring in the system environment) of the project, the context of the system (the set of values that drive the runtime of the system/subsystem), and other external factors. However, Java serialization is ill-suited for enterprise systems in which data needs to be organized in a well-defined structure (for example, an RDBMS). We'll first walk through a quick overview of Java object serialization, then walk through some of the more important aspects of JDBC to see how the latter implements crucial features that the former lacks."
"Are you an ASP developer looking to port an existing e-business application to J2EE or writing a new J2EE application from scratch but don't want to suffer from "information overload" to get started? Then this roadmap is for you. This roadmap is specifically designed for ASP developers looking to make the jump to J2EE, a platform independent set of open standards for developing Web applications and other types of distributed applications in the Java language. Along the way we'll introduce you to J2EE, programming in the Java language, developing J2EE Web applications, and relate it to what you already know from your experience writing ASP, COM objects, and ISAPI filters for IIS and the Windows environment."
"Geronimo is the Apache Software Foundation's open source J2EE 1.4 server, born in 2003. Part 1 of this two-part series described Geronimo from a system-design standpoint, examined its architecture, probed some key structural concepts, and introduced basic user terminology. Now continue the Geronimo tour and explore the server's deployment, configuration, and management capabilities in some detail."
"While these ideas are old, we keep finding new ways to realize them in Java? technology. The latest round of decoupling, dependency injection, reflects the ideals stated above. Like many new concepts implemented in different ways in different places, a lot of confusion has arisen between the concept and the implementation. In this two-part article series, I discuss the concepts of DI (also known as Inversion of Control, or IoC), then demonstrate how it's implemented in Apache Geronimo."
"This article described some of the issues involved with authorization for J2EE applications, along with some of the existing standard capabilities of WebSphere Application Server and other J2EE application servers. It is in your best interest to use existing standards wherever possible. When they do not provide the complete solution, it is wiser to use them as far as they are useful and then extend their capabilities, rather than replace them entirely with custom solutions. Authorization is a complex and difficult topic, so think carefully about the issues."
"Follow along with the steps for deploying simple J2EE applications on computers running Apache Geronimo, and find out how similar the steps are to those for any other J2EE-compliant application server. While this article focuses mainly on how to deploy EJBs on Apache Geronimo, you'll also learn about JSPs and servlets. This article assumes that you know how to write and deploy EJBs in another J2EE container, such as IBM WebSphere® Application Server, JBoss, or WebLogic."
"In the first installment of the J2EE pathfinder series, we began an exploration of the current technologies for state management in J2EE. Last month, we discussed the best options for managing stateless networks in J2EE; this month we'll talk about the technologies for managing stateful ones."
"This tutorial provides an overview of the Java? 2 Enterprise Edition (J2EE) Connector Architecture (JCA). The tutorial starts with a high-level look at JCA, including the base elements of the architecture. You'll explore each of these elements in detail, with step-by-step descriptions and examples. The course closes with a sample application that will help you see how all the parts of a JCA-compliant and enabled system work together."
"The information age has put tremendous emphasis on the use of distributed enterprise computing platforms. On such platforms, data must be protected at all cost and must persist indefinitely, even in the face of network failures, memory leaks, and server crashes. To maintain this type of persistence, application components must be capable of handling concurrency, connection management, data integrity, and synchronization. All three of J2EE's data management technologies handle these functions for the developer, although each one handles them somewhat differently."
"Are you a .NET developer looking to port a .NET e-business application to the Java 2 Platform Enterprise Edition (J2EE)? Or, do you need to write your first J2EE application from scratch? Either way, this roadmap is for you. It's designed specifically for .NET developers who want to make the jump to J2EE, a platform-independent set of open standards for developing Web and other types of distributed applications in the Java language. We'll introduce you to programming in the Java language and developing J2EE Web applications. Better yet, we'll relate this information to concepts and techniques you already know from your experience writing .NET applications."
"How are the two standards for software management related to each other? Are they complimentary or overlapping? Is there any benefit to combining the two? In the case of WSDM and J2EE, there is a very substantial benefit in combining the two management specifications:"
"Application components fulfill requests for business services. To fulfill these requests, they often must change the state of the underlying datastore. It is imperative that those changes do not compromise the integrity of the persistent datastore. (In the first article on data persistence, we defined a persistent datastore as an independent data repository capable of preserving its data even in the event of a server crash or network failure.) To ensure persistence, application components must be capable of handling concurrency, connection management, data integrity, and synchronization. All three of J2EE's data management technologies handle these functions for the developer, although each one has its own way of doing so."
"The goal of J2EE certification is both a blessing and a curse for the Geronimo project (see The toll of certification). In order to be certifiable, Geronimo must support all mandatory features described in the J2EE 1.4 specification (see Resources). The specification refers to a collection of other specifications that also have their own mandatory clauses. Figure 1 gives you some idea of what Geronimo must implement before qualifying for certification."
"We'll begin by briefly discussing the qualities of the stateless (as opposed to stateful) network, then talk in detail about the pros and cons of each of our two stateless technologies. We'll close the article with a broad look at the most common application setups you will encounter in J2EE enterprise programming, and the best technology solutions for each setup given our two options."
"IBM Lotus Expeditor is an offering from IBM that eases Java™ Platform, Enterprise Edition application extension to clients with a familiar programming model. IBM Lotus Expeditor Toolkit enables rapid application development and deployment by eliminating the need to rewrite Java EE projects to run on the Lotus Expeditor runtime. In this article, we demonstrate how you can achieve this."
"J2EE is a platform-independent environment designed for developing and deploying Web-based applications for enterprise-wide use. The platform has been likened to a meta language or language superset. But at its core, J2EE is simply the Java programming language and a specific, minimal set of Java classes. (See Resources for a link to the class documentation for J2EE.)"
"The J2EE Server provides for network communications and security that can be configured to the needs of the system. The Derby engine does not duplicate these functions but readily takes advantage of these services in a Server environment. Much of the code of many database system binaries provides for system security and networking that is redundant in a J2EE system. The Derby footprint remains small because the libraries do not contain this code. When embedded in a J2EE Server, a fully functional JDBC-compliant resource manager is installed by adding a single 2 MB jarfile to the system."
"One example of success has been the freezing of JAX-RPC and a new specification (JAX-WS) being opened as its successor, thereby preventing incompatible changes to JAX-RPC. This won't change the long term need to migrate to a current API, but it will prevent the short term requirement for that. Freezing a specification enables you to recognize when a given set of APIs are viewed as non-strategic, but it will not affect the behavior of your existing applications that you might have built using that technology. Preservation of customer investment is one of the priority objectives that IBM attempts to achieve by participating in standards."
"For the most part, Java applications are either J2EE applications or J2SE applications, and there's no ambiguity about which. J2EE applications require the services of a J2EE container, which implements a long list of J2EE APIs, including Enterprise JavaBeans (EJB), JTA, JNDI, JMS, JCA, and JMX. The J2EE APIs are designed to work together; after all, the J2EE design is the product of distilling out common requirements from hundreds of man-years of experience developing enterprise applications. Like all frameworks, a primary motivation for the J2EE APIs is "don't reinvent the wheel.""
"This installment of J2EE pathfinder is a follow-up to last month's introduction to the proper handling of session scopes. In addition to accessing session scopes, JSP implicit objects can be used to handle HTML parameters, forward a request to a Web component, include the content of a component, log data through the JSP container, control the output stream, handle exceptions, and more."
"It is important to note that the benefits of reuse are independent of this issue. Whether the code is shared at run time or not, applications can still use a common set of code libraries that are developed elsewhere and still provide the usual benefits of reuse. This issue is about runtime packaging, not reuse."
"In this article, we'll follow up on the second installment in this series, "J2EE technologies for the stateful network," in which you learned some of the basics of stateful application development in J2EE. This time, we'll focus less on the big picture and more on how we create and manage a stateful user experience."
"We heard that same story, too. We listened while colleagues discussed IBM's new DB2® Information Integrator, a product designed to provide a single-site image of data residing on different platforms, stored in different formats, and accessible through different application programming interfaces (APIs). And we wondered just what this technology might do for J2EE programmers tasked with building Web components that needed to work with disparate data."
"Several J2EE pathfinder installments have been written since this developerWorks column debuted in February 2003. You can browse through all the J2EE pathfinder columns, starting with the most recent, in these continually refreshed lists:"
"In a Web 2.0 context, mash-up applications frequently use services and feeds exposed through an SOA's service APIs (see Java EE meets SOA). These applications need to consume services in a B2C context. For example, a mash-up might pull data ? such as weather information, traffic information, and a map ? from three unique sources. The time required to retrieve these three unique pieces of data adds to the overall request-processing time. Regardless of the growing number of data sources and service APIs, consumers still expect highly responsive applications."
"In the sections that follow, you'll learn, step-by-step, how to meet these requirements and incorporate custom tags into your JSP pages. Here are the five steps between you and a successful JSP custom tag implementation:"
"Wrox recently released the third edition of its Professional Java Server Programming book, now subtitled J2EE 1.3 Edition. I stopped by Amazon to see what readers had to say about this book, but the four reviews (as of press time) of the new edition are little more than a sentence or two in length with minimal meaningful information of the book's quality. To help you make a better decision about purchasing, here's a look at what to expect with the latest offering."
"However, we haven't fully solved the problem. We now have a dependency between the two applications. While we can bring down the Benefits application, the Timesheet application must now have the same availability requirements as the Benefits application, creating a potential administration hassle. Furthermore, we now have to deal with a problem that's not addressed by the J2EE 1.2 specification: how to include the EJB stub code in the Benefits WAR file. Theoretically, we could separate out the client code from the Timesheet EJB-JAR file, but that seems error prone and likely to create problems. We'll come back to this possibility later."
"The latest version of the platform, Java EE 5, was released in May 2006. Primarily focused on developer productivity, Java EE 5 brings simpler programming models without sacrificing any of the platform's power and richness. Two mechanisms ? Java annotations and better defaults ? are responsible for most of its simpler development models. Major functional improvements include enhanced Web services support and incorporation of JavaServer Faces (JSF) and the Java Standard Tag Library (JSTL) into the platform."
"Java EE 5 also introduces a new programming model for Web services: JAX-WS. Before looking at what is different, you might want to know what has not changed from JAX-RPC to JAX-WS:"
"So, what have you accomplished? You have created a MVC-based J2EE application, in very little time, without a single line of Java code. By using a MySQL database, the ADF framework allowed you to create a fully-functional reservations system that was deployed to Oracle's OC4J server. As a final note, ADF-developed applications are not confined to Oracle's application server. JDeveloper provides support for installing the ADF libraries and packaging and deploying a complete ADF application to another J2EE application server such as JBoss."
"Creating Web services from various J2EE components and exposing them to the Net remain one of the critical aspects of a J2EE-compliant e-business. The flexibility and the versatility of the business process depend on this. In this article, we would like to address this issue from a programmer's point of view. We shall concentrate our efforts on a similar architecture with BEA Weblogic as the application server. We shall take some of the basic building blocks of a J2EE-based system, convert each to an individual Web service, and deploy on Weblogic."
"Corba: This predecessor of EJB is the open standard for heterogeneous distributed computing. J2EE offers support for Corba through Remote Method Invocation (RMI) over Internet Inter-ORB Protocol (IIOP), which lets Corba objects talk to Java objects over the network, a Java Interface Definition Language (IDL), which lets Java objects communicate with Corba objects on the same machine, and Java Transaction Service (JTS), a Java implementation of the Corba Object Transaction Service (OTS)."
"The aim of this article is to introduce small/medium size Web-based applications and propose a simple J2EE-based architecture. We will also explore the feasibility and limitations of this architecture in different scenarios."
"Business applications typically manage data. Therefore, developers often need to provide components that enable users to analyze that data. One way to do this is by providing users access to text-based reports. Another option is to provide a view to the data through a series of graphical charts. Charts can be an extremely useful tool because they allow users to visually compare data elements, spotting trends and patterns not easily discernable through reports when dealing with large amounts of data. Much of today's business software is Web-based and delivered through a browser. Nevertheless, requirements for these applications, namely data analysis requirements, remain the same. Luckily, if you are developing software with J2EE technologies, there are some open-source options to assist you. This article will demonstrate how J2EE developers can quickly add visually-appealing, graphical charts to their work."
"Finally, an intelligent SLA needs to be flexible. It needs to account for variations in behavior as a result of unforeseen factors, but define a hard threshold for how flexible it is allowed to be. For example, an SLA may read ?The search functionality will respond within three seconds (specific) for 95 percent of requests (flexible).? The occasional seven-second response time is acceptable, as long as the integrity of the application is preserved?it responds well most of the time. By defining concrete values for the specific value as well as the limitations of the flexible value, you can quantify what ?most of the time? means to the performance of the application, and you have a definite value with which to evaluate and verify the SLA."
"This JSP page is straightforward and simple. It uses JSP Expression Language to output the value of the request parameters "uid," "profile_name," and "profile_picture_url" you placed in the request in the getFacebookInfo() method from MainPageServlet.java. Using these values, it displays the users' name and profile picture, with links to their profile, and congratulates them for using "myfacebookapp.""
"TORONTO--(BUSINESS WIRE)--Feb. 4, 2002--Sitraka, leaders in Java application development solutions and creators of the award-winning JProbe Suite of Java performance tuning tools, announced today that the company is strengthening its focus on J2EE Performance Assurance. Sitraka's product strategy signals the company's commitment to enabling development, QA and operations teams to manage all aspects of J2EE performance across the entire application life cycle. In a separate announcement made today, Sitraka unveiled the release of Sitraka PerformaSure, a transaction-centric J2EE diagnosis tool and a key component in the company's emerging J2EE Performance Assurance offering."
"In this article, I will focus on the Business Delegate enterprise design pattern. This pattern describes a relatively new application of an old concept that facilitates decoupling between application tiers and various business services. I will describe the pattern in detail with an example of real enterprise usage. In addition, I will talk about key concepts and the evolution of this pattern. The idea of hiding complex implementations from different software clients or tiers is not new, GoF* book describes several patterns that make it possible. For example, a Façade [GoF] pattern provides a single high-level interface for a set of interfaces in a system and therefore hides the original implementation from the client subsystems. An Adapter [GoF] pattern or Broker pattern provide coupling for disparate systems, thereby also concealing the implementation of the parent system from the subsystems that use it."
"In development, components are tested in unit tests. A unit test is designed to test the functionality and performance of an individual component, independently from other components that it will eventually interact with. The most common unit testing framework is an open source initiative called JUnit. JUnit?s underlying premise is that alongside the development of your components, you should write tests to validate each piece of functionality of your components. A relatively new development paradigm, Extreme Programming (www.xprogramming.com), promotes building test cases prior to building the components themselves, which forces you to better understand how your components will be used prior to writing them."
"Due to the nature of security, there may never be a winner of a .NET-J2EE battle. There are already several playing fields the war is being waged upon. There is Microsoft's SDK versus Sun's API, there are .ASP pages versus .JSP ones, and then there is XML and other middle and back-end integration to consider. But for now, I will examine the differences in one aspect of these platforms' security solution, their primary core languages."
"Sitraka is aware of this difference, but has (sensibly, in my opinion) focused its attention on where developers are feeling the most pain: during initial development. The fact is, most J2EE applications currently being worked on are still in the initial development stage at this point, and have yet to be deployed anyway. Hopefully, PerformaSure will help shorten time to market for some of these applications, along with improving initial quality and customer acceptance, by helping developers to identify problems in the development and initial QA phases, rather than having to have performance inadequacies pointed out to them by customers or by the occasional large catastrophic failure after deployment."
"Many organizations use the J2EE platform to create services. A service in this environment has multiple layers, each of which handles a specific function. A service is usually created in the J2EE environment as a stateless session bean. A stateless session bean is an EJB component that does not maintain any conversational state with the client. It is a type-based component in which each method call is completely independent from other method calls."
"The concept of temporarily storing frequently-referenced data at your application's elbow to save the overhead of repeated trips into the database is so well-entrenched that many databases can be enabled to do it passively. And within J2EE, a J2EE server can passively do entity bean caching, if you're using entity beans to do data access."
"Whether it is tuning a J2EE application, a database, or your own custom-built architecture, it is always best to start by defining the methodology that you will use, analyzing that methodology to ensure that it accurately solves your problem, and determining the requirements of that methodology. Although the first article in this series introduced you to J2EE performance tuning and the goals in tuning a J2EE environment, this article defines a tuning methodology you can use in your environment and the information you will need to apply this methodology."
"To make a Java EE .NET interoperable solution secure by default, security architects and developers should consider the following security requirements. Also refer to [WSI-countermeasure] for the details of security scenarios and the counter-measures to the security threats."
"There are several very good tools out on the market today. One of my personal favorites is Subversion. Although it is a relative newcomer to the version control scene, it is quickly gaining popularity among developers. It has been coined as "CVS without the suck" by many developers in that if you know CVS, you already know most of Subversion. One of the features I like most about Subversion is that you can move items in the repository without losing your change history. For Java development, this is extremely useful."
"WTP provides projects and wizards to help you get started quickly with different types of Web and J2EE applications. You can use these wizards to create most standard Web and J2EE artifacts. Additional tools will help you create, build, validate, and run your applications on servers."
