Mathew's Thoughts

• Mock both classes and interfaces (you cannot mock final methods or final classes).
• Return your own data from calls to mock objects.
• Allows you to mock an exception from the mock object.
• Chain multiple mock calls.
• Specify how many times a method must be called in a unit test.
• EasyMock and Mockito support partial mocking.

• Create the Mock
• Connect the mock with the object being unit tested
• Set up the expectation on the mock (which methods on the mock need to get invoked, how many times, etc). To set up the expectations you call methods on the mock and thats it. The mock object will record the facts so as to verify it later.
• Replay mode. Hereafter the mock will keep track of invocations to itself and throw exceptions if
• Execute the test
• Verify the mock invocations.

    import static org.easymock.EasyMock.createControl;
    import static org.easymock.EasyMock.expect;
    import static org.easymock.EasyMock.replay;
    import static org.easymock.EasyMock.verify;

    private List vazips = new ArrayList();
    private LookupDataServiceImpl svc;
    private LookupDao mockdao;

    public void setUp() {

        vazips.add("20147");
        vazips.add("20191");

        // create the object to test
        svc = new LookupDataServiceImpl();

        // create the mock dao
        mockdao = createControl().createMock(LookupDao.class);
        svc.setLookupDao(mockdao);
    }

    public void test_NoExpectationsRecorded() {
        // - no expectations are recorded
        // - WILL FAIL the test since EasyMock requires you to
        // - record the expectations

        // - Switch to replay mode and run test
        replay(mockdao);

        // - invoke test
        svc.getZipCodes("va");

        // - verify WILL NOT GET CALLED...will fail in previous step
        verify(mockdao);
    }

java.lang.AssertionError: 
     Unexpected method call getZipCodes("va"):

    public void test_CorrectExpectationIsRecorded() {
        // - One expectations are recorded
        mockdao.addZipCode("va", "11122");

        // - run test
        replay(mockdao);
        svc.addZipCode("va", "11122");

        // - verify
        verify(mockdao);
    }

    public void test_VerifyReturnData() {
        // - One expectations are recorded
        expect(mockdao.getZipCodes("va")).andReturn(vazips);

        // - run test
        replay(mockdao);
        List<String> zipcodes = svc.getZipCodes("va");

        for (Iterator<String> iter = zipcodes.iterator(); iter.hasNext(); ) {
            System.out.println((String) iter.next());
        }

        // - verify
        verify(mockdao);
        assertTrue(zipcodes.size() == 3);
    }

expect(mockdao.getZipCodes("va")).andReturn(vazips);

expect(mockdao.getZipCodes("va")).andThrow(new RuntimeException("mock runtime exception"));

   import org.jmock.Expectations;
   import org.jmock.Mockery;
   import org.jmock.integration.junit4.JMock;
   import org.jmock.lib.legacy.ClassImposteriser;

   public void test_VerifyReturnData() {
        final String stateCode = "va";

        // - record your expectations here
        context.checking(new Expectations() {
            {
                oneOf(mockdao).getZipCodes(stateCode);
                will(returnValue(vazips));
            }
        });

        // - Execute test
        List<String> zipcodes = svc.getZipCodes("va");
        for (Iterator<String> iter = zipcodes.iterator(); iter.hasNext(); ) {
            System.out.println((String) iter.next());
        }

        // - verify
        context.assertIsSatisfied();
        Assert.assertTrue(zipcodes.size() == 3);
    }

       context.checking(new Expectations() {
            {
                oneOf(mockdao).addZipCode("12121", "ca");
                will(throwException(new RuntimeException("mock runtime exception")));
            }
        });

    import static org.mockito.Mockito.mock;
    import static org.mockito.Mockito.verify;
    import static org.mockito.Mockito.when;

    public void setUp() {
        vazips.add("20147");
        vazips.add("20191");

        // create the object to test
        svc = new LookupDataServiceImpl();

        // create the mock dao
        mockdao = mock(LookupDao.class);
        svc.setLookupDao(mockdao);
    }

    public void test_Mock() {
        // NOTE: Mockito does not have concept of expectations
        // you execute the test with the mock and after the test
        // validate any method behaviors you want
        // run test method

        svc.getZipCodes("VA");

        // verify
        verify(mockdao).getZipCodes("VA");
    }

    public void test_VerifyReturnData() {
        // stubs the return values on the mock dao
        when(mockdao.getZipCodes("va")).thenReturn(vazips);

        // run test method
        List<String> zipcodes = svc.getZipCodes("va");
        System.out.println(zipcodes.size());
        for (Iterator<String> iter = zipcodes.iterator(); iter.hasNext(); ) {
            System.out.println((String) iter.next());
        }

        // verify
        verify(mockdao).getZipCodes("va");
        assertTrue(zipcodes.size() > 0);
    }

when(mockdao.getZipCodes("ca")).thenThrow(new RuntimeException("mock runtime exception"));

• Assume you are on version 2.5 of your application. You would like to see the difference between certain files in 2.5 against an old revision 1.2.
• You then decide you want to add a new feature. So you decide to branch (branch-1). Some of us like branches. And why not - why mess around with the main code.
• Add some new code.
• Check that in.
• Damn I want to try out a different way of doing this, but don't want to mess with this branch - again.
• Switch to mainline and create another branch (branch-2).
• On branch-2 I try out my new approach. Got it working. Check it in.
• After some thought I decide that branch-2 is the way to go.
• Delete branch-1.
• Then merge branch-2 back into mainline.
• Finally delete the temporary branch-2.

• Hands-down technical person's view : Ivory tower, occasionally useful but mostly a pain, where all the "talkers" end up , and so on.
• Management: I have a deadline , get out of my way.
• Sr Mgmt - Hmmm. Do I need that. Actually I know what that is - let me tell you (but yikes I have never done that before)
• Operations/Support - If they existed I would not have this mess
• Business - I need it now. Whats all this waste in adding a simple MS Access application on my desktop to create quarterly financial reports.
• and so on

• Context & Dependency Injection (CDI). This allows for any POJO to be injected into dependent classes. Right now you have the ability to inject container managed resources (such as connection pools, EJB's). You cannot inject regular POJO objects. JEE6 adds that ability.
• CDI - Introduces annotations such as
  
  • @ManagedBean - Identifies a bean as a container managed bean.
  • @Model identifies a model object in a MVC architecture.
  • @*Scope annotations such as @SessionScoped which tie an instance of a bean to a scope such as request, session or application.
  • @Inject is used to inject managed beans into other dependent classes.
  • ...and so on...
• CDI allows session beans to be used in place of JSF beans (influenced from Seam obviously). This means you can use session beans in your JSF EL expressions.
• Bean Validations: Set of annotations to apply on java objects so that the validations can be shared between UI and backend tier.
• Eliminate web.xml with new annotations such as @WebServlet, @WebFilter , etc.
• Ability of servlets to respond to asynchronous requests (AJAX). This could greatly simplify the existing mechanisms on the server to handle such requests. Having the servlets take over this allows for more efficient use of server threads vs existing implementations.
• Introducing the concept of web fragments. Basically separate web.xml files so that appropriate frameworks can be configured in their own files.
• JSF 2.0 (includes annotations that let you eliminate the faces-config.xml file, AJAX support, facelets).
• Simplication of EJB in 3.1 (no requirement for business interfaces, singleton beans, asyhnchronous session beans)
• Concept of Profiles to differentiate between different configurations or stacks of JEE...similar to J2ME .See my article on J2ME at 
  http://my.advisor.com/doc/12697
• Ability to package EJBs as part of the WAR file.
• Inclusion of JAX-RS into the JEE spec (REST with JAX-RS).
• Support for JPA 2.0 (notably to me is the inclusion of a Criteria API...such as the one in Hibernate).

1. Updated the maven dependencies to reflect CXF libraries.
2. web.xml - to point to the CXF Servlet
3. Spring context (app-context.xml) - It was now a lot simpler and cleaner.
4. Finally I used CXF wsdl2java utils to generate a client

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.aver</groupId>
    <artifactId>echo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>CXF Echo Service</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>2.5.6</version>
        </dependency>

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>2.2.3</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <configuration>
                    <contextPath>/echoservice</contextPath>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>9090</port>
                            <maxIdleTime>60000</maxIdleTime>
                        </connector>
                    </connectors>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<web-app>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/app-context.xml
        </param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <servlet>
        <servlet-name>CXFServlet</servlet-name>
        <servlet-class>
            org.apache.cxf.transport.servlet.CXFServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>CXFServlet</servlet-name>
        <url-pattern>/services/*</url-pattern>
    </servlet-mapping>
</web-app>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="http://www.springframework.org/schema/beans www.springframework.org/schema/beans/spring-beans-2.0.xsd
    cxf.apache.org/jaxws 

">cxf.apache.org/schemas/jaxws.xsd">

    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

    <jaxws:endpoint id="echoService" implementor="#echo"
        address="/EchoService" />

    <bean id="echo" class="com.aver.EchoServiceImpl" />
</beans

./wsdl2java -p com.aver.client -client localhost:9090/echoservice/services/EchoService?wsdl

Invoking echo...
echo.result=echo: 'uyy ' received on 10-07-2009 10:53:59 PM

• Spring Batch - Part I
• Spring Batch - Part II - Flat File To Database
• Spring Batch - Part III - From Database to Flat File

• Separated out related code into different physical files.
• Created the src/components folder to hold reusable UI components in their respective .mxml files. 
• Created a new Class called Movie (file name Movie.as) in a package named dto. This class will hold the values of our grid properties. We will load the XML into instances of this class and collect them in a ArrayCollection.
• Finally we use some validators in our form to validate that both movie name and rating are entered. Unless entered (as valid) the Add Movie button will NOT be enabled.

<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" xmlns:comp="components.*" initialize="initApp()">

   <mx:Script>
		<![CDATA[
			import dto.Movie;
			import mx.controls.Alert;
			import mx.collections.ArrayCollection;
		

            [Bindable]
            public var movieList:ArrayCollection;

            public var moviexml:XML = 
		      <movies>
			       <movie>
				     <name>Angels & Demons</name>
				     <rating>1</rating>
				   </movie>
				   <movie>
				     <name>Ice Age 3</name>
				     <rating>2</rating>
				   </movie>
				   <movie>
				     <name>Transformers: Revenge of the Fallen</name>
				     <rating>3</rating>
				   </movie>
		      </movies>;	
      		
            public function initApp():void {
                movieList = new ArrayCollection(); 
                for each (var movie:XML in moviexml.movie) {
                    var mv:Movie = new Movie();
                    mv.name = movie.name;
                    mv.rating = movie.rating;
                    movieList.addItem(mv);
                }
                movieGrid.initApp();
            }
       ]]>
	</mx:Script>	
	

	<mx:VBox width="50%">
	   <mx:Label color="blue" text="Movies I have seen..."/>
	   <comp:MovieGrid id="movieGrid" movieList="{movieList}" width="100%"/>
	   <comp:addmovieform movieList="{movieGrid.movieList}"/>
	</mx:VBox>
		
</mx:Application>        

• The new xmlns:comp namespace which refers to the components folder (components.* allows us to refer to all components in the src/components folder.
• We pass in references to values in the mx:VBox such as in comp:MovieGrid we pass in the movieXML parameter into the component.
• The mx:VBoxis a layout container that places components vertically (there is an mx:HBox too if you want).
• In the initApp method I iterate through the XML , create Movie instances and add them to the movieList ArrayCollection.

package dto {
	public class Movie {
		public var name:String;
		public var rating:Number;
		
		public function Movie() {
		}
	}
}

• .actionScriptProperties, .flexProperties contain various Flex related configuration.
• .project is the Flex eclipse project configuration.
• By default Flex Builder created a FirstFlexApp.mxml file. This is what you will run to execute your application.

<?xmlversion="1.0"?>
<mx:Applicationxmlns:mx="http://www.adobe.com/2006/mxml"creationComplete="initApp()">
...
</mx:Application>

<mx:XMLList id="moviexml">
   <movie>
     <name>Angels&Demons</name>
     <rating>1</rating>
   </movie>

   <movie>
     <name>Ice Age3</name>
     <rating>2</rating>
   </movie>

   <movie>
     <name>Transformers:Revenge of theFallen</name>
     <rating>3</rating>
   </movie>
</mx:XMLList>

    <mx: Panel title="Movie List" height="100%" width="100%" 
        paddingTop="10" paddingLeft="10" paddingRight="10">

        <mx:Label width="100%" color="blue"
            text="Movies I have seen..."/>

        <mx: DataGrid id="movieGrid" width="50%" height="50%" rowCount="4" resizableColumns="true" editable="false" >
            <mx:columns>
                <mx: DataGridColumn dataField="name" headerText="Name"/>
                <mx: DataGridColumn dataField="rating" headerText="Rating" />
				<mx: DataGridColumn width="40" sortable="false" fontWeight="bold">
				    <mx:itemRenderer >
						<mx:Component>
                                                // refer to full listing for code here
						</mx:Component>  
				    </mx:itemRenderer>
				</mx: DataGridColumn>            
            </mx:columns>
        </mx: DataGrid>
        
        <mx: Panel width="359" height="170" layout="absolute">
            <mx:Label x="10" y="10" text="Movie Name:"/>
            <mx:Label x="42" y="36" text="Rating:"/>
            <mx:TextInput x="96" y="8" id="fldMovieName"/>
            <mx:TextInput x="96" y="34" width="25" id="fldMovieRating" maxChars="1"/>
            <mx:Button x="69" y="76" label="Add Movie" click="addMovie()"/>
        </mx: Panel>
        
    </mx: Panel> 

mxataGridColumn

<mx:Script>
<![CDATA[
   import mx.collections.XMLListCollection;
   import mx.controls.Alert;


   [Bindable]
   private var movieList:XMLListCollection; 
            
   public function initApp():void {
      movieList = new XMLListCollection(moviexml); 
      movieGrid.dataProvider = movieList;
   }

   private function addMovie():void {	        	
      if ( fldMovieName.text == "" || fldMovieRating.text == "") {
         Alert.show("Enter valid values for movie and rating.","Alert");
      }
      else {
         movieList.addItem(
           
              {fldMovieName.text}
              {fldMovieRating.text}
            );
      }
   }
]]>
</mx:Script>

• <ui:insert name="title"> : Creates a placeholder to drop page titles.
• <ui:insert name="body"> : Creates a placeholder to drop page content.

• <ui:composition template="/template.xhtml"> : The composition tagis used to identify the template to be used for this page.
• <ui:define name="title"> : The ui:define tag is used here toinsert the page title
• <ui:define name="body"> : The ui:define tag is used here toinsert the page contents.

• com.sun.facelets.FaceletViewHandler is the what does the templating magic.

• REST prescribes that all services be treated as resources that can be accessed via a URL. Thus the web is REstful.
• REST also requires the services to be stateless.
• REST does NOT describe any common data exchange formats. The producer and consumer are free to choose whatever format they can agree on.
• REST services in many cases are cacheable (though I think in many business cases it is not and thats just fine).
• REST is commonly used over HTTP (though since it is an architectural style one can use the same principles on any transport).

• GET to retrieve data.
• DELETE to delete.
• INSERT to add new data
• PUT to update data.

• @Path("/timeoftheday") - Specifies the URI part for all the services in thisclass.
• @GET- Used to annotate the read method.
• @Produces("text/plain")- Marks the method as a producer of plain/text content.
• @Path("/asjson/{name}/") - Describes the specific method. The optional {name} describes in our case the parameter passed into this service method.

• http://localhost:8080/jaxrs/services/timeoftheday/asplaintext/mathew
• http://localhost:8080/jaxrs/services/timeoftheday/asxml/mathew
• http://localhost:8080/jaxrs/services/timeoftheday/asjson/mathew

 ID INT NOT NULL AUTO_INCREMENT,
 rcv_dt date,
 mbr_nm VARCHAR(100) not null,
 chk_nbr VARCHAR(10) not null,
 chk_dt date,
 pymt_typ VARCHAR(50) not null,
 dpst_amt double,
 pymt_amt double,
 comments VARCHAR(100),
 PRIMARY KEY (ID)

 

• 1 through 4 are the same as the previous blog.
• 5 - Defines the step job and its steps.
• 6 - Registers a JdbcCursorItemReader which will read the rows from the database. It will then write them out to the flat file. The latest version also has a new reader JdbcPagingItemReader. This is a better option since it will read a predefined set of rows rather than making round trips for each row.
• 8 - Configure the writer to write to a flat file

 
// ====================================================
// Ledger BEAN
// ====================================================
package com.batch.todb;

import java.util.Date;

public class Ledger {
    private int id;
    private Date receiptDate;
    private String memberName;
    private String checkNumber;
    private Date checkDate;
    private String paymentType;
    private double depositAmount;
    private double paymentAmount;
    private String comments;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Date getReceiptDate() {
        return receiptDate;
    }

    public void setReceiptDate(Date receiptDate) {
        this.receiptDate = receiptDate;
    }

    public String getMemberName() {
        return memberName;
    }

    public void setMemberName(String memberName) {
        this.memberName = memberName;
    }

    public String getCheckNumber() {
        return checkNumber;
    }

    public void setCheckNumber(String checkNumber) {
        this.checkNumber = checkNumber;
    }

    public Date getCheckDate() {
        return checkDate;
    }

    public void setCheckDate(Date checkDate) {
        this.checkDate = checkDate;
    }

    public String getPaymentType() {
        return paymentType;
    }

    public void setPaymentType(String paymentType) {
        this.paymentType = paymentType;
    }

    public double getDepositAmount() {
        return depositAmount;
    }

    public void setDepositAmount(double depositAmount) {
        this.depositAmount = depositAmount;
    }

    public double getPaymentAmount() {
        return paymentAmount;
    }

    public void setPaymentAmount(double paymentAmount) {
        this.paymentAmount = paymentAmount;
    }

    public String getComments() {
        return comments;
    }

    public void setComments(String comments) {
        this.comments = comments;
    }
}
 
 
// ====================================================
// ROW MAPPER TO CONVERT DATABASE RECORD TO JAVA OBJECT
// ====================================================
package com.batch.fromdb;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

import com.batch.todb.Ledger;

@Component("ledgerRowMapper")
public class LedgerRowMapper implements RowMapper {
    public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
        Ledger ledger = new Ledger();
        ledger.setId(rs.getInt("id"));
        ledger.setReceiptDate(rs.getDate("rcv_dt"));
        ledger.setMemberName(rs.getString("mbr_nm"));
        ledger.setCheckNumber(rs.getString("chk_nbr"));
        ledger.setCheckDate(rs.getDate("chk_dt"));
        ledger.setPaymentType(rs.getString("pymt_typ"));
        ledger.setDepositAmount(rs.getDouble("dpst_amt"));
        ledger.setPaymentAmount(rs.getDouble("pymt_amt"));
        ledger.setComments(rs.getString("comments"));
        return ledger;
    }

}

// ====================================================
// JUNIT CLASS
// ====================================================
package com.batch.fromdb;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.StopWatch;

@ContextConfiguration(locations = "classpath:com/batch/fromdb/contextFromDB.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class FromDBBatchTestCase extends
		AbstractDependencyInjectionSpringContextTests {

	private final static Logger logger = Logger
			.getLogger(FromDBBatchTestCase.class);

	@Autowired
	private JobLauncher launcher;

	@Autowired
	private Job job;
	private JobParameters jobParameters = new JobParameters();

	@Before
	public void setup() {
		PropertyConfigurator
				.configure("c:/mathew/springbatch2/src/com/batch/log4j.properties");
	}

	@Test
	public void testLaunchJob() throws Exception {
		StopWatch sw = new StopWatch();
		sw.start();
		launcher.run(job, jobParameters);
		sw.stop();
		logger.info(">>> TIME ELAPSED:" + sw.prettyPrint());
	}

	@Autowired
	public void setLauncher(JobLauncher bootstrap) {
		this.launcher = bootstrap;
	}

	@Autowired
	public void setJob(Job job) {
		this.job = job;
	}
}

 ID INT NOT NULL AUTO_INCREMENT,
 rcv_dt date,
 mbr_nm VARCHAR(100) not null,
 chk_nbr VARCHAR(10) not null,
 chk_dt date,
 pymt_typ VARCHAR(50) not null,
 dpst_amt double,
 pymt_amt double,
 comments VARCHAR(100),
 PRIMARY KEY (ID)

• 1 through 4 are the same as the previous blog.
• 5 - Defines the job and its steps. Also registers a job listener and a step listener
• 6 - The reader used to read the flat file with comma separated columns. The FlatFileItemReader will read the rows from the flat file and pass it to the writer to persist to the database..
• 8 - Not shown here is the item writer. It is configured using annotations and the class is LedgerWriter.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:batch="http://www.springframework.org/schema/batch"

    xsi:schemaLocation="
    www.springframework.org/schema/beans www.springframework.org/schema/beans/spring-beans-2.0.xsd
    www.springframework.org/schema/tx www.springframework.org/schema/tx/spring-tx-2.0.xsd
    www.springframework.org/schema/aop www.springframework.org/schema/aop/spring-aop-2.0.xsd
    www.springframework.org/schema/util www.springframework.org/schema/util/spring-util-2.0.xsd
    www.springframework.org/schema/batch www.springframework.org/schema/batch/spring-batch-2.0.xsd
    www.springframework.org/schema/context 

">www.springframework.org/schema/context/spring-context-2.5.xsd">

    <!-- 1) USE ANNOTATIONS TO CONFIGURE SPRING BEANS -->
    <context:component-scan base-package="com.batch" />

    <!-- 2) DATASOURCE, TRANSACTION MANAGER AND JDBC TEMPLATE  -->
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/seamdb" />
        <property name="username" value="root" />
        <property name="password" value="" />
    </bean>

    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" />

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>


    <!-- 3) JOB REPOSITORY - WE USE IN-MEMORY REPOSITORY FOR OUR EXAMPLE -->
    <bean id="jobRepository"
        class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
        <property name="transactionManager" ref="transactionManager" />
    </bean>

    <!-- 4) LAUNCH JOBS FROM A REPOSITORY -->
    <bean id="jobLauncher"
        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository" />
    </bean>


    <!--
        5) Define the job and its steps. In our case I use one step. Configure
        its readers and writers
    -->
    <batch:job id="simpleJob">
        <batch:step id="step1">
            <batch:tasklet>
                <batch:chunk reader="cursorReader" writer="flatFileWriter"
                    commit-interval="1000" />
            </batch:tasklet>
        </batch:step>
    </batch:job>

    <!-- ======================================================= -->
    <!--  6) READER -->
    <!-- ======================================================= -->
    <bean id="cursorReader"
        class="org.springframework.batch.item.database.JdbcCursorItemReader">
        <property name="dataSource" ref="dataSource" />
        <property name="sql" value="select * from ledger" />
        <property name="rowMapper" ref="ledgerRowMapper" />
    </bean>


    <!-- ======================================================= -->
    <!--  7) WRITER -->
    <!-- ======================================================= -->
    <bean id="flatFileWriter" class="org.springframework.batch.item.file.FlatFileItemWriter">
        <property name="resource" value="file:/Users/mathew/temp/ledgers-output.txt" />
        <property name="lineAggregator">
            <bean
                class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
                <property name="delimiter" value="," />
                <property name="fieldExtractor">
                    <bean
                        class="org.springframework.batch.item.file.transform.BeanWrapperFieldExtractor">
                        <property name="names" value="id,receiptDate,memberName" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

1. Use annotations to identify and autowire my spring beans.
2. Ignore the data source configuration. It is not used for this example. Because I have a DAO I use for Part II & III this is here.
3. Configure the job repository. Using an in-memory persistent store for this example.
4. The job launcher.
5. Register the two beans that make up my 2 steps for the job. One prints hello world and the other the time of the day.
6. Last but not the least is the Job definition itself. Note the batch:listener which registers a listener to track job execution.

package com.batch.simpletask;

import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;

public class HelloTask implements Tasklet {

    private String taskStartMessage;

    public void setTaskStartMessage(String taskStartMessage) {
        this.taskStartMessage = taskStartMessage;
    }

    public RepeatStatus execute(StepContribution arg0, ChunkContext arg1)
            throws Exception {
        System.out.println(taskStartMessage);
        return RepeatStatus.FINISHED;
    }
}

package com.batch.simpletask;

import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;

public class HelloTask implements Tasklet {

    private String taskStartMessage;

    public void setTaskStartMessage(String taskStartMessage) {
        this.taskStartMessage = taskStartMessage;
    }

    public RepeatStatus execute(StepContribution arg0, ChunkContext arg1)
            throws Exception {
        System.out.println(taskStartMessage);
        return RepeatStatus.FINISHED;
    }
}

package com.batch.simpletask;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.StopWatch;

@ContextConfiguration(locations = "classpath:com/batch/simpletask/simpletaskletcontext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class SimpleTaskletTestCase extends
        AbstractDependencyInjectionSpringContextTests {

    private final static Logger logger = Logger
            .getLogger(SimpleTaskletTestCase.class);

    @Autowired
    private JobLauncher launcher;

    @Autowired
    private Job job;
    private JobParameters jobParameters = new JobParameters();

    @Before
    public void setup() {
        PropertyConfigurator
                .configure("c:/mathew/springbatch2/src/com/batch/log4j.properties");
    }

    @Test
    public void testLaunchJob() throws Exception {
        StopWatch sw = new StopWatch();
        sw.start();
        launcher.run(job, jobParameters);
        sw.stop();
        logger.info(">>> TIME ELAPSED:" + sw.prettyPrint());

    }

    @Autowired
    public void setLauncher(JobLauncher bootstrap) {
        this.launcher = bootstrap;
    }

    @Autowired
    public void setJob(Job job) {
        this.job = job;
    }
}

Hello World - the time is now
Thu Sep 24 21:36:03 EDT 2009

• Ruby & Ruby on Rails
• PHP & Zend Framework
• Python & Django

• Sun's Virtual Box VM software 2.0.2 http://www.virtualbox.org/.
• Downloaded Ubuntu 8.0.4 as of this writing (http://www.ubuntu.com/getubuntu/download). What you get is an image file (.iso file)!
• Next I used VirtualBox to set up a new VM using the Ubunto iso image file.

sudo update-alternatives --config java
No alternatives for java

• Download the linux version of JDK 1.6 from http://java.sun.com/javase/downloads/ea/6u10/6u10rcDownload.jsp#6u10JDKs.
  
• Next chmod of the downloaded bin file so that we can execute it (lazy me did a chmod 777 jdk-6u10-rc2-bin-b32-linux-i586-12_sep_2008.bin)
• Next execute that file ./jdk-6u10-rc2-bin-b32-linux-i586-12_sep_2008.bin
• This should create a exploded directory jdk1.6.0_10
• sudo mv jdk1.6.0_10 /usr/bin/jvm (make sure there is a folder named /usr/bin/jvm/jdk1.6.0_10)
• To map java run command
• sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk1.6.0_10/jre/bin/java 60 --slave /usr/share/man/man1/java.1.gz java.1.gz /usr/lib/jvm/jdk1.6.0_10/man/m
  
• To map javac run command
• sudo update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk1.6.0_10/bin/javac 60 --slave /usr/share/man/man1/javac.1.gz javac.1.gz /usr/lib/jvm/jdk1.6.0_10/man/m
  
• Thats it.
  

sudo update-alternatives --config java
mathew@mathew-desktop:~$ sudo update-alternatives --config java
[sudo] password for mathew:

There is only 1 program which provides java
(/usr/lib/jvm/jdk1.6.0_10/jre/bin/java). Nothing to configure.

• Next I installed PHP5. Ubuntu has described that in good detail at https://help.ubuntu.com/8.04/serverguide/C/php5.html. Not repeating it here. Most important - run the hello world php to make sure all is good.
• Some useful apache2 file/folder locations.
• To edit site site root folder => sudo vi /etc/apache2/sites-available/default
• I changed my DocumentRoot to  /home/mathew/projects/zendqs/public (this is in preparation for my first Zend example...the quickstart example from the zend site).
• To restart apache2 => sudo /etc/init.d/apache2 restart
  
• Download the latest version of Zend (1.6 as of this blog http://framework.zend.com/).
  
• Now we need to tell Apache2 about Zend. Edit the Apache2 configuration file /etc/php5/apache2/php.ini
• Add the line: include_path = "/usr/share/ZendFramework-1.6.1"
• As you can see I moved my ZendFramework download folder to the location above.
  
• Remember this site if you run into any mod_rewrite issues http://www.huanix.com/2007/04/18/mod_rewrite-for-apache2-in-ubuntu-feisty-fawn-704/. This article will tell you how to enable mod_rewrite if it is not already done. You will come across mod rewrite when if you follow the Zend Quickstart example as I plan to.
  

            // setup timer to refresh list automatically

            Timer refreshTimer = new Timer() {

                  public void run() {

                        refreshWatchList();

                  }

            };

            refreshTimer.scheduleRepeating(REFRESH_INTERVAL);

      private void refreshWatchList() {

            // lazy initialization of service proxy

            if (stockPriceSvc == null) {

                  stockPriceSvc = GWT.create(StockPriceService.class);

            }

            AsyncCallback<StockPrice[]> callback = new AsyncCallback<StockPrice[]>() {

                  public void onFailure(Throwable caught) {

                        // do something with errors

                  }

                  public void onSuccess(StockPrice[] result) {

                        updateTable(result);

                  }

            };

            // make the call to the stock price service

            stockPriceSvc.getPrices(stocks.toArray(new String[0]), callback);

      }

• Spring namespace is used to configure security.
• security:authentication-manager need not be listed. If not a default will be created. List it if you need to refer it from some other configuration. In my case I just did to make the point.
• security:http is very self explanatory. We configure form login page names and the roles-to-URL patterns to protect. You can choose to not have this mapping here and instead implement your own object definition source class and provide the info from there.
• Finally security:authentication-provider is used to configure a password encoder and in this case a in-memory user store. The password is 'password'. I have listed the MD5 values above to show the use of the encoder.
  

• Note the use of the taglib authz to show/hide admin related content.
  

    <global-method-security secured-annotations="enabled" jsr250-annotations="enabled"/>

Android is a complete open source stack that allows one to build mobile applications. The stack includes an operating system, middleware and common applications. It also provides us with a Java API to develop our own custom mobile applications. It does not discriminate between common applications vs custom applications. Everything that the common applications can do so can yours (making calls, sending SMS, etc.).

What gets me excited is the (Linux kernel based) OS. There is no open source OS on the mobile platform. This is a major plus when it comes to mobile environments.

Before going into an Android sample, it is obvious to ask...what about Java ME (previously called J2ME). I do not see any reason why there cannot be a Java ME runtime created for Android OS. With that we could continue to use Java ME. Also this would open up use of JavaFX on this platform. As of today I could not locate Java ME implementations. If the reader knows of one please do let me know.

The one concern I had was regarding the Optional API's in Android. It is a known fact that not all mobile devices are created equal (in hardware and other related device capabilities). Some devices will not support a certain feature therefore those API's will not work on them. This is exactly the reason why Java ME created configuration and profiles. So now the Android optional API is going to end up in the same situation as Java ME. Whatever they decide to call it eventually, there has to be some basic API sets such as Java ME's configuration and profile. So I do not see any big need to jump ship from Java ME to Android (other than the new car smell). I do believe that eventually there will be a Java ME implementation on the Android.

• Activity - An activity is nothing but a user screen.
• IntentReceiver - These are non UI components you build so that you can listen for external events such as a phone ring.
• Service - Non-UI component that will always run in the background.
• Content Provider - Allows the application to store data locally.
  

First get yourself a copy of Android from http://code.google.com/android/intro/installing.html. Follow the instructions there or just do the following:

• Unzip the Android zip to some folder.
• Add <android-folder>\tools to your OS path environment.
• Install the Eclipse plugin via URL https://dl-ssl.google.com/android/eclipse/ . Restart Eclipse if prompted.
• Open Eclipse Window->Preferences. Select Android on the left and set the SDL location to yours (example C:\mathew\android-sdk_m5-rc15_windows).

Now create a New Android project in eclipse. It will pop up

Click finish and you should now have your project ready. The wizard has created the following basic application class named HelloApplication.java

• Apache Directory Server 1.5.2. I decided to use the sample directory data.
• Installed the Apache Directory Studio eclipse plugin.

• hostname - localhost
• port - 10389
• Bind DN or user - uid=admin,ou=system
• password - secret (this is the default password for apache ds)

• @Service marks this as a component managed by Spring.
• @Autowired marks the field as a dependency which Spring will inject. You could provide a setter method for Clock and then have the @Autowired annotation against the method. But I am in favor of annotating the field itself. Why waste code lines just to do injection

• The tag 'context:annotation-config' tells spring to go the annotation way.
• The tag 'context:component-scan' tells spring to look for annotated classes in the specified package. Once you put this tag you do not need the 'context:annotation-config' tag.
• Sometimes when we auto wire by type there may be multiple beans of the same type (or inherited type). One case is if you define multiple datsasources. How do you tell your bean in that case which one to pick. In this case use @Qualifier("beanid") to select the specific one.
  

• You can use @Repository to instead of @Service to mark DAO implementations.
• @Component is a generic annotation to mark any object as a spring managed object. @Repository and @Service are special stereotypes that mark business service and DAO classes.
• @Required is used to mark a property as required to be set. At runtime an IllegalArgumentException will be thrown if this dependency is not wired.
• @Transactional is used to mark methods/classes as transactional. If applied on the class it applies to all methods otherwise to specific methods. For this to work you must set up a transaction manager and also enable annotation driven transaction demarcation using
  

  <tx:annotation-driven transaction-manager="txManager"/>
  

• You can also use the JSR-250 annotation @Resource(name="abc") to perform dependency injection. Name will be the id of the bean.
• Another pair of JSR-250 annotations that are supported are the lifecycle method annotations @PostConstruct and @PreDestroy. These will mark methods that need to be notified when those lifecycle events occur.
  

• trunk will contain your main line development
• branches will contain just that. You can also use this folder to create temporary branches and then remove them later (remove does not delete the folder...it just removes it from the HEAD version).
• tags will hold code that has been labeled over time

• Edit the code file. The edits are local and not visible to other users.
• Check in the file. Now other users can "see" the changes when they sycnh to the HEAD version.
• To get changes from others perform an 'update' on the folder. This will synch your working copy with the HEAD version.
• Remember when you check a file into subversion it versions the entire code base and not just that one file. This way subversion is able to take you to the state of the code for a given checkin. This is slightly confusing for folks who are used to other repository tools that version file by file.
• Of course in your local copy you can have files from various versions and not just the head.

svn copy svn://hostname/svnrepository/myapp1/trunk \
         svn://hostname/svnrepository/myapp1/tags/R1-S1 \
         -m "Release1-Sprint1 tag"

svn copy svn://hostname/svnrepository/myapp1/trunk \
         svn://hostname/svnrepository/myapp1/branches/release1.1 \
         -m "Creating branch for 1.1."

• Talk to a J2EE application and get the status of inventory for a certain product. This is via a EJB interface (stateless session bean).
• Talk to a .NET application to find out current vendors, who we have contracted with, to purchase products.
• Send an email approval request to a requisition manager and wait for his approval before proceeding with the purchase.
• Once approved, send the order to vendor-A via ftp. Vendor-A loves FTP and comma delimited text file formats. So we need to transform the message to their needs.
• Monitor recepit of a file from vendor-A which says "yes we received the order...we expect to ship it on blah date". 
• Send an XML document with transaction details (via Web Services) to the payment processing system to approve payment for this order.
• We need to make sure everything is audited. 
• One last thing....only authorized users can perform these steps. Integrate with the cooporate LDAP server for authentication needs.

• The entire process is a workflow with clearly defined tasks happening along the way. So we need a way to describe the business process and orchestrate the entire flow.
• The workflow has a manual task in there (manager approval). So this is a asynchronous workflow that can take many days to execute.
• Distributed applications and technologies (j2ee, .net). 
• Different communication mechanisms (web services, EJB/RMI, FTP, email). 
• Data transformation is required at various steps.
• Security. Only authorized individuals can use this system. How do we interoperate the different security mechanisms used.

• An SOA based architecture to build services.
• A reliable messaging backbone (or bus) via which the various resources can communicate. Earlier I listed some types of resources. They were all external to the ESB. You could also have resources internal to the ESB, like specific business components residing inside.
• A message routing mechanism so that messages flow from one resource to the other. No more direct resource to resource links (via code).
• Content based routing. 
• Data transformation. Change one XML document to another XML doc with different schema or from XML to a comma delimited text file.
• Provides adapters which deal with talking to resources, thereby saving you the trouble of writing resource specific code.
• Adapters also perform marshalling and unmarshalling of data between the resource and the message bus.
• A business process modeling language and runtime to manage business workflows (BPEL).
• Transactional services.
• Security.
• Supports open standards such as Web Services (SOAP, WSDL, UDDI).
• Supports various communication mechanisms such as FTP, Secure FTP, CORBA. RMI, REST, HTTP, SSL, SMTP, etc.
• Some ESB's will also provide support for SOA Governance. This allows enforcing and tracking service usage.

1. When the page is loaded, draw some tabbed panes.
2. When the page is loaded, make an ajax call to get an RSSxml file and then parse through the XML response and display all blogtitles.
3. When a link is clicked you want some list items (in litags) to turn blue via css manipulation.
4. And you want to display the number of paragraphs within adiv.
5. Last you want the div to hide (slowly).
6. Oh also when you click on the tabs you want to print outthe current time.

• $("#orderedlist > li") means return the li elementsinside the element with id 'orderedlist'. 
• $.ajax is the call to the ajax function. If you arefamiliar with JSON you should be fine reading that code.
• $(xml).find('entry').find('title').each(function(){....}parses the AJAX XML response. Finds all entry/title elements and foreach executes the anonymous function.
• $("a").click(function(){....} attaches an anonymous eventhandler function to ALL link tags.
• $("a").addClass adds a style class to all link tags.
• $("#mycontainer p").size() means count the number of<p> tags inside the div element with id 'mycontainer'.
• $("#numparas").text means replace the text inside.

I am using YUI (version 2.4.1) datatable for tabular data rendering. I needed to allow the users to have the ability to select one or more rows using checkboxes and then submit them to the server for further action. Up to this point you can find sample code on YUI website or other sites if you search around.

For a better user experience I also needed to give them links to 'Select All' and 'Unselect All' which did exactly that. This I was not able to find on the web (I am sure it is there somewhere). Since I finally figured it out, I thought it only fair to blog-it so others can find. Code is quite simple.

In the sample below I will only highlight the code necessary to make this happen. For more details on YUI datatable refer to Yahoo site.

To start off lets add a check box to the table. In the sample below the first column is the check box column.

In my case the data is coming via. JSON and I need the default case to be select all. Thus my JSON result set will have checked = true for all rows.

• Most important. The Acegi download jar has a basic configuration war file (acegi-security-samples-tutorial-1.0.5.war). I used the Spring configuration in there as my starting point. 
• http://www.acegisecurity.org/articles.html
• One recent article on the web http://www.javaworld.com/javaworld/jw-10-2007/jw-10-acegi2.html.

• WebWork for web UI framework. Migration to Struts2 will be easier later when the project moves to JDK 1.5 (if ever).
• Sitemesh - instead of tiles I preferred this one. Less configuration and works great for my needs.
• Spring + Hibernate (and jdbc where needed) on the business logic tier.
• Lastly I am using YUI for certain widgets such as datatable and calendar.

• The Spring aop support in the configuration xml is extremely useful. Use it to your advantage.
• I have my Webwork actions being managed by Spring. This allows me to intercept the action classes in Spring and then do some work there; like exception handling. On the way out of the action classes I expect any application exceptions to be logged in a log file and also messages converted to full messages from resource bundles

1. AJAX-lite clients. These web pages use XMLHttpRequest or some wrapper framework to make asynchronous calls to the server. They receive back HTML responses which the client then inserts into specific locations in the web page. These applications may sometimes use widget libraries to enhance user experience.
2. RIA-AJAX. The asynchronous nature still exists. Always uses rich widget libraries (such as dojo, YUI, backbase, tibco GI, etc). But here the event handling and data manipulation is at the widget level (a widget being anything from a text box to a panel or window).

• @WebService declares the class as exposing a web service method(s).
• @WebMethod declares the particular method as being exposed as a web service operartion.
• @WebParam gives easy-to-read parameter names which will show up in the auto-generated WSDL. Always provide these for the sake of your consumers sanity.
• Also you can see that the java method is named 'printback' but exposed as name 'echo' by the @WebMethod annotation.

• Sets up the xfire bean to recognize jsr 181 annotations.
• Last bean is our echo service implementation bean (withannotations).

• mvn package
• mvn jetty:run

• RPC based. 
• Document based.

1. Create your XML schema (.xsd file). Inside the schema you will create your request messages and response messages. Bring up your favorite schema edit or to create the schema or write sample request and response XML and then reverse-engineer the schema (check if your tool supports it).
2. You have shifted the focus onto the document (or the XML). Now use Spring-WS to point to the XSD and set up a few Spring managed beans and soon you have the web service ready. No WSDL was ever written.

<ec:EchoRequest>
        <ec::Echo>
           <ec:Name>Mathew</ec:Name>
        </ec:Echo>
</ec:EchoRequest>

<ec:EchoResponse>
    <ec:EchoResponse>
         <ec:Message>echoback: name Mathew received on 05-06-2007 06:42:08PM</ec:Message>
    </ec:EchoResponse>
</ec:EchoResponse>

package echo.service;

public interface EchoService {
    public String echo(java.lang.String name);
}

package echo.service;

import java.text.SimpleDateFormat;
import java.util.Calendar;

public class EchoServiceImpl implements EchoService {

    public String echo(String name) {
        if (name == null || name.trim().length() == 0) {
            return "echo back: -please provide a name-";
        }
        SimpleDateFormat dtfmt = new SimpleDateFormat("MM-dd-yyyy hh:mm:ss a");
        return "echo back: name " + name + " received on "
                + dtfmt.format(Calendar.getInstance().getTime());
    }

}

    <display-name>Echo Web Service Application</display-name>

    <servlet>
        <servlet-name>spring-ws</servlet-name>
        <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring-ws</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

    <bean id="echoEndpoint" class="echo.endpoint.EchoEndpoint">
        <property name="echoService"><ref bean="echoService"/></property>
    </bean>

    <bean id="echoService" class="echo.service.EchoServiceImpl"/>

    <bean class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
        <property name="mappings">
            <props>
                <prop key="{http://www.averconsulting.com/echo/schemas}EchoRequest"
                >echoEndpoint</prop>
            </props>
        </property>
        <property name="interceptors">
            <bean
                class="org.springframework.ws.server.endpoint.interceptor.PayloadLoggingInterceptor"
            />
        </property>
    </bean>

    <bean id="echo" class="org.springframework.ws.wsdl.wsdl11.DynamicWsdl11Definition">
        <property name="builder">
            <bean
                class="org.springframework.ws.wsdl.wsdl11.builder.XsdBasedSoap11Wsdl4jDefinitionBuilder">
                <property name="schema" value="/WEB-INF/echo.xsd"/>
                <property name="portTypeName" value="Echo"/>
                <property name="locationUri" value="http://localhost:9090/echoservice/"/>
            </bean>
        </property>
    </bean>

• Registered the 'echoService' implementation bean.
• Registered an endpoint class named 'echoEndpoint'. The endpoint is the class that receives the incoming web service request. 
• The endpoint receives the XML document. You parse the XML data and then call our echo service implementation bean.
• The bean 'PayloadRootQNameEndpointMapping' is what maps the incoming request to the endpoint class. Here we set up one mapping. Anytime we see a 'EchoRequest' tag with the specified namespace we direct it to our endpoint class.
• The 'XsdBasedSoap11Wsdl4jDefinitionBuilder'class is what does the magic of converting the schema XSD to a WSDL document for outside consumption. Based on simple naming conventions in the schema (like XXRequest and XXResponse) the bean can generate a WSDL. This rounds up the 'thinking in XSD for document web services' implementation approach.  Once deployed the WSDL is available at http://localhost:9090/echoservice/echo.wsdl.

package echo.endpoint;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.Namespace;
import org.jdom.output.XMLOutputter;
import org.jdom.xpath.XPath;
import org.springframework.ws.server.endpoint.AbstractJDomPayloadEndpoint;

import echo.service.EchoService;

public class EchoEndpoint extends AbstractJDomPayloadEndpoint {
    private EchoService echoService;

    public void setEchoService(EchoService echoService) {
        this.echoService = echoService;
    }

    protected Element invokeInternal(Element request) throws Exception {
        // ok now we have the XML document from the web service request
        // lets system.out the XML so we can see it on the console (log4j
        // latter)
        System.out.println("XML Doc >> ");
        XMLOutputter xmlOutputter = new XMLOutputter();
        xmlOutputter.output(request, System.out);

        // I am using JDOM for my example....feel free to process the XML in
        // whatever way you best deem right (jaxb, castor, sax, etc.)

        // some jdom stuff to read the document
        Namespace namespace = Namespace.getNamespace("ec",
                "http://www.averconsulting.com/echo/schemas");
        XPath nameExpression = XPath.newInstance("//ec:Name");
        nameExpression.addNamespace(namespace);

        // lets call a backend service to process the contents of the XML
        // document
        String name = nameExpression.valueOf(request);
        String msg = echoService.echo(name);

        // build the response XML with JDOM
        Namespace echoNamespace = Namespace.getNamespace("ec",
                "http://www.averconsulting.com/echo/schemas");
        Element root = new Element("EchoResponse", echoNamespace);
        Element message = new Element("Message", echoNamespace);
        root.addContent(message);
        message.setText(msg);
        Document doc = new Document(root);

        // return response XML
        System.out.println();
        System.out.println("XML Response Doc >> ");
        xmlOutputter.output(doc, System.out);
        return doc.getRootElement();
    }
}

1. mvn package (this will generate the web service war file in the target folder).
2. mvn jetty:run (this will bring up Jetty and you can access the wsdl at http://localhost:9090/echoservice/echo.wsdl.
3. Finally use some web service accessing tool like the eclipse plug-in soapUI to invoke the web service.

• Your organizations experiences.
• Your team dynamics and skills.
• And of course how much confidence you have on the selected methodology.

• Develop Overall Model: Work with analysts/business users to get the application domain model defined. Based on the complexity of the application you may divide the project into many sub-domains and create a domain model for each area. You would gather high level requirements and may even be doing some use cases in this phase, though I doubt that will happen this early. Lot of interaction with business users during this phase.
• Build Feature List: Work with project management to define and create the feature list for the current release. The feature list should reflect business users priorities. Features should be as small as possible to implement in terms of time.
• Plan By Feature: Organize your features in terms of priority (related to client needs as well as development). For every feature we capture LOE (level of efforts). Drop your features into interations, each no longer than 4 to 6 weeks in duration. LOE should include design, coding and testing (if possible include reviews). Plan for dropping each feature into a QA test environment. For subsequent iterations (after the first) keep aside some time to fix defects and changes to earlier iteration. You can even increase by a week or so subsequent iterations. This filler time you can adjust as needed based on outstanding defect count and change requests.
• Design By Feature: Developers get your hands dirty now. Draw up class diagrams, sequence diagrams for current iteration.
• Build By Feature: Code it and drop iteration into QA enviornment.