Group items tagged

AS3 Date

deserialized as java.util.Date

Event Bus

Contextual Components and Conversations

Contexts and Components

two main kinds of contexts:

unique context that exists during the whole lifetime of the Flex application

compared to to the server-side session

temporary contexts that can be created and destroyed at any time during the lifetime of the application

can exist simultaneously

isolated from each other

Components are stateful objects that can be of any ActionScript 3 class with a default constructor

have a name

A context is mostly a container for component instances

three available scopes:

in detail.

Class as parameter

serverside

Remote call using class as parameter

Does GraniteDS could manage date and TimeZone ?

Flash Player (GMT +X) -> IExternizable methods (GMT + X - X = GMT + 0) - > AMF over HTTP (GMT + 0) -> Granite AMF0Deserializer (GMT + 0) -> Granite Converter (GMT + 0 + Y = GMT + Y) -> Java Services (GMT + Y)Java Services (GMT + Y) -> Granite Converter (GMT + Y - Y = GMT + 0) -> Granite AMF0Deserializer (GMT + 0) -> AMF over HTTP (GMT + 0) -> IExternizable methods (GMT + 0 + X = GMT + X) -> Flash Player (GMT + X)

We use

for AMF for convention

define a

for your AMF that is over HTTP

: timezone for your flex client

: timezone for your server

don't want to modify the default templates

Stateless beans must have a dependent scope while a stateful session bean can have any scope. By default they are transactional, but you can use the transaction attribute annotation.

CDI beans can be injected into EJBs and EJBs can be injected into CDI beans

When to use which bean How do you know when to use which bean? Simple.

In general, you should use CDI beans unless you need the advanced functionality available in the EJBs such as transactional functions. You can write your own interceptor to make CDI beans transactional, but for now, its simpler to use an EJB until CDI gets transactional CDI beans which is just around the corner

Comparing JSF Beans, CDI Beans and EJBs

JSF Managed Beans

In short, don’t use them if you are developing for Java EE 6 and using CDI. They provide a simple mechanism for dependency injection and defining backing beans for web pages, but they are far less powerful than CDI beans.

JSF beans cannot be mixed with other kinds of beans without some kind of manual coding.

CDI Beans

includes a complete, comprehensive managed bean facility

interceptors, conversation scope, Events, type safe injection, decorators, stereotypes and producer methods

JSF-like features, you can define the scope of the CDI bean using one of the scopes defined in the javax.enterprise.context package (namely, request, conversation, session and application scopes). If you want to use the CDI bean from a JSF page, you can give it a name using the javax.inject.Named annotation

Comparing JSF Beans, CDI Beans and EJBs

Comparing JSF Beans, CDI Beans and EJBs

JSF Managed Beans

Most of the important information is really stored in the edges

FIELD

PROPERTY

Either all annotations must be on the fields, or all annotations on the get methods, but not both (unless the @AccessType annotation is used)

if placed on a get method, then the class is using PROPERTY access

For FIELD access the class field value will be accessed directly to store and load the value from the database

field can be private or any other access type

For PROPERTY access the class get and set methods will be used to store and load the value from the database

PROPERTY has the advantage of allowing the application to perform conversion of the database value when storing it in the object

be careful to not put any side-affects in the get/set methods that could interfere with persistence

Common Problems

Odd behavior

One common issue that can cause odd behavior is

For this reason it is generally recommended to

causing duplicate inserts, missed updates, or a corrupt object model

if you are going to use property access, ensure your property methods are free of side effects

Event Bus

Contextual Components and Conversations

Built-in Salt and repeated hashing support

Due to the limited capabilities of the ActionScript 3 reflection API than cannot access private fields, it is necessary to create an externalizable AS3 class (implementing flash.utils.IExternalizable and its corresponding externalizable Java class

In both classes you have to implement two methods

the Gas3 generator can automatically generate the writeExternal and readExternal methods.

With GraniteDS automated externalization and without any modification made to our bean, we may serialize all properties of the Person class, private or not

In order to externalize the Person.java entity bean, we must tell GraniteDS which classes we want to externalize with a

externalize all classes named com.myapp.entity.Person by using the org.granite.hibernate.HibernateExternalizer

you could use this declaration, but note that type in the example above is replaced by

            <include annotated-with="javax.persistence.Entity"/>             <include annotated-with="javax.persistence.MappedSuperclass"/>             <include annotated-with="javax.persistence.Embeddable"/>

: type

annotated-with

Instead of configuring externalizers with the above method, you may use the

feature:

precedence rules for these three configuration options: