Downloads & Current Status

The SOA module has been removed from the standard distribution for NetBeans IDE 6.7. To use the SOA functionality with NetBeans IDE 6.7, you need to install GlassFish ESB v2.1 from the OpenESB website.

Editing the deployment configuration of a JBI
Service Assembly. The editable configuration parameters include a list
of Service Units in the deployment package. Support for common editing
scenarios, such as adding and modifying concrete WSDL elements, adding
and removing service connections between Service Units, and connecting
to endpoints of external Service Units is provided.

Visually editing data transformations. The Mapper
view has a source document panel, a target document panel, and a
transformations panel. The Source view shows the XML source of the XSLT
document being edited.

For specific technologies included in NetBeans SOA,
please follow the link to the subproject's homepage in the table above
and use the Mailing Lists links on the left of the page to subscribe to the appropriate mailing lists.

General questions about the IDE and SOA functionality can also be asked on the nbusers@netbeans.org mailing list.

Building

SOA Overview

The SOA functionality, which stands for service oriented architecture, is geared toward enterprise application
development. The SOA functionality is available in the full profile of the NetBeans IDE. The IDE's SOA pack contains open-sourced features from
Sun's Java Studio Enterprise and Java CAPS products, as well as all-new
features for creating composite applications, BPEL-based Web services, secure Java EE Web services, and real-world XML artifacts like XML Schema and WSDL. The SOA pack is provided with all necessary runtimes, such as the GlassFish application server on which you can deploy applications, and Open ESB 2.0.

Open ESB 2.0 implements a Java Business Integration (JBI) runtime
that incorporates the JSR 208 specification for Java Business
Integration and other open standards. Open ESB allows you to integrate
web services and enterprise applications as loosely coupled composite
applications, realizing the benefits of a service-oriented architecture
(SOA). For more information, about the runtime parts of SOA, visit the open source project Open ESB.

Concept & Vision

The overarching theme for the SOA functionality is to provide tools that help developers build composite applications
using a variety of technologies to solve medium- to large-scale
business requirements. We place considerable emphasis on
SOA technologies as a means to achieve
this end.

Composite Applications

Composite applications are applications with a capital
"A"—large applications that span multiple systems, technologies,
and architectures. In the enterprise, in which there is a mix of
technology, systems, and architecture, composite applications are the norm. However, tools
today primarily address only selected pieces of what we call the application problem,
meaning the business need for an application that must be addressed by
the application developer. Except in very rare circumstances, the full
scope of an enterprise application spans multiple front-ends (for
example, intranets, extranets, B2C portals) and multiple back-ends (for
example, databases, mainframes, manual processes); requires
coordination across multiple technologies, systems, and business units;
and must incorporate considerations like end-to-end security.

For the mathematically minded, rather than a single equation, an
enterprise-class application problem consists of many dependent
equations with multiple terms that must be solved together. Thus, as
tool providers, we can either approach this problem as providers of
tools to make solving each equation easier, or tools for making solving
all equations at once not just easier, but possible.

Role of NetBeans SOA

We consider large-scale application needs as the real problem that
the NetBeans SOA can and should address, rather than just
providing lower-level technology tools that leave highly-skilled
developers to fill in the gaps between them. Rather than focus on point
technologies, such as Web applications, thick client front-ends, and
EJB back-ends, tools for composite applications should look at the full
scope of the problem and address not just the individual point
technology issues, but also the spaces between the technologies. Though
traditionally this view is thought of as enterprise application
integration, or EAI, to the developer this is all just part of building
an application, albeit a large and complicated application which makes
use of heterogeneous resources. While certainly these kinds of problems
can be solved by a combination of point technologies (like those found
in the Java EE SDK) and lots of developer-provided glue, such solutions
are not ideal because they require large amounts of time and resources,
and are generally brittle and difficult to adapt to changing business
needs.

It's easy to build a tool that helps developers build a widget
faster and easier. What's more difficult is building a tool that helps
developers avoid building widgets and instead focus on solving the real
problem: solving a business need using technology as a means. Most
tools designed for point technologies treat the technology as an end;
rather, technology is a means to an end, and while developers need good
tools to deal with complex technologies, if tools are to evolve beyond
just "easier and faster," they must not stop at the technology and
instead try to solve the larger problems that today require a great
deal of manual skill and resources to address. Therefore, we can
provide the most value to developers by considering the broader context
within which they solve their business needs. This is the goal for the
NetBeans SOA project.

SOA as a Means to an End

The rise of SOA formalizations gives
both developers and tool providers a way to achieve a consistent
composite application solution. With SOA technologies, there is now a
mechanism (or we should say, several mechanisms unified under one
architecture) for bridging systems in a consistent way, using standard
protocols, that cross point technology boundaries. Unlike technologies
like CORBA and RMI, SOA encourages loose coupling between services.
Loose coupling allows composite application developers to focus on use
cases and system interactions beyond the traditional programmatic
styles used in the past, and allows a clear separation of technologies
and systems. Therefore, SOA is the underlying theme, but the practical
route forward is in building composite applications, and doing so using
tools that encompass the entire solution rather than just point
solutions based on a particular technology.