Modes define what SQL syntax MySQL should support and what kind of
data validation checks it should perform
Group items matching
in title, tags, annotations or url
11More
MySQL :: MySQL 5.1 Reference Manual :: 5.1.7 Server SQL Modes - 0 views
-
-
Server SQL Modes
-
When working with InnoDB tables using the InnoDB Plugin, consider also the innodb_strict_mode configuration option. It enables additional error checks for InnoDB tables, as listed in InnoDB Strict Mode
- ...7 more annotations...
-
Setting the SESSION variable affects only the current client. Any client can change its own session sql_mode value at any time
-
To avoid this, it is best to use single-row statements because these can be aborted without changing the table
-
ie. the cheezy and hugely time consuming workaround for avoiding the partial update failure issue with slaves (ie. master-slave data skew)
-
-
STRICT_TRANS_TABLES
-
Strict mode does not affect whether foreign key constraints are checked
-
POSTGRESQL
-
ORACLE
-
TRADITIONAL
4More
Hibernate - Many-to-Many example - join table + extra column (Annotation) - 0 views
-
Many-to-Many example – join table + extra column (Annotation)
-
For many to many relationship with
-
NO extra column in the join table
- ...1 more annotation...
-
please refer to this @many-to-many tutorial
70More
Chapter 2. Mapping Entities - 0 views
-
Composite identifier
-
You can define a composite primary key through several syntaxes:
-
@EmbeddedId
- ...66 more annotations...
-
map multiple properties as @Id properties
-
annotated the property as
-
map multiple properties as @Id properties and declare an external class to be the identifier type
-
declared on the entity via the @IdClass annotation
-
The identifier type must contain the same properties as the identifier properties of the entity: each property name must be the same, its type must be the same as well if the entity property is of a
-
basic type
-
last case is far from obvious
-
recommend you not to use it (for simplicity sake)
-
@EmbeddedId property
-
@EmbeddedId
-
@Embeddable
-
@EmbeddedId
-
@Embeddable
-
@Embeddable
-
@EmbeddedId
-
Multiple @Id properties
-
arguably more natural, approach
-
place @Id on multiple properties of my entity
-
only supported by Hibernate
-
does not require an extra embeddable component.
-
@IdClass
-
@IdClass on an entity points to the class (component) representing the identifier of the class
-
WarningThis approach is inherited from the EJB 2 days and we recommend against its use. But, after all it's your application and Hibernate supports it.
-
Mapping entity associations/relationships
-
One-to-one
-
three cases for one-to-one associations:
-
associated entities share the same primary keys values
-
foreign key is held by one of the entities (note that this FK column in the database should be constrained unique to simulate one-to-one multiplicity)
-
association table is used to store the link between the 2 entities (a unique constraint has to be defined on each fk to ensure the one to one multiplicity)
-
@PrimaryKeyJoinColumn
-
shared primary keys:
-
explicit foreign key column:
-
@JoinColumn(name="passport_fk")
-
foreign key column named passport_fk in the Customer table
-
may be bidirectional
-
owner is responsible for the association column(s) update
-
In a bidirectional relationship, one of the sides (and only one) has to be the owner
-
To declare a side as
-
not responsible for the relationship
-
the attribute
-
mappedBy
-
is used
-
mappedBy
-
Indexed collections (List, Map)
-
Lists can be mapped in two different ways:
-
as ordered lists
-
as indexed lists
-
@OrderBy("number")
-
List<Order>
-
List<Order>
-
List<Order>
-
To use one of the target entity property as a key of the map, use
-
@MapKey(name="myProperty")
-
@MapKey(name"number")
-
Map<String,Order>
-
String number
-
-
@MapKeyJoinColumn/@MapKeyJoinColumns
-
if the map key type is another entity
-
@ManyToAny
-
2.4.5.2. @Any
-
@Any annotation defines a polymorphic association to classes from multiple tables
-
this is most certainly not meant as the usual way of mapping (polymorphic) associations.
-
@ManyToAny allows polymorphic associations to classes from multiple tables
-
first column holds the type of the associated entity
-
remaining columns hold the identifier
-
not meant as the usual way of mapping (polymorphic) associations
2More
Chapter 7. Integration with EJB3 - 0 views
-
Integration with EJB3
-
important to note that identity caches the user access rights so only the first call to hasRole() will be remote
4More
Project Overview - 0 views
-
Project Overview
-
comprehensive development and integration platform for building Flex / Java EE RIA applications
-
open source
- ...1 more annotation...
-
implementation of the Flex remoting protocol and of the AMF3 data format, with out-of-the-box adapters for all usual Java frameworks
2More
Chapter 11. Client-Side Validation API (JSR 303) - 0 views
-
Client-Side Validation API (JSR 303)
-
GraniteDS introduces an ActionsScript3 implementation of the Bean Validation specification and provides code generation tools integration so that your Java constraint annotations are reproduced in your AS3 beans
2More
Chapter 1. Getting Started - 0 views
-
Hello World, revisited with EJB3
-
history is persisted in the database by means of a JPA entity bean and those objects are serialized back to the Flex client each time you enter a new name.
8More
Chapter 10. Integration with CDI - 0 views
-
Integration with CDI
-
GraniteDS provides out-of-the-box integration with CDI via the Tide API
-
tideAnnotations
- ...5 more annotations...
-
tideInterfaces
-
tideRoles
-
exceptionConverters
-
amf3MessageInterceptor
-
define the list of interface/class names that enable remote access to CDI beans
13More
Chapter 15. Data Management - 0 views
-
Data Management
-
Tide maintains a client-side cache of entity instances and ensures that every instance is unique in the Flex client context
-
Tide provides an integration between the Flex/LCDS concept of managed entities and the server persistence context (JPA or Hibernate).
- ...10 more annotations...
-
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
-
Data Paging
5More
Chapter 14. Tide client framework - 0 views
-
Tide client framework
-
framework features notably
-
Dependency Injection
- ...2 more annotations...
-
Event Bus
-
Contextual Components and Conversations
9More
Chapter 5. AS3 Code Generator - 0 views
-
AS3 Code Generator
-
GraniteDS comes with an ActionScript3 code generator that writes AS3 beans for all Java beans
-
ActionScript 3 generator is able to write AS3 typed client proxies for exposed remote services
- ...6 more annotations...
-
Gas3 may also replicate validation annotations in order to use the Flex side validation framework
-
implemented as an Eclipse plugin
-
Ant task.
-
Maven Plugin (Flexmojos)
-
flexmojos-maven-plugin
-
org.sonatype.flexmojos
6More
shared by kuni katsuya on 15 May 12
- No Cached
Chapter 3. Project Setup - 0 views
www.graniteds.org/...graniteds.projectsetup.html
graniteds maven archetypes spring jpa hibernate tide seam2 cdi
shared by kuni katsuya on 15 May 12
- No Cached
-
Using Maven archetypes
-
GraniteDS/Tide/CDI/JPA: graniteds-tide-cdi-jpa
-
GraniteDS/Tide/Seam 2/JPA/Hibernate: graniteds-tide-seam-jpa-hibernate
- ...3 more annotations...
-
Maven 3 is highly recommended but Maven 2.2 should also work
-
CDI archetype defines an embedded GlassFish run configuration
-
mvn embedded-glassfish:run
6More
Chapter 10. Integration with CDI - 0 views
-
GraniteDS provides out-of-the-box integration with CDI via the Tide API
-
Integration with CDI
-
fully supports serialization of JPA entities from and to your Flex application, taking care of lazily loaded associations
- ...3 more annotations...
-
GraniteDS also integrates with container security for authentication and role-based authorization
-
granite-cdi.jar
-
JBoss 6 and GlassFish v3
19More
shared by kuni katsuya on 15 May 12
- No Cached
Chapter 2. Usage Scenarios - 0 views
www.graniteds.org/...graniteds.usagescenarios.html
graniteds usage scenarios javaee6 jboss glassfish jpa2 cdi tide
shared by kuni katsuya on 15 May 12
- No Cached
-
Client Options
-
client there are two main choices
-
standard Flex RemoteObject API
- ...16 more annotations...
-
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
-
Tide remoting API with the GraniteDS/Tide server framework integration
-
most advanced features and greatly simplifies asynchronous handling and client data management
-
preferred for new projects
-
Server Options
-
two options
-
GraniteDS service factory
-
RemoteObject API,
-
GraniteDS support for externalization of lazily loaded JPA entities/collections, and support for scalable messaging though Gravity
-
GraniteDS/Tide service factory
-
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
7More
Chapter 3. Project Setup - 0 views
-
Developing with Maven
-
artifacts are available in the Maven central repository
-
group org.graniteds
- ...4 more annotations...
-
granite-core
-
granite-hibernate
-
GraniteDS/Tide/CDI/JPA: graniteds-tide-cdi-jpa
-
Maven archetypes
8More
Chapter 15. Data Management - 0 views
-
Data Management
-
Tide provides an integration between the Flex/LCDS concept of managed entities and the server persistence context (JPA or Hibernate)
-
Tide maintains a client-side cache of entity instances and ensures that every instance is unique in the Flex client context
- ...5 more annotations...
-
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
Netbeans PHP Configuration - Reference - Confluence - 0 views
confluence.visualfrenzy.com/...Netbeans+PHP+Configuration
netbeans php debug remote debugging xdebug
shared by kuni katsuya on 17 May 12
- No Cached
11More
Java EE wins over Spring « Bill the Plumber - 0 views
-
Spring is controlled by ONE COMPANY. It is not an independent open source organization like Apache. At least with Java EE there are multiple OPEN SOURCE implementations. How long before VMWare decides its $500 million investment needs to be recouped and they start charging for Spring in a big way? Don’t think it can happen? Think again…VMWare is in the same poor position BEA/WLS was against JBoss with Red Hat’s VM/Cloud tech eating away at VMWare’s margins. There is a much higher chance of them scrambling for revenue sources than Red hat ever being acquired by Oracle.
-
Core JavaServer Faces JSF 2.0 Cookbook JavaServer Faces 2.0, The Complete Reference EJB 3.1 Cookbook Enterprise JavaBeans 3.1 Beginning Java EE 6 with GlassFish 3 Java EE 6 with GlassFish 3 Application Server Java EE 6 Development With NetBeans 7 Real World Java EE Patterns Rethinking Best Practices Real World Java EE Night Hacks Dissecting the Business Tier
-
books about the different APIs of Java EE 6:
- ...8 more annotations...
-
if you’ve heard Rod Johnson speak he is always adamant that Spring has replaced Java EE. Its good to see that his rhetoric is utter BS!
-
Sorry, even Spring MVC sucks as much balls as JSF does.
-
Java EE wins over Spring
-
CDI closed API hole
-
Application server started to get their act together with regards to boot time. It started with Glassfish and ended with JBoss 7. Both of which can boot in a matter of seconds.
-
Arquillian allows you to run your unit tests in a real environment with real transactions, etc. Personally I always despised mocks because they didn’t test in the environment you were going to run in. I thought they were pointless and to this day, I refuse to use this testing pattern.
-
I’m glad Rod and company were able to cash out with the VMWare acquisition before Java EE was able to regain its dominance
-
SpringSource pushed Java EE to innovate and for that I’m very grateful. For Java EE, it was either evolve or die. They evolved, now its time for Spring to die.
Sparx Systems - Reference Booklets - 0 views