Group items matching

in title, tags, annotations or url

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

JSON-P

we believe that providing solid support for standardized PaaS-based programming and multi-tenancy would delay the release of Java EE 7 until the spring of 2014

way too long

defer the remaining aspects of our agenda for PaaS enablement and multi-tenancy support to

already laid some of the infrastructure for cloud support in Java EE 7

resource definition metadata

improved security configuration

JPA schema generation

Java EE 8 Platform release for the

support for HTML 5 in the form of Web Sockets

JSON-P

simplified JMS 2.0 APIs

improved Managed Bean alignment, including

JAX-RS 2.0 client API

method-level validation

more comprehensive expression language

must declare your classes in separated source files if you want them to be correctly handled by the generator

Java Decompiler

creates a bad sort of dependency where we need to update the base class every time we make a new derived class. Not good!

AS3 Date

deserialized as java.util.Date

simplified and unofficial UML Profile for EJB 3.0 with support for

Enterprise JavaBeans

session beans

jboss.as.jpa.adapterModule

jboss.as.jpa.adapterClass

org.jboss.as.jpa.hibernate3.HibernatePersistenceProviderAdaptor

Working with other persistence providers

A project to build integration for persistence providers like EclipseLink, is here.

Troubleshooting

“org.jboss.as.jpa” logging can be enabled to get the following information: INFO - when persistence.xml has been parsed, starting of persistence unit service (per deployed persistence.xml), stopping of persistence unit service DEBUG - informs about entity managers being injected, creating/reusing transaction scoped entity manager for active transaction TRACE - shows how long each entity manager operation took in milliseconds, application searches for a persistence unit, parsing of persistence.xml

To enable TRACE, open the as/standalone/configuration/standalone.xml (or as/domain/configuration/domain.xml) file. Search for <subsystem xmlns="urn:jboss:domain:logging:1.0"> and add the org.jboss.as.jpa category

Packaging the Hibernate 3.5 or greater 3.x JPA persistence provider with your application

jboss.as.jpa.providerModule needs to be set to hibernate3-bundled.

<property name="jboss.as.jpa.providerModule" value="hibernate3-bundled" />

Sharing the Hibernate 3.5 or greater JPA persistence provider between multiple applications

Applications can share the same Hibernate3 (for Hibernate 3.5 or greater) persistence provider by manually creating an org.hibernate:3 module (in the AS/modules folder). Steps to create the Hibernate3 module:

<property name="jboss.as.jpa.providerModule" value="org.hibernate:3" />

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:

allows additional behavior to be added to an existing class by wrapping the original class and duplicating its interface and then delegating to the original

AOP proxy is like a dynamic decorator

Single table inheritance is the default

mapped superclass is

but allow common mappings to be define for its subclasses

Single Table Inheritance

single table is used to store all of the instances of the entire inheritance hierarchy

table will have a column for

in the hierarchy

is used to determine which class the particular row belongs to

abstract

Project

extends Project

extends Project

@DiscriminatorValue("S")

@DiscriminatorValue("L")

@DiscriminatorColumn(name="PROJ_TYPE")

@Inheritance

@Table(name="PROJECT")

single table inheritance

Joined, Multiple Table Inheritance

mirrors the object model in the data model

table is defined for each class in the inheritance hierarchy to store only the local attributes of that class

Each table in the hierarchy must also store the object's id (primary key), which is

share the same id attribute

joined inheritance

@Inheritance(strategy=

@DiscriminatorColumn(name="PROJ_TYPE")

@Table(name="PROJECT")

abstract

Project

@DiscriminatorValue("L")

@Table(name=

Project

@DiscriminatorValue("S")

@Table(name=

Project

Table Per Class Inheritance

Advanced

table is defined for

in the inheritance hierarchy to store

of that class and

table per class inheritance

@Inheritance(strategy=

abstract

Project

@Table(name="LARGEPROJECT")

LargeProject

Project

@Table(name="SMALLPROJECT")

SmallProject

Project

Mapped Superclasses

similar to table per class inheritance, but does not allow querying, persisting, or relationships to the superclass

mapped superclass

@MappedSuperclass

abstract

Project

@Column(name="NAME")

@Table(name="LARGEPROJECT")

LargeProject

Project

@AttributeOverride

"PROJECT_NAME"

"name"

@Table("SMALLPROJECT")

SmallProject

Project

cannot have a relationship to a mapped superclass

names

Do not move or rename the package of an

Avoid deep inheritance hierarchies

Do not use public nested types

Do not declare public or protected fields

Do not expose implementation inheritance to the client