Seam 3 Modules

Seam 3 modules are Portable Extensions to CDI, which integrate CDI with other frameworks. The modules include:

• Drools
• Faces (JSF)
• International
• Security
• XML Bean Config
• Seam 2 Backwards Compatiblity
• Spring Intergration
• jBPM
• JAX-RS
• Servlet
• Transactions and Persistence
• Document Management
• Seam Application Framework
• JMS
• JBoss ESB
• Errai/GWT
• Remoting
• Scheduling
• Environment Configuration

API compatibility

We also need to decide which pluggable Java EE 6 APIs (JSF 2, JPA 2, JAX-WS, JAX-RS, Bean Validation, etc) Seam 3 will support in Servlet/Java SE/J2EE/Java EE 5 environments.

Prerequisite infrastructure

There is a core set of infrastructure that modules will need to be completed and consistent. We want to keep this set of functionality to a minimum, but without it, modules may either providing the same solution to a problem over and over again, or worse, solving the problem differently. Here is a list of the APIs or best practices that are required:

• Resource loading API - Any time a module needs to load a class or classpath resource, this API should be used
• BeanManager in servlet context - Putting the BeanManager into the servlet context would be much more portable than having to rely on JNDI.

Developer experience

Seam doesn't have to solve every problem in the world. Some of what Seam offers could be a collection of existing productivity-enhancing libraries (that we hand select). One example is project Lompok, which relieves the developer from having to write getters and setters by using annotation and an annotation processor. Another is a hot class reloader, which may come from another JBoss.org project. Yet another is Arquillian the test harness for Seam 3 modules and applications. These tools would be used/advocated in Seam examples.

Drools (led by Tihomir Surdilovic)

Drools is a state of the art rules engine. Using a rules engine you are able to decouple your application code from business rules:

1. Simplify the development of complex use cases
2. Improve business rules maintainability
3. Decrease turn-around times for business changes
4. Improve performance for complex set of rules
5. Close the gap between Business Users and IT

Drools provides:

1. Full Forward Chaining ReteOO algorithm
2. Multiple execution modes
3. Completely dynamic Knowledge Base management
4. Full support for Predicate Logic and First Order Logic
5. Complete set of flow control features
6. POJOs as facts (no mapping/data copy required)

The entire Drools API is available to you in a Seam application, however Seam allows you to easily and conveniently configure all major aspects of Drools:

Drools Expert is the core rules engine. Seam allows you to easily build Knowledge Packages, configure the KnowledgeBuilder and supports all Rule Resource Formats such as DRL (native), DSLs and spreadsheets. Having built your rules, you can easily deploy them (for example, via a Knowledge Agent providing automatic loading, caching and re-loading of resources). At runtime, you can access and query the Knowledge Session, modify facts in the working memory, access the Drools Pipeline (allow Drools to work with non Java data sources), or perform batch executions.

Drools Flow is a workflow engine that provides integrated of processes and rules. Seam gives you easy access to the build and execute work flows, as well as query the execution log.

Drools Fusion is a complex event processing engine. CE deals with the task of processing multiple events with the goal of identifying the meaningful events within a cloud of events. CEP employs techniques such as detection of complex patterns of many events, event correlation and abstraction, event hierarchies, and relationships between events such as causality, membership, and timing, and event-driven processes.

Using Seam with Drools fusion allows easy configuration of the clock, and TODO.

Drools Guvnor is a business rules management system, allows developer and business analysts to manage rules in a multi user environment, it is a single point of truth for your business rules, allowing change in a controlled fashion, with user friendly interfaces.

TODO what does Seam add?

Seam 2 backwards compatibility (lead needed)

The Seam 2 backward compatibility module enables CDI applications to consume legacy Seam components, allowing you to reuse application components written for the Seam 1 and Seam 2.

Spring integration (led by Marius Bogoevici)

Seam's Spring integration enables CDI applications to consume beans managed by a Spring IOC container, allowing you to reuse application components written for the Spring IOC framework.

Major themes will be:

• injection support
• native qualifier handling
• scope/context interoperability
• ability to work with Spring Transactions
• ability to share persistence contexts between the containers

jBPM support (led by Piotr Steininger with Joram Barez and Pete Muir)

Today's enterprise world rely on often large and complex sets of business processes to sustain and grow. These processes have traditionally been captured in visually (using diagrams of various styles) for comprehension and visibility. Several standards have evolved for process documentation however until several years ago, the ability to take the diagrams from the analysts' desk to developers' IDEs was missing. With the introduction of BPM tools such as jBPM and standardized process definition semantics such as jPDL, it has finally became possible to bridge that gap.

Some of the advantages of using jBPM and jPDL include:

• integrated development environment for both process modelers and developers
• separation of the what to do and how to do it concerns
• reduction of errors and defects arising from miscommunication or lack of up-to-date information (now code IS the documentation)
• higher adaptability to change (the ubiquitous constant in business)
• independence from the vendors and implementation
• suitability for agile development with blended and distributed teams

Many organizations have already taken advantage of the power and flexibility provided by jBPM. However, the integration of jBPM into many popular frameworks like Spring and EJB, has often proven challenging and cumbersome.

Seam offers substantial gains with built-in support for jBPM. The portable extension provides a set of annotation to declaratively demarcate events such as: creating of process instances, starting and resuming the execution or advancing execution through transitions. These operations typically involved writing many lines of boiler-plate code to handle references to the Process Virtual Machine. Now, with CDI programming model and Seam-BPM, one can create any POJO and let the container do the heavy lifting.

JAX-RS integration (led by Jozef Hartinger)

Seam integrates the RESTEasy implementation of the JAX-RS specification (JSR 311). You can decide how deep the integration into your Seam application is going to be:

• Seamless integration of RESTEasy bootstrap and configuration, automatic detection of resources and providers.
• Serving HTTP/REST requests with the SeamResourceServlet, no external servlet or configuration in web.xml required.
• Writing resources as Seam components, with full Seam lifecycle management and interception (bijection).

• Design notes

Document management (led by Nicklas Karlsson, with Norman Richards, Tomaz Cerar and Daniel Roth)

Seam offers various document management and reporting options based around JSF templates. Seam uses it's own copy of JSF, meaning you don't need to be inside the JSF lifecycle to render your documents.

Seam's Excel support allows for easy data-exporting through feature and formatting rich generation of Excel spreadsheets from xhtml templates or JSF datatables.

Seam's PDF support gives easy layout of PDF documents with JSF templates. Included is support for barcode generation.

Closely related is Seam Mail, allowing creation of JavaMail based emails from JSF templates.

Seam application framework (led by Gavin King)

Seam makes it really easy to create applications by writing plain Java classes with annotations, which don't need to extend any special interfaces or superclasses. But we can simplify some common programming tasks even further, by providing a set of pre-built components which can be re-used either by configuration in components.xml (for very simple cases) or extension.

The Seam Application Framework can reduce the amount of code you need to write when doing basic database access in a web application, using either Hibernate or JPA.

We should emphasize that the framework is extremely simple, just a handful of simple classes that are easy to understand and extend. The magic is in Seam itself — the same magic you use when creating any Seam application even without using this framework.

JBoss ESB 5 integration (led by Kev Connor and Pete Muir)

JBoss ESB integration is an oft-discussed goal for the medium term (we are waiting on JBoss ESB 5). Plans include the ability to use CDI beans as ESB components (or endpoints), as well as being able to send events CDI-style over the ESB.

Watch this space!

GWT via ErraiBus (led by Heiko Braun and Pete Muir)

Built on top of The Google Web Toolkit (GWT), Errai offers a seamless programming model that permeates across the client and server, and creates a whole new approach to thinking about web-based applications. ErraiBus provides common APIs across the client and server, using an event bus to communicate.

The CDI integration offers you the ability to use CDI beans as your server side components (allowing you access to aspects of the CDI's contextual dependency injection). Furthermore we aim to offer the ability to use CDI-style events inside the ErraiBus.

Scheduling (led by Pete Royle)

Seam's scheduling support allows easy job management through integration with Quartz allowing detection of already scheduled jobs, rescheduling and more. JDK timers and EJB timers are also supported for jobs requiring less options.

In the future, support for Drools timers may be added.

Environment configuration (led by Matt Corey)

Environment configuration provides ways to configure the Java EE environment by leveraging type-safe Java code rather than XML. It also allows you to leverage contextual information provided by the bean container to help influence configuration.

The first example of configuration is JNDI binding. Using this module, you can designate a field value that should be bound to JNDI under the provided name, the complement to the @Resource(lookup = "...") annotation in Java EE. You could put this bean in a separate archive from the production deployment, separating the production code from the configuration without leaving Java.