Group items tagged

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

@Size(min = 3, max = 80)

@NotNull

LastName

extend AbstractBuilder

must implement the buildInternal() method:

Builder extends AbstractBuilder<Customer>

@Override protected Customer buildInternal()

Implementing the Builder Pattern using the Bean Validation API

variation of the Builder design pattern for instantiating objects with multiple optional attributes.

this pattern frees you from providing multiple constructors with the different optional attributes as parameters (hard to maintain and hard to read for clients)

or providing setter methods for the optional attributes

UserService

UserDao

FacebookWS

User u

UserService uses UserDAO and FacebookWS

but don’t know how those dependencies are instantiated

And you shouldn’t really care, all that is important is that UserService depends on dao and webservice object.

BDD template given-when-then) tests are easy to read

@Entity

public class User

calling new User(“someName”,”somePassowrd”, “someOtherName”, “someOtherPassword”) becomes hardly readable and maintainable

code duplication

Maintaining this code would turn into a nightmare in no time

running the code above will throw an exception by the JPA provider,

Joshua Blooch gives fine example of builder pattern.

Instead of making the desired object directly, the client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameterless build method to generate the object, which is immutable. The builder is a static member class of the class it builds.

Coffee

public static class Builder

Builder(CoffeeType type, int cupSize)

Builder withMilk()

Coffee build()

Coffee(this)

private Coffee(Builder builder)

Coffee coffee = new Coffee.Builder(CoffeeType.Expresso, 3).withMilk().build();2}

especially if most of those parameters are optional.

For all entity attributes I create private fields

those that are obligatory become parameters for the public constructor

parameter-less constructor, I create one, but I give him

protected access level

protected

one direction must be defined as the owner and the other must use the mappedBy attribute to define its mapping

you will end up getting duplicate rows

If the mappedBy is not used, then the persistence provider will assume there are two independent relationships

As with all bi-directional relationships it is your object model's and application's responsibility to maintain the relationship in both direction

Mapping a Join Table with Additional Columns

solution is to create a class that models the join table

requires a composite primary key

To make your life simpler, I would recommend adding a generated Id attribute to the association class

Another usage is if you have a Map relationship between two objects, with a third unrelated object or data representing the Map key

Merge

When the transaction is committed, or if the persistence context is flushed, then the object will be inserted into the database

used to merge the changes made to a detached object into the persistence context

it merges the changes into the persistence context (transaction)

When the transaction is committed, or if the persistence context is flushed, then the object will be updated in the database.

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

last case is far from obvious

not responsible for the relationship

mappedBy

To use one of the target entity property as a key of the map, use

if the map key type is another entity

Note that dpHibernate doesn't depend on Spring

entity classes must implement the org.dphibernate.core.IHibernateProxy interface, both on the Java and Actionscript classes

talking about what the requirements were, using the same language

The time gap disappeared since both the developer and tester worked inside the iteration

testers had some influence over the development, by catching errors early in the process and deciding what to do about them

JBoss AS Tools

able to deploy my application directly from the workspace

bad news is that JBoss AS 7 does not currently support other persistence providers like Eclipselink, OpenJPA or DataNucleus

GlassFish and Resin, you can simply drop the JARs of your preferred provider and its dependencies in a designated folder of your server installation and edit your persistence.xml to override the default provider of the server

JBoss AS 7 appears to require an adapter per persistence provider, which to me looks like an unfortunate and unnecessary design decision

documentation continues to be sketchy and far below the standard of JBoss AS 5

top-level performance

classloader leaks

productivity issues of the Eclipse integration

lack of support for JPA providers other than Hibernate

Each of these is currently a blocker for using JBoss AS 7 in production

Redeployment

after a couple of redeployments, there was an OutOfMemoryError

new classloader leak

JBoss AS 7: Catching up with Java EE 6

Performance measurements

JBoss AS 7.0.2

GlassFish 3.1.1

Empty server startup time 1.9 s

3.2 s

Empty server heap memory 10.5 MB

26.5 MB

Empty server PermGen memory 36.3 MB

28.4 MB

MyApp deployment time 5.8 s

JBoss AS 7 is now at a competitive level with Resin and Glassfish and actually outperforms Glassfish in almost all of these tests

XSDDataTypes Package: This package contains classes representing XSD primitive data types. This package is available as an XMI file. To import the file as a UML Package, use EA's XMI import facility which is available from the menu item: Project | Import/Export | Import Package from XMI. UML Profile for XML: This resource file contains the stereotyped classes which allow the schema generation to be customized. The UML Profile for XML can be imported into a model using the Resource View (see Importing Profiles for details on importing UML profiles into EA).

Steps to Generate XSD: Select the package to be converted to XSD by right-clicking on the package in the Project Browser. Select Project | Generate XML Schema from the main menu. Set the desired output file using the Filename field. Set the desired xml encoding using the Encoding field. Click on the Generate button to generate the schema. The progress of the schema generator will be shown in the Progress edit box.

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

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

application stops working when you move it to another server

project in Flex Builder

check “use remote object access service”

This adds a compiler argument pointing to the location of your

When you then

your application, the required

of services-config.xml are

read at

not at runtime

{server.name}

{server.port}

{context.root}

{server.name} and {server.port} are replaced at

{context.root} is still substituted at

Flex SDK provides an API that allows you to configure your channels at runtime

number of ways you can pass values to a SWF at runtime

read a configuration file using HTTPService at application startup

assignments for the project permissions

Every project has a permission scheme

One permission scheme can be associated with multiple projects

access rights

Permission schemes prevent having to set up permissions individually for every project

Once a permission scheme is set up