Group items tagged

Permissions are provided in two ways: A Collection of Strings, where each String can usually be converted into Permission objects by a Realm's PermissionResolver A Collection of Permission objects

most Realms store both sets of data for a Subject

a Realm implementation to utilize an implementation of the Account interface instead, which is a convenience interface that combines both AuthenticationInfo and AuthorizationInfo

Separating object id and business key

recommend using the "semi"-unique attributes of your persistent class to implement equals() (and hashCode()

The database identifier property should only be an object identifier, and basically should be used by Hibernate only

Instead of using the database identifier for the equality comparison, you should use a set of properties for equals() that identify your individual objects

"name" String and "created" Date, I can use both to implement a good equals() method

Workaround by forcing a save/flush

work around by forcing a save() / flush() after object creation and before insertion into the set

Note that it's highly inefficient and thus not recommended

role name to resolve

Collection of Permissions

AS3 Date

deserialized as java.util.Date

because Permissions represent raw functionality and only change when the application's source code changes, they are immutable at runtime - they represent 'what' the system can do

by transitive association, the user 'has' the permissions in their roles

all Permission checks are relegated to Realm implementations, and only those implementations really determine how a user 'has' a permission or not

Realm could use the semantics described here, or it could utilize some other mechanism entirely

describing its parameter object and is therefore not type-safe and its use is subject to many syntax errors.

GraniteDS provides a Java-like reflection API that encapsulates describeType calls and offers a type-safe, object-oriented, set of reflection classes and methods

caches its results for better performance

supports advanced features such as ApplicationDomain and namespaces

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:

install the MevenIDE plugin

select all 7 plugins from the Maven category

Creating the Parent POM Project

create a parent pom project and then create ear, ejb and war child projects

create the EJB Project

make sure the Project Location is the root directory of the Parent POM Project

Maven recognise it as a sub-module

The WAR Project

The EAR Project

Deploying to GlassFish

There are a few ways of deploying applications to GlassFish

GlassFish command line utility to deploy to both local and remote servers is asadmin

Maven for the deployment

glassfish-v2/bin/asadmin

exec-maven-plugin

deploy