Its been a while since I chimed in on the topic of Exceptions:

Checked : (java.lang.Exception). This type of exception represents useful information about the operation of a legally specified request that the caller may have had no control over and that the caller needs to be informed about. With checked exceptions, Java language forces us to document all the anticipated ways in which control might exit a method:

Unchecked : (java.lang.RuntimeException). These are exceptions that occur as a result of programming errors that the program could not be expected to catch.

Now, it is time to talk about the Exception Handling capabilities with DAOs in the Spring Framework

(2.5)

SQL Exception Translator – sql exception can be translated to a DataAccessException using the translate method

- ex1, ex2, ex3 , ex4

The method HibernateDaoSupport :: convertHibernateAccessException – convert the given HibernateException to an appropriate exception from the org.springframework.dao hierarchy.

SessionFactoryUtils :
public static DataAccessException convertHibernateAccessException(HibernateException ex) {
		if (ex instanceof JDBCConnectionException) {
			return new DataAccessResourceFailureException(ex.getMessage(), ex);
		}
		if (ex instanceof SQLGrammarException) {
			return new InvalidDataAccessResourceUsageException(ex.getMessage(), ex);
		}
		if (ex instanceof DataException) {
			return new InvalidDataAccessResourceUsageException(ex.getMessage(), ex);
		}
		if (ex instanceof LockAcquisitionException) {
			return new CannotAcquireLockException(ex.getMessage(), ex);
		}
		if (ex instanceof ConstraintViolationException) {
			return new DataIntegrityViolationException(ex.getMessage(), ex);
		}
		if (ex instanceof JDBCException) {
			return new HibernateJdbcException((JDBCException) ex);
		}
		if (ex instanceof PropertyValueException) {
			return new DataIntegrityViolationException(ex.getMessage(), ex);
		}
		if (ex instanceof PersistentObjectException) {
			return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
		}
		if (ex instanceof TransientObjectException) {
			return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
		}
		if (ex instanceof ObjectDeletedException) {
			return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
		}
		if (ex instanceof QueryException) {
			return new HibernateQueryException((QueryException) ex);
		}
		if (ex instanceof UnresolvableObjectException) {
			return new HibernateObjectRetrievalFailureException((UnresolvableObjectException) ex);
		}
		if (ex instanceof WrongClassException) {
			return new HibernateObjectRetrievalFailureException((WrongClassException) ex);
		}
		if (ex instanceof NonUniqueResultException) {
			return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1);
		}
		if (ex instanceof StaleObjectStateException) {
			return new HibernateOptimisticLockingFailureException((StaleObjectStateException) ex);
		}
		if (ex instanceof StaleStateException) {
			return new HibernateOptimisticLockingFailureException((StaleStateException) ex);
		}

		// fallback
		return new HibernateSystemException(ex);
	}

Hibernate Template

If you download the spring framework with dependencies, one of the modules included is the spring-test.

spring
- Convenient jar file combining all standard modules (except for the test module and the Spring MVC support)
- Also includes the AOP Alliance interfaces (as a convenience)!
- Does not include contents of spring-aspects.jar, spring-test.jar and spring-webmvc*.jar!

spring-test
- Contents: test context framework, JUnit support, JNDI mocks, Servlet API mocks, Portlet API mocks
- Dependencies: spring-core, (spring-context, spring-jdbc, spring-web, JUnit, Servlet API, Portlet API)

As the spring documentation mentions, for unit testing transactional systems you can achieve rollback of your tests pretty easily:

Typically you will extend the subclass, AbstractTransactionalDataSourceSpringContextTests. This class also requires that a DataSource bean definition – again, with any name – be present in the application context. It creates a JdbcTemplate instance variable, that is useful for convenient querying, and provides handy methods to delete the contents of selected tables (remember that the transaction will roll back by default, so this is safe to do).

This problem was identified with MySql.

Nice article here on spring test

This link tells us about the spring testing method calls

AbstractTransactionalDataSourceSpringContextTests superclass
provides the following services:

Injects test dependencies, meaning that we don't need to
perform application context lookups. Injection uses
autowiring by type.

Executes each test method in its own transaction, which is
automatically rolled back by default. This means that even 
if tests insert or otherwise change database state, there
is no need for a teardown or cleanup script.

If you want a transaction to commit--unusual, but useful 
if you want a particular test to populate the database,
for example--you can call the setComplete() method inherited
from AbstractTransactionalSpringContextTests. This will cause
the transaction to commit instead of roll back.

There is also convenient ability to end a transaction before
the test case ends, through calling the endTransaction() method.
This will roll back the transaction by default, and commit it
only if setComplete() had previously been called.

Provides useful inherited protected fields, such as a JdbcTemplate
that can be used to verify database state after test operations,
or verify the results of queries performed by application code.
An ApplicationContext is also inherited, and can be used for
explicit lookup if necessary.

All the Spring Test Life Cycle Methods

API

• getConfigLocations
• setDataSource
• setTransactionManager
• onSetUpBeforeTransaction
• onSetUpInTransaction
• onTearDownInTransaction
• endTransaction
• onTearDownAfterTransaction

example scenario:

Now onto the 2.5 way of testing:

org.springframework.test.context – Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.

Spring 2.5 continues this rich and convenient testing framework, while now removing the requirement that your unit tests extend Spring framework tests. Instead of subclassing, it uses java annotations.

Related links:

• Spring 2.5
• Spring Transactions
• Transaction Management with IBatis and Spring
• Spring Guide wiki
• Converting iBATIS DAO to Spring DAO
• Ibatis Configuration example
• IBatis and Spring Slides

Been a while since I started first looking at IBatis. The Spring Framework has a sample application named JPetstore (available in the core download) that gives you an example of IBatis, Spring, and Struts 1.x .

Different Spring Ibatis SQLMaps approaches:

Use Of Annotations

Implementing DAOs based on plain iBATIS API

<bean
id=”dataSource”
class=”org.springframework.jdbc.datasource.SingleConnectionDataSource”
destroy-method=”destroy”
>

<bean id=”transactionManager”
class=”org.springframework.jdbc.datasource.DataSourceTransactionManager”>
<property name=”dataSource” ref=”dataSource”/>
</bean>

<bean id=”sqlMapClient” class=”org.springframework.orm.ibatis.SqlMapClientFactoryBean”>
<property name=”configLocation” value=”classpath:/sqlmap-config.xml”/>
<property name=”dataSource” ref=”dataSource”/>

</bean>

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE sqlMapConfig PUBLIC
“-//ibatis.apache.org//DTD SQL Map Config 2.0//EN”
“http://ibatis.apache.org/dtd/sql-map-config-2.dtd”>
<sqlMapConfig>
<settings defaultStatementTimeout=”5″ />
<sqlMap resource=”MyType.xml” />
</sqlMapConfig>

You can actually omit the ‘transaction-manager’ attribute in the <tx:annotation-driven/> tag if the bean name of the PlatformTransactionManager that you want to wire in has the name ‘transactionManager’.

<!– Instructs Spring to perfrom declarative transaction managemenet on annotated classes –>
<tx:annotation-driven/>

@Autowired
public void setSqlMapClient(SqlMapClient sqlMapClient) {
iBatisTemplate = new SqlMapClientTemplate(sqlMapClient);
}

@@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)

- The @Transactional annotation may be placed before an interface definition, a method on an interface, a class definition, or a public method on a class. However, please note that the mere presence of the @Transactional annotation is not enough to actually turn on the transactional behavior.
public MyType insertMyType(MyType myType) {
MyType myType = null;
myType= (MyType) iBatisTemplate.insert(”insertIntoMyType”, MyType;
return myType;
}

Use Of Spring’s DaoSupport Class

<bean
id=”dataSource”
class=”org.apache.commons.dbcp.BasicDataSource”
destroy-method=”close”
>

<bean id=”sqlMapClient” class=”org.springframework.orm.ibatis.SqlMapClientFactoryBean”>
<property name=”configLocation” value=”classpath:/sqlmap-config.xml”/>
<property name=”dataSource” ref=”dataSource”/>
</bean>

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE sqlMapConfig PUBLIC “-//iBATIS.com//DTD SQL Map Config 2.0//EN”
“http://www.ibatis.com/dtd/sql-map-config-2.dtd”>
<sqlMapConfig>
<settings useStatementNamespaces=”true” />
<sqlMap resource=”person.xml” />
</sqlMapConfig>

PersonDaoIbatisImpl extends SqlMapClientDaoSupport

public void addPerson(Person person) {
Long id = (Long) this.getSqlMapClientTemplate().insert(”person.insert”,
person);
person.setId(id);
}

• org.springframework.orm.ibatis.support.SqlMapClientDaoSupport – Instead of a plain SqlMapClient, you can also pass a preconfigured SqlMapClientTemplate instance in. This allows you to share your SqlMapClientTemplate configuration for all your DAOs

As a total beginner to Spring Web Flow, the main thing I have noticed in going through the material is that there is quite a difference between the 1.x and the new release 2.0.

Web Flow | Spring Web Flow Forum

• Spring WF 1.X API | Spring WF 1.X Reference Guide | Spring WF Practical Intro | Spring WF 1.X Reference Apps | Spring 1.X WF YouTube | Spring WF1 Wiki Article | Spring WF 1 Examined | Spring WF 1 Starter
• Spring WF 1 with Grails
• Spring WF 1 – Struts2

There seems to be in package org.springframework.webflow.action a FlowAction and a FlowExecutor class. As well, the ExternalContext class which is credited to allowing WF to be decoupled from Servlet API .

• Spring WF 2.0.X API | Spring WF 2.0.X Reference Guide | Spring WF 2.0.X Reference Apps | Spring 2 WF Example

I do not see a FlowAction or FlowExecutor in org.spring.webflow.action package like in webflow 1.

Instead, lets look at what we have from the example Spring Flow 2.0 Example application.

To use annotations for the transactions within the example, we do the following:

1. Put an tag tx:annotation-driven in the spring config file
2. Put @Transactional annotation in the services classes

@Transactional – The @Transactional annotation may be placed before an interface definition, a method on an interface, a class definition, or a public method on a class. However, please note that the mere presence of the @Transactional annotation is not enough to actually turn on the transactional behavior.

You can actually omit the ‘transaction-manager’ attribute in the <tx:annotation-driven/> tag if the bean name of the PlatformTransactionManager that you want to wire in has the name ‘transactionManager’.

<!– Instructs Spring to perfrom declarative transaction managemenet on annotated classes –>
<tx:annotation-driven/>

<!– Drives transactions using local JPA APIs –>
<bean id=”transactionManager” class=”org.springframework.orm.jpa.JpaTransactionManager”/>

The LocalContainerEntityManagerFactoryBean can be configured with all Persistent Unit information like is done here.

@PersistenceUnit – annotated on EntityManagerFactory instances are thread-safe

<!– Creates a EntityManagerFactory for use with the Hibernate JPA provider and a simple in-memory data source populated with test data –>
<bean id=”entityManagerFactory” class=”org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean”>
<property name=”jpaVendorAdapter”>
<bean class=”org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter”/>
</property>
</bean>

<!– Deploys a in-memory datasource –>
<bean id=”dataSource” class=”org.springframework.jdbc.datasource.DriverManagerDataSource”>
<property name=”driverClassName” value=”org.hsqldb.jdbcDriver”/>
<property name=”url” value=”jdbc:hsqldb:mem:tutorialSwf”/>
<property name=”username” value=”sa”/>
<property name=”password” value=”"/>
</bean>

<!– Activates annotation-based bean configuration –>
<context:annotation-config/>

Mapping URLs to Handlers – maps request URLs to handlers. A simple way to create URL mapping rules is to define one as follows:

<!– Maps request URIs to controllers –>
<bean class=”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping”>
<property name=”mappings”>
<props>
<prop key=”/f/*”>flowController</prop>
</props>
</property>
<property name=”defaultHandler”>
<!– Selects view names to render based on the request URI: e.g. /main selects “main” –>
<bean class=”org.springframework.web.servlet.mvc.UrlFilenameViewController”/>
</property>
</bean>

The Flow Handler manages executions of a single flow definition. Above the handler selects view based on the URI in a default handler. To Implement one, extend AbstractFlowHandler.

Flow Controller – The FlowHandler MVC integration approach, you define one handler per flow. This is overkill in the cases where default flow handling rules are sufficient. Web controller for the Spring web MVC framework that routes incoming requests to one or more managed web flows. Requests into the web flow system are managed using a configurable ServletFlowExecutionManager.

<!– Handles requests mapped to the Spring Web Flow system –>
<bean id=”flowController” class=”org.springframework.webflow.mvc.servlet.FlowController“/>

The flow executor is the core Web Flow configuration element. Flow execution listeners are also defined in the flow executor.

<!– Executes flows: the central entry point into the Spring Web Flow system –>
<webflow:flow-executor id=”flowExecutor”>
<webflow:flow-execution-listeners>
<webflow:listener ref=”jpaFlowExecutionListener”/>
</webflow:flow-execution-listeners>
</webflow:flow-executor>

FlowRegistry – placed where you register your flows

flow-builder-services attribute – customize the services used to build the flows in a registry…When the tag is defined, you only need to reference the services you want to customize.

<!– The registry of executable flow definitions –>
<webflow:flow-registry id=”flowRegistry” flow-builder-services=”facesFlowBuilderServices”>
<webflow:flow-location-pattern value=”/WEB-INF/flows/**/*.xml”/>
</webflow:flow-registry>

flow scoped persistence context – provides isolation of intermediate edits by only committing changes to the database at the end of flow execution. This pattern is often used in conjunction with an optimistic locking strategy to protect the integrity of data modified in parallel by multiple users.

@PersistenceContext – annotated on EntityManager instances are not thread safe

<flow xmlns=”http://www.springframework.org/schema/webflow” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/webflow http://www.springframework.org/schema/webflow/spring-webflow-2.0.xsd”>
<persistence-context/>
…

configure the correct FlowExecutionListener in this case for JPA

<!– Installs a listener that manages JPA persistence contexts for flows that require them –>
<bean id=”jpaFlowExecutionListener” class=”org.springframework.webflow.persistence.JpaFlowExecutionListener”>
<constructor-arg ref=”entityManagerFactory”/>
<constructor-arg ref=”transactionManager”/>
</bean>

…

Here is how they handle the view:

<!– Maps logical view names to Facelet templates (e.g. ’search’ to ‘/WEB-INF/search.xhtml’ –>
<bean id=”faceletsViewResolver” class=”org.springframework.web.servlet.view.UrlBasedViewResolver”>
<property name=”viewClass” value=”org.springframework.faces.mvc.JsfView”/>
<property name=”prefix” value=”/WEB-INF/”/>
<property name=”suffix” value=”.xhtml”/>
</bean>

Or a simple ViewResolver

I have been an Eclipse user most of my Java career. Though, I do have limited experience with Visual Age, Forte, JBuilder, and Netbeans.  In the Eclipse space, it has been WSAD, MyEclipse, Eclipse WTP (2.x,3.2, Europa 3.3), and RAD 6/7.

Part of NFJS exposed me to IntelliJ.  Here is one take on this IDE.

Spring 2.0 introduced support for various annotations for configuration purposes, such as:

• @Transactional – The @Transactional annotation may be placed before an interface definition, a method on an interface, a class definition, or a public method on a class. However, please note that the mere presence of the @Transactional annotation is not enough to actually turn on the transactional behavior.
• @Required – used to mark a property as being ‘required-to-be-set’ (i.e. an annotated (setter) method of a class must be configured to be dependency injected with a value)
• @PersistenceContext – annotated on EntityManager instances are not thread safe
• @PersistenceUnit – annotated on EntityManagerFactory instances are thread-safe

Thus, to use annotations for the transactions for my purposes, I do the following:

1. Put an tag tx:annotation-driven in the config file (i.e applicationContext.xml)
2. Put @Transactional annotation in the services class implementation that contains operations on the entity manager

Spring 2.5 introduces support for a complete set of configuration annotations:

• @Autowired in combination with support for the JSR-250 annotations @Resource
• @PostConstruct
• @PreDestroy

As part my learnings of what is new with the Spring Framework, I found a nice Spring Flow 2.0 Example (with JSF and JPA).

The Spring Web Flow 2.0.2 release ( by Erwin Vervaet and Keith Donald ) comes as a separate download from the basic Spring functionality in 2.5.5.

On the Spring Web Flow (SWF) vision from 1.x to 2.x :

“[in 1.0] the SWF controller engine cared for one half of the web request lifecycle; the half related to request processing, often called the action phase. The other half, the render phase, was pushed off on the caller: either Spring MVC, Struts, or JSF front controllers
…..
The downside of this approach is it makes it difficult to apply application control logic during the view rendering phase
…..
Beginning with Web Flow 2.0 M2, the entire web request lifecycle is now under the control of Spring Web Flow, including the view rendering phase.
….
the ability for the SWF engine to communicate with external systems and conversational contexts over HTTP (embedding the proper flow execution callback URL in the redirect that is sent to the external system)”

Reference Guide 2.x

Also, note that getting these Spring Flow 2.x reference sample projects are easy to get a hold of. In the download of Web Flow is a projects/build-spring-webflow directory where you can run ant. It will build Web Flow along with the .war files for the sample projects (ant 1.7 and Java 5 are required to build).

There is a Struts2  plugin for Spring Web Flow called  struts2webflow

As far as further examples than the ones above, I found some web flow 2.x examples at this site spring by example.

Spring flow 1.0 showed that it could  easily integrate with struts. These  sample (1.x) applications can also be found on Java Passion Site. A good 1.x reference is the  Practical ntroduction . All the samples projects are Spring IDE projects that importable into Eclipse (see springide or plugin central for spring ide).

Here in the 1.x struts example:

Our first action in the jsp is as follows:

<A href=”flowAction.do?_flowId=birthdate”>Birth Date</A>

This action in the struts config says:

<action path=”/flowAction” name=”actionForm” scope=”request” type=”org.springframework.webflow.executor.struts.FlowAction”/>

We also bind to the Action Form:

<form-bean name=”actionForm” type=”org.springframework.web.struts.SpringBindingActionForm”/>

In the webflow-config.xml we define the flow registry:
<flow:executor id=”flowExecutor” registry-ref=”flowRegistry”/>
<!– Creates the registry of flow definitions for this application –>
<flow:registry id=”flowRegistry”>
<flow:location path=”/WEB-INF/birthdate.xml”/>
<flow:location path=”/WEB-INF/birthdate-alternate.xml”/>
</flow:registry>

Start State : the first state in the flow

<start-state idref=”enterBirthdate” />

View State: selects a view to render

<view-state id=”enterBirthdate” view=”birthdateForm”>

When the execution of the flow starts, enter the enterBirthdate state. Then select the birthdateForm view for display to the user, and pause the flow of execution until a user event happens.

Render Action: initializes the form object.

<render-actions>
<action bean=”formAction” method=”setupForm” />
</render-actions>

For view state, above Initializes the backing “form object” by invoking the setupForm method for formAction.

Note that the action was defined in the webflow-config.xml (instance of spring-webflow-config-1.0.xsd)

<bean id=”formAction” class=”org.springframework.webflow.samples.birthdate.BirthDateFormAction” />

Transition: Each View state must define a transition that leads to another state

<transition on=”submit” to=”processBirthdateFormSubmit” />

Action state: logic that needs to be executed in context of the request, once executed the result flow is returned which the flow may respond to.

<action-state id=”processBirthdateFormSubmit”>
<action bean=”formAction” method=”bindAndValidate”>
<attribute name=”validatorMethod” value=”validateBirthdateForm” />
</action>

transition on=”success” to=”enterCardInformation” />
<transition on=”error” to=”enterBirthdate” />

</action-state>

Related Links for Basic info on JSF:

• Introducing Java Server Faces (JSF) to 4GL Developers
• JSRs: 127, 252 (1.2)
• An Introduction to JSF
• JSF Hello World

I have used derby a while back. Several years later, I wanted to get it installed again on my machine.

In short, Derby is the Java Database that IBM contributed to the open source community. It was known then as cloudscape.

I start off by getting the bin download from the derby database

create DERBY_HOME environment variable : C:\JAVA\derby10\db-derby-10.2.2.0-bin\
Make sure I have my JAVA_HOME environment variable properly set
add to the PATH: C:\JAVA\derby10\db-derby-10.2.2.0-bin\bin\

from the command line:

>sysinfo

>ij

ij is the derby sql client command line

ij>connect ‘jdbc:derby://localhost:1527/mydb;
create=true;traceFile=trace.out;user=user1;password=secret4me’;

C:\JAVA\derby10\db-derby-10.2.2.0-bin\bin>

setNetworkClientCP.bat

C:\JAVA\derby10\db-derby-10.2.2.0-bin\demo\programs\simple>set CLASSPATH=.;%DERB
Y_HOME%\lib\derby.jar;%DERBY_HOME%\lib\derbynet.jar;%DERBY_HOME%\lib\derbyclient
.jar;%DERBY_INSTALL%\lib\derbytools.jar

C:\JAVA\derby10\db-derby-10.2.2.0-bin\frameworks>startNetworkserver.bat

C:\JAVA\derby10\db-derby-10.2.2.0-bin\demo\programs\simple>java org.apache.derby
.tools.sysinfo -cp embedded SimpleApp.class
FOUND IN CLASS PATH:

Derby embedded engine library (derby.jar)
C:\JAVA\derby10\db-derby-10.2.2.0-bin\lib\derby.jar

user-specified class (SimpleApp)
C:\JAVA\derby10\db-derby-10.2.2.0-bin\demo\programs\simple

SUCCESS: All Derby related classes found in class path.

get ibm jars for derby
C:\JAVA\derby10\db-derby-10.2.2.0-bin\demo\programs\simple>set CLASSPATH=.;%DERB
Y_HOME%\lib\db2jcc.jar;%DERBY_HOME%\lib\db2jcc_license_c.jar

C:\JAVA\derby10\db-derby-10.2.2.0-bin\frameworks>startNetworkserver.bat
C:\JAVA\derby10\db-derby-10.2.2.0-bin\demo\programs\simple>java SimpleApp jccjdb
cclient
SimpleApp starting in jccjdbc mode.
Loaded the appropriate driver.
Connected to and created database derbyDB
Created table derbyDB
Inserted 1956 Webster
Inserted 1910 Union
Updated 1956 Webster to 180 Grand
Updated 180 Grand to 300 Lakeshore
Verified the rows
Dropped table derbyDB
Closed result set and statement
Committed transaction and closed connection
SimpleApp finished

/* the default framework is embedded*/
public String framework = “embedded”;
public String driver = “org.apache.derby.jdbc.EmbeddedDriver”;
public String protocol = “jdbc:derby:”;

public static void main(String[] args)
{
new SimpleApp().go(args);
}

void go(String[] args)
{
/* parse the arguments to determine which framework is desired*/
parseArguments(args);

System.out.println(”SimpleApp starting in ” + framework + ” mode.”);

try
{
/*
The driver is installed by loading its class.
In an embedded environment, this will start up Derby, since it is not already running.
*/
Class.forName(driver).newInstance();
System.out.println(”Loaded the appropriate driver.”);

Connection conn = null;
Properties props = new Properties();
props.put(”user”, “user1″);
props.put(”password”, “user1″);

/*
The connection specifies create=true to cause
the database to be created. To remove the database,
remove the directory derbyDB and its contents.
The directory derbyDB will be created under
the directory that the system property
derby.system.home points to, or the current
directory if derby.system.home is not set.
*/
conn = DriverManager.getConnection(protocol +
“derbyDB;create=true”, props);

System.out.println(”Connected to and created database derbyDB”);

conn.setAutoCommit(false);

/*
Creating a statement lets us issue commands against
the connection.
*/
Statement s = conn.createStatement();

/*
We create a table, add a few rows, and update one.
*/

private void parseArguments(String[] args)
{
int length = args.length;

for (int index = 0; index < length; index++)
{
if (args[index].equalsIgnoreCase(”jccjdbcclient”))
{
framework = “jccjdbc”;
driver = “com.ibm.db2.jcc.DB2Driver”;
protocol = “jdbc:derby:net://localhost:1527/”;
}
if (args[index].equalsIgnoreCase(”derbyclient”))
{
framework = “derbyclient”;
driver = “org.apache.derby.jdbc.ClientDriver”;
protocol = “jdbc:derby://localhost:1527/”;
}
}
}

The Pragmatic Programmer

The Mythical Man Month

AntiPatternsCatalog

Eclipse Dali

The Vietnam Of Computer Science

Jacobsen : Use Cases and Aspects

GWT

coolandusefulgwt

GWT Designer

Clay Shirky : “Its Turtles All the Way Up“

Ted Neward on Rest vs Soap

Purl.org

REST: Get, Post, Put, Delete

Roy Fielding : Architectural Styles & the Design of Network-based Software Architectures

Spring 2.5 : SpringSource

Bob Mcwhirter : the founder of drools (jboss rules) and codehaus

Jess is another rules platform

Habits of Effective Programmers

Darshan Arney takes on: ‘ The Top software developers are more productive than average software developers not by a factor of 10x or 100x or even 1000x but by 10,000x.’

Ken Sipe 7 habits

Broken Windows Theory

Book – TopGrading

Raymond : The Cathedral and the Bazaar

Dijkstra: Computer Science is no more about computers than astronomy is about telescopes.

Writing the Right Stuff

The Corridor Principle

AgileManifesto

csszengarden

Groovy

grails.org

Groovy Recipes

Ken Sipe – Perficient

Neal Ford – Thoughtworks

Brian Goetz – Sun

David Geary

Brian Sletten - zepheira.com

Brian Sam-Bodden -   Integrallis

Jason Rudolph – Relevance

Venkat Subramaniam – Relevance

David Bock -  Java Guy

Jeff Brown – G2one

Scott Davis – aboutgroovy.com

Jared Richardson

Starting at about  12:00 tommorow I’ll be arriving at NoFluffJustStuff conference – also known as the Research Triangle Software Symposium. This is put on by Jay Zimmerman and his cast of notable experts from the software industry.

There are a lot of good choices on the menu.

jpa spec jsr 317

open jpa manual

In an applicationserver, EntityManager instances are typically injected, rendering the EntityManagerFactory unnecessary.

javax.persistence:

• Persistence : contains static helper methods to obtain EntityManagerFactory
  instances in a vendor-neutral fashion.
• EntityManagerFactory: is a factory for Entity-Manager
• EntityManager: is the primary JPA interface used by applications.Each EntityManager manages a set of persistent objects, and has APIs to insert new objects and delete existing ones. EntityManagers also act as factories for Query instances.
• Entity: persistent objects that represent datastore records.
• Query: Query interface is implemented by each JPA vendor to find persistent objects that
  meet certain criteria. JPA standardizes support for queries using both the Java Persistence Query Language (JPQL) and the Structured Query Language (SQL). You obtain Query instances from an EntityManager.

JPA uses a version field in your entities to detect concurrent modifications to the same datastore record. When the JPA runtime detects an attempt to concurrently modify the same record, it throws an exception to the transaction attempting to commit last. This prevents overwriting the previous commit with stale data.

private int version;

JPA introduces another form of object identity, called entity identity or persistent identity. Entity identity tests whether two persistent objects represent the same state in the datastore.

In this post I will cover getting started with the Roller4.0 blogging software including setting up the planet (aggregation server).

Anyway, I am using the mysql database (5.0.41 community edition) with roller 4
(best available) which i placed in Tomcat’s webapps directory naming the folder roller4_0 .

I am using tomcat 5.5 with java5.

Setup: Tomcat’s common/classes folder have placed file roller-custom.properties:
installation.type=auto
database.configurationType=jdbc
database.jdbc.driverClass=com.mysql.jdbc.Driver
database.jdbc.connectionURL=jdbc:mysql://localhost:3306/rollerdb
database.jdbc.username=root
database.jdbc.password=admin
mail.configurationType=properties
mail.hostname=smtp-server.nc.rr.com
mail.username=x
mail.password=x

Important: You need to put the mysql driver, and two other jars into Tomcats’s common/lib directory:

• mysql-connector-java-3.1.13-bin
• activation (obtained from my java 5 lib folder)
• mail (obtained from my java 5 lib folder)

After starting Tomcat, I go to the main screen via url http://localhost:8080/roller4_0/index.jsp

which says I have a successful connection but have no tables . So I click the button to create the tables.

Then, I get the page to create users and the blog.

Yes, you need a planet-custom properties (roller-custom.properties in common/classes) file…

I set up a blog which i called planet which I give a theme of
roller front page…

My weblog template now has
## 1) SITE-WIDE entries (the default)
##set($pager = $site.getWeblogEntriesPager($since, $maxResults))

One of the struts 2 sample applications is the Mailreader application which has training course via Struts from Square One site .

Building Web Applications
Building Struts 2 Applications [ Welcome] [More ...]

Struts 2 components

Action Handler, Result Handler, Custom Tags

Interceptor : bring custom code into call stack

• Timer Interceptor
• Prepare (able) - If the Action implements Preparable, calls its prepare method.

value stack : stack of objects that expression language can pull from

• Action instance pushed onto stack

Jumpstarting JUnit (More …)

Capturing Input(More …)

Validating Input (More …)

Request Lifecycle in Struts 2 applications

• User Sends request: User sends a request to the server for some resource.
• FilterDispatcher determines the appropriate action: The FilterDispatcher looks at the request and then determines the appropriate Action.
• Interceptors are applied: Interceptors configured for applying the common functionalities such as workflow, validation, file upload etc. are automatically applied to the request.
• Execution of Action: Then the action method is executed to perform the database related operations like storing or retrieving the data from database.
• Output rendering: Then the Result render the output.
• Return of Request: Then the request returns through the interceptors in the reverse order. The returning request allows us to perform the clean-up or additional processing.

Display the result to user: Finally the control is returned to the servlet container, which sends the output to the user browser.
Struts 2 Big Picture

The diagram depicts the architecture of Struts 2 Framework. It shows the the initial request goes to the Servlet container, which is then passed through a standard filer chain.

1. ActionContextCleanUp filter: The ActionContextCleanUp filter is optional. It is useful when integrating other technologies such as SiteMesh Plugin.
2. FilterDispatcher: the required FilterDispatcher is called, which in turn consults the ActionMapper to determine if the request should invoke an action. If the ActionMapper determines that an Action should be invoked, the FilterDispatcher delegates control to the ActionProxy.
3. ActionProxy: The ActionProxy consults the Configuration Files manager, which is initialized via the struts.xml file. Then the ActionProxy creates an ActionInvocation, which implements the command pattern. The ActionInvocation process invokes the Interceptors (if configured) and then invokes the action.
4. Once the Action returns, the ActionInvocation is responsible for looking up the proper result associated with the Action result code mapped in struts.xml. The result is then executed, which often (but not always, as is the case for Action Chaining) involves a template written in JSP or FreeMarker to be rendered. While rendering, the templates can use the Struts Tags provided by the framework. Some of those components will work with the ActionMapper to render proper URLs for additional requests.
5. Then the Interceptors are executed again in reverse order. Finally the response returns through the filters configured in web.xml file.
6. If the ActionContextCleanUp filter is configured, the FilterDispatcher does not clean the ThreadLocal ActionContext. If the ActionContextCleanUp filter is not present then the FilterDispatcher will cleanup all the ThreadLocals present.

Resources

• converting-struts-2-part1
• converting-struts-2-part2
• Tutorial

If you install the war on an application server (like tomcat ) you can easily run the sample projtect. Here is the struts 201 slides

Th version I have of the application mentions: “For more about the MailReader, including alternate implementations and a set of formal Use Cases, please visit the Struts University MailReader site” .

• MailReader Database Worksheet (Struts University)
• MailReader Object Model (Struts University)
• MailReader Tour (Struts University)
• MailReader Use Cases (Struts University)

The full source code for MailReader is available as svn site, binaries, nightlies

Other Struts2 Trainings include Migrating to Struts2 the and JPA .

REFERENCES:

• http://struts.apache.org/2.x/docs/home.html
• http://struts.apache.org/2.x/docs/core-developers-guide.html
• http://opensource.atlassian.com/confluence/oss/display/STRUTS/Home
• http://cwiki.apache.org/confluence/display/S2WIKI/Home
• http://www.gmjjavadesigns.com/gmjd/entry/struts_2_ajax_tags

Just last week, I learned about what’s new with Roller in 4.0

Thought it was finally time to try my own installation after being a one time user of this Roller platform on JRoller as user on http://www.jroller.com/interjavanet/ . I had forgotten my password over on that blog, and it did not seem to be stright forward on how you get your password reset.

Did I mention that Roller is now on Apache at http://roller.apache.org ?

They have their own wiki now at http://cwiki.apache.org/confluence/display/ROLLER

Anyway, I am using the mysql database (5.0.41 community edition) with roller 4
(apache-roller-src-4.0-rc9) which i placed in Tomcat’s webapps directory naming the folder roller4_0 .

I am using tomcat 5.5 with java5.

Setup: Tomcat’s common/classes folder have placed file roller-custom.properties:
installation.type=auto
database.configurationType=jdbc
database.jdbc.driverClass=com.mysql.jdbc.Driver
database.jdbc.connectionURL=jdbc:mysql://localhost:3306/rollerdb
database.jdbc.username=root
database.jdbc.password=admin
mail.configurationType=properties
mail.hostname=smtp-server.nc.rr.com
mail.username=x
mail.password=x

Important: You need to put the mysql driver, and two other jars into Tomcats’s common/lib directory:

• mysql-connector-java-3.1.13-bin
• activation (obtained from my java 5 lib folder)
• mail (obtained from my java 5 lib folder)

AFter starting Tomcat, I go to the main screen via url http://localhost:8080/roller4_0/index.jsp

which says I have a successful connection but have no tables . So I click the button to create the tables.

Then, I get the page to create users and the blog.

References :

• The Roller source code wiki page
• The Roller Build Guide wiki page
• The Roller Install Guide wiki page

Just noticed that Dave Johnson has upgraded Roller in version 4.o to use Struts2 and OpenJPA.

After learning about Webwork last year, I played with using Struts2 examples in a 1.4.x environment.

Roller wiki

Install Guide

• http://www.rkcole.com/articles/struts/crudTutorial/
• http://techienet.org/book-page/sarath/struts2-step-step-guide-programmers
• http://ahmadshajee.blogspot.com/2007/09/struts2-part-i-introduction.html
• http://j2eefolks.blogspot.com/2007/04/struts-2-features-and-short-summary.html

Last week was the conference, this week comes people trying to define it. My best definition would be netvibes.com

A checkpoint on Web 2.0 in the enterprise

As such, the situational application would be another web 2.0 concept. this article defines it great.

“where small groups and departments developed their own applications independent of the corporate IT department. Today more and more end users who are not professional programmers are developing web applications that better fit their own needs. A simple example is a wiki, where the users can create and modify the pages and their content. No programmer has to decide ahead of time what the topics of interest will be or the structure and layout of the pages. The users evolve something over time that suites their needs within the time budget they have to invest in the site.”

REST is another buzzwodr like this slide presentation that explains it.

In Raleigh, I got a chance to attend IBM’s technical briefing on web 2.0 .

For now, will just list various bits of info that I will organize later.

QEDWiki (Quick and easy design) . Assembly : “QEDWiki is a unique Wiki framework in that it provides both Web users and developers with a single Web application framework for hosting and developing a broad range of Web 2.0 applications.”

Damia . Feeds: “provides easy-to-use tools that developers and IT users alike can use to quickly assemble data feeds from the Internet and a variety of enterprise data sources. The benefits of this service include the ability to aggregate and transform a wide variety of data or content feeds, which can be used in enterprise mashups.”

Mashup Hub. Tag : “Mashup Hub provides two broad areas of support: feed generation for enterprise data sources and a catalog of feeds and user interface (UI) widgets.”

Info 2.0

Many eyes

Baby name wizard

gather.com

second life

strike iron

gold corp

zoho

zoot

what is dojo?

Dojo is an Open Source JavaScript UI toolkit. It makes writing JavaScript easier, building great interfaces faster, and deploying dynamic UIs at scale much easier. The foundation of Dojo is “Dojo Base”, a single tiny library which contains Ajax, event handling, effects, blazing fast CSS queries, language utilities, and a lot more. On top of this Base, the rest of Dojo Core adds high-quality facilities for Drag and Drop, extended forms of Ajax and I/O, JSON-RPC, internationalization, and back-button handling.

You can use the div tag to define widget locations and Dojo will place the widget there either during page load or in response to events.

dojo book 0.4 –API — reference documentation — Dojo jot wiki — dojo toolkit home

JavaPassion PDF has 86 pages of info.

What is JSON?

(Using Dojo and JSON to Build Ajax Applications article ) – JSON is a Java library that helps convert Java objects into a string representation. This string, when eval()ed in JavaScript, produces an array that contains all of the information that the Java object contained. JSONObject class , JSONArray class “- Dojo provides an abstraction layer for invoking JSON-RPC requests”

json over xml?

IBM Paper: “JSON is built on two structures:

1. A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
2. An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence

JSON-RPC is a lightweight remote procedure call protocol in which JSON serializes requests and responses

The request is a single object with three properties:

• method – A string containing the name of the method to be invoked.
• params – An array of objects to pass as arguments to the method.
• id – The request ID. This can be of any type. It is used to match the response with the request that it is replying to.

When the method invocation completes, the service must reply with a response. The response is a single object with three properties:

• result – The object that was returned by the invoked method. This must be null, in case there was an error invoking the method.
• error – An error object if there was an error invoking the method. It must be null, if there was no error.
• id – This must be the same ID as the request it is responding to.

A notification is a special request that does not have a response. It has the same properties as the request object with one exception:

id – Must be null“

Using Dojo and JSON to Build Ajax Applications article: Dojo libraries are organized in packages just like Java code. For this example, we will need to import two packages.

The dojo.io package contains classes that allow us to make HTTP requests using protocols such as XMLHTTPTransport.

The dojo.event package is designed to provide a unified event system for DOM and programmatic events.

The dojo.event.connect() method allows you to associate a handler for the onclick event for myButton:

function onLoad() {

   var buttonObj = document.getElementById("myButton");

   dojo.event.connect(buttonObj, "onclick",

          this, "onclick_myButton");

  }  function onclick_myButton() {

   var bindArgs = {

    url: "welcome.jsp",

    error: function(type, data, evt){

     alert("An error occurred.");

    },

    load: function(type, data, evt){

     alert(data);

    },

    mimetype: "text/plain",

    formNode: document.getElementById("myForm")

   };

   dojo.io.bind(bindArgs);

  }

The magical dojo.io.bind() function is where the power lies. It takes as argument bindArgs, an array of name/value pairs. In this example, we specify five pairs:

1. url: The URL to make the request to.
2. mimetype: The response type expected.
3. load: Code to execute upon success.
4. error: Code to execute upon error.
5. formNode: The ID of the form whose fields to submit as parameters to the URL.

Once the call to dojo.io.bind(bindArgs) is made,depending on whether the request encountered any errors, either the load or error code is executed. Both load and error take three arguments:
type: The type of function; it will always be set to load for load() and error for error().
data: The response received. If mimetype is specified as text/plain, data contains the raw response. If, however, text/json is used, data contains the value of eval('(' + responseReceived + ')'), where responseReceived is what the call returned.

evt: The event object.

• Dojo with a struts action example
• http://dojotoolkit.org/search/node/tree
• http://willcode4beer.com/ware.jsp?set=dojoTreeWidget
• http://www.sauter-online.de/dojo/demos/widget/Tree/tree.html
• http://www.thearcmind.com/confluence/display/RandomThoughts/DOJO+First+Glance
  
• http://dojo.jot.com/WikiHome/Tree
• http://home.exetel.com.au/cweatures/combosample/combotest.html
• http://www.stack.be/~roel/blog/archives/the-dojo-tree-control-for-beginners-part-1/
• http://www.stack.be/~roel/blog/archives/the-dojo-tree-control-for-beginners-part-2/
• http://www.it-eye.nl/weblog/2007/05/02/use-ajax-treecompontent-in-jsp-with-dojo/

softarc – the anti- experienced Coding Architect

Using NetBeans Open Source Toolbox , and More Netbeans

You are doing more modeling than you think

http://devlicio.us/blogs/derik_whittaker/archive/2007/05/09/questions-every-candidate-should-ask-a-potential-new-employer.aspx