SeamFramework.orgCommunity Documentation

Seam 3

Bundled Reference Guide

1. Credits
1.1. List of contributors
1.2. Would you like to contribute?
2. Seam
2.1. Overview
2.2. Seam Bill of Materials
I. Solder
Introduction
3. Getting Started
3.1. Maven dependency configuration
3.2. Transitive dependencies
3.3. Pre-Servlet 3.0 configuration
4. Enhancements to the CDI Programming Model
4.1. Preventing a class from being processed
4.1.1. @Veto
4.1.2. @Requires
4.2. @Exact
4.3. @Client
4.4. Named packages
4.5. @FullyQualified bean names
5. Annotation Literals
6. Evaluating Unified EL
7. Resource Loading
7.1. Extending the Resource Loader
8. Logging, redesigned
8.1. JBoss Logging: The foundation
8.2. Solder Logging: Feature set
8.3. Typed loggers
8.4. Native logger API
8.5. Typed message bundles
8.6. Implementation classes
8.6.1. Generating the implementation classes
8.6.2. Including the implementation classes in Arquillian tests
9. Annotation and AnnotatedType Utilities
9.1. Annotated Type Builder
9.2. Annotation Instance Provider
9.3. Annotation Inspector
9.4. Synthetic Qualifiers
9.5. Reflection Utilities
10. Obtaining a reference to the BeanManager
11. Bean Utilities
12. Properties
12.1. Working with properties
12.2. Querying for properties
12.3. Property Criteria
12.3.1. AnnotatedPropertyCriteria
12.3.2. NamedPropertyCriteria
12.3.3. TypedPropertyCriteria
12.3.4. Creating a custom property criteria
12.4. Fetching the results
13. Unwrapping Producer Methods
14. Default Beans
15. Generic Beans
15.1. Using generic beans
15.2. Defining Generic Beans
16. Service Handler
17. XML Configuration Introduction
17.1. Getting Started
17.2. The Princess Rescue Example
18. Solder Config XML provider
18.1. XML Namespaces
18.2. Adding, replacing and modifying beans
18.3. Applying annotations using XML
18.4. Configuring Fields
18.4.1. Initial Field Values
18.4.2. Inline Bean Declarations
18.5. Configuring methods
18.6. Configuring the bean constructor
18.7. Overriding the type of an injection point
18.8. Configuring Meta Annotations
18.9. Virtual Producer Fields
18.10. More Information
Introduction
19. Installation
19.1. Pre-Servlet 3.0 configuration
20. Servlet event propagation
20.1. Servlet context lifecycle events
20.2. Application initialization
20.3. Servlet request lifecycle events
20.4. Servlet response lifecycle events
20.5. Servlet request context lifecycle events
20.6. Session lifecycle events
20.7. Session activation events
21. Injectable Servlet objects and request state
21.1. @Inject @RequestParam
21.2. @Inject @HeaderParam
21.3. @Inject ServletContext
21.4. @Inject ServletRequest / HttpServletRequest
21.5. @Inject ServletResponse / HttpServletResponse
21.6. @Inject HttpSession
21.7. @Inject HttpSessionStatus
21.8. @Inject @ContextPath
21.9. @Inject List<Cookie>
21.10. @Inject @CookieParam
21.11. @Inject @ServerInfo
21.12. @Inject @Principal
22. Servlet Exception Handling Integration
22.1. Background
22.2. Defining a exception handler for a web request
23. Retrieving the BeanManager from the servlet context
24. Exception Handling - Introduction
24.1. How Solder's Exception Handling Works
25. Exception Handling - Usage
25.1. Eventing into the exception handling framework
25.1.1. Manual firing of the event
25.1.2. Using the @ExceptionHandled Interceptor
25.2. Exception handlers
25.3. Exception handler annotations
25.3.1. @HandlesExceptions
25.3.2. @Handles
25.4. Exception chain processing
25.5. Exception handler ordering
25.5.1. Traversal of exception type hierarchy
25.5.2. Handler precedence
25.6. APIs for exception information and flow control
25.6.1. CaughtException
25.6.2. ExceptionStack
26. Exception handling - Advanced Features
26.1. Exception Modification
26.1.1. Introduction
26.1.2. Usage
26.2. Filtering Stack Traces
26.2.1. Introduction
26.2.2. ExceptionStackOutput
26.2.3. StackFrameFilter
26.2.4. StackFrameFilterResult
26.2.5. StackFrame
27. Exception Handling - Framework Integration
27.1. Creating and Firing an ExceptionToCatch event
27.2. Default Handlers and Qualifiers
27.2.1. Default Handlers
27.2.2. Qualifiers
27.3. Supporting ServiceHandlers
27.4. Programmatic Handler Registration
Exception Handling - Glossary
II. Seam Persistence
28. Seam Persistence Reference
28.1. Introduction
28.2. Getting Started
28.3. Transaction Management
28.3.1. Configuration
28.3.2. Declarative Transaction Management
28.4. Seam-managed persistence contexts
28.4.1. Using a Seam-managed persistence context with JPA
28.4.2. Seam-managed persistence contexts and atomic conversations
28.4.3. Using EL in EJB-QL/HQL
28.4.4. Setting up the EntityManager
III. Seam Transaction
29. Seam Transaction Reference
29.1. Introduction
IV. Seam Security
30. Security - Introduction
30.1. Overview
30.1.1. Authentication
30.1.2. Identity Management
30.1.3. External Authentication
30.1.4. Authorization
30.2. Configuration
30.2.1. Maven Dependencies
30.2.2. Enabling the Security Interceptor
30.2.3. Third Party Dependencies
31. Security - Authentication
31.1. Basic Concepts
31.2. Built-in Authenticators
31.3. Which Authenticator will Seam use?
31.4. Writing a custom Authenticator
32. Security - Identity Management
32.1. Overview
32.2. Configuring Seam to use Identity Management
32.3. Using the Identity Management Features
32.3.1. Managing Users and Groups
32.3.2. Managing Relationships
32.3.3. Managing Roles
32.4. JpaIdentityStore
32.4.1. Recommended database schema
32.4.2. Configuring JpaIdentityStore
32.4.3. Configuring your Entities
33. Security - External Authentication
33.1. Introduction
33.1.1. Configuration
33.2. OpenID
33.2.1. Overview
33.2.2. Enabling OpenID for your application
33.2.3. Choosing which OpenID provider to use
33.2.4. Managing the OpenID authentication process
34. Security - Authorization
34.1. Basic Concepts
34.1.1. IdentityType
34.1.2. User
34.1.3. Group
34.1.4. Role
34.1.5. RoleType
34.2. Role and Group-based authorization
34.3. Typesafe authorization
34.3.1. Creating a typesafe security binding
34.3.2. Creating an authorizer method
34.3.3. Applying the binding to your business methods
34.3.4. Built-in security binding annotations
V. Seam International
Introduction
35. Installation
36. Locales
36.1. Application Locale
36.2. User Locale
36.3. Available Locales
37. Timezones
37.1. Joda Time
37.2. Application TimeZone
37.3. User TimeZone
37.4. Available TimeZones
38. Messages
38.1. Message Creation
38.2. Properties Files
VI. Seam Faces
Introduction
39. Installation
39.1. Maven dependency configuration
39.2. Pre-Servlet 3.0 configuration
39.3. How to setup JSF in a Java EE 6 webapp
40. Faces Events Propagation
40.1. JSF Phase events
40.1.1. Seam Faces Phase events
40.1.2. Phase events listing
40.2. JSF system events
40.2.1. Seam Faces System events
40.2.2. System events listing
40.2.3. Component system events
41. Faces Scoping Support
41.1. @RenderScoped
41.2. @Inject javax.faces.context.Flash flash
41.3. @ViewScoped
42. Messages API
42.1. Adding Messages
42.2. Displaying pending messages
43. Faces Artifact Injection
43.1. @*Scoped and @Inject in Validators and Converters
43.2. @Inject'able Faces Artifacts
44. Seam Faces Components
44.1. Introduction
44.2. <s:validateForm>
44.3. <s:viewAction>
44.3.1. Motivation
44.3.2. Usage
44.3.3. View actions vs the PreRenderViewEvent
44.4. UI Input Container
VII. Seam Reports
Introduction
45. Installation
45.1. Installation using Seam Forge
45.1.1. Plugin Installation
45.1.2. Plugin Configuration
46. Usage
VIII. Seam Mail
47. Seam Mail Introduction
47.1. Getting Started
IX. Seam Remoting
48. Seam Remoting - Basic Features
48.1. Configuration
48.1.1. Dynamic type loading
48.2. The "Seam" object
48.2.1. A Hello World example
48.2.2. Seam.createBean
48.3. The Context
48.3.1. Setting and reading the Conversation ID
48.3.2. Remote calls within the current conversation scope
48.4. Working with Data types
48.4.1. Primitives / Basic Types
48.4.2. JavaBeans
48.4.3. Dates and Times
48.4.4. Enums
48.4.5. Collections
48.5. Debugging
48.6. Handling Exceptions
48.7. The Loading Message
48.7.1. Changing the message
48.7.2. Hiding the loading message
48.7.3. A Custom Loading Indicator
48.8. Controlling what data is returned
48.8.1. Constraining normal fields
48.8.2. Constraining Maps and Collections
48.8.3. Constraining objects of a specific type
48.8.4. Combining Constraints
49. Seam Remoting - Model API
49.1. Introduction
49.2. Model Operations
49.3. Fetching a model
49.3.1. Fetching a bean value
49.4. Modifying model values
49.5. Expanding a model
49.6. Applying Changes
50. Seam Remoting - Bean Validation
50.1. Validating a single object
50.2. Validating a single property
50.3. Validating multiple objects and/or properties
50.4. Validation groups
50.5. Handling validation failures
X. Seam REST
Introduction
51. Installation
51.1. Basics
51.2. Transitive dependencies
51.3. Registering JAX-RS components explicitly
51.4. Servlet container support
52. Exception Handling
52.1. Seam Catch Integration
52.2. Declarative Exception Mapping
52.2.1. Annotation-based configuration
52.2.2. XML configuration
52.2.3. Declarative exception mapping processing
53. Bean Validation Integration
53.1. Validating HTTP requests
53.1.1. Validating entity body
53.1.2. Validating resource fields
53.1.3. Validating other method parameters
53.2. Validation configuration
53.3. Using validation groups
54. Templating support
54.1. Creating JAX-RS responses using templates
54.1.1. Accessing the model
54.2. Built-in support for templating engines
54.2.1. FreeMarker
54.2.2. Apache Velocity
54.2.3. Pluggable support for templating engines
54.2.4. Selecting preferred templating engine
55. RESTEasy Client Framework Integration
55.1. Using RESTEasy Client Framework with Seam REST
55.2. Manual ClientRequest API
55.3. Client Executor Configuration
56. Seam REST Dependencies
56.1. Transitive Dependencies
56.2. Optional dependencies
56.2.1. Seam Catch
56.2.2. Seam Config
56.2.3. FreeMarker
56.2.4. Apache Velocity
56.2.5. RESTEasy
XI. Seam JCR
57. Seam JCR - Introduction
57.1. Introduction
57.2. Maven dependency configuration
58. Seam JCR - JBoss ModeShape Integration
58.1. ModeShape Integration Installation
58.2. Usage
59. Seam JCR - JackRabbit Integration
59.1. JackRabbit Integration Installation
59.2. Usage
60. Seam JCR - Event Mapping
60.1.
60.2.
61. Seam JCR - Object Content Mapping
61.1. What is Object Content Mapping?
61.2. Mapping and Conversion Capabilities
61.3. JCR Data Access Objects
XII. Seam JMS
62. Introduction
62.1. Mission statement
62.2. Seam 3 JMS Module Overview
63. Installation
64. Resource Injection
64.1. JMS Resource Injection
64.1.1. Destination Based Injection
64.1.2. Resource Configuration
64.2. Module Extensions
65. Messaging API
65.1. QueueBuilder and TopicBuilder
65.2. Message Manager
65.3. Durable Messaging Capabilities
65.4. MessageListeners versus Message Driven Beans
66. Bridging the Gap
66.1. Event Routing
66.1.1. Routes
66.1.2. @EventRouting
66.2. Routing CDI Events to JMS
66.2.1. Usage
66.3. CDI Events from JMS Messages
66.3.1. Usage
67. Annotation Routing APIs
67.1. Observer Method Interfaces
XIII. Seam Validation
68. Introduction
69. Installation
69.1. Prerequisites
69.2. Maven setup
69.3. Manual setup
70. Dependency Injection
70.1. Retrieving of validator factory and validators via dependency injection
70.2. Dependency injection for constraint validators
71. Method Validation
XIV. Seam Social
Introduction
72. Getting Started
72.1. Building
72.2. Usage big picture
72.3. Starting with OAuth configuration
72.3.1. Create an OAutConfigSettings bean thru Seam configuration (in bean.xml)
72.3.2. Adding the @ConfigureOAuth annotation when injecting the OAuth service bean
72.4. Inject an OAuthService bean with one of the following ways :
72.5. Request the Authorization URL for the service and redirect the app to this url
72.6. Store the verifier in OAuthService bean and init access token
72.7. After what we can send calls to the service
72.8. Testing
XV. Seam Wicket
Introduction
73. Installation
74. Seam for Apache Wicket Features
74.1. Injection
74.2. Conversation Control
74.3. Conversation Propagation