CDI, Weld and the future of Seam

CDI (JSR-299), Weld andthe future of Seam

Dan AllenSenior Software EngineerJBoss by Red Hat

2 CDI (JSR-299), Weld and the future of Seam | Dan Allen

Who am I?

● Author of Seam in Action, Manning 2008

● Seam Community Liaison

● Weld, Seam & Arquillian project member

● JSR-314 (JSF 2) EG representative

● Open Source advocate

mojavelinux

Agenda

● Terminology

● Why JSR-299?

● JSR-299 themes

● Brief tour of programming model

● Weld

● Seam

Technology terminology

● CDI (JSR-299)● Contexts & dependency injection for Java EE

● Weld● JSR-299 Reference Implementation & TCK● Extended CDI support (Servlets, Java SE)● CDI enhancements for extension writers● Maven archetypes for CDI and Java EE

● Seam 3● Portable extensions for Java EE● Integrations with non-Java EE technologies

Stated goal of JSR-299

Web tier(JSF)

Transactional tier(EJB)

Why reinvest?

Seam 2

Java EE 5

What CDI provides

● Services for Java EE components● Lifecycle management of stateful beans bound to

well-defined contexts (including conversation context)● A type-safe approach to dependency injection● Interaction via an event notification facility● Reduced coupling between interceptors and beans● Decorators, which intercept specific bean instances● Unified EL integration (bean names)

● SPI for developing extensions for the Java EE platform● Java EE architecture flexible, portable, extensible

What CDI provides

● Services for Java EE components● Lifecycle management of stateful beans bound to

well-defined contexts (including conversation context)● A type-safe approach to dependency injection● Interaction via an event notification facility● Reduced coupling between interceptors and beans● Decorators, which intercept specific bean instances● Unified EL integration (bean names)

● SPI for developing extensions for the Java EE platform● Java EE architecture flexible, portable, extensible

CDI: The big picture

● Fill in

● Catalyze

● Evolve

Why injection?

● Weakest aspect of Java EE 5

● Fixed set of injectable resources● @EJB● @PersistenceContext, @PersistenceUnit● @Resource (e.g., DataSource, UserTransaction)

● Name-based injection is fragile● Not “refactor friendly”● Requires special tooling to validate

JSR-299 theme

Loose coupling...

...with strong typingstrong typing

@Inject@Observes

@InterceptorBinding

@Qualifier

Event<Order>

@Produces @WishListList<Product> getWishList()

@UserDatabase EntityManager

Loose coupling

● Decouple server and client● Using well-defined types and “qualifiers”● Allows server implementation to vary

● Decouple lifecycle of collaborating components● Automatic contextual lifecycle management● Stateful components interact like services

● Decouple orthogonal concerns (AOP)● Interceptors & decorators

● Decouple message producer from consumer● Events

StrongStrong typing typing

● Type-based injection● Eliminate reliance on string-based names

● Compiler can detect typing errors● No special authoring tools required● Casting mostly eliminated

● Semantic code errors detected at application startup● Tooling can detect ambiguous dependencies

Leverage and extend Java’s type system

@Annotation

This information is pretty useful!

Who's bean is it anyway?

● Everyone throwing around this term “bean”● JSF● EJB● Seam● Spring● Guice● CDI

● Need a “unified bean definition”

Managed bean specification

● Common bean definition

● Instances are managed by the container

● Common services● Interceptors● Resource injections● Lifecycle callbacks

● Foundation spec

How managed beans evolved: http://www.infoq.com/news/2009/11/weld10

JSF EJB CDI JAX-RS

ManagedBeans

CDI bean ingredients

● Auto-discovered

● Set of bean types

● Set of qualifiers

● Scope

● Bean EL name (optional)

● Set of interceptor bindings

● Alternative classification

● Bean implementation class

Welcome to CDI, managed beans!

public class Welcome { public String buildPhrase(String city) { return "Welcome to " + city + "!"; } }

Welcome to CDI, EJB 3.1 session beans!

@Stateless public class Welcome { public String buildPhrase(String city) { return "Welcome to " + city + "!"; } }

When is a bean recognized?

● Bean archive (WAR) ● Bean archive (JAR)

beans.xml can be empty!

Injection 101

public class Greeter { @Inject Welcome w;

public void welcome() { System.out.println( w.buildPhrase("Reston")); }}

@Default qualifier implied@Default qualifier implied

Where can it be injected?

● Field

● Method parameter● Constructor*● Initializer● Producer● Observer

What can be injected?

Managed bean

Object returned by producer

EJB session bean (local or remote)

Java EE resource (DataSource, JMS destination, etc)

JTA UserTransaction

Persistence unit or context

Security principle

Bean Validation factory

Web service reference

Additional resources introduced through SPI

The bean vs “the other implementation”

● Multiple implementations of same interface

● One implementation extends anotherpublic class Welcome { public String buildPhrase(String city) { return "Welcome to " + city + "!"; } }

public class TranslatingWelcome extends Welcome {

@Inject GoogleTranslator translator;

public String buildPhrase(String city) { return translator.translate( "Welcome to " + city + "!"); } }

Quiz: Now which implementation gets injected?

public class Greeter { private Welcome welcome; @Inject void init(Welcome welcome) { this.welcome = welcome; }

It's ambiguous!

Settling an ambiguous resolution

● Qualifier

● Alternative

● Hide bean types

qualifier

n. an annotation used to resolve an APIimplementation variant at an injection point

Defining a qualifier

● A qualifier is an annotation@Qualifier@Retention(RUNTIME)@Target({TYPE, METHOD, FIELD, PARAMETER})public @interface Translating {}

Qualifying an implementation

● Adding a qualifier annotation:● makes type more specific● assigns semantic meaning

@Translatingpublic class TranslatingWelcome extends Welcome {

public String buildPhrase(String city) { return translator.translate( "Welcome to " + city + "!"); } }

Qualifier as a “binding type”

Using a specific implementation

● Qualified implementation must be requested explicitly● Akin to the factory method pattern

● Resolves ambiguity at injection point!public class Greeter { private Welcome welcome;

@Inject void init(@Translating Welcome welcome) { this.welcome = welcome }

public void welcomeVisitors() { System.out.println( welcome.buildPhrase("Reston")); }}

No reference to implementation class!No reference to implementation class!

Alternative bean

● Swap replacement implementation per deployment

● Replaces bean and its producer methods and fields

● Disabled by default● Must be activated in /META-INF/beans.xml

Put simply: an override

Defining an alternative

@Alternativepublic class TranslatingWelcome extends Welcome {

public String buildPhrase(String city) { return translator.translate( "Welcome to " + city + "!"); }}

Substituting the alternative

● Implementation must be activated using beans.xml<beans> <alternatives> <class>com.acme.TranslatingWelcome</class> </alternatives></beans>

Assigning a bean name

@Named("greeter")public class Greeter { private Welcome welcome;

@Inject void init(Welcome welcome) { this.welcome = welcome; }

Assigning a bean name by convention

@Namedpublic class Greeter { private Welcome welcome;

@Inject void init(Welcome welcome) { this.welcome = welcome; }

Bean name is decapitalizedsimple class name Bean name is decapitalizedsimple class name

Welcome to CDI, JSF!

● Use the bean directly in the JSF view<h:form> <h:commandButton value="Welcome visitors" action="#{greeter.welcomeVisitors}"/></h:form>

JSFmanaged

Facelets

Stashing the bean in a context

● Bean saved for the duration of a request@RequestScoped@Named("greeter")public class Greeter { private Welcome welcome; private String city; // getter and setter hidden

@Inject void init(Welcome welcome) { this.welcome = welcome }

public void welcomeVisitors() { System.out.println(welcome.buildPhrase(city)); }}

Collapsing layers with state management

● Now it’s possible for bean to hold state<h:form> <h:inputText value="#{greeter.city}"/> <h:commandButton value="Welcome visitors" action="#{greeter.welcomeVisitors}"/></h:form>

● Satisfies initial goal of JSR-299● ...in fact, integrates JSF and any managed bean

Scope types and contexts

● Absence of scope - @Dependent● Bound to lifecycle of bean holding reference

● Servlet scopes● @ApplicationScoped● @RequestScoped● @SessionScoped

● JSF conversation scope - @ConversationScoped

● Custom scopes● Define scope type annotation (e.g., @FlashScoped)● Implement the context API in an extension

Scope transparency

● Scopes not visible to client● No coupling between scope and use of type● Scoped beans are proxied for thread safety

Conversation context

● Request <= Conversation << Session

● Boundaries demarcated by application

● Optimistic transaction● Conversation-scoped persistence context● No fear of exceptions on lazy fetch operations

Controlling the conversation

@ConversationScopedpublic class BookingAgent {

@Inject @BookingDatabase EntityManager em; @Inject Conversation conversation;

private Hotel selected; private Booking booking;

public void select(Hotel h) { selected = em.find(Hotel.class, h.getId()); conversation.begin(); }

Controlling the conversation

public boolean confirm() { if (!isValid()) { return false; }

em.persist(booking); conversation.end(); return true; }}

producer method

n. a method whose return value producesan injectable object

Producer method examples

@Produces @RequestScopedpublic FacesContext getFacesContext() { return FacesContext.getInstance();}

@Producespublic PaymentProcessor getPaymentProcessor( @Synchronous PaymentProcessor sync, @Asynchronous PaymentProcessor async) { return isSynchronous() ? sync : async;}

@Produces @SessionScoped @WishListpublic List<Product> getWishList() { return em.createQuery("...").getResultList();}

From non-beanFrom non-bean

Runtime selectionRuntime selection

Custom setupCustom setup

Bridging Java EE resources

● Use producer field to expose Java EE resource@Statelesspublic class UserEntityManagerProducer { @Produces @UserRepository @PersistenceContext(unitName = "userPU") EntityManager em;}

@Statelesspublic class PricesTopicProducer { @Produces @Prices @Resource(name = "java:global/env/jms/Prices") Topic pricesTopic;}

Injecting resource in type-safe way

● String-based resource names are hiddenpublic class UserManager { @Inject @UserRepository EntityManager userEm; ...}

public class StockDisplay { @Inject @Prices Topic pricesTopic; ...}

Rethinking interceptors

@Interceptors( SecurityInterceptor.class, TransactionInterceptor.class, LoggingInterceptor.class)@Stateful public class BusinessComponent { ...}

Um, what's the point?

Interceptor wiring in JSR-299 (1)

● Define an interceptor binding type@InterceptorBinding@Retention(RUNTIME)@Target({TYPE, METHOD})public @interface Secure {}

● Marking the interceptor implementation@Secure@Interceptorpublic class SecurityInterceptor {

@AroundInvoke public Object aroundInvoke(InvocationContext ctx) throws Exception { // ...enforce security... ctx.proceed(); }

● Applying interceptor with proper semantics@Securepublic class AccountManager {

public boolean transfer(Account a, Account b) { ... }

Multiple interceptors

● Application developer only concerned about semantics@Transactionalpublic class AccountManager {

@Secure public boolean transfer(Account a, Account b) { ... }

Enabling and ordering interceptors

● Bean archive has no enabled interceptors by default

● Interceptors activated in beans.xml of bean archive● Referenced by binding type● Ordering is per-module● Declared in module in which the interceptor is used

<beans> <interceptors> <class>com.acme.SecurityInterceptor</class> <class>com.acme.TransactionInterceptor</class> </interceptors></beans>

Interceptors applied in order listedInterceptors applied in order listed

Composite interceptor bindings

● Interceptor binding types can be meta-annotationspublic@Secure@Transactional@InterceptorBinding@Retention(RUNTIME)@Target(TYPE)@interface BusinessOperation {}

Order does not matterOrder does not matter

Multiple interceptors (but you won’t know it)

● Interceptors inherited from composite binding typespublic@BusinessOperationclass AccountManager {

Wrap up annotations using stereotypes

● Common architectural patterns – recurring roles

● A stereotype packages:● A default scope● A set of interceptor bindings● The ability to that beans are named● The ability to specify that beans are alternatives

Annotation jam!

● Without stereotypes, annotations pile uppublic@Secure@Transactional@RequestScoped@Namedclass AccountManager {

Defining a stereotype

● Stereotypes are annotations that group annotationspublic@Secure@Transactional@RequestScoped@Named@Stereotype@Retention(RUNTIME)@Target(TYPE)@interface BusinessComponent {}

Using a stereotype

● Stereotypes give a clear picture, keep things simplepublic@BusinessComponentclass AccountManager {

Events

● Completely decouple action and reactions

● Selectors tune which event notifications are received

● Can be observed:● immediately,● after transaction completion or● asynchronously (via extension)

Firing an event

public class GroundController { @Inject @Landing Event<Flight> flightLanding;

public void clearForLanding(String flightNum) { flightLanding.fire(new Flight(flightNum)); }}

Event instance withtype-safe payloadEvent instance withtype-safe payload

An event observer

public class GateServices { public void onIncomingFlight( @Observes @Landing Flight flight, Greeter greeter, CateringService cateringService) { Gate gate = ...; flight.setGate(gate); cateringService.dispatch(gate); greeter.welcomeVisitors(); }}

Takes event API type withadditional binding typeTakes event API type withadditional binding type

Additional parameters areinjected by the containerAdditional parameters areinjected by the container

Weld: JSR-299 Reference Implementation

● Developed under Seam project umbrella

● Version 1.0.1 available

● Bundled in JBoss AS 6 & GlassFish V3

● Support for Tomcat, Jetty & Java SE

● CDI enhancements & utilities for extension writers

● Maven archetypes for CDI & Java EE

Seam’s mission statement

To provide a fully integrated development

platform for building rich Internet applicationsbased upon the Java EE environment.

Seam 3: Key themes

● Portability● Portable extensions run on any CDI implementation

● Modularity (i.e., Seam à la carte)● Module per integration● Individual module leads● Independent release cycles

● “Stack” releases

● Strong tooling● Java compiler● JBoss Tools

Seam's new modular ecosystem

What's on the menu so far?

● Drools

● JMS

● Faces

● International

● Persistence

● JavaScript Remoting

● Security

● Servlet

● Wicket

● XML configuration

...and more http://sfwk.org/Seam3

XML-based configuration

● Define, specialize or override beans

● Add annotations (qualifiers, interceptor bindings, ...)

● Assign initial property values

End-to-end testing for Java EE

● SeamTest replacement

● ShrinkWrap● Fluent API for creating Java archives

JavaArchive archive = ShrinkWrap.create("archive.jar", JavaArchive.class) .addClasses(MyClass.class, MyOtherClass.class) .addResource("mystuff.properties");

● Arquillian● Integration test harness● Pluggable container support (embedded or remote)● Supports injection into test class● Tests can be run from IDE or build script

Summary

● JSR-299 provides a set of services for Java EE● Bridges JSF and EJB● Offers loose coupling with strong typingstrong typing● Catalyzed managed bean & interceptor specifications

● Extensive SPI for third-party integration with Java EE

● Weld: JSR-299 Reference Implementation

● Seam 3: Portable extensions for Java EE

How do I get started with CDI or Java EE 6?

● Seam 3 projecthttp://seamframework.org/Seam3

● Weld Maven archetypes for CDI and Java EEhttp://tinyurl.com/goweld

● Weld reference guidehttp://tinyurl.com/weld-reference-101

● CDI JavaDochttp://docs.jboss.org/cdi/api/latest/

● Any Java EE 6 container!

Dan AllenSenior Software EngineerJBoss, by Red Hat

http://in.relation.tohttp://seamframework.org/Seam3

CDI, Weld and the future of Seam

Technology

Transcript of CDI, Weld and the future of Seam

Through Seam Blasting_bahasa

Tutorial JBoss Seam

2 Pred VK 5 Statika zvarov.ppt - lab.fs.uni-lj.silab.fs.uni-lj.si/.../VK_2_Pred_2pros_5_Statika_zvarov.pdf · 2 3 V A R J E N I (ZVARNI) S P O J I (angleško: weld(ed) joint (seam),

WELD - AlmaAsco

Weld Reference

Sys Weld 2012

Sonic Weld

Standing Seam Technology Installation Guideline · standing seam technology, design and application standing seam technology, design and application 3. seamed roof coverings 3.1 roof

Seam framework in_action

Thermal Weld Seam Inspection in Pipe Production Lines · PDF fileThermal Weld Seam Inspection in Pipe Production Lines ... Laser and HFI welding are used. ... with a saw signal

TDC 2008 JBoss Seam

Weld processes.ppt

Maret 2013 SEAM LEC

Kumwell Exothermic Weld

kasipkor.kzkasipkor.kz/wp-content/uploads/2016/09/41-Foundry-par… · Web viewMethods and means of control for slick cylinder and bevel ... Weld seam quality control ... – One

Passaggi seam

STANDING SEAM - INICIO

HD-CR 35 NDT • The market leader for high quality CR HD-CR ... · Weld seam inspection Film quality - and better. Aerospace External Battery Pack Battery solution for autonomous

JBossinBossa 2010 - Seam

CDI - Unindo Seam, Spring e Guice