Help

Built with Seam

You can find the full source code for this website in the Seam package in the directory /examples/wiki. It is licensed under the LGPL.

This page is deprecated. Please refer to the the Seam 3 project page for a complete list of modules.

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

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).

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.

14 comments:
 
07. Dec 2009, 07:03 America/New_York | Link

Is removing pages.xml a good idea? I know jsf has metadata facets now but pages.xml lets you assign actions/parameters/restrictions etc to lots of pages at once using widcards, will there be some kind of replacement for that functionality?

 
09. Dec 2009, 19:02 America/New_York | Link

Good question. I like pages.xml, but it can grow enormously and become hard to manage (even for small sites). Having a separate page configuration for each page might be overkill. I don't have that many entries, but it becomes cumbersome to find and change stuff and more error prone.

I like the flexibility of XML, but I like keeping everything in a database for generating reports later. Is it possible we can have a page entity with support for annotations similar to the way the security/identity management currently works? That way, we can define our own page entities any way we see fit while sticking to a pre-defined format / interface. Or, can a base class be provided in which we can extend?

To make the transition easier, can we have support for inserting these records into the database with a page manager which reads pages.xml or *.page.xml and creates a page entity in the db (or creates the corresponding SQL statements so this pojo isn't needed at runtime)?

Walter

 
13. Dec 2009, 05:58 America/New_York | Link
Walter, we may be thinking of the same thing, but take it a step further and give us an engine that we could use to create our own interpreter support pages.xml and *.page.xml. Then could create other things like annotation processors, reading this data from the database, etc. That would allow maximum flexibility and could be very powerful (especially the annotation processor idea).
 
15. Dec 2009, 14:34 America/New_York | Link

Yup, Jason is thinking along the right lines - the idea is to step back a bit from the xml format...

 

Read about how to report a bug.

 
15. Dec 2009, 15:28 America/New_York | Link
gonzalad

Hello,

Xml format or not, I have also the same need as Stuart : using wilcard for pages.

We have a few application using the following directives for instance :

<page view-id="/views/*" login-required="true">
  <begin-conversation join="true"/>
</page>

or

<page view-id="/global/*">
  <action execute="#{conversationHelper.endRootConversation}"/>
</page>

Will I be able to achieve the same thing using Seam 3 ?

Thanks very much ! We're eagerly waiting for Seam 3 release here.

 
16. Dec 2009, 03:44 America/New_York | Link

Scheduling module should probably be included as well. Haven't look at the one in the sandbox, but here's some features that would be nice (all assuming Quartz):

  • Support for Quartz's StatefulJob
  • Easy job management (delete, stop, reschedule, etc). We need control over job/group names for this
  • Automatically check if job is already scheduled and don't reschedule if it is (for use with persistent job stores)
  • Simple? workflow support (somehow use Drools?). Seam-batch?

Btw, how to nest bullets with this Wiki?

 
16. Dec 2009, 03:56 America/New_York | Link

Some ideas for JMS

  • JMS resource injection should really use the 1.1 API's: Connection, Session, MessageProducer, etc. Having separate ones for queues/topics just feels wrong.
  • 'Broadcast' events -- received by all sessions (is this already in Weld?)
  • Transparent inter-app communication with events would be really nice. Even better if it works without MDB's. (Tomcat/Jetty)
  • Message broker integration (ActiveMQ?). For use with Tomcat.
 
16. Dec 2009, 12:58 America/New_York | Link

Yeah, the idea of having a SeamConfiguration that you could just inject or override would be nice. Of course, you could also have the XML at some point but that would just be for assembly of said object...

 

If a man speaks in the forest and there is no woman around to hear him, is he still wrong?

 
16. Dec 2009, 13:07 America/New_York | Link
Nikolay Elenkov wrote on Dec 16, 2009 03:44:
Scheduling module should probably be included as well.

Good point, added :-)

Btw, how to nest bullets with this Wiki?

I was wondering the same, I guess you can't, without resorting to html...

 

Read about how to report a bug.

 
16. Dec 2009, 13:56 America/New_York | Link

It would be cool to have a performance module by integrating Perf4J with CDI interceptors...

http://perf4j.codehaus.org/

 

If a man speaks in the forest and there is no woman around to hear him, is he still wrong?

 
03. Jan 2010, 23:31 America/New_York | Link
Alberto Gori
Stuart Douglas wrote on Dec 07, 2009 07:03:
Is removing pages.xml a good idea? I know jsf has metadata facets now but pages.xml lets you assign actions/parameters/restrictions etc to lots of pages at once using widcards, will there be some kind of replacement for that functionality?

What about a typesafe solution based on annotations? I think the purpose here is to remove the unsafe expression language from our code. I think this is possible thanks to annotations and CDI. A small example:

public void homePageAction(@Observes @Rendered("/home.xhtml") View view, 
                           @HttpParam("id") Integer id) {
...
view.redirectTo("/error.xhtml");
}
 
15. Feb 2010, 17:24 America/New_York | Link
Gauthier Peel | gpeel.AT.sopragroup.com
Hello,
I would like the nested conversations of seam 2 very much !
Is this functionnality inlcuded inside another item (Faces maybe)
 
24. Feb 2010, 21:49 America/New_York | Link
Arbi Sookazian
However our main focus is now on developing Seam 3, a collection of portable extensions for CDI and Java EE 6!

http://in.relation.to/14435.lace

So with the above statement and with the recent acquisition of the legendary Lincoln Baxter III (http://in.relation.to/14386.lace), does this mean the Seam dev team will actually start answering questions (consistently) in the Seam forum again???

 
04. Mar 2010, 18:37 America/New_York | Link
However our main focus is now on developing Seam 3, a collection of portable extensions for CDI and Java EE 6!

We're certainly going to do our best!

Legendary? Now you don't hear that every day ;)