Group items tagged

highly recommended to use JPA optimistic locking in a multi-tier environment (@Version annotation)

Tip The easiest and recommended way for getting Tide enabled managed entities is to generate them from Java classes with Gas3 or the GDS Eclipse builder using the tide="true" option.

In a typical Flex/app server/database application, an entity lives in three layers: the Flex client the Hibernate/JPA persistence context the database

only invariant is the id.

id reliably links the different existing versions of the entity in the three layers

Changes for Hibernate 3.5 applications

if your application uses Hibernate 3 classes that are not available in Hibernate 4, for example, some of the validator or search classes, you may see ClassNotFoundExceptions when you deploy your application. If you encounter this problem, you can try one of two approaches: You may be able to resolve the issue by copying the specific Hibernate 3 JARs containing those classes into the application "/lib" directory or by adding them to the classpath using some other method. In some cases this may result in ClassCastExceptions or other class loading issues due to the mixed use of the Hibernate versions, so you will need to use the second approach. You need to tell the server to use only the Hibernate 3 libraries and you will need to add exclusions for the Hibernate 4 libraries. Details on how to do this are described here: JPA Reference Guide.

In previous versions of the application server, the JCA data source configuration was defined in a file with a suffix of *-ds.xml. This file was then deployed in the server's deploy directory. The JDBC driver was copied to the server lib/ directory or packaged in the application's WEB-INF/lib/ directory. In AS7, this has all changed. You will no longer package the JDBC driver with the application or in the server/lib directory. The *-ds.xml file is now obsolete and the datasource configuration information is now defined in the standalone/configuration/standalone.xml or in the domain/configuration/domain.xml file. A JDBC 4-compliant driver can be installed as a deployment or as a core module. A driver that is JDBC 4-compliant contains a META-INF/services/java.sql.Driver file that specifies the driver class name. A driver that is not JDBC 4-compliant requires additional steps, as noted below.

DataSource Configuration

domain mode, the configuration file is the domain/configuration/domain.xml

standalone mode, you will configure the datasource in the standalone/configuration/standalone.xml

MySQL datasource element:

        <connection-url>jdbc:mysql://localhost:3306/YourApplicationURL</connection-url>        <driver-class> com.mysql.jdbc.Driver </driver-class>        <driver> mysql-connector-java-5.1.15.jar </driver>

       <security>            <user-name> USERID </user-name>            <password> PASSWORD</password>        </security>

example of the driver element for driver that is not JDBC 4-compliant. The driver-class must be specified since it there is no META-INF/services/java.sql.Driver file that specifies the driver class name.

 <driver-class>com.mysql.jdbc.Driver</driver-class>

JDBC driver can be installed into the container in one of two ways: either as a deployment or as a core module

Install the JDBC driver

Install the JDBC driver as a deployment

In AS7 standalone mode, you simply copy the JDBC 4-compliant JAR into the AS7_HOME/standalone/deployments directory

example of a MySQL JDBC driver installed as a deployment:     AS7_HOME/standalone/deployments/mysql-connector-java-5.1.15.jar

Write unit tests

without involving the EntityManager

Let the tool (JPA-provider) generate the DDL

and allows data modifications to be queued up (like a shopping cart),

EXTENDED

is managed by the underlying persistence provider.

an entity is new if it has just been instantiated using the new operator, and it is not associated with a persistence context. It has no persistent representation in the database and no identifier value has been assigned.

a managed entity instance is an instance with a persistent identity that is currently associated with a persistence context.

the entity instance is an instance with a persistent identity that is no longer associated with a persistence context, usually because the persistence context was closed or the instance was evicted from the context.

a removed entity instance is an instance with a persistent identity, associated with a persistence context, but scheduled for removal from the database.

Replacing the current Hibernate 4.0.x jars with a newer version

update the current as7/modules/org/hibernate/main folder

Delete *.index files in as7/modules/org/hibernate/main and as7/modules/org/hibernate/envers/main folders

Remove the older jars and copy new Hibernate jars into as7/modules/org/hibernate/main + as7/modules/org/hibernate/envers/main.

Update the as7/modules/org/hibernate/main/module.xml

as7/modules/org/hibernate/envers/main/module.xml to name the jars that you copied in.

return a row

3 ways to do this

EntityManger.find()

returns a typed instance of the entity when it is found, null when it is not found

But what if the row isn’t in the database (anymore)?

We get an unchecked exception: NoResultException

We never know for sure what we can expect from our database, so throwing an unchecked exception seems the wrong choice for this use-case

All entities marked as [Managed] are considered as corresponding to Hibernate/JPA managed entities on the server

It is highly recommended to use JPA optimistic locking in a multi-tier environment (@Version annotation

In conclusion, the recommended approach to avoid any kind of subtle problems is to have a real uid property which will be persisted in the database

Here all loaded collections of the Person object will be uninitialized so uperson contains only the minimum of data to correctly merge your changes in the server persistence context

Tide uses the client data tracking (the same used for dirty checking, see below) to determine which parts of the graph need to be sent.

Dirty Checking and Conflict Handling

Data Validation

Tide integrates with Hibernate Validator 3.x and the Bean Validation API (JSR 303) implementations, and propagate the server validation errors to the client UI components

Data Paging

GraniteDS does not support the standard Consumer and Producer Flex messaging API

its own client implementations of these classes org.granite.gravity.Consumer and org.granite.gravity.Producer that provide very similar functionality

most advanced features and greatly simplifies asynchronous handling and client data management

preferred for new projects

Server Options

two options

RemoteObject API,

GraniteDS support for externalization of lazily loaded JPA entities/collections, and support for scalable messaging though Gravity

Tide API

full feature set of Tide data management and further integration with data push through Gravity

complete support for Spring and Seam security or integration with CDI events

Tide/CDI/JPA2/Java EE 6 on JBoss 6/7 or GlassFish 3

If you are on a Java EE 6 compliant application server, it is definitely the best option

Entity Beans in combination with an EntityManager

use CDI to inject the EntityManager into my JpaRealm

JpaRealm is not container managed but is instantiated by Shiro

delegate your JpaRealm into @Stateless EJB, which can @Inject EntityManager

JpaRealm

@PersistenceContext   private EntityManager entityManager;

EnvironmentLoaderListener

found the cause

Instead of configuring the ShiroFilter in my web.xml I had the IniShiroFilter configured. The IniShiroFilter creates a new SecurityManager from the ini file. This new SecurityManager didn't know about the realm I've added in my EnvironmentLoader, so it didn't have any realms.

I replaced it with the ShiroFilter in my web.xml and all seems to be working now with my CdiEnvironmentLoaderListener.

In JEE managed mode, such as an EntityManager injected into a SessionBean, the EntityManager reference, represents a new persistence context for each transaction. This means objects read in one transaction become detached after the end of the transaction, and should no longer be used, or need to be merged into the next transaction. In managed mode, you never create or close an EntityManager.

do not support nested transactions