Lucky Ryan

Apache CXF with Spring Integration

Ryan — Sun, 16 Jun 2013 06:54:25 +0000

Apache CXF is an easy way to expose a business class as a web service via REST (jaxrs) or SOAP (jaxws). In some cases you may just want to separate the client and business logic across multiple servers. Spring Integration comes into play because it will add a nice abstraction from the web service interface into your core classes. The goal is to layer the web service on top of existing classes without the need for any changes to existing code.

Application Setup

This example is based on a previous post using Spring Data. For this example that app was split into two project, CXF-client & CXF-service. All web files retained for Client. Service has the DAO and models. Exceptions, DTO and new services are in each.

Dependencies

The first step is to add the Apache and Spring dependencies to the project pom.xml. SI and Dozer are only needed for the service side.

  
      org.apache.cxf
      cxf-rt-frontend-jaxws
      2.7.5
  
  
  
      org.apache.cxf
      cxf-rt-frontend-jaxrs
      2.7.5
  

  
      javax.ws.rs
      javax.ws.rs-api
      2.0-m10
  

  
      org.springframework.integration
      spring-integration-xml
      2.2.3.RELEASE
  

  
  
      net.sf.dozer
      dozer
      5.4.0

Next define the interface for the web service. Although it’s possible to directly annotate your business class it’s good practice to keep them separate. This will allow you to only expose those methods you need and make it flexible to change the method parameters.

Design Consideration

This example interface is the defined interface that apache CXF will use to build the endpoints. If you are splitting an application client/service and using CXF for both sides, then the easy path would be to use this interface for both. One option is to copy the file and manually keep them in sync after changes. Another (my preferred) would be to put the interface and any dependent types in a new module then include the jar in the client and service app.

Service Interfaces

// REST Setup (Follows JAX-RS)
@Path("/sampleService")
@Produces("application/json")
public interface SampleServiceREST {

    @POST
    @Consumes("application/json")
    @Produces("application/json")
    @Path("/saveForm")
    public SignupForm saveFrom(SignupForm signupForm);

}

REST
@Path is the URL that will serve the resource. @Produces is the response type, @POST = Http POST verb, @Consumes is the expected content type and @Path extends the URL to expose this method.


// SOAP Setup (Follows JAX-WS)
@WebService
public interface SampleServiceSOAP {

    public SignupForm saveFrom(@WebParam(name="signupForm") SignupForm signupForm) throws InvalidUserException;
}

SOAP
@WebService is used by CXF to expose this interface as a WSDL. @WebParam give the parameter a friendly name in the WSDL. The default is arg0. More info can be found on the apache site about the annotations. Specific reference to the InvalidUserException is needed to jaxws will send the correct exception. Any undefined exceptions will be translated to a SOAPFault. If you do use a custom exception then make sure it exists in both the service and client application.

Now we have a nice interface but it doesn’t do anything yet and nothing implements it. Before exposing it as a CXF servlet we are going to use Spring Integration to implement the interface and route the calls to our business layer. At first pass these routes will be simple but could always be extended to do transformations, logging or anything else you may need.

Spring Integration Setup

Link the Service Interface to the business service methods

Note that we only need one Spring integration file to handle both SOAP & REST. Just like any spring config each file can support multiple bean definitions. In this case we want both the SOAP & REST calls to call the same business service method but use independent routes and processing chains.

Spring Integration Gateways become and implementation of an interface. SampleServiceSOAP or SampleServiceREST both are only interfaces with let CXF know that to expect and how to act. Spring Integration will automatically create bean implementations of those interfaces for us. But since it won’t know what to do for each service call, then we direct SI to put the massage (payload) on a set channel then direct it to our business class for processing. The chain is a connivence spring offers that saves XML. Without it each step, transformation, service, logging would need to follow channels. When using the chain SI infers the channels automatically for us. Note that message processing is sequential and synchronous. The message payload will start at the first chain entry and work down until the end at which point it is sent back to the web service.

Example Chain

SampleForm is posted from the client. Our business class needs a User object for persistence. So it needs transformation first, then the correct service method can be called us the user object. The service will return back a User object updated with the DB id. It then needs to be transformed back into a SampleForm so the client will know how to handle it.

The transformations are done with Dozer. Dozer out of the box will copy any duplicate named properties between two POJO’s. Since SampleForm and User have the same field names we can use the easy setup of dozer. This makes it easy to separate object & concerns across layers of the application. A lot of times it is easy to just use the same POJO all the way through the app which can make things messy as an application grows.

private DozerBeanMapper mapper = new DozerBeanMapper();

public User signupFormToUser(SignupForm signupForm) {
    User user = mapper.map(signupForm, User.class);
    return user;
}

public SignupForm userToSignupForm(User user) {
    SignupForm signupForm = mapper.map(user, SignupForm.class);
    return signupForm;
}

Link CXF Services to Spring Integration

At this point the interfaces are now backed by SI and both when invoked will forward the payload to the business class. The next step is to wire the newly defined gateways into CXF which will expose them as a web servlet.

Define the CXF servlet in the WEB-INF folder

Here we define two endpoints with a unique URL that will invoke out SI gateways when called. Notice the SOAP container uses the #bean ref to access the spring bean. That is not needed for the REST container since it has the ref tag.

Next add the CXF servlet to the web.xml so we can expose the endpoints.




    Sample App
    

    
        contextConfigLocation
        
            classpath:/applicationContext.xml
            classpath:/applicationContext-dao.xml
            classpath:/applicationContext-si-cxf.xml
            WEB-INF/cxf-servlet.xml
        
    

    
        org.springframework.web.context.ContextLoaderListener
    

    
        Apache CXF Endpoint
        cxf
        cxf
        org.apache.cxf.transport.servlet.CXFServlet
        1
    
    
        cxf
        /services/*

Now the app should start and we can verify that the services are now exposed.

You can test the interface with a REST client (FireFox plugin or curl) or SOAP UI and see that the business service is invoked as expected.

Setup the client

The client application is a Spring MVC app that uses Java Config. Below is the entry to load a jaxrs & jaxws client service as a spring bean.

@Bean
public JacksonJsonProvider getJacksonJsonProvider() {
    return new JacksonJsonProvider();
}

@Bean
public ExceptionHandler getExceptionHandler() {
    return new ExceptionHandler();
}

@Bean
public SampleServiceREST getSampleServiceRestClient() {
    List providers = new ArrayList();
    providers.add(getJacksonJsonProvider());
    providers.add(getExceptionHandler());
    return JAXRSClientFactory.create("http://localhost:8090/services/rest",SampleServiceREST.class,providers);
}

@Bean
public SampleServiceSOAP getSampleServiceSoapClient() {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setServiceClass(SampleServiceSOAP.class);
    factory.setAddress("http://localhost:8090/services/soap");
    return (SampleServiceSOAP) factory.create();
}

The xml equivalent is

This is about it for the client. It will also need the POM dependencies listed above but not the controller can use these services instead of “sampleService”.

JAXRS Exception Handling

There is some special considerations if using custom exceptions with REST/jaxrs. See this post (Apache CXF Exception Handler) about an option to pass exceptions via rest.

Project Files

Download Project Source Code

The post Apache CXF with Spring Integration appeared first on Lucky Ryan.

Apache CXF exception handler for jaxrs (REST)

Ryan — Sat, 15 Jun 2013 23:06:59 +0000

In another post (Apache CXF with Spring Integration) I covered splitting an application into a client/service structure using Apache CXF. In that project the business service would throw a custom exception if a certain user tried to register. The problem is that without any special handing CXF will return a 500 error and lose the custom exception. The client will see the 500 response code and throw it’s own exception which is ambiguous. The result is broken logic in the Spring MVC controller which expected the custom exception. To solve this and restore the original functionality I implemented CXF exception handlers to set appropriate headers which the client can use to map back to the original custom exception and message.

Below is the service class that is throwing the custom exception:

@Service("sampleService")
public class SampleServiceImpl implements SampleService {

    @Autowired
    UserDao userDao;

    public User saveUser(User user) throws InvalidUserException{

        String firstName = user.getFirstName();

        if(!StringUtils.isEmpty(firstName) && "Dave".equalsIgnoreCase(firstName)) {
            throw new InvalidUserException("Sorry Dave");
        }

        return userDao.save(user);

    }
}

Below is the original controller that would handle the InvalidUserException. The goal is to not change the controller method at all and still use CXF to make a REST call for the form creation.

@RequestMapping(value = "/create", method = RequestMethod.POST)
public String search(Model model, @Valid SignupForm signupForm, BindingResult result, RedirectAttributes redirectAttributes) {

    String returnPage = PAGE_INDEX;

    if (!result.hasErrors()) {
        try {
            model.addAttribute("form", sampleService.saveFrom(signupForm));
            returnPage = PAGE_SHOW;
        } catch (InvalidUserException e) {
            model.addAttribute("page_error", e.getMessage());
        }
    }
    return returnPage;
}

The first step is to implement a jaxrs exception handler that will modify the response. The CXF Exception Handler class lives on the service side and is responsible for setting the response.

import com.luckyryan.sample.exception.InvalidUserException;

import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;

public class ExceptionHandler implements ExceptionMapper {
    public Response toResponse(InvalidUserException exception) {
        Response.Status status;

        status = Response.Status.INTERNAL_SERVER_ERROR;

        return Response.status(status).header("exception", exception.getMessage()).build();
    }
}

Once this is registered in the jaxrs service provider list, it will be called automatically when the InvalidUserException is thrown.

This handler will set a 500 response code. That tells the rest client that an exception happened and will let us wire up a handler in the client. A custom header “exception” is also set with the original exception message so we can crab it from the client.

Add the ExceptionHandler to the service provider list in the server definition. This is set in cxf-servlet.xml.

At this point the service will now respond with a 500 response and custom header with the exception message. Next the client will need to translate that combo into the custom exception for the controller.

The CXF Exception Handler class lives in the client.

import org.apache.cxf.jaxrs.client.ResponseExceptionMapper;

import javax.ws.rs.core.Response;

public class ExceptionHandler implements ResponseExceptionMapper {

    @Override
    public Throwable fromResponse(Response response) {
        throw new InvalidUserException(response.getHeaderString("exception"));
    }
}

This implements ResponseExceptionMapper which will give access to the Response object. Once this handler is added to the provider list it will be invoked for any 500 response for the service call.

Next it’s wired into the provider list.

Spring Java Config & Application Context XML

This example app uses Spring with CXF. There are two examples below, one for Java Config and the other for xml. Only use the one relevant to your application.

Spring Java Config

@Bean
public JacksonJsonProvider getJacksonJsonProvider() {
    return new JacksonJsonProvider();
}

@Bean
public ExceptionHandler getExceptionHandler() {
    return new ExceptionHandler();
}

@Bean
public SampleServiceREST getSampleServiceRestClient() {
    List providers = new ArrayList();
    providers.add(getJacksonJsonProvider());
    providers.add(getExceptionHandler());
    return JAXRSClientFactory.create("http://localhost:8090/services/rest",SampleServiceREST.class,providers);
}

Spring XML version

That’s it! Now the application will handle the exception as before until it’s refactored into a better REST model.

The post Apache CXF exception handler for jaxrs (REST) appeared first on Lucky Ryan.

Spring MVC with basic object persistence using Spring Data JPA and Hibernate

Ryan — Thu, 21 Feb 2013 07:37:29 +0000

In an previous post we created a Sample Spring MVC project that didn’t do much except have a simple form. In this example we will add a basic service to process the form input and then save it to the database. For the database I am using MySQL, layered with Hibernate as the object mapper and then Spring Data JPA for abstraction and some nice boilerplate crud operations.

The first step is creating our service to handle the business the logic. I am a firm believer in separation of concerns and the law of demeter. I interpret it here as using Spring MVC for Model=Forms, Views=JSP, Controller=View Processor & link to the business service. This means that NO business logic is in the controller. Only code relevant to rendering the views or models goes here. These three things should be able to maintained by a front-end developer. The business logic could be in one or more services which could either reside in the application or external service accessed via REST or SOAP.

For this case we’ll setup the service in the application and its first purpose is to reject any user named “Dave” (sorry Dave…), then it will convert the form into a DB model for saving. The object ID from the database will be added to the form and returned back for display on the confirmation page.

Create the Service interface:

public interface SampleService {

    public SignupForm saveFrom(SignupForm signupForm) throws InvalidUserException;

}

Create the service implementation:

@Service("sampleService")
public class SampleServiceImpl implements SampleService {

    public SignupForm saveFrom(SignupForm signupForm) throws InvalidUserException{

        String firstName = signupForm.getFirstName();

        if(StringUtils.isEmpty(firstName) || "Dave".equalsIgnoreCase(firstName)) {
            throw new InvalidUserException("Sorry Dave");
        }

		// TODO: Save the form

        return signupForm;
    }
}

Notice the @Service annotation at the top. This is the same as @Component and will automatically be added to the Spring application context at startup. Make sure the component scan includes the base package with your services.

Next add the dependencies for spring data, jpa and hibernate to the pom.xml


    org.springframework.data
    spring-data-jpa
    1.2.0.RELEASE



    org.hibernate.javax.persistence
    hibernate-jpa-2.0-api
    1.0.1.Final



    org.hibernate
    hibernate-core
    4.1.9.Final


    org.hibernate
    hibernate-entitymanager
    4.1.9.Final


    org.hibernate
    hibernate-ehcache
    4.1.9.Final



      com.jolbox
      bonecp
      0.7.1.RELEASE



    mysql
    mysql-connector-java
    5.1.22
	runtime

JDBC Driver/Connection Pool
BoneCP was added for the JDBC driver and connection pool. This could be swapped out for Apache commons DBCP, C3P0 or any other you prefer.

Next create the DB model and add annotations that will instruct hibernate how to persist the object. Since the form allows a user to signup we will create a user class. This is created in com.luckyryan.sample.dao.model

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue
    private Long id;
    
    private String firstName;
    private String lastName;
    private String email;

    public Long getId() {
        return id;
    }

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

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Now we need a UserDao to manage the User objects. This is were the cool stuff happens. Spring Data JPA makes this extremely easy. All we need in an interface and it will do the implementation for us. Even better is that there already is a CrudRepository interface that can be extended that will give you the basic operations for free. The UserDao is created in the dao package

import org.springframework.data.repository.CrudRepository;

public interface UserDao extends CrudRepository {
}

DAO Interface
There is no need to annotate the class. We will set the JPA scan path in the spring config so it will automatically be picked up and added to the application context.

Create a property file for the db settings
jdbc.properties

jdbc.url=${jdbc.url}
jdbc.username=${jdbc.username}
jdbc.password=${jdbc.password}

This above property file is using a reference to pom.xml properties. This is accomplished using the resources plugin. If you get errors with this see the note at the bottom of the page. You could alternatively just specify the properties here if you don’t need to use profile or environment specific settings.

Configure JPA, Hibernate and BoneCP with Spring Data. The XML and Java Config options are listed below, you only need the style relevant to your project, not both.

xml




    
    

    
    
        
        
        
        
        
        
        
        
        
        
        
        
    

    
    

    
        
        
            
        
    

    
        
        
        
            
                
                
                
                
            
        
        
            
                hibernate.cache.use_second_level_cache = true
                hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory
                hibernate.cache.use_query_cache = true
                hibernate.generate_statistics = true

The xml can be included in the project web.xml or as an include in another applcationContext.


    contextConfigLocation
    
        classpath:applicationContext-dao.xml

Java Config

package com.luckyryan.sample.config;


import com.jolbox.bonecp.BoneCPDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.hibernate4.HibernateExceptionTranslator;
import org.springframework.orm.jpa.JpaDialect;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaDialect;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import java.util.Properties;

@PropertySource(value = "classpath:db.properties")
@EnableTransactionManagement(proxyTargetClass = true)
@EnableJpaRepositories("com.luckyryan.sample.dao")
@Configuration
public class dbConfig {

    @Autowired
    Environment env;

    @Bean
    public BoneCPDataSource boneCPDataSource() {

        BoneCPDataSource boneCPDataSource = new BoneCPDataSource();
        boneCPDataSource.setDriverClass("com.mysql.jdbc.Driver");
        boneCPDataSource.setJdbcUrl(env.getProperty("jdbc.url"));
        boneCPDataSource.setUsername(env.getProperty("jdbc.username"));
        boneCPDataSource.setPassword(env.getProperty("jdbc.password"));
        boneCPDataSource.setIdleConnectionTestPeriodInMinutes(60);
        boneCPDataSource.setIdleMaxAgeInMinutes(420);
        boneCPDataSource.setMaxConnectionsPerPartition(30);
        boneCPDataSource.setMinConnectionsPerPartition(10);
        boneCPDataSource.setPartitionCount(3);
        boneCPDataSource.setAcquireIncrement(5);
        boneCPDataSource.setStatementsCacheSize(100);
        boneCPDataSource.setReleaseHelperThreads(3);

        return boneCPDataSource;

    }

    @Bean
    public HibernateExceptionTranslator hibernateExceptionTranslator() {
        return new HibernateExceptionTranslator();
    }

    @Bean
    @Autowired
    public EntityManagerFactory entityManagerFactory(BoneCPDataSource dataSource) {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(true);
        vendorAdapter.setShowSql(false);
        vendorAdapter.setDatabasePlatform("org.hibernate.dialect.MySQL5InnoDBDialect");
        vendorAdapter.setDatabase(Database.MYSQL);

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("com.luckyryan.sample.dao.model");
        factory.setDataSource(dataSource);

        Properties properties = new Properties();
        properties.setProperty("hibernate.cache.use_second_level_cache", "true");
        properties.setProperty("hibernate.cache.region.factory_class", "org.hibernate.cache.ehcache.EhCacheRegionFactory");
        properties.setProperty("hibernate.cache.use_query_cache", "true");
        properties.setProperty("hibernate.generate_statistics", "true");

        factory.setJpaProperties(properties);

        factory.afterPropertiesSet();

        return factory.getObject();
    }

    @Bean
    @Autowired
    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager txManager = new JpaTransactionManager();
        JpaDialect jpaDialect = new HibernateJpaDialect();
        txManager.setEntityManagerFactory(entityManagerFactory);
        txManager.setJpaDialect(jpaDialect);
        return txManager;
    }

}

This file config can be added to the main config with the import annotation.

@Configuration
@Import(dbConfig.class)
public class appConfig {
	...
}

HibernateExceptionTranslator
Notice that a HibernateExceptionTranslator is specified in the Java Config and not in the xml. This was an xml freebie and needs specific declaration for the java config.

The Java Config version takes advantage of the environment feature introduced in Spring 3.1. This is a great feature that allows you to change profiles at runtime which would allow changes to the db properties and which database was being used. In the XML version this still used db.properties and maven resources plugin to set this at build time.

The first part is BoneCP. This is the data source and connection pool that will talk to mysql. We tell BoneCP to use the MySQL driver and set options for pooling and connection settings.

Next tell Spring Data to scan a package for repository interfaces. No specific class annotation is needed for this to work.


or
@EnableJpaRepositories("com.luckyryan.sample.dao")

We need a transaction manager, give it the entity manager bean and the dialect that we are using.

The entity manger is core. This is were we tell it the data source and that we want to use Hibernate as the JPA implementation.
packagesToScan is the scan path of the annotated models. Instead of annotations you can skip this property and define a mapping file.
jpaVendorAdapter is were we set hibernate. There are properties that we can add here that are good time savers for testing. generateDdl will automatically update the schema to match the declared models at startup. Awesome for testing but I suggest revising this setting in production, sometimes automatic column changes are not desirable. showSql will output the sql string to the log, great for debugging but also something that should not hit production. You will also need to tell hibernate which database you are using so it can map and build the sql appropriately.
jpaProperties is an a generic property list. The XML makes this nice because a key value pair is automatically converted to the correct type where it’s explicit declaration in the java config. For this app we are passing in hibernate properties which also removed the need for a persistence.xml since we already have annotated models and now global properties like caching are declared.

Now we can autowire the Dao into the service and save the user form.

@Service
public class SampleServiceImpl implements SampleService {

    @Autowired
    UserDao userDao;

    public SignupForm saveFrom(SignupForm signupForm) throws InvalidUserException{

        String firstName = signupForm.getFirstName();

        if(StringUtils.isEmpty(firstName) || "Dave".equalsIgnoreCase(firstName)) {
            throw new InvalidUserException("Sorry Dave");
        }

        // Shown for example only, you could use a constructor, builder pattern or Dozer
        // point is that the DAO only knows and cares about users and not any UI form.
        User user = new User();
        user.setFirstName(signupForm.getFirstName());
        user.setEmail(signupForm.getEmail());
        user.setLastName(signupForm.getLastName());

        user = userDao.save(user);

        signupForm.setId(user.getId());

        return signupForm;

    }
}

The above will show that saves the form and the updated signupForm now has an id that we can use in the jsp to build CRUD links. Overall the above method is crap for design but at least shows the concept. I know it a few days I won’t be able to sleep because I wrote this method this way…

Now create a local schema (with what ever name you defined in the property file) and start the app. It will automatically create the table and columns for you. Enter some test data, submit and you will see a new row in the database.

Next steps would be showing the updated form on the completion page or adding an edit method to the form.

Build Error – Stack overflow
If you get a build error because the property file resulting in a stack overflow error. It is probably because the maven resources plugin is trying to replace circular references. To fix it you can update the resources part of the build section of the pom.xml to exclude the applicationContext*.xml files.


    
        src/main/resources
        
            *.xml
        
        true
    
    
        src/main/resources
        
            *.xml
        
        false

Download Project Source Code

The post Spring MVC with basic object persistence using Spring Data JPA and Hibernate appeared first on Lucky Ryan.

Create a Maven Archetype from an existing project

Ryan — Sat, 16 Feb 2013 07:16:50 +0000

Maven archetypes are project templates that can quickly jump start new projects that are based on a set of core files. One of my favorite examples is AppFuse. Matt has created archetypes for a variety of projects that will get you up and running with a basic app that has user management built in. For this example my goal is to turn the simple Spring MVC project into a template to create new example projects.

There are two ways to kickoff an archetype project:
1. Build the project layout by scratch and add files as need
2. Run the Maven archetype plugin on an existing project and configure from there.

Since we already have a sample project I’m going to cover option two.

First navigate to the root directory of the source project and run the following maven command

mvn archetype:create-from-project

After some maven magic you should see “BUILD SUCCESS”.

[INFO] 
[INFO] --- maven-archetype-plugin:2.2:jar (default-jar) @ TestProject-archetype ---
[INFO] Building archetype jar: /Users/ryan/projects/SampleMVC/target/generated-sources/archetype/target/SampleMVC-archetype-1.0
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 19.660s
[INFO] Finished at: Fri Feb 15 21:58:42 PST 2013
[INFO] Final Memory: 10M/554M
[INFO] ------------------------------------------------------------------------
[INFO] Archetype created in /Users/ryan/projects/SampleMVC/target/generated-sources/archetype
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 22.853s
[INFO] Finished at: Fri Feb 15 21:58:43 PST 2013
[INFO] Final Memory: 8M/554M
[INFO] ------------------------------------------------------------------------

The first success is the packaged archetype. This packages a jar file which can be used in a maven repo when generating new projects. Since we need to make modifications we’ll skip that for now. The second success id the archetype project.

Copy the target/generated-sources/archetype to a new directory and evaluate for changes.

The root structure is
- pom.xml
- src/
- target/

Target can me removed with mvn clean

pom.xml is the pom of the archetype and only has those things needed to build the archetype jar. We’ll only need to change to a 1.0-SNAPSHOT version since the first release is not final yet.

src/ is the archetype project source. This only has a few required components. main & test are standard. test/resources was created for us and has entries for integration testing.

Testing Archetypes

There is support for running integration tests which will verify project creating and even compare the generated project to a reference one. This is useful when building up a project. See archetype:integration-test for more information.

main/resources has two folders:
1. archetype-resources – this is the project template and what will be generated when the archetype is run
2. META-INF/maven – this contains the archetype-metadata.xml file which has the settings and options when generating a new project.

Looking through the src/main/java folder we see that all the packages from the original project are gone. This is because maven will add it back from the groupId or package variable when generating a new project. Anything from this root will still be retained in the new project. For example is the package is “com.luckyryan.sample” then webapp would become /src/main/java/com/luckyryan/sample/webapp. Anything under webapp with be stored respective to that folder.

After a quick look all seems to be in order so let’s look at the project options.



    
        
            com.luckyryan
        
        
        
            1.0-SNAPSHOT
        
        
            com.luckyryan.sample
        
    
  
    
      src/main/java
      
        **/*.java
      
    
    
      src/main/webapp
      
        **/*.jsp
        **/*.xml
      
    
    
      src/main/resources
      
        **/*.xml

I added the required properties at the top of the file. groupId,artifactId, package & version are used by default. I define them here to give default values since in my scenario they won’t change.

Custom Variables

You can define custom variables in this section. For each variable you will also need to add it in src/test/resources/projects/basic/archetype.properties as a key/value pair. The helpful part of required variable definition is maven will prompt the user to enter the value during project creation.

File that contain variables must be in a fileSet with filtered=”true”. The default in file syntax is like a Velocity template “${varName}” but they can also be used in directory names as “__varname__” (two _ before and after the var name).

Filesets tell maven what needs to be coped and how. The filtered flag indicates that those files will be processed by the Velocity engine and any matching variables will be replaced. So if you have a need to change a value in a file or config the use the “${varName}” syntax and make sure it is in a file set with filtered=”true”. The packaged flag will copy those filed into a structure prefixed with the package property.

An excellent description of metadata files options can be found on the maven site.

Once the archetype matches what we want. It’s time to install it locally and generate a sample project.
1. From the archetype root run mvn install
2. Create a new project directory /Users/ryan/projects/new_sample
3. Run the generate command mvn archetype:generate -DarchetypeCatalog=local. Local tells maven to look to the local repo for all archetypes and present with a list to pick one.
4. Enter the required parameters and the project is created.
5. cd into the project directory and run mvn jetty:run
6. Preview the new app

Archetype DeploymentsOnce you want to share the archetype then the packaged jar will need to be deployed to a maven repo. From there you can use the following command to generate a new project.

mvn archetype:generate 
    -DarchetypeGroupId=you_archetype_group_id 
    -DarchetypeArtifactId=sample-spring-mvc-archetype 
    -DarchetypeVersion=1.0-SNAPSHOT -DgroupId=new.project.id 
    -DartifactId=sample 
    -DarchetypeRepository=path_to_maven_repo_with_archetype_jar

This was a quick example to get exposure to creating archetypes. For more Maven information I recommend reviewing the Apache Maven site and the Sonatype Maven Guide.

The post Create a Maven Archetype from an existing project appeared first on Lucky Ryan.

Spring MVC form validation with HDIV (HTTP Data Integrity Validator)

Ryan — Fri, 15 Feb 2013 06:26:46 +0000

HDIV is a cool site addition to help secure web applications. Out of the box it will help prevent cross site request forgery (CSRF), remove the ability to alter non-editable data (hidden fields, params…) and even has options to limit characters globally across form fields. Having used it a project I found that the documentation can be hard to follow and there are implications when attempting to mix in Spring validation via the @Valid annotation. This is a quick guide to setup the basic features and tips when wanting to extending into custom field validation.

This is based on a very simple sample Spring MVC app referenced in an earlier post.

Our goal will be to secure the site so only the form page can be directly accessed. The success page should redirect to the form with an error if the first page is skipped. We will also add a global filter to prevent unauthorized characters (SQL injection, XSS, bad data…) from being entered into any field using the @Valid annotation.

First add the required dependencies to the project pom.xml. For this example we will use HDIV version 2.1.3. 2.1.4-SNAPSHOT has some nice enhancements but changes and considerations are necessary.


  
      org.hdiv
      hdiv-core
      2.1.3
  

  
      org.hdiv
      hdiv-config
      2.1.3
  

  
      org.hdiv
      hdiv-spring-mvc
      2.1.3
  

  
      org.hdiv
      hdiv-jstl-taglibs-1.2
      2.1.3
  


  
      javax.validation
      validation-api
      1.0.0.GA
  

  
      org.hibernate
      hibernate-validator
      4.3.1.Final

Create the hdiv-config.xml file in /src/main/resources/





    
        /,/index
    

    
    
        
    

    
    
        safeText

The documentation on the HDIV site is good for creating this file.

This file defines a few beans for with easy syntax. The config class is set to exclude common static files (css,png…) from the security filter, errorPage is where the 301 redirect will send the client when a HDIV violation is detected. RandomName refers to the parameter name that HDIV will use to track the page token. On forms this is the last hidden input in the form, on regular pages it’s appended to the param string.

Start pages will generate the CSRF token and allow users to directly load the page without needing the token first.

The random name does make it a little harder to load test with JMeter as you will need to use an XPath extractor with a value of “//input[@type="hidden"][last()]/@value” to get the token. With JMeter 2.9 you can use the CSS/jQuery extractor with expression “input[type=hidden]“, attribute “value” and match number to last hidden index. Then you will need to use the token & param name to pass in on the next request.

The next beans are for field validation. This gives all the features for SQL injection & XSS prevention. The id of the validation declaration is used to map urls. The acceptedPattern above is the default/recommended for text boxes.

Editable validation defines the URL’s that will filter all form input. This is at best restricted to a page, field level would need to be handled in the controller to bindings.

At this stage it’s defined but not active until we setup the HDIV filter in web.xml and wire it up to Spring in the servlet-config.


       contextConfigLocation
       
           classpath*:/applicationContext.xml
           classpath:/hdiv-config.xml
       
   

....


    
        ValidatorFilter
        org.hdiv.filter.ValidatorFilter
    

    
        ValidatorFilter
        app
    

....



    org.hdiv.listener.InitListener

Add hdiv-config.xml to the contextConfigLocation params. This will let Spring load the beans. Next add the filters so HDIV can interact with the session and params. Lastly add the listener and this file is done.

Next wire the text validations into Spring. This will get the hasErrors() to respond and get the HDIV message out to the form:errors tag.

This above will enable @Valid to use HDIV instead of the default hibernate validator. The hibernate validator is loaded automatically from the classpath and gives you access to javax JSR-303 validation annotations. But in this case we will not be using them and delegate it all to HDIV.

Java Config Update (4/8/13)
I have another post about converting the servlet & web.xml to use springs new java config option. If you want to port HDIV over to use that method then follow the steps in the Servlet to Java Config post and apply the following:


// This overrides the javax field validator with HDIV
// Remove this block to disable HDIV field validation
@Override
public Validator getValidator() {
    return getParameterValidator();
}

@Bean
public EditableParameterValidator getParameterValidator() {
    return new EditableParameterValidator();
}

HDIV Version 2.1.4

This config changes with HDIV version 2.1.4-SNAPSHOT. The editableValidator is already registered as a bean named “hdivEditableValidator” so only adding the validation to the mvc tag is necessary. Also worth noting that the new version will check for a JSR-303 validation in the classpath and if it exists it will delegate successful validations to it (like a validation chain of 2). Only frustrating this is that there is no way at this time to specify order or priority so if you have a nice email field validation message but another field fails HDIV validation, then only the HDIV message is shown. For small apps I suggest using HDIV for all except field validation, instead use the hibernate validator and javax annotations. This adds risk as you will need to ensure all fields are handled properly but the tradeoff is more control over the user experience.

Update the controller form post method to check validations. The second method is the HDIV redirect on error which adds a basic message to the model.

@RequestMapping(value = "/create", method = RequestMethod.POST)
public String search(Model model, @Valid SignupForm signupForm, BindingResult result, RedirectAttributes redirectAttributes) {

    if (result.hasErrors()) {
        return "index";
    }
    
	// Process or save the form here
	
	return "show";
}

...

@RequestMapping(value = "/security-error", method = RequestMethod.GET)
public String securityError(RedirectAttributes redirectAttributes) {
    redirectAttributes.addFlashAttribute("page_error", "You do have have permission to do that!");
    return "redirect:/";
}

Here is the simple form. Notice there is no declaration for HDIV specifically in the form. This will be added dynamically so we don’t need to worry about it.

The first part will check for a page level error and display the text if necessary.


       
           
           Error!
               ${page_error}
       



    
        Enter Your Information

        
         error">
            Email

            
                
                
            
        
        
         error">
            First Name
            
                
                
            
        
        
         error">
            Last Name

When the app is run and the /create is accessed without the form you will get the following error message at the top of the page. This will also show up for any other HDIV non field error like form tampering or bad sessions.

Try entering a script and it will return a field error

The post Spring MVC form validation with HDIV (HTTP Data Integrity Validator) appeared first on Lucky Ryan.

Migrate Spring MVC servlet.xml to Java Config

Ryan — Fri, 08 Feb 2013 07:12:16 +0000

Since Spring 3, Java configuration (@Configuration) has been moved into spring-core and has caught my attention. This is a quick sample of how to convert an existing servlet.xml file into a java config file.

Beginning xml

1. Create the configuration class, I like to create a “config” package with a class named appConfig.java
2. Add @Configuration, this will let spring know this contains bean definitions.

package com.luckyryan.sample.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class appConfig {

}

3. Add @EnableWebMVC, this is the same as

@EnableWebMvc
@Configuration
public class appConfig {

}

4. Add @ComponentScan(basePackages = {“com.luckyryan.sample”}), this is the same as

@EnableWebMvc
@ComponentScan(basePackages = {"com.luckyryan.sample"})
@Configuration
public class appConfig {

}

5. Extend the class to use WebMvcConfigurerAdapter. This adds stub implementations from the WebMvcConfigurer interface which is used by @EnableWebMVC. It also gives us a chance to override resources and the default handler.

@EnableWebMvc
@ComponentScan(basePackages = {"com.luckyryan.sample"})
@Configuration
public class appConfig extends WebMvcConfigurerAdapter {

}

6. Declare our static resources. I added cache to the java config but it’s not required.

@EnableWebMvc
@ComponentScan(basePackages = {"com.luckyryan.sample"})
@Configuration
public class appConfig extends WebMvcConfigurerAdapter {

	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
    	registry.addResourceHandler("/assets/**").addResourceLocations("classpath:/META-INF/resources/webjars/").setCachePeriod(31556926);
    	registry.addResourceHandler("/css/**").addResourceLocations("/css/").setCachePeriod(31556926);
    	registry.addResourceHandler("/img/**").addResourceLocations("/img/").setCachePeriod(31556926);
    	registry.addResourceHandler("/js/**").addResourceLocations("/js/").setCachePeriod(31556926);
 	}

}

7. Set default servlet handler, this is the same as

@EnableWebMvc
@ComponentScan(basePackages = {"com.luckyryan.sample"})
@Configuration
public class appConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/assets/**").addResourceLocations("classpath:/META-INF/resources/webjars/").setCachePeriod(31556926);
        registry.addResourceHandler("/css/**").addResourceLocations("/css/").setCachePeriod(31556926);
        registry.addResourceHandler("/img/**").addResourceLocations("/img/").setCachePeriod(31556926);
        registry.addResourceHandler("/js/**").addResourceLocations("/js/").setCachePeriod(31556926);
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver getInternalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

8. Add bean for InternalResourceViewResolver

package com.luckyryan.sample.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@EnableWebMvc
@ComponentScan(basePackages = {"com.luckyryan.sample"})
@Configuration
public class appConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/assets/**").addResourceLocations("classpath:/META-INF/resources/webjars/").setCachePeriod(31556926);
        registry.addResourceHandler("/css/**").addResourceLocations("/css/").setCachePeriod(31556926);
        registry.addResourceHandler("/img/**").addResourceLocations("/img/").setCachePeriod(31556926);
        registry.addResourceHandler("/js/**").addResourceLocations("/js/").setCachePeriod(31556926);
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver getInternalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

9. Update the servlet declaration in web.xml for the new config class and annotation conf. Note: this replaces the need for which was not featured in the servlet.xml example.

...
...

    sample
    org.springframework.web.servlet.DispatcherServlet
    
        contextClass
        
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        
    
    
        contextConfigLocation
        
            com.luckyryan.sample.config.appConfig
        
    



    sample
    /

The post Migrate Spring MVC servlet.xml to Java Config appeared first on Lucky Ryan.

Setup a simple Spring MVC site with Maven

Ryan — Wed, 06 Feb 2013 08:41:39 +0000

There are already a lot of good tutorials on setting up MVC apps, and if you are starting a real project with Spring MVC I would suggest AppFuse. This guide is a basic setup which I use as a base example for other articles. It covers a few core concepts.

Maven

Project layout

The first step is to create a basic Maven project. If you are not using eclipse or IntelliJ which can generate the project for you then create the following structure.

SampleProject
->    src
-->       main
--->          java	
--->          resources
--->          webapp
-->       test
--->          java
--->          resources
-     pom.xml

src is the source to your project.
pom.xml is the build and dependency file used by Maven.
main & test are source folders and should mirror in child folder structure. Main is your live code, Test is you junit, selenium, mocks or whatever you need to prove the app is stable.
java contains the source java classes
resources will have property files, config files and other non java classes needed for your code
webapp (only under main) is were the web files css, js, jsp, servlet.xml or web.xml, WEB-INF and all other web display assets.

Setup a basic pom

Below is the pom for this sample application. Detailed information on the sections are available on the Maven site.



    4.0.0

    SampleMVC
    SampleMVC
    1.0
    war

    
        
        UTF-8

        
        3.2.1.RELEASE
        1.2
        2.5
        2.2.2
        1.9.0
        2.5-atlassian-5
        2.6
    

    
    

    

        
        
            javax.servlet
            jstl
            ${jstl.version}
        
        
            javax.servlet
            servlet-api
            ${servlet.version}
        

        
        
            opensymphony
            sitemesh
            ${sitemesh.version}
        
        
            org.webjars
            bootstrap
            ${bootstrap.version}
        

        
        
            org.springframework
            spring-core
            ${spring.version}
        
        
            org.springframework
            spring-beans
            ${spring.version}
        
        
            org.springframework
            spring-context
            ${spring.version}
        
        
            org.springframework
            spring-web
            ${spring.version}
        
        
            org.springframework
            spring-webmvc
            ${spring.version}
        

        
        
            commons-lang
            commons-lang
            ${commons-lang.version}
        
    

    
        
            jetty
            
                true
            
            
                
                    
                        org.mortbay.jetty
                        maven-jetty-plugin
                        6.1.26
                        
                            true
                            /app
                            1
                            9999
                        
                        
                            
                                start-jetty
                                pre-integration-test
                                
                                    run
                                
                                
                                    true
                                
                            
                            
                                stop-jetty
                                post-integration-test
                                
                                    stop

groupId, artifactId and version are used to identify the project for Maven.
Properties allows you to define values that can be used in the pom, works great to reduce repeating versions with syntax ${value}. You can also use the resource settings to populate property files (spring, application.properties…).
Build we don’t use here but it’s the place for plugins, build tasks and anything you need to get the app packaged just the way you want. In this case we just run jetty so nothing special is needed.
Dependencies are all the dependent java classes needed to run the app. There are different scopes allowed that tell Maven when to load them. Typically compile (the default) is fine, the next most common I use is test. Maven will load the dependency only for testing and exclude it from the deployment package. Another thing to note is transitive dependencies. Maven 2.0 will automatically pull in dependencies of the declared project dependencies to save you from having to find them all on you own. Maven is fairly good about resolving conflicts in versions but it may be necessary to “exclude” certain artifacts from declared dependencies. If that gets messy then checkout the dependency management which can set default versions and override transitive dependencies. It also useful in parent poms or multi-module structures (later topic).
- jstl & servlet-api – These are used for the servlet and jsp pages. This is not specific to MVC but required for a webapp.
- sitemesh – Template engine for the site UI.
- bootstrap – Twitter bootstrap that also includes jQuery. Both help to make quick layouts. This is provided by WebJars, which allows us to treat the boilerplate layout code as a jar dependency and keeps the webapp clean. There are a lot of other packages available for extending the UI.
- spring-core – name says it all.
- spring-beans – bean definitions.
- spring-context – bean registration (component scan, annotation config…)
- spring-web – base web properties, RequestMapping…
- spring-webmvc – MVC components, Controllers, DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter
- commons-lang – Using this for StringUtils
Profile is the last part for this file. Profiles can be enabled by default (as seen here) or loaded via the -P flag when invoking maven. This is great when using build servers where environment specific packages or special testing should to be turned on or off. However this is does affect the packaged artifact at build time. If you need runtime profiles then the Spring Environment addition in version 3.1 can help. The profile defined here is for running Jetty so we can quickly test the app locally.

Servlet and Web files

web.xml

Create web.xml and parent folders in src/main/webapp/WEB-INF/web.xml




    Sample App

    
        contextConfigLocation
        
            
        
    

    
        sitemesh
        com.opensymphony.sitemesh.webapp.SiteMeshFilter
    

    
    
        sitemesh
        /*
        FORWARD
        REQUEST
    

    
    
        index
    

    
        org.springframework.web.context.ContextLoaderListener
    

    
    
        sample
        org.springframework.web.servlet.DispatcherServlet      
    

    
        sample
        /

The web.xml file instructs the servlet container (in our case it’s jetty) how to start up and what to load. This is for servlet 2.5, in servlet 3.0 this file is not necessary and annotations can be used (later topic).

context-param – defines resources that are used by the servlet. Typically an applicationContext.xml for Spring would be listed here and used by the ContextLoaderListener
filter – filters make up a filter chain so order is important. In this case we are only using one. Each filter will have a definition and a corresponding mapping (defined by same name) that tells the servlet when to apply it. This filter is used by sitemesh to build out web template.
listener – invoked when the application starts. This listener will look for a spring config and initialize the ApplicationContext. By convention it will look for sample-servlet.xml in the classpath where “sample” is the servlet name. You can also specify one or more in the contextConfigLocation section.
servlet – Spring web magic. This defines a servlet that will process all requests through Spring MVC.
servlet-mapping – defines the url pattern that this servlet listen on. I chose to make it root and use Spring MVC resource definitions (in sample-servlet.xml) to exclude non Spring MVC components like CSS, JS & images

sample-servlet.xml

Create the sample-servlet.xml in the same location as web.xml.

Sitemesh

Create the required sitemesh files. This defines our decorators & parsers. See sitemesh for more info.


    
        /resources/*
    
    
        /*

Create the decorators folder and default.jsp. (src/main/webapp/decorators/default.jsp). & will pull in the respective sections of the child page.

<%@ page language="java" pageEncoding="UTF-8" contentType="text/html;charset=utf-8" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>



    < %@ taglib prefix="decorator" uri="http://www.opensymphony.com/sitemesh/decorator" %>

    

    <decorator:title></decorator:title>

    

    
    

    

    




    
        
            
                
                
                
            
            Sample App

            
                
                    Home
                
            
            
        
    




    
        
            
            Error!
                ${page_error}

JSP Pages

Create an index.jsp and show.jsp in src/main/webapp/WEB-INF/pages/*.

< %@ page language="java" pageEncoding="UTF-8" contentType="text/html;charset=utf-8" %>
< %@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
< %@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
< %@ taglib prefix="spring" uri="http://www.springframework.org/tags" %>


    Sample App Sign-up Page



Sign Up Here!


    
        Enter Your Information

        
         error">
            Email

            
                
                
            
        
        
         error">
            First Name
            
                
                
            
        
        
         error">
            Last Name

< %@ page language="java" pageEncoding="UTF-8" contentType="text/html;charset=utf-8" %>


    Sample App Sign-up Page



Sign Up Complete!

Spring MVC

Controllers

Now we have an app with pages but nothing to actually handle the request and map to a page.

The next step is to create a Controller and register it with Spring.

Create IndexController.java in src/main/java/com/luckyryan/sample/webapp/controller/IndexController.java. NOTE: this is NOT the same webapp folder used with the jsp files, this is under the package structure of java.

package com.luckyryan.sample.webapp.controller;

import com.luckyryan.sample.model.SignupForm;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@Controller
public class IndexController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView index() {
        return new ModelAndView("index", "signupForm", new SignupForm());
    }

    @RequestMapping(value = "/create", method = RequestMethod.POST)
    public String create(Model model, SignupForm signupForm, BindingResult result, RedirectAttributes redirectAttributes) {

        if (result.hasErrors()) {
            return "index";
        }

        return "show";
    
    }

    @RequestMapping(value = "/security-error", method = RequestMethod.GET)
    public String securityError(RedirectAttributes redirectAttributes) {
        redirectAttributes.addFlashAttribute("page_error", "You do have have permission to do that!");
        return "redirect:/";
    }

}

The @Controller annotation indicates that this class is a MVC controller. Spring will use the request mappings to figure out what url will hit which controller and method. Since we only have one controller using a mapping of “/” will capture root requests. If we had multiple controllers then RequestMapping could be defined for the entire class e.g. “registration” or “account” and any method on that controller would inherit the path. For this case I expect http://localhost:8080/sample/ would invoke IndexController.index(). In the example of “registration” then I would expect http://localhost:8080/sample/registration/ would invoke index.

Each method can return either a ModelAndView or just a string. The return value will use the ViewResolver to locate the proper jsp page to load. In our case we had

This means that a method return of “index” would resolve to /WEB-INF/pages/index.jsp. In the case of jsp, json and other views, View resolvers can be chained and ordered until a desired view is found. Acceptable return values are set by the ViewResolver. For this method we only want to show a blank for, to do that we instantiate a new SignupForm object (to be created next) and assign it to “signupForm” in the model. This allows use to access that object in the jsp via jstl or spring tags. Spring tags make it easy and do the work for you.

The create method only returns a string. Since model is available as a parameter we can directly access or set necessary values. The method signatures for controller request method can vary greatly based on what you need, just pay attention to order as some parameters do better when left as the last one.

There is a lot of opportunity for configuration here. Spring has excellent documentation when wanting to go beyond the basic.

Form Model

Create the SignupForm.java class src/main/java/com/luckyryan/sample/model/SignupForm.java

package com.luckyryan.sample.model;

public class SignupForm {

    private String firstName;
    private String lastName;
    private String email;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Spring can bind models to the request automatically so we don’t need to mess with parameter mapping. Enhancements such as validation are also possible and make life easy.

Now we can start up the servlet container and app from Maven with the following command: mvn clean jetty:run

The app should start up and be accessible at http://localhost:8080/sample/

The simple form will display, enter any values and we get the confirmation page.

This covers the basics of the app. Other topics will cover where to go from here and handle common tasks when building apps.

The post Setup a simple Spring MVC site with Maven appeared first on Lucky Ryan.