Baeldung

Spring Maven Repository

Eugen Paraschiv — Sun, 19 May 2013 11:12:17 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

This article will show what Maven Repositories to use when using Spring artifacts in a project – see the full list of repositories on the Spring wiki. The previous Spring artifact management infrastructure was maven.springframework.org – this has now been deprecated in favor of the more powerful repo.springsource.org.

2. Maven Repository for Releases

Spring publishes all their GA/Release artifacts to Maven Central, so if only releases are needed, there is no need to add any new repository into the pom. There is however a custom, browsable Maven repository available for Spring Releases as well, if for some reason Maven Central is not available:


    
        repository.springsource.release
        SpringSource GA Repository
        http://repo.springsource.org/release

The Spring artifact versioning rules are explained on the project wiki.

Spring Milestones and Snapshots are not published directly to Maven Central, so these have their own specific Maven repos.

3. Maven Repository for Milestones and Release Candidates

For Spring Milestones and RCs, the following repository needs to be added to the pom:


    
        repository.springsource.milestone
        SpringSource Milestone Repository
        http://repo.springsource.org/milestone

One this repository has been defined, the project can start using the Spring milestone dependencies:


    org.springframework
    spring-core
    4.0.0.M1

4. Maven Repository for Snapshots

Similar to milestones, Spring snapshots are hosted in a custom repository:


    
        repository.springsource.snapshot
        SpringSource Snapshot Repository
        http://repo.springsource.org/snapshot

Once the repository is enabled in the pom, the project can start the using Spring snapshots:


    org.springframework
    spring-core
    3.3.0.BUILD-SNAPSHOT

And even:


    org.springframework
    spring-core
    4.0.0.BUILD-SNAPSHOT

The snapshot Spring repositories can now also be browsed.

5. Maven Repository for Spring OSGI

OSGI compatible Spring artifacts are maintained in the SpringSource Enterprise Bundle Repository – in short, EBR. These repositories contains valid OSGI bundles and libraries for the entire Spring Framework, as well as a complete set of dependencies for these libraries. For bundles:


    com.springsource.repository.bundles.release 
    SpringSource Enterprise Bundle Repository - SpringSource Bundle Releases 
    http://repository.springsource.com/maven/bundles/release 


 
    com.springsource.repository.bundles.external 
    SpringSource Enterprise Bundle Repository - External Bundle Releases 
    http://repository.springsource.com/maven/bundles/external

And for OSGI compatible libraries:


    com.springsource.repository.libraries.release
    SpringSource Enterprise Bundle Repository - SpringSource Library Releases
    http://repository.springsource.com/maven/libraries/release


    com.springsource.repository.libraries.external
    SpringSource Enterprise Bundle Repository - External Library Releases
    http://repository.springsource.com/maven/libraries/external

6. Conclusion

This article describes the practical information about setting up Spring specific Maven Repositories in the pom – in order to use Release Candidates, Milestones and Snapshots.

Spring DataIntegrityViolationException

Eugen Paraschiv — Fri, 17 May 2013 08:17:13 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

In this article, we will discuss the Spring org.springframework.dao.DataIntegrityViolationException – this is a generic data exception typically thrown by the Spring exception translation mechanism when dealing with lower level persistence exceptions. The article will discuss the most common causes of this exception along with the solution for each one.

**2. DataIntegrityViolationException and Spring Exception Translation**

The Spring exception translation mechanism can be applied transparently to all beans annotated with @Repository – by defining an exception translation bean post processor bean in the Context:

Or in Java:

@Configuration
public class PersistenceHibernateConfig{
   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
      return new PersistenceExceptionTranslationPostProcessor();
   }
}

The Exception translation mechanism is also enabled by default on the older persistence template available in Spring – the HibernateTemplate, JpaTemplate, etc.

**3. Where is DataIntegrityViolationException thrown**

**3.1. DataIntegrityViolationException with Hibernate**

When Spring is configured with Hibernate, the exception is thrown in the exception translation layer provided by Spring – SessionFactoryUtils – convertHibernateAccessException.

There are three possible Hibernate exceptions that may cause the DataIntegrityViolationException to be thrown:

org.hibernate.exception.ConstraintViolationException
org.hibernate.PropertyValueException
org.hibernate.exception.DataException

**3.2. DataIntegrityViolationException With JPA**

When Spring is configured with JPA as its persistence provider, the DataIntegrityViolationException is thrown, similar to Hibernate, in the exception translation layer – namely in EntityManagerFactoryUtils – convertJpaAccessExceptionIfPossible.

There is a single JPA exception that may trigger a DataIntegrityViolationException to be thrown – the javax.persistence.EntityExistsException.

4. Cause: org.hibernate.exception.ConstraintViolationException

This is by far the most common cause of DataIntegrityViolationException being thrown – the Hibernate ConstraintViolationException indicates that the operation has violated a database integrity constraint.

Consider the following example – for One to One mapping through an explicit foreign key column between a Parent and Child entities – the following operations should fail:

@Test(expected = DataIntegrityViolationException.class)
public void whenChildIsDeletedWhileParentStillHasForeignKeyToIt_thenDataException() {
   Child childEntity = new Child();
   childService.create(childEntity);

   Parent parentEntity = new Parent(childEntity);
   service.create(parentEntity);

   childService.delete(childEntity);
}

The Parent entity has a foreign key to the Child entity – so deleting the child would break the foreign key constraint on the Parent – which results in a ConstraintViolationException – wrapped by Spring in the DataIntegrityViolationException:

org.springframework.dao.DataIntegrityViolationException: 
could not execute statement; SQL [n/a]; constraint [null]; 
nested exception is org.hibernate.exception.ConstraintViolationException: could not execute statement
    at o.s.orm.h.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:138)
Caused by: org.hibernate.exception.ConstraintViolationException: could not execute statement

To solve this, the Parent should be deleted first:

@Test
public void whenChildIsDeletedAfterTheParent_thenNoExceptions() {
   Child childEntity = new Child();
   childService.create(childEntity);

   Parent parentEntity = new Parent(childEntity);
   service.create(parentEntity);

   service.delete(parentEntity);
   childService.delete(childEntity);
}

5. Cause: org.hibernate.PropertyValueException

This is one of the more common causes of the DataIntegrityViolationException – in Hibernate, this will come down to an entity being persisted with a problem. Either the entity has a null property which is defined with a not-null constraint, or an association of the entity may reference an unsaved, transient instance.

For example, the following entity has a not-null name property -

@Entity
public class Foo {
   ...

   @Column(nullable = false)
   private String name;

   ...
}

If the following test tries to persist the entity with a null value for name:

@Test(expected = DataIntegrityViolationException.class)
public void whenInvalidEntityIsCreated_thenDataException() {
   fooService.create(new Foo());
}

A database integrigy constraint is violated, and so the DataIntegrityViolationException is thrown:

org.springframework.dao.DataIntegrityViolationException: 
not-null property references a null or transient value: 
org.baeldung.spring.persistence.model.Foo.name; 
nested exception is org.hibernate.PropertyValueException: 
not-null property references a null or transient value: 
org.baeldung.spring.persistence.model.Foo.name
	at o.s.orm.h.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:160)
...
Caused by: org.hibernate.PropertyValueException: 
not-null property references a null or transient value: 
org.baeldung.spring.persistence.model.Foo.name
	at o.h.e.i.Nullability.checkNullability(Nullability.java:103)
...

6. Cause: org.hibernate.exception.DataException

A Hibernate DataException indicates an invalid SQL Statement – something was wrong with the statement or the data, in that particular context. For example, using or Foo entity from before, the following would trigger this exception:

@Test(expected = DataIntegrityViolationException.class)
public final void whenEntityWithLongNameIsCreated_thenDataException() {
   service.create(new Foo(randomAlphabetic(2048)));
}

The actual exception for persisting the object with a long name value is:

org.springframework.dao.DataIntegrityViolationException: 
could not execute statement; SQL [n/a]; 
nested exception is org.hibernate.exception.DataException: could not execute statement
   at o.s.o.h.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:143)
...
Caused by: org.hibernate.exception.DataException: could not execute statement
	at o.h.e.i.SQLExceptionTypeDelegate.convert(SQLExceptionTypeDelegate.java:71)

In this particular example, the solution is to specify the max length of the name:

@Column(nullable = false, length = 4096)

7. Cause: javax.persistence.EntityExistsException

Simillarly to Hibernate, the EntityExistsException JPA exception will also be wrapped by the Spring Exception Translation into a DataIntegrityViolationException. The only difference is that JPA itself is already high level which makes this JPA exception the only potential cause of data integrity violations.

8. Potentially DataIntegrityViolationException

In some cases where the DataIntegrityViolationException may be expected, another exception may be thrown – one such case is if a JSR-303 validator, such as hibernate-validator 4 or 5 exists on the classpath.

In that case, if the following entity is persisted with a null value for name, it will no longer fail with a data integrity violation triggered by the persistence layer:

@Entity
public class Foo {
    ...
    @Column(nullable = false)
    @NotNull
    private String name;

    ...
}

This is because the execution won’t get to the persistence layer – it will fail before that with a javax.validation.ConstraintViolationException:

javax.validation.ConstraintViolationException: 
Validation failed for classes [org.baeldung.spring.persistence.model.Foo] 
during persist time for groups [javax.validation.groups.Default, ]
List of constraint violations:[ ConstraintViolationImpl{
    interpolatedMessage='may not be null', propertyPath=name, 
    rootBeanClass=class org.baeldung.spring.persistence.model.Foo, 
    messageTemplate='{javax.validation.constraints.NotNull.message}'}
]
    at o.h.c.b.BeanValidationEventListener.validate(BeanValidationEventListener.java:159)
    at o.h.c.b.BeanValidationEventListener.onPreInsert(BeanValidationEventListener.java:94)

9. Conclusions

At the end of this article, we should have a clear map to navigate the variety of causes and problems that may lead to a DataIntegrityViolationException in Spring, as well as a good grasp on how to fix all of these problems.

P.S. If you read this far, you should follow me on Twitter.

Spring @RequestMapping

Eugen Paraschiv — Thu, 16 May 2013 14:51:20 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

In this article, we will discuss one of the main annotations in Spring MVC – the @RequestMapping – this is used to map web requests to Spring Controller methods.

Throughout the article, we will test each of the mappings showed via simple curl commands.

**2. @RequestMapping Basic Example**

Let’s start with a simple example – mapping an HTTP request to a method using some straightforward criteria.

**2.1. @RequestMapping – by Path**

@RequestMapping(value = "/foos")
@ResponseBody
public String getFoosBySimplePath() {
    return "Get some Foos";
}

To test out this mapping with a simple curl command, run:

curl -i http://localhost:8080/spring-mvc/foos

**2.2. @RequestMapping – the HTTP Method**

By default, the HTTP method mapped by a @RequestMapping is GET – this can of course be changed – for example to map to a POST request:

@RequestMapping(value = "/foos", method = RequestMethod.POST)
@ResponseBody
public String postFoos() {
    return "Post some Foos";
}

To test the POST via a curl comamnd:

curl i -X POST http://localhost:8080/spring-mvc/foos

**3. @RequestMapping and HTTP Headers**

**3.1. @RequestMapping with the headers attribute**

The mapping can be narrowed even further by specifying a header for the request:

@RequestMapping(value = "/foos", headers = "key=val")
@ResponseBody
public String getFoosWithHeader() {
    return "Get some Foos with Header";
}

And even multiple headers via the header attribute of @RequestMapping:

@RequestMapping(value = "/foos", headers = { "key1=val1", "key2=val2" })
@ResponseBody
public String getFoosWithHeaders() {
    return "Get some Foos with Header";
}

To test the operation, we’re going to use the curl header support:

curl -i -H "key:val" http://localhost:8080/spring-mvc/foos

Note that for the curl syntax for separating the header key and the header value is a colon, same as in the HTTP spec, while in Spring the equals sign is used.

**3.2. @RequestMapping Consumes and Produces**

Mapping media types produced by a controller method is worth special attention – we can map a request based on its Accept header via the @RequestMapping headers attribute introduced above:

@RequestMapping(value = "/foos", method = RequestMethod.GET, headers = "Accept=application/json")
@ResponseBody
public String getFoosAsJsonFromBrowser() {
    return "Get some Foos with Header Old";
}

The matching for this way of defining the Accept header is flexible – it uses contains instead of equals, so a request such as the following would still map correctly:

curl -H "Accept:application/json,text/html" http://localhost:8080/spring-mvc/foos

Starting with Spring 3.1, a the @RequestMapping annotation now has a produces and a consumes attributes, specifically for this purpose:

@RequestMapping(value = "/foos", method = RequestMethod.GET, produces = "application/json")
@ResponseBody
public String getFoosAsJsonFromREST() {
    return "Get some Foos with Header New";
}

Also, the old type of mapping with the headers attribute will automatically be converted to the new produces mechanism starting with Spring 3.1, so the results will be identical.

This is consumed via curl in the same way:

curl -H "Accept:application/json" http://localhost:8080/spring-mvc/foos

Additionally, produces support multiple values as well:

@RequestMapping(value = "/foos", produces = { "application/json", "application/xml" })

Keep in mind that these are basically the same mapping, so Spring won’t accept them together – having both these methods active would result in:

Caused by: java.lang.IllegalStateException: Ambiguous mapping found. 
Cannot map 'fooController' bean method
public java.lang.String org.baeldung.spring.web.controller.FooController.getFoosAsJsonFromREST()
to {[/foos],methods=[GET],params=[],headers=[],consumes=[],produces=[application/json],custom=[]}: 
There is already 'fooController' bean method
public java.lang.String org.baeldung.spring.web.controller.FooController.getFoosAsJsonFromBrowser() 
mapped.

A final note on the new produces and consumes mechanism – these behave differently from most other annotations: when specified at type level, the method level annotations do not complement but override the type level information.

**4. @RequestMapping with Path Variables**

Parts of the mapping URI can be bound to variables via the @PathVariable annotation.

4.1. Single @PathVariable

A simple example with a single path variable:

@RequestMapping(value = "/foos/{id}")
@ResponseBody
public String getFoosBySimplePathWithPathVariable(@PathVariable("id") long id) {
   return "Get a specific Foo with id=" + id;
}

This can be tested with curl:

curl http://localhost:8080/spring-mvc/foos/1

If the name of the method argument matches the name of the path variable exactly, then this can be simplified by using @PathVariable with no value:

@RequestMapping(value = "/foos/{id}")
@ResponseBody
public String getFoosBySimplePathWithPathVariable(@PathVariable String id) {
   return "Get a specific Foo with id=" + id;
}

Note that @PathVariable benefits from automatic type conversion, so we could have also declared the id as:

@PathVariable long id

4.2. Multiple @PathVariable

More complex URI may need to map multiple parts of the URI to multiple values:

@RequestMapping(value = "/foos/{fooid}/bar/{barid}")
@ResponseBody
public String getFoosBySimplePathWithPathVariables(@PathVariable long fooid, @PathVariable long barid) {
    return "Get a specific Bar with id=" + barid + " from a Foo with id=" + fooid;
}

This is easily tested with curl in the same way:

curl http://localhost:8080/spring-mvc/foos/1/bar/2

4.3. @PathVariable with RegEx

Regular expressions can also be used when mapping the @PathVariable; for example, we will restrict the mapping to only accept numerical values for the id:

@RequestMapping(value = "/bars/{numericId:[\\d]+}")
@ResponseBody
public String getBarsBySimplePathWithPathVariable(@PathVariable final long numericId) {
    return "Get a specific Bar with id=" + numericId;
}

This will mean that the following URIs will match:

http://localhost:8080/spring-mvc/bars/1

But this will not:

http://localhost:8080/spring-mvc/bars/abc

**5. @RequestMapping with Request Parameters**

@RequestMapping allows easy mapping of URL parameters with the @RequestParam annotation.

We are now mapping a request to an URI such as:

http://localhost:8080/spring-mvc/bars?id=100

@RequestMapping(value = "/bars")
@ResponseBody
public String getBarBySimplePathWithRequestParam(@RequestParam("id") long id) {
    return "Get a specific Bar with id=" + id;
}

We are then extracting the value of the id parameter using the @RequestParam(“id”) annotation in the controller method signature.

The send a request with the id parameter, we’ll use the parameter support in curl:

curl -i -X POST id=100 http://localhost:8080/spring-mvc/bars

In this example, the parameter was bound directly without having been declared first.

For more advanced scenarios, @RequestMapping can explicitly define the parameters to be mapped as yet another way of narrowing the request mapping:

@RequestMapping(value = "/bars", params = "id")
@ResponseBody
public String getBarBySimplePathWithExplicitRequestParam(@RequestParam("id") long id) {
    return "Get a specific Bar with id=" + id;
}

Even more flexible mappings are allowed – multiple params values can be defined, and not all of them have to be used:

@RequestMapping(value = "/bars", params = { "id", "second" })
@ResponseBody
public String getBarBySimplePathWithExplicitRequestParams(@RequestParam("id") long id) {
    return "Narrow Get a specific Bar with id=" + id;
}

And of course, a request to an URI such as:

http://localhost:8080/spring-mvc/bars?id=100&second=something

Will always be mapped to the best match – which is the narrower match, which defines both the id and the second parameter.

**6. @RequestMapping Corner Cases**

**6.1. @RequestMapping – multiple paths mapped to the same controller method**

Although a single @RequestMapping path value is usually used for a single controller method, this is just good practice, not a hard and fast rule – there are some cases where mapping multiple requests to the same method may be necessary. For that case, the value attribute of @RequestMapping does accept multiple mappings, not just a single one:

@RequestMapping(value = { "/advanced/bars", "/advanced/foos" })
@ResponseBody
public String getFoosOrBarsByPath() {
    return "Advanced - Get some Foos or Bars";
}

Now, both of these curl commands should hit the same method:

curl -i http://localhost:8080/spring-mvc/advanced/foos
curl -i http://localhost:8080/spring-mvc/advanced/bars

**6.2. @RequestMapping – multiple HTTP request methods to the same controller method**

Multiple requests using different HTTP verbs can be mapped to the same controller method:

@RequestMapping(value = "/foos/multiple", method = { RequestMethod.PUT, RequestMethod.POST })
@ResponseBody
public String putAndPostFoos() {
    return "Advanced - PUT and POST within single method";
}

With curl, both of these will now hit the same method:

curl -i -X POST http://localhost:8080/spring-mvc/foos/multiple
curl -i -X PUT http://localhost:8080/spring-mvc/foos/multiple

**6.3. @RequestMapping – a fallback for all requests**

To implement a simple fallback for all requests using a specific HTTP method:

@RequestMapping(value = "*")
@ResponseBody
public String getFallback() {
    return "Fallback for GET Requests";
}

Or even for all request:

@RequestMapping(value = "*", method = { RequestMethod.GET, RequestMethod.POST ... })
@ResponseBody
public String allFallback() {
    return "Fallback for All Requests";
}

7. Spring Configuration

The Spring MVC Configuration is simple enough – considering that our FooController is defined in the following package:

package org.baeldung.spring.web.controller;

@Controller
public class FooController { ... }

Starting with Spring 3.1, we will only need a @Configuration class to enable the full MVC support and configure classpath scanning for the controller:

@Configuration
@EnableWebMvc
@ComponentScan({ "org.baeldung.spring.web.controller" })
public class MvcConfig {
    //
}

8. Conclusion

This article focus on the @RequestMapping annotation in Spring 3 - discussing a simple usecase, the mapping of HTTP headers, binding parts of the URI with @PathVariable and working with URI parameters and the @RequestParam annotation.

The implementation of this simple project can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

P.S. If you read this far, you should follow me on Twitter.

Hibernate 4 with Spring

Eugen Paraschiv — Mon, 13 May 2013 12:09:22 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

This article will focus on setting up Hibernate 4 with Spring – we’ll look at how to setup and configure Spring 3 with Hibernate 4 using both Java and XML Configuration. Parts of this process are common to Hibernate 3, and have been discussed previously on the Hibernate 3 with Spring article.

2. Maven

To add the Spring Persistence dependencies to the pom, please see the Spring with Maven article.

Continuing with Hibernate 4, the Maven dependencies are simple:


   org.hibernate
   hibernate-core
   4.2.1.Final

Then, to enable Hibernate to use its proxy model, we need javassist as well:


   org.javassist
   javassist
   3.17.1-GA

And since we’re going to use MySQL for this tutorial, we’ll also need:


   mysql
   mysql-connector-java
   5.1.25
   runtime

3. Java Spring Configuration for Hibernate 4

To use Hibernate 4 in a project, a few things have changed on the configuration side when moving from a Hibernate 3 setup.

The main aspect that is different when upgrading from Hibernate 3 is the way to create the SessionFactory with Hibernate 4.

This is now done by using the LocalSessionFactoryBean from the hibernate4 package – which replaces the older AnnotationSessionFactoryBean from the hibernate3 package. The new FactoryBean has the same responsibility – it bootstraps the SessionFactory from annotation scanning. This is neccessary because, starting with Hibernate 3.6, the old AnnotationConfiguration was merged into Configuration and so the new Hibernate 4 LocalSessionFactoryBean is using this new Configuration mechanism.

It is also worth noting that, in Hibernate 4, the Configuration.buildSessionFactory method and mechanism have also been deprecated in favour of Configuration.buildSessionFactory(ServiceRegistry) – which the Spring LocalSessionFactoryBean is not yet using.

The Spring Java Configuration for Hibernate 4:

import java.util.Properties;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate4.HibernateTransactionManager;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.google.common.base.Preconditions;

@Configuration
@EnableTransactionManagement
@PropertySource({ "classpath:persistence-mysql.properties" })
@ComponentScan({ "org.baeldung.spring.persistence" })
public class PersistenceConfig {

   @Autowired
   private Environment env;

   @Bean
   public LocalSessionFactoryBean sessionFactory() {
      LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
      sessionFactory.setDataSource(restDataSource());
      sessionFactory.setPackagesToScan(new String[] { "org.baeldung.spring.persistence.model" });
      sessionFactory.setHibernateProperties(hibernateProperties());

      return sessionFactory;
   }

   @Bean
   public DataSource restDataSource() {
      DriverManagerDataSource dataSource = new DriverManagerDataSource();
      dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
      dataSource.setUrl(env.getProperty("jdbc.url"));
      dataSource.setUsername(env.getProperty("jdbc.user"));
      dataSource.setPassword(env.getProperty("jdbc.pass"));

      return dataSource;
   }

   @Bean
   public HibernateTransactionManager transactionManager() {
      HibernateTransactionManager txManager = new HibernateTransactionManager();
      txManager.setSessionFactory(sessionFactory().getObject());

      return txManager;
   }

   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
      return new PersistenceExceptionTranslationPostProcessor();
   }

   Properties hibernateProperties() {
      return new Properties() {
         {
            setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
            setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
         }
      };
   }
}

4. XML Spring Configuration for Hibernate 4

Simillary, Hibernate 4 can be configured with XML as well:




   

   
      
      
      
         
            ${hibernate.hbm2ddl.auto}
            ${hibernate.dialect}

To bootstrap the XML into the Spring Context, we can use a simple Java Configuration file if the application is configured with Java configuration:

@Configuration
@EnableTransactionManagement
@ImportResource({ "classpath:hibernate4Config.xml" })
public class HibernateXmlConfig{
   //
}

Alternativelly we can simply provide the XML file to the Spring Context, if the overall configuration is purely XML.

For both types of configuration, the JDBC and Hibernate specific properties are stored in a properties file:

# jdbc.X
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_hibernate_dev?createDatabaseIfNotExist=true
jdbc.user=tutorialuser
jdbc.pass=tutorialmy5ql

# hibernate.X
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop

5. Spring, Hibernate and MySQL

The Drivers and Dialects supported by Hibernate have been extensively discussed for Hibernate 3 – and everything still applies for Hibernate 4 as well.

6. Usage

At this point, Hibernate 4 is fully configured with Spring and we can inject the raw Hibernate SessionFactory directly whenever we need to:

public abstract class BarHibernateDAO{

   @Autowired
   SessionFactory sessionFactory;

   ...

   protected Session getCurrentSession(){
      return sessionFactory.getCurrentSession();
   }
}

7. Conclusion

In this example, we configured Spring with Hiberate 4 – both with Java and XML configuration. The implementation of this simple project can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

P.S. If you read this far, you should follow me on Twitter.

Spring BeanDefinitionStoreException

Eugen Paraschiv — Sat, 11 May 2013 20:11:45 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

In this article, we will discuss the Spring org.springframework.beans.factory.BeanDefinitionStoreException – this is typically the responsibility of a BeanFactory when a bean definition is invalid, the loading of that bean is problematic. The article will discuss the most common causes of this exception along with the solution for each one.

2. Cause: java.io.FileNotFoundException

**2.1. IOException parsing XML document from ServletContext resource**

This usually happens in a Spring Web application, when a DispatcherServlet is set up in the web.xml for Spring MVC:

  
   mvc  
   org.springframework.web.servlet.DispatcherServlet

By default, Spring will look for a file called exactly springMvcServlet-servlet.xml in the /WEB-INF directory of the web application.

If this file doesn’t exist, then the following exception will be thrown:

org.springframework.beans.factory.BeanDefinitionStoreException: 
IOException parsing XML document from ServletContext resource [/WEB-INF/mvc-servlet.xml]; 
nested exception is java.io.FileNotFoundException: 
Could not open ServletContext resource [/WEB-INF/mvc-servlet.xml]

The solution is of course to make sure the mvc-servlet.xml file indeed exists under /WEB-INF; if it doesn’t, then a sample one can be created:

**2.2. IOException parsing XML document from class path resource**

This usually happens when something in the application points to an XML resource that doesn’t exist, or is not placed where it should be.

Pointing to such a resource may happen in a variety of ways.

Using for example Java Configuration, this may look like:

@Configuration
@ImportResource("beans.xml")
public class SpringConfig {...}

In XML, this will be:

Or even by creating an Spring XML context manually:

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

All of these will leads to the same exception if the file doesn’t exist:

org.springframework.beans.factory.BeanDefinitionStoreException: 
IOException parsing XML document from ServletContext resource [/beans.xml]; 
nested exception is java.io.FileNotFoundException: 
Could not open ServletContext resource [/beans.xml]

The solution is create the file and to place it under the /src/main/resources directory of the project – this way, the file will exist on the classpath and it will be found and used by Spring.

3. Cause: Could not resolve placeholder …

This error occurs when Spring tries to resolve a property but is not able to – for one of many possible reasons.

But first, the usage of the property – this may be used in XML:

... value="${some.property}" ...

The property could also be used in Java code:

@Value("${some.property}")
private String someProperty

First thing to check is that the name of the property actually matches the property definition; in this example, we need to have the following property defined:

some.property=someValue

Then, we need to check where the properties file is defined in Spring – this is described in detail in my Properties with Spring article. A good best practice to follow is to have all properties files under the /src/main/resources directory of the application and to load them up via:

"classpath:app.properties"

Moving on from the obvious – another possible cause that Spring is not able to resolve the property is that there may be multiple PropertyPlaceholderConfigurer beans in the Spring context (or multiple property-placeholder elements)

If that is the case, then the solution is either collapsing these into a single one, or configuring the one in the parent context with ignoreUnresolvablePlaceholders.

4. Cause: java.lang.NoSuchMethodError

This error comes in a variety of forms – one of the more common ones is:

org.springframework.beans.factory.BeanDefinitionStoreException:
Unexpected exception parsing XML document from ServletContext resource [/WEB-INF/mvc-servlet.xml];
nested exception is java.lang.NoSuchMethodError:
org.springframework.beans.MutablePropertyValues.add (Ljava/lang/String;Ljava/lang/Object;)
Lorg/springframework/beans/MutablePropertyValues;

This usually happens when there are multiple versions of Spring on the classpath. Having an older version of Spring accidentally on the project classpath is more common than one would think – I described the problem and the solution for this in the Spring Security with Maven article.

In short, the solution for this error is simple – check all the Spring jars on the classpath and make sure that they all have the same version – and that version is 3.0 or above.

Simillarly, the exception is not restricted to the MutablePropertyValues bean – there are several other incarnations of the same problem, caused by the same version inconsistency:

org.springframework.beans.factory.BeanDefinitionStoreException:
Unexpected exception parsing XML document from class path resource [/WEB-INF/mvc-servlet.xml];
- nested exception is java.lang.NoSuchMethodError:
org.springframework.util.ReflectionUtils.makeAccessible(Ljava/lang/reflect/Constructor;)V

5. Cause: java.lang.NoClassDefFoundError

A common problem, simillarly related to Maven and the existing Spring dependencies is:

org.springframework.beans.factory.BeanDefinitionStoreException:
Unexpected exception parsing XML document from ServletContext resource [/WEB-INF/mvc-servlet.xml];
nested exception is java.lang.NoClassDefFoundError: 
org/springframework/transaction/interceptor/TransactionInterceptor

This occurs when transactional functionality is configured in the XML configuration:

The NoClassDefFoundError means that the Spring Transactional support – namely spring-tx – does not exist on the classpath.

The solution is simple – spring-tx needs to be defined in the Maven pom:


    org.springframework
    spring-tx
    3.2.2.RELEASE

Of course this is not limited to the transaction functionality – a similar error is thrown if AOP is missing as well:

Exception in thread "main" org.springframework.beans.factory.BeanDefinitionStoreException: 
Unexpected exception parsing XML document from class path resource [/WEB-INF/mvc-servlet.xml]; 
nested exception is java.lang.NoClassDefFoundError: 
org/aopalliance/aop/Advice

The jars that are now required are: spring-aop (and implicitly aopalliance):


    org.springframework
    spring-aop
    3.2.2.RELEASE

6. Conclusion

At the end of this article, we should have a clear map to navigate the variety of causes and problems that may lead to a BeanDefinitionStoreException as well as a good grasp on how to fix all of these problems.

P.S. If you read this far, you should follow me on Twitter.

Maven Release to Nexus

Eugen Paraschiv — Tue, 07 May 2013 12:13:32 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

In the previous article of this series, we set up a deployment process with Maven to Nexus. In this article, we’ll configure the Release Process with Maven – both in the pom of the project as well as in a Jenkins job.

2. Repository in the pom

In order for Maven to be able to release to a Nexus Repository Server, we need to define the repository information via the distributionManagement element:


   
      nexus-releases
      http://localhost:8081/nexus/content/repositories/releases

The hosted Releases Repository comes out of the box on Nexus, so there is no need to create it explicitly.

3. SCM in the Maven pom

The Release process will interact with the Source Control of the project – this means we first need to define the element in our pom.xml:


   scm:git:https://github.com/user/project.git
   http://github.com/user/project
   scm:git:https://github.com/user/project.git

Or, using the git protocol:


   scm:git:git@github.com:user/project.git
   scm:git:git@github.com:user/project.git
   scm:git:git@github.com:user/project.git

3. The Release Plugin

The standard Maven plugin used by a Release Process is the maven-release-plugin – the configuration for this plugin is minimal:


   org.apache.maven.plugins
   maven-release-plugin
   2.4.1
   
      v@{project.version}
      true
      releases

What is important here is that the releaseProfiles configuration will actually force a Maven profile – the releases profile – to become active during the Release process.

It is in this process that the nexus-staging-maven-plugin is used to perform a deploy to the nexus-releases Nexus repository:


   
      releases
      
         
            
               org.sonatype.plugins
               nexus-staging-maven-plugin
               1.4.4
               
                  
                     default-deploy
                     deploy
                     
                        deploy
                     
                  
               
               
                  nexus-releases
                  http://localhost:8081/nexus/
                  true

The plugin is configured to perform the Release process without the staging mechanism, same as previously, for the Deployment process (skipStaging=true).

And also similar to the Deployment process, Releasing to Nexus is a secured operation – so we’re going to use the Out of the Box deployment user form Nexus again.

We also need to configure the credentials for the nexus-releases server in the global settings.xml (%USER_HOME%/.m2/settings.xml):


   
      nexus-releases
      deployment
      the_pass_for_the_deployment_user

This is the full configuration

4. The Release Process

Let’s break apart the release process into small and focused steps. We are performing a Release when the current version of the project is a SNAPSHOT version – say 0.1-SNAPSHOT.

4.1. release:clean

Cleaning a Release will:

delete the release descriptor (release.properties)
delete any backup POM files

4.2. release:prepare

Next part of the Release process is Preparing the Release; this will:

perform some checks – there should be no uncommitted changes and the project should depend on no SNAPSHOT dependencies
change the version of the project in the pom file to a full release number (remove SNAPSHOT suffix) – in our example – 0.1
run the project test suites
commit and push the changes
create the tag out of this non-SNAPSHOT versioned code
increase the version of the project in the pom – in our example – 0.2-SNAPSHOT
commit and push the changes

4.3. release:perform

The latter part of the Release process is Performing the Release; this will:

checkout release tag from SCM
build and deploy released code

This second step of the process relies on the output of the Prepare step - the release.properties.

5. On Jenkins

Jenkins can perform the release process in one of two ways – it can either use it’s own release plugins, or it can simply run perform the release with a standard maven job running the correct release steps.

The existing Jenkins plugins focused on the release process are:

However, since the Maven command for performing the release is simple enough, we can simply define a standard Jenkins job to perform the operation – no plugins necessary.

So, for a new Jenkins job (Build a maven2/3 project) – we”ll define 2 String parameters: releaseVersion=0.1 and developmentVersion=0.2-SNAPSHOT.

At the Build configuration section, we can simply configure the following Maven command to run:

release:clean release:prepare release:perform 
   -DreleaseVersion=${releaseVersion} -DdevelopmentVersion=${developmentVersion}

When running a parametrized job, Jenkins will prompt the user to specify values for these parameters – so each time we run the job we need to fill in the right values for releaseVersion and developmentVersion.

Also, it’s worth using the Workspace Cleanup Plugin and check the Delete workspace before build starts option for this build. However keep in mind that the perform step of the Release should necessarily be run by the same command as the prepare step – this is because the latter perform step will use the release.properties file created by prepare. This means that we cannot have a Jenkins Job running prepare and another running perform.

6. Conclusion

This article showed how to implement the process of Releasing a Maven project with or without Jenkins. Similar to Deployment, this process is using the nexus-staging-maven-plugin to interact with Nexus and focuses on a git project.

P.S. If you read this far, you should follow me on Twitter.

Hibernate 3 with Spring

Eugen Paraschiv — Sun, 05 May 2013 18:22:16 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview

This article will focus on setting up Hibernate 3 with Spring – we’ll look at how to use both XML and Java configuration to set up Spring 3 with Hibernate 3 and MySQL.

2. Java Spring Configuration for Hibernate 3

Setting up Hibernate 3 with Spring and Java config is straightforward:

import java.util.Properties;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.google.common.base.Preconditions;

@Configuration
@EnableTransactionManagement
@PropertySource({ "classpath:persistence-mysql.properties" })
@ComponentScan({ "org.baeldung.spring.persistence" })
public class PersistenceConfig {

   @Autowired
   private Environment env;

   @Bean
   public AnnotationSessionFactoryBean sessionFactory() {
      AnnotationSessionFactoryBean sessionFactory = new AnnotationSessionFactoryBean();
      sessionFactory.setDataSource(restDataSource());
      sessionFactory.setPackagesToScan(new String[] { "org.baeldung.spring.persistence.model" });
      sessionFactory.setHibernateProperties(hibernateProperties());

      return sessionFactory;
   }

   @Bean
   public DataSource restDataSource() {
      DriverManagerDataSource dataSource = new DriverManagerDataSource();
      dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
      dataSource.setUrl(env.getProperty("jdbc.url"));
      dataSource.setUsername(env.getProperty("jdbc.user"));
      dataSource.setPassword(env.getProperty("jdbc.pass"));

      return dataSource;
   }

   @Bean
   public HibernateTransactionManager transactionManager() {
      HibernateTransactionManager txManager = new HibernateTransactionManager();
      txManager.setSessionFactory(sessionFactory().getObject());

      return txManager;
   }

   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
      return new PersistenceExceptionTranslationPostProcessor();
   }

   Properties hibernateProperties() {
      return new Properties() {
         {
            setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
            setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
         }
      };
   }
}

Compared to the XML Configuration – described next – there is a small difference in the way one bean in the configuration access another. In XML there is no difference between pointing to a bean or pointing to a bean factory capable of creating that bean. Since the Java configuration is type-safe – pointing directly to the bean factory is no longer an option – we need to retrieve the bean from the bean factory manually:

txManager.setSessionFactory(sessionFactory().getObject());

3. XML Spring Configuration for Hibernate 3

Similarly, we can set up Hibernate 3 with XML config as well:




   

   
      
      
      
         
            ${hibernate.hbm2ddl.auto}
            ${hibernate.dialect}

Then, this XML file is boostrapped into the Spring context using a @Configuration class:

@Configuration
@EnableTransactionManagement
@ImportResource({ "classpath:persistenceConfig.xml" })
public class PersistenceXmlConfig {
   //
}

For both types of configuration, the JDBC and Hibernate specific properties are stored in a properties file:

# jdbc.X
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_hibernate_dev?createDatabaseIfNotExist=true
jdbc.user=tutorialuser
jdbc.pass=tutorialmy5ql
# hibernate.X
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop

4. Spring, Hibernate and MySQL

The example above uses MySQL 5 as the underlying database configured with Hibernate – however, Hibernate supports several underlying SQL Databases.

4.1. The Driver

The Driver class name is configured via the jdbc.driverClassName property provided to the DataSource.

In the example above, it is set to com.mysql.jdbc.Driver from the mysql-connector-java dependency we defined in the pom, at the start of the article.

4.2. The Dialect

The Dialect is configured via the hibernate.dialect property provided to the Hibernate SessionFactory.

In the example above, this is set to org.hibernate.dialect.MySQL5Dialect as we are using MySQL 5 as the underlying Database. There are several other dialects supporting MySQL:

org.hibernate.dialect.MySQL5InnoDBDialect – for MySQL 5.x with the InnoDB storage engine
org.hibernate.dialect.MySQLDialect – for MySQL prior to 5.x
org.hibernate.dialect.MySQLInnoDBDialect – for MySQL prior to 5.x with the InnoDB storage engine
org.hibernate.dialect.MySQLMyISAMDialect – for all MySQL versions with the ISAM storage engine

Hibernate supports SQL Dialects for every supported Database.

5. Usage

At this point, Hibernate 3 is fully configured with Spring and we can inject the raw Hibernate SessionFactory directly whenever we need to:

public abstract class FooHibernateDAO{

   @Autowired
   SessionFactory sessionFactory;

   ...

   protected Session getCurrentSession(){
      return sessionFactory.getCurrentSession();
   }
}

6. Maven

To add the Spring Persistence dependencies to the pom, please see the Spring with Maven article – we’ll need to define both spring-context and spring-orm.

Continuing to Hibernate 3, the Maven dependencies are simple:


   org.hibernate
   hibernate-core
   3.6.10.Final

Then, to enable Hibernate to use its proxy model, we need javassist as well:


   org.javassist
   javassist
   3.17.1-GA

And since we’re going to use MySQL for this tutorial, we’ll also need:


   mysql
   mysql-connector-java
   5.1.25
   runtime

7. Conclusion

In this example, we configured Hibernate 3 with Spring – both with Java and XML configuration. The implementation of this simple project can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

P.S. If you read this far, you should follow me on Twitter.

Tweeting StackExchange Questions with Spring Social

Eugen Paraschiv — Fri, 03 May 2013 21:27:48 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Introduction

This is the third and final article about a small side-project – a bot that automatically tweets Questions from various Q&A StackExchange sites on specialized accounts (full list at the end of the article).

The first article discussed building a simple client for the StackExchange REST API. In the second article we set up the interaction with Twitter using Spring Social.

This article will describe the final part of the implementation – the part responsible with the interaction between the Stackexchange client and the TwitterTemplate.

2. The Tweet Stackexchange Service

The interaction between the Stackexchange Client – exposing the raw Questions, and the TwitterTemplate – fully set up and able to tweet – is a very simple service – the TweetStackexchangeService. The API published by this is:

public void tweetTopQuestionBySite(String site, String twitterAccount){ ... }
public void tweetTopQuestionBySiteAndTag(String site, String twitterAccount, String tag){ ... }

The functionality is simple – these APIs will keep reading Questions from the Stackexchange REST API (through the client), until one is found that has not been tweeted before on that particular account.

When that question is found, it is tweeted via the TwitterTemplate corresponding to that account, and a very simple Question entity is saved locally. This entity is only storing the id of the Question and the Twitter Account that it has been tweeted on.

For example the following question:

Binding a list in @RequestParam

Has been tweeted on the SpringAtSO account.

The Question entity simply contains:

the id of the Question – 4596351 in this case
the Twitter Account on which the question has been tweeted – SpringAtSO
the Stackexcange Site from which the question originates – Stackoverflow

We need to keep track of this information so that we know which questions have already been tweeted and which haven’t.

3. The Scheduler

The scheduler makes use of the Spring’s scheduled task capabilities – these are enabled via the Java configuration:

@Configuration
@EnableScheduling
public class ContextConfig {
   //
}

The actual scheduler is relativelly simple:

@Component
@Profile(SpringProfileUtil.DEPLOYED)
public class TweetStackexchangeScheduler {

   @Autowired
   private TweetStackexchangeService service;

   // API

   @Scheduled(cron = "0 0 1,5 * * *")
   public void tweetStackExchangeTopQuestion() throws JsonProcessingException, IOException {
      service.tweetTopQuestionBySiteAndTag("StackOverflow", Tag.clojure.name(), "BestClojure", 1);
      String randomSite = StackexchangeUtil.pickOne("SuperUser", "StackOverflow");
      service.tweetTopQuestionBySiteAndTag(randomSite, Tag.bash.name(), "BestBash", 1);
   }
}

There are two tweet operations configured above – one tweets from StackOverflow questions which are tagged with “clojure” on the Best Of Clojure twitter account.

The other operation tweets questions tagged with “bash” – and because these kind of questions actually appear on multiple sites from the Stackexchange network: StackOverflow, SuperUser and AskUbuntu, there is first a quick selection process to pick one of these sites, after which the question is tweeted.

Finally, the cron job is scheduled to run at 1 AM and 5 AM each day.

4. Setup

This being a pet project, it started out with a very simple database structure – it’s still simple now, but it was even more so. So one of the main goals was to be able to easily change the database structure – there are of course several tools for database migrations, but they’re all overkill for such a simple project.

So I decided to keep setup data in a simple text format – that is going to be updated semi-automatically.

Setup has two main steps:

the ids of the questions tweeted on each twitter account are retrieved and stored in a text file
the database schema is dropped and the application restarted – this will create the schema again and setup all data from the text file back into the new database

4.1. The Raw Setup Data

The process of retrieving the data the existing database is simple enough with JDBC; first we define a RowMapper:

class TweetRowMapper implements RowMapper {
   private Map> accountToQuestions;

   public TweetRowMapper(Map> accountToQuestions) {
      super();
      this.accountToQuestions = accountToQuestions;
   }

   public String mapRow(ResultSet rs, int line) throws SQLException {
      String questionIdAsString = rs.getString("question_id");
      long questionId = Long.parseLong(questionIdAsString);
      String account = rs.getString("account");

      if (accountToQuestions.get(account) == null) {
         accountToQuestions.put(account, Lists. newArrayList());
      }
      accountToQuestions.get(account).add(questionId);
      return "";
   }
}

This will build a list of Questions for each Twitter account.

Next, we’re going to use this in a simple test:

@Test
public void whenQuestionsAreRetrievedFromTheDB_thenNoExceptions() {
   Map> accountToQuestionsMap = Maps.newHashMap();
   jdbcTemplate.query
      ("SELECT * FROM question_tweet;", new TweetRowMapper(accountToQuestionsMap));

   for (String accountName : accountToQuestionsMap.keySet()) {
      System.out.println
         (accountName + "=" + valuesAsCsv(accountToQuestionsMap.get(accountName)));
   }
}

After retrieving the Questions for an account, the test will simply list them out; for example:

SpringAtSO=3652090,1079114,5908466,...

4.2. Restoring the Setup Data

The lines of data generated by the previous step are stored in a setup.properties file which is made available to Spring:

@Configuration
@PropertySource({ "classpath:setup.properties" })
public class PersistenceJPAConfig {
   //
}

When the application starts up, the setup process is performed. This simple process uses a Spring ApplicationListener, listening on a ContextRefreshedEvent:

@Component
public class StackexchangeSetup implements ApplicationListener {
    private boolean setupDone;

    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (!setupDone) {
            recreateAllQuestionsOnAllTwitterAccounts();
            setupDone = true;
        }
    }
}

Finally, the questions are retrieved from the setup.properties file and recreated:

private void recreateAllQuestionsOnTwitterAccount(String twitterAccount) {
   String tweetedQuestions = env.getProperty(twitterAccount.name();
   String[] questionIds = tweetedQuestions.split(",");
   recreateQuestions(questionIds, twitterAccount);
}
void recreateQuestions(String[] questionIds, String twitterAccount) {
   List stackSitesForTwitterAccount = twitterAccountToStackSites(twitterAccount);
   String site = stackSitesForTwitterAccount.get(0);
   for (String questionId : questionIds) {
      QuestionTweet questionTweet = new QuestionTweet(questionId, twitterAccount, site);
      questionTweetDao.save(questionTweet);
   }
}

This simple process allows easy updates of the DB structure – since the data is fully erased and fully re-created, there is no need to do any actual migration whatsoever.

5. Full List of Accounts

The full list of Twitter accounts is:

SpringAtSO – Spring questions from StackOverflow
JavaTopSO - Java questions from StackOverflow
RESTDaily – REST questions from StackOverflow
BestJPA - JPA questions from StackOverflow
BestMaven – Maven questions from StackOverflow
BestGit - Git questions from StackOverflow
AskUbuntuBest - AskUbuntu best overal questions (all topics)
ServerFaultBest – ServerFault best questions (all topics)
BestBash – best Bash questions from StackOverflow, ServerFault and AskUbuntu
BestClojure – Clojure questions from StackOverflow
BestScala – Scala questions from StackOverflow
BestEclipse - Eclipse questions from StackOverflow
jQueryDaily – jQuery questions from StackOverflow
BestAlgorithms – Algorithm questions from StackOverflow

2 tweets per day are created on each of these accounts, with the highest rated questions on their specific subject.

6. Conclusion

This third article finishes the series about integrating with StackOverflow and other StackExchange sites to retrieve questions through their REST API, and integrating with Twitter and Spring Social to tweet these questions. A potential direction worth exporing is doing the same with Google Plus – probably using Pages, not accounts.

14 Twitter accounts are up and running as a result of this project – focusing on various topics and producing low volume and hopefully high quality content (ideas for other tags that deserves their own Twitter account are welcome in the comments).

Spring Security Form Login

Eugen Paraschiv — Wed, 01 May 2013 14:13:14 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

Last Update: 19.05.2013 (2nd update)

1. Introduction

This article is going to focus on Login with Spring Security. We’re going to built on top of the simple Spring MVC example, as Spring MVC is a necessary part of setting up the login mechanism.

2. The Maven Dependencies

To add Maven dependencies to the project, please see the Spring Security with Maven article. Both standard spring-security-web and spring-security-config will be required.

3. The web.xml

The Spring Security configuration in the web.xml is simple – only an additional filter added to the standard Spring MVC web.xml:




   Spring Secured Application

   
   
      mvc
      org.springframework.web.servlet.DispatcherServlet
      1
   
   
      mvc
      /
   

   
      contextClass
      
         org.springframework.web.context.support.AnnotationConfigWebApplicationContext
      
   
   
      contextConfigLocation
      org.baeldung.spring.web.config
   
   
      
         org.springframework.web.context.ContextLoaderListener
      
   

   
   
      springSecurityFilterChain
      org.springframework.web.filter.DelegatingFilterProxy
   
   
      springSecurityFilterChain
      /*

The filter – DelegatingFilterProxy – simply delegates to a Spring managed bean – the FilterChainProxy – which itself is able to benefit from full Spring bean lifecycle management and such.

2. The Spring Security configuration

The Spring configuration is mostly written in Java, but Spring Security configuration doesn’t yet support full Java and still needs to be XML for the most part. There is an ongoing effort to add Java based configuration for Spring Security, but this is not yet mature.

The overall project is using Java configuration, so the XML configuration file needs to be imported via a Java @Configuration class:

@Configuration
@ImportResource({ "classpath:webSecurityConfig.xml" })
public class SecSecurityConfig {
   public SecSecurityConfig() {
      super();
   }
}

The Spring Security XML Configuration – webSecurityConfig.xml:

2.1.

We are allowing anonymous access on /login so that users can authenticate. We are also securing everything else.

Note that the order of the element is significant – the more specific rules need to come first, followed by the more general ones.

2.2.

login-page – the custom login page
default-target-url – the landing page after a successful login
authentication-failure-url – the landing page after an unsuccessful login

2.3.

The element is simply configured to go back to the login page.

2.4.

The Authentication Provider is backed by a simple, in-memory implementation – InMemoryUserDetailsManager specifically – configured in plain text. This only exists in Spring 3.1 and above and is meant to be used for rapid prototyping when a full persistence mechanism is not yet necessary.

The login form page is going to be registered with Spring MVC using the straightforward mechanism to map views names to URLs with no need for an explicit controller in between:

   registry.addViewController("/login.html");

This of course corresponds to the login.jsp:

The Spring Login form has the following relevant artifacts:

j_spring_security_check – the URL where the form is POSTed to trigger the authentication process
j_username – the user name
j_password – the password

We briefly discussed a few configurations of the login mechanism when we introduced the Spring Security XML Configuration above – let’s go into some detail now.

One reason to override most of the defaults in Spring Security is to hide the fact that the application is secured with Spring Security and minimize the information a potential attacker knows about the application.

Fully configured, the element looks like this:

4.1. The Login page

The custom login page is configured via the login-page attribute on :

login-page='/login.html'

If this is not specified, a default URL is used – spring_security_login – and Spring Security will generate a very basic Login Form at that URL.

4.2. The POST URL for Login

The default URL where the Spring Login will POST to trigger the authentication process is /j_spring_security_check.

This URL can be overridden via the login-processing-url attribute on :

login-processing-url="/perform_login"

A good reason to override this default URL is to hide the fact that the application is actually secured with Spring Security – that information should not be available externally.

4.3. The Landing page on Success

After a successful Login process, the user is redirected to a page – which by default is the root of the web application.

This can be overridden via the default-target-url attribute on :

default-target-url="/homepage.html"

In case the always-use-default-target is set to true, then the user is always redirected to this page. If that attribute is set to false, then the user will be redirected to the previous page they wanted to visit before being promoted to authenticate.

4.3. The Landing page on Failure

Same as with the Login Page, the Login Failure Page is autogenerated by Spring Security at /spring_security_login?login_error by default.

This can be overridden via the authentication-failure-url attribute on :

authentication-failure-url="/login.html?error=true"

5. Conclusion

In this Spring Login Example we configured a simple authentication process – we discussed the Spring Security Login Form, the Security XML Configuration and some of the more advanced customizations available in the namespace.

The implementation of this Spring Login tutorial can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

When the project runs locally, the sample html can be accessed at:

http://localhost:8080/spring-security-login/login.html

P.S. If you read this far, you should follow me on Twitter.

Spring MVC Tutorial

Eugen Paraschiv — Tue, 30 Apr 2013 10:01:32 +0000

Quality-only Ad Network. Simple!
Powered by InfluAds

1. Overview and Maven

This is a simple Spring MVC tutorial showing how to set up a Spring MVC project, both with Java based Configuration as well as with XML Configuration.

The Maven dependencies for Spring MVC project are described in the in detail in the Spring with Maven article.

2. The web.xml

This is a simple configuration of the web.xml for a Spring MVC project:




   Spring MVC Java Config App

   
      mvc
      org.springframework.web.servlet.DispatcherServlet
      1
   
   
      mvc
      /
   

   
      contextClass
      
         org.springframework.web.context.support.AnnotationConfigWebApplicationContext
      
   
   
      contextConfigLocation
      org.baeldung.spring.web.config
   
   
      
         org.springframework.web.context.ContextLoaderListener

We are using Java based Configuration, so we’re using AnnotationConfigWebApplicationContext as the main context class – this accepts @Configuration annotated classes as input. As such, we only need to specify the package where these configuration classes are located, via contextConfigLocation.

To keep this mechanism flexible, multiple packages are also configurable here, simply space delimited:

   
      contextConfigLocation
      org.baeldung.spring.web.config org.baeldung.spring.persistence.config

This allows more complex projects with multiple modules to manage their own Spring Configuration classes and contribute them to the overall Spring context at runtime.

Finally, the Servlet is mapped to / – meaning it becomes the default Servlet of the application and it will pick up every pattern that doesn’t have another exact match defined by another Servlet.

3. The View Configuration

The Spring MVC Java configuration is simple – it uses the MVC configuration support introduced in Spring 3.1:

@EnableWebMvc
@Configuration
public class ClientWebConfig extends WebMvcConfigurerAdapter {

   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      super.addViewControllers(registry);

      registry.addViewController("/sample.html");
   }

   @Bean
   public ViewResolver viewResolver() {
      InternalResourceViewResolver bean = new InternalResourceViewResolver();

      bean.setViewClass(JstlView.class);
      bean.setPrefix("/WEB-INF/view/");
      bean.setSuffix(".jsp");

      return bean;
   }
}

Very important here is that we can register view controllers that create a direct mapping between the URL and the view name – no need for any Controller between the two now that we’re using Java configuration.

4. The JSP Views

We defined above a basic view controller – sample.html – the corresponding jsp resource is:


   

   
      This is the body of the sample view

The JSP based view files are located under the /WEB-INF folder of the project, so they’re only accessible to the Spring infrastructure and not by direct URL access.

5. Conclusion

In this example we configured a simple and functional Spring MVC project, using Java configuration.

The implementation of this simple Spring MVC tutorial can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.

When the project runs locally, the sample.html can be accessed at:

http://localhost:8080/spring-mvc/sample.html

P.S. If you read this far, you should follow me on Twitter.