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
but is not a primary key for efficiency concerns
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
the glory of Spring's founding myth of killing the beast that was J2EE seems to be fading. The former beast is now as manageable and easy to use as Spring ever was, or even more so
Deconstructing Spring myths
looking at the capabilities of the Spring Framework itself, where are the killer features?
list of reasons why I feel more productive on Java EE 6 than on Spring 3.1
these days there's really no reason for preferring vendor-specific APIs over JPA 2.0
Spring and Java EE applications mostly differ in the following areas only:
the web framework (Spring MVC vs. JSF vs. Wicket vs. Vaadin vs. Struts vs.....)
Spring Beans vs. EJB
Spring Dependency Injection vs. CDI or Java EE 5 @EJB or @Resource injection
A Permission represents the ability to perform an action or access a resource. A Permission is the most
granular, or atomic, unit in a system's security policy and is the cornerstone upon which fine-grained security
models are built.
a Permission instance only represents functionality or access - it does not grant it
permissions are immutable and reflect an application's raw functionality
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
used
as a base class for JPA/Hibernate persisted permissions that wish to store the parts of the permission string
in separate columns (e.g. 'domain', 'actions' and 'targets' columns)