Group items matching

in title, tags, annotations or url

In short, it provides much easier configuration of the backend infrastructure and services you want to expose to the client and it integrates perfectly with the Spring application contexts and the Spring programming model in general.

free and more feature rich alternative to BlazeDS, but also outranks LCDS’ out-of-the-box features when it comes to data management, streaming media and integrating with mobile devices and Cloud computing

developer tools like code generation, invocation test drive and interoperability with multiple IDEs and frameworks

supporting integration with mobile clients (Android, Windows Phone 7, RIM Playbook and soon iOS) and the Java service layer, which includes support for Java POJOs, EJBs, Spring Beans, Grails controllers, Hibernate Objects and XML Web Services

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

Tutorials All Tutorials UML Tutorials UML 2.1 Tutorial UML Tutorial - Part 1 Intro UML Tutorial - Part 2 Intro The Business Process Model The Component Model The Dynamic Model The Logical Model The Physical Model The Use Case Model UML Database Modeling Enterprise Architect Tutorials Creating Strategic Models Diagram Filters BPEL: Step by Step Guide Resource Management Testing Management Traceability RTF Documentation Use Case Metrics Structured Use Case Scenarios

Video Demonstrations All Videos Getting Started Requirements Management Modeling & Productivity Tools Code Engineering and the Debug Workbench Version Control Integration (Eclipse, Visual Studio, TFS)

UML Tutorial - Structure UML Tutorial - Behavior The Business Process Model Deployment of EA MDA Overview Rich-Text (RTF) Reporting Version Control Integration Requirements Management

White Papers & E-Books

Roles Business Analyst Database Administrator Deployment & Rollout Developer Project Manager Software Architects Software Engineer Technology Developer Testers

Solutions

MDG Technologies MDG Technologies EJB Technology.xml Testing Technology.xml

UML Profiles & Patterns UML Patterns UML Patterns Create UML Patterns Import UML Patterns Use UML Patterns UML Profiles UML Profiles: Introduction UML Profile for SPEM XML Schema (XSD) Generation Web Modeling Profile Eriksson-Penker Business Extensions Open Distributed Processing (UML4ODP)

In an EAV data model, each attribute-value pair is a fact describing an entity, and a row in an EAV table stores a single fact

EAV tables are often described as "long and skinny": "long" refers to the number of rows, "skinny" to the few columns

Data is recorded as three columns: The entity: the item being described. The attribute or parameter: a foreign key into a table of attribute definitions. At the very least, the attribute definitions table would contain the following columns: an attribute ID, attribute name, description, data type, and columns assisting input validation

The value of the attribute

Row modeling, where facts about something (in this case, a sales transaction) are recorded as multiple rows rather than multiple columns

differences between row modeling and EAV (which may be considered a generalization of row-modeling) are:

A row-modeled table is homogeneous in the facts that it describes

The data type of the value column/s in a row-modeled table is pre-determined by the nature of the facts it records. By contrast, in an EAV table, the conceptual data type of a value in a particular row depend on the attribute in that row

In the EAV table itself, this is just an attribute ID, a foreign key into an Attribute Definitions table

The Attribute

The Value

Coercing all values into strings

larger systems use separate EAV tables for each data type (including binary large objects, "BLOBS"), with the metadata for a given attribute identifying the EAV table in which its data will be stored

Where an EAV system is implemented through RDF, the RDF Schema language may conveniently be used to express such metadata

access to metadata must be restricted, and an audit trail of accesses and changes put into place to deal with situations where multiple individuals have metadata access

quality of the annotation and documentation within the metadata (i.e., the narrative/explanatory text in the descriptive columns of the metadata sub-schema) must be much higher, in order to facilitate understanding by various members of the development team.

Attribute metadata

Validation metadata include data type, range of permissible values or membership in a set of values, regular expression match, default value, and whether the value is permitted to be null

Presentation metadata: how the attribute is to be displayed to the user

Grouping metadata: Attributes are typically presented as part of a higher-order group, e.g., a specialty-specific form. Grouping metadata includes information such as the order in which attributes are presented

Advanced validation metadata Dependency metadata:

In general, JDBC Templates are a poor solution. They don’t have enough abstraction to work on different databases because you use plain SQL in queries. There is also no real ORM mapping which results in quite a lot of boilerplate code

SimpleJdbcTemplate(ds)

@InterceptorBinding

this annotation bypasses the management layer and as such it is recommended only for development and testing purposes

Defining a Managed DataSource

Installing a JDBC driver as a deployment

Installing the JDBC Driver

deployment or as a core module

managed by the application server (and thus take advantage of the management and connection pooling facilities it provides), you must perform two tasks.  First, you must make the JDBC driver available to the application server; then you can configure the data source itself.  Once you have performed these tasks you can use the data source via standard JNDI injection.

recommended way to install a JDBC driver into the application server is to simply deploy it as a regular JAR deployment.  The reason for this is that when you run your application server in domain mode, deployments are automatically propagated to all servers to which the deployment applies; thus distribution of the driver JAR is one less thing for administrators to worry about.

Note on MySQL driver and JDBC Type 4 compliance: while the MySQL driver (at least up to 5.1.18) is designed to be a Type 4 driver, its jdbcCompliant() method always return false. The reason is that the driver does not pass SQL 92 full compliance tests, says MySQL. Thus, you will need to install the MySQL JDBC driver as a module (see below).

Installing a JDBC driver as a module

<module xmlns="urn:jboss:module:1.0" name="com.mysql">  <resources>    <resource-root path="mysql-connector-java-5.1.15.jar"/>  </resources>  <dependencies>    <module name="javax.api"/>  </dependencies></module>

jboss-7.0.0.<release>/modules/com/mysql/main

define your module with a module.xml file, and the actual jar file that contains your database driver

content of the module.xml file

Under the root directory of the application server, is a directory called modules

module name, which in this example is com.mysql

where the implementation is, which is the resource-root tag with the path element

define any dependencies you might have.  In this case, as the case with all JDBC data sources, we would be dependent on the Java JDBC API's, which in this case in defined in another module called javax.api, which you can find under modules/javax/api/main as you would expect.

Defining the DataSource itself

   <datasource jndi-name="java:jboss/datasources/MySqlDS" pool-name="MySqlDS">      <connection-url>jdbc:mysql://localhost:3306/EJB3</connection-url>         <driver>com.mysql</driver>

    <drivers>      <driver name="com.mysql" module="com.mysql">        <xa-datasource-class>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</xa-datasource-class>      </driver>    </drivers>

jboss-7.0.0.<release>/domain/configuration/domain.xml or jboss-7.0.0.<release>/standalone/configuration/standalone.xml

Think of JSR-299 as the core of Seam 3 - it's the basic programming model for your application components, and for the built-in components that make up the Seam framework

Seam 3 is implemented as a set of portable extensions, or modules

run in any environment which supports JSR-299 (including any Java EE 6 environment).

BPM integration, Seam Security, Drools integration, RESTeasy integration, PDF and email templates, Excel generation, etc

2.0.0.Final End of 2012 Full specification compliance

Weld 2

can be handled on the

by defining a

possible to define common handlers for particular fault codes on the client-side, and exception converters on the server-side, to convert server exceptions to common fault codes

define an

class

Converter

ExceptionConverter

t.getMessage(), detail, t

ENTITY_NOT_FOUND

This class will

all EntityNotFound exceptions on the server-side, and convert it to a proper ENTITY_NOT_FOUND fault event.

exception converter has to be

scan="true" in granite-config.xml

in the jar containing the exception converter class

granite-config.xml

<exception-converters> <exception-converter type="com.package.SomeExceptionConverter"/> </exception-converters>

Handler

register it as an exception handler for the

in a static initializer block to be sure it is

ExceptionConverter

5. Exception Handling

5. Exception Handling

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

Class as parameter

serverside

Remote call using class as parameter

Does GraniteDS could manage date and TimeZone ?

Flash Player (GMT +X) -> IExternizable methods (GMT + X - X = GMT + 0) - > AMF over HTTP (GMT + 0) -> Granite AMF0Deserializer (GMT + 0) -> Granite Converter (GMT + 0 + Y = GMT + Y) -> Java Services (GMT + Y)Java Services (GMT + Y) -> Granite Converter (GMT + Y - Y = GMT + 0) -> Granite AMF0Deserializer (GMT + 0) -> AMF over HTTP (GMT + 0) -> IExternizable methods (GMT + 0 + X = GMT + X) -> Flash Player (GMT + X)

We use

for AMF for convention

define a

for your AMF that is over HTTP

: timezone for your flex client

: timezone for your server

don't want to modify the default templates

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

Stateless beans must have a dependent scope while a stateful session bean can have any scope. By default they are transactional, but you can use the transaction attribute annotation.

CDI beans can be injected into EJBs and EJBs can be injected into CDI beans

When to use which bean How do you know when to use which bean? Simple.

In general, you should use CDI beans unless you need the advanced functionality available in the EJBs such as transactional functions. You can write your own interceptor to make CDI beans transactional, but for now, its simpler to use an EJB until CDI gets transactional CDI beans which is just around the corner

Comparing JSF Beans, CDI Beans and EJBs

JSF Managed Beans

In short, don’t use them if you are developing for Java EE 6 and using CDI. They provide a simple mechanism for dependency injection and defining backing beans for web pages, but they are far less powerful than CDI beans.

JSF beans cannot be mixed with other kinds of beans without some kind of manual coding.

CDI Beans

includes a complete, comprehensive managed bean facility

interceptors, conversation scope, Events, type safe injection, decorators, stereotypes and producer methods

JSF-like features, you can define the scope of the CDI bean using one of the scopes defined in the javax.enterprise.context package (namely, request, conversation, session and application scopes). If you want to use the CDI bean from a JSF page, you can give it a name using the javax.inject.Named annotation

Comparing JSF Beans, CDI Beans and EJBs

Comparing JSF Beans, CDI Beans and EJBs

JSF Managed Beans

JPA 2.0, still contains only a subset of the features supported by many database vendors

features not supported in JP QL.

performance required by an application is to replace the JP QL query with a hand-optimized SQL version. This may be a simple restructuring of the query that the persistence provider was generating, or it may be a vendor-specific version that leverages query hints and features specific to a particular database.

recommend avoiding SQL initially if possible and then introducing it only when necessary

benefits of SQL query support is that it uses the same Query interface used for JP QL queries. With some small exceptions that will be described later, all the Query interface operations discussed in previous chapters apply equally to both JP QL and SQL queries.

keep application code consistent because it needs to concern itself only with the EntityManager and Query interfaces.

An unfortunate result of adding the TypedQuery interface in JPA 2.0 is that the createNativeQuery() method was already defined in JPA 1.0 to accept a SQL string and a result class and return an untyped Query interface

consequence is that when the createNativeQuery() method is called with a result class argument one might mistakenly think it will produce a TypedQuery, like createQuery() and createNamedQuery() do when a result class is passed in.

@NamedNativeQuery

resultClass=Employee.class

The fact that the named query was defined using SQL instead of JP QL is not important to the caller

SQL Result Set Mapping

JPA provides SQL result set mappings to handle these scenarios

A SQL result set mapping is defined using the @SqlResultSetMapping annotation. It may be placed on an entity class and consists of a name (unique within the persistence unit) and one or more entity and column mappings.

entities=@EntityResult(entityClass=Employee.class)

@SqlResultSetMapping

Multiple Result Mappings

A query may return more than one entity at a time

The SQL result set mapping to return both the Employee and Address entities out of this query

emp_id, name, salary, manager_id, dept_id

address_id, id, street, city, state, zip

order in which the entities are listed is not important

ntities={@EntityResult(entityClass=Employee.class), @EntityResult(entityClass=Address.class)}

Windows

Oracle Java 7 Update 2

Oracle Java 6 Update 27

x86 32-bit

x86 64-bit

If you introduce interfaces intentionally - and not as a general rule, you will considerably reduce the number of files. Your code becomes easier to understand and so maintain

"Contract First", "Coding To Interfaces" or "Decoupling"