Monday, December 10, 2012

Spring Social with JavaConfig (Part 1)

In this tutorial, we will create an application that can post messages and retrieve profile information from Facebook and Twitter. We will use Spring Social to implement these features. To secure our application we will use Spring Security, and to manage our views, we will use Thymeleaf.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Dependencies

These are the main Maven dependencies:

Spring 3.2.0.RELEASE
Spring Data JPA 1.2.0.RELEASE
Spring Security 3.1.3.RELEASE
Thymeleaf 2.0.14
Hibernate 3.6.3.Final
See pom.xml for full details

Required Tools

These are the minimum required tools:

Git
Maven 3.0.4
MySQL
Eclipse IDE or SpringSource Tool Suite (STS)

GitHub Repository

There are two versions of the application: a JavaConfig-based and an XML config-based app. Both versions are identical in their feature set.

Functional Specs

Our application's requirements are the following:

Post to Facebook and Twitter
Retrieve profile information from Facebook and Twitter
Secure the application
Allow login and creation of new users
Create a page for managing users

Here's our Use Case diagrams:

[User]-(Post to Facebook)
[User]-(Post to Twitter)
[User]-(Retrieve info from Facebook)
[User]-(Retrieve info from Twitter)
[User]-(Sign in)
[User]-(Sign up)

//http://yuml.me/

[Admin]-(Edit users)
[Admin]-(Delete users)
[Admin]-(Add users)

//http://yuml.me/

Screenshots

Before we proceed, let's preview some screenshots of our application:

Facebook Profile

Twitter Profile

Manage Users

Post to Facebook

Tweet to Tweeter

Connect to Social Site

Connected to Social Site

In the next section, we will show how to generate the OAuth secret keys for Facebook and Twitter. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 2)

Review

In the previous section, we have discussed the functional requirements of our application. In this section we will study how to generate OAuth keys for Facebook and Twitter. These are required so that Spring Social can communicate with these social media sites.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Generate OAuth keys

Facebook

To generate a Facebook secret key, you need to sign-up for a Facebook account first. Once you have an account, follow these steps:

Open a browser
Visit https://developers.facebook.com/apps
Click on Create New App
Fill-in the App Name
You will be redirected to the Basic settings page
Now copy the App ID value. This is your client ID
Then copy the App Secret value. This is your client secret

Note: The values need to be stored in the spring.properties file (see Part 5).

On my sample app, here's the Basic settings page. I've purposely changed the App ID and App Secret values:

Twitter

To generate a Twitter secret key, you need to sign-up for a Twitter account first. Once you have an account, follow these steps:

Open a browser
Visit https://dev.twitter.com/
Visit the My applications page at https://dev.twitter.com/apps
Click on Create a new application
Fill-in the Name
Fill-in the Description
Fill-in the Website (You will need to invent a fictitious URL)
You will be redirected to the Details tab of your new application
Now copy the Consumer key value. This is your client ID
Then copy the Consumer secret value. This is your client secret

Note: The values need to be stored in the spring.properties file (see Part 5).

On my sample app, here's the Details tab. I've purposely changed the Consumer key and Consumer secret values:

In the next section, we will setup the Spring Social-related configuration through JavaConfig. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 3)

Review

In the previous section, we have shown the steps on how to generate and retrieve the OAuth secret keys from Facebook and Twitter. In this section we will setup the Spring Social configuration settings through JavaConfig.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Spring Social configuration

What is Spring Social?

Spring Social is an extension of the Spring Framework that allows you to connect your applications with Software-as-a-Service (SaaS) providers such as Facebook and Twitter.

Features:

An extensible service provider framework that greatly simplifies the process of connecting local user accounts to hosted provider accounts.

A connect controller that handles the authorization flow between your Java/Spring web application, a service provider, and your users.

Java bindings to popular service provider APIs such as Facebook, Twitter, LinkedIn, TripIt, and GitHub.

A sign-in controller that enables users to authenticate with your application by signing in through a service provider.

Source: http://www.springsource.org/spring-social

Here's our Spring Social configuration:

SocialConfig.java

	package org.krams.config;

	import javax.sql.DataSource;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Scope;
	import org.springframework.context.annotation.ScopedProxyMode;
	import org.springframework.core.env.Environment;
	import org.springframework.security.core.Authentication;
	import org.springframework.security.core.context.SecurityContextHolder;
	import org.springframework.security.crypto.encrypt.Encryptors;
	import org.springframework.security.crypto.encrypt.TextEncryptor;
	import org.springframework.social.connect.ConnectionFactoryLocator;
	import org.springframework.social.connect.ConnectionRepository;
	import org.springframework.social.connect.UsersConnectionRepository;
	import org.springframework.social.connect.jdbc.JdbcUsersConnectionRepository;
	import org.springframework.social.connect.support.ConnectionFactoryRegistry;
	import org.springframework.social.connect.web.ConnectController;
	import org.springframework.social.facebook.connect.FacebookConnectionFactory;
	import org.springframework.social.twitter.connect.TwitterConnectionFactory;
	import org.springframework.web.filter.HiddenHttpMethodFilter;

	@Configuration
	public class SocialConfig {

	@Autowired
	private Environment env;

	@Autowired
	private DataSource dataSource;

	@Bean
	public ConnectionFactoryLocator connectionFactoryLocator() {
	ConnectionFactoryRegistry registry = new ConnectionFactoryRegistry();
	registry.addConnectionFactory(new FacebookConnectionFactory(
	env.getRequiredProperty("facebook.clientId"),
	env.getRequiredProperty("facebook.clientSecret")));

	registry.addConnectionFactory(new TwitterConnectionFactory(
	env.getRequiredProperty("twitter.consumerKey"),
	env.getRequiredProperty("twitter.consumerSecret")));
	return registry;
	}

	@Bean
	public TextEncryptor textEncryptor() {
	return Encryptors.noOpText();
	}

	@Bean
	public UsersConnectionRepository usersConnectionRepository() {
	return new JdbcUsersConnectionRepository(dataSource,
	connectionFactoryLocator(),
	textEncryptor());
	}

	@Bean
	@Scope(value="request", proxyMode=ScopedProxyMode.INTERFACES)
	public ConnectionRepository connectionRepository() {
	Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
	if (authentication == null)
	throw new IllegalStateException("Unable to get a ConnectionRepository: no user signed in");

	return usersConnectionRepository().createConnectionRepository(authentication.getName());
	}

	@Bean
	public ConnectController connectController() {
	ConnectController controller = new ConnectController(connectionFactoryLocator(), connectionRepository());
	controller.setApplicationUrl(env.getRequiredProperty("application.url"));
	return controller;
	}

	@Bean
	public HiddenHttpMethodFilter hiddenHttpMethodFilter() {
	HiddenHttpMethodFilter filter = new HiddenHttpMethodFilter();
	return filter;
	}
	}

view raw SocialConfig.java hosted with ❤ by GitHub

Let me explain the contents of this configuration:

We have autowired the environment properties and the datasource
We have declared a ConnectionFactoryLocator which allows us to register connections to Facebook and Twitter. Notice how we passed the OAuth secret IDs and secret keys to the locator
We've declared a TextEncryptor for encrypting strings. This is required by Spring Social's JdbcUsersConnectionRepository
JdbcUsersConnectionRepository is used for persisting connections to a database through JDBC
ConnectionRepository allows a specific user to save and retrieve connections. We need to use this in conjunction with Spring Security because it provides us ready-made authenticated users. Notice how we assigned the current authenticated user
ConnectController is a controller for managing the connection flow to social media sites
HiddenHttpMethodFilter is required by Spring Social so that users can disconnect from social media sites. The filter needs to be declared in the web.xml or ApplicationInitializer

Note: If you need an in-depth explanation of each classes, please see the official Spring Social docs

In the next section, we will focus on Spring Security-related configuration. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 4)

Review

In the previous section, we have discussed the Spring Social-related configuration. In this section we will focus on Spring Security for securing our application.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Spring Security

What is Spring Security?

Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications.

Spring Security is one of the most mature and widely used Spring projects. Founded in 2003 and actively maintained by SpringSource since, today it is used to secure numerous demanding environments including government agencies, military applications and central banks. It is released under an Apache 2.0 license so you can confidently use it in your projects.

Source: http://www.springsource.org/spring-security

Here's our Spring Security configuration:

SecurityConfig.java

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.web.filter.DelegatingFilterProxy;

	@Configuration
	@ImportResource({"classpath:spring-security.xml"})
	public class SecurityConfig {

	@Bean
	public DelegatingFilterProxy springSecurityFilterChain() {
	DelegatingFilterProxy filterProxy = new DelegatingFilterProxy();
	return filterProxy;
	}

	}

view raw SecurityConfig.java hosted with ❤ by GitHub

First, we declare a DelegatingFilterProxy bean using JavaConfig. This allows Spring Security to intercept requests to our application and verify if the required authentication and authorization are met. This bean needs to be registered in the web.xml (or ApplicationInitializer) as a filter (see next section).

Second, we declare the usual XML-based configuration. This allows us to define the intercept-url patterns. Why are we not using JavaConfig here? Because the XML-based configuration is simpler, less-verbose, and easier:

spring-security.xml

	<?xml version="1.0" encoding="UTF-8"?>
	<beans:beans xmlns="http://www.springframework.org/schema/security"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/security
	http://www.springframework.org/schema/security/spring-security-3.1.xsd
	http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util-3.1.xsd">

	<http pattern="/resources" security="none" />

	<http auto-config="true" use-expressions="true">
	<intercept-url pattern="/" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/login" access="permitAll"/>
	<intercept-url pattern="/signup" access="permitAll"/>
	<intercept-url pattern="/logout" access="permitAll"/>
	<intercept-url pattern="/error" access="permitAll"/>
	<intercept-url pattern="/denied" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/welcome" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/users" access="hasRole('ROLE_ADMIN')"/>
	<intercept-url pattern="/fb/profile" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/fb/post" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/tw/profile" access="hasRole('ROLE_USER')"/>
	<intercept-url pattern="/tw/post" access="hasRole('ROLE_USER')"/>

	<form-login login-page="/login"
	authentication-failure-url="/login/failure"
	default-target-url="/"/>

	<access-denied-handler error-page="/denied"/>

	<logout invalidate-session="true"
	logout-success-url="/logout/success"
	logout-url="/logout"/>
	</http>

	<authentication-manager>
	<authentication-provider user-service-ref="repositoryBasedUserDetailsService">
	<password-encoder hash="md5"/>
	</authentication-provider>
	</authentication-manager>
	</beans:beans>

view raw spring-security.xml hosted with ❤ by GitHub

For an in-depth explanation of this configuration, please see my tutorial on Spring Security 3.1 - Implement UserDetailsService with Spring Data JPA

In the next section, we will study the remaining JavaConfig-based configuration. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 5)

Review

In the previous section, we have discussed the Spring Security-related configurations. In this section we will discuss the remaining configuration of our application.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

JavaConfig

As stated in the introduction, we will be using JavaConfig-based configuration instead of the usual XML config. However, I don't want to alienate our readers who are used to XML. As a result, I've decided to provide both implementations. However, our focus here is still on JavaConfig.

Note: With JavaConfig, we can now omit the ubiquitous web.xml. But in order to that, we need to run a Servlet 3.0 web container. For this tutorial, I have tested the application with Tomcat 7.0.30 (Maven plugin), 7.0.33 (standalone Tomcat), and Jetty 8.1.5.v20120716 (Maven plugin).

ApplicationInitializer.java

The ApplicationInitializer.java is the equivalent of web.xml. Here's where we declare the DispatcherServlet and also we've registered two filters: one for Spring Security and another for Spring Social.

	package org.krams.config;

	import javax.servlet.FilterRegistration;
	import javax.servlet.ServletContext;
	import javax.servlet.ServletException;
	import javax.servlet.ServletRegistration;

	import org.springframework.web.WebApplicationInitializer;
	import org.springframework.web.context.ContextLoaderListener;
	import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
	import org.springframework.web.filter.DelegatingFilterProxy;
	import org.springframework.web.filter.HiddenHttpMethodFilter;
	import org.springframework.web.servlet.DispatcherServlet;

	public class ApplicationInitializer implements WebApplicationInitializer {

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
	// Load application context
	AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
	rootContext.register(ApplicationContext.class);
	rootContext.setDisplayName("Spring Social Tutorial");

	// Add context loader listener
	servletContext.addListener(new ContextLoaderListener(rootContext));

	// Declare dispatcher servlet
	ServletRegistration.Dynamic dispatcher =
	servletContext.addServlet("dispatcher", new DispatcherServlet(rootContext));
	dispatcher.setLoadOnStartup(1);
	dispatcher.addMapping("/");

	// Register Spring security filter
	FilterRegistration.Dynamic springSecurityFilterChain =
	servletContext.addFilter("springSecurityFilterChain", DelegatingFilterProxy.class);
	springSecurityFilterChain.addMappingForUrlPatterns(null, false, "/*");

	// Register Spring Social filter so that we can disconnect from providers
	FilterRegistration.Dynamic hiddenHttpMethodFilter =
	servletContext.addFilter("hiddenHttpMethodFilter", HiddenHttpMethodFilter.class);
	hiddenHttpMethodFilter.addMappingForUrlPatterns(null, false, "/*");
	}

	}

view raw ApplicationInitializer.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<web-app xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">
	<display-name>Spring Social Tutorial</display-name>

	<filter>
	<filter-name>springSecurityFilterChain</filter-name>
	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>

	<filter-mapping>
	<filter-name>springSecurityFilterChain</filter-name>
	<url-pattern>/*</url-pattern>
	</filter-mapping>

	<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
	/WEB-INF/spring-security.xml
	/WEB-INF/applicationContext.xml
	</param-value>
	</context-param>

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

	<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	</servlet>

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

	<filter>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
	</filter>

	<filter-mapping>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<url-pattern>/*</url-pattern>
	</filter-mapping>
	</web-app>

view raw web.xml hosted with ❤ by GitHub

ApplicationContext.java

The ApplicationContext.java contains our main configuration. It's responsible for loading other configurations, either as JavaConfig or XML config.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.ComponentScan;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Import;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.context.annotation.PropertySource;
	import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
	import org.springframework.context.support.ResourceBundleMessageSource;
	import org.springframework.core.io.ClassPathResource;
	import org.springframework.core.io.Resource;
	import org.springframework.web.servlet.config.annotation.EnableWebMvc;
	import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

	@Configuration
	@ComponentScan(basePackages = {"org.krams"})
	@EnableWebMvc
	@Import({DataConfig.class, ThymeleafConfig.class, SocialConfig.class, SecurityConfig.class})
	@ImportResource({"classpath:trace-context.xml"})
	@PropertySource("classpath:spring.properties")
	public class ApplicationContext extends WebMvcConfigurerAdapter {

	// Maps resources path to webapp/resources
	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
	registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
	}

	// Provides internationalization of messages
	@Bean
	public ResourceBundleMessageSource messageSource() {
	ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
	messageSource.setBasename("messages");
	return messageSource;
	}

	// Only needed if we are using @Value and ${...} when referencing properties
	// Otherwise @PropertySource is enough by itself
	@Bean
	public static PropertySourcesPlaceholderConfigurer properties() {
	PropertySourcesPlaceholderConfigurer propertySources = new PropertySourcesPlaceholderConfigurer();
	Resource[] resources = new ClassPathResource[] {
	new ClassPathResource("spring.properties") };
	propertySources.setLocations(resources);
	propertySources.setIgnoreUnresolvablePlaceholders(true);
	return propertySources;
	}
	}

view raw ApplicationContext.java hosted with ❤ by GitHub

Let's describe each annotation:

@Configuration
- Marks a class as a JavaConfig
@ComponentScan(basePackages = {"org.krams"})
- Configures scanning of Spring components

This is equivalent in XML as:

<context:annotation-config />

<context:component-scan base-package="org.krams" />

view raw context-annotation-config.xml hosted with ❤ by GitHub
@EnableWebMvc
- Activates Spring's MVC support

This is equivalent in XML as:

<mvc:annotation-driven />

view raw mvc-annotation-driven.xml hosted with ❤ by GitHub
@Import({DataConfig.class, ThymeleafConfig.class, SocialConfig.class, SecurityConfig.class})
- This allows us to import JavaConfig-based config. Notice we have imported four configuration classes
@ImportResource("classpath:trace-context.xml")
- This allows us to import XML-based config files. (As a side note why can't we just declare this as a JavaConfig? It turns out there's no direct translation for the trace-context.xml, so we'll have to import it as XML).

This is equivalent in XML as:

<import resource="trace-context.xml"/>

view raw import-resource.xml hosted with ❤ by GitHub
@PropertySource("classpath:spring.properties")
- This allows us to import property files
@Bean
- Declares a Spring bean

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

	<!-- Activates various annotations to be detected in bean classes -->
	<context:annotation-config />

	<!-- Scans the classpath for annotated components that will be auto-registered as Spring beans.
	For example @Controller and @Service. Make sure to set the correct base-package -->
	<context:component-scan base-package="org.krams" />

	<!-- Configures the annotation-driven Spring MVC Controller programming model.
	Note that, with Spring 3.0, this tag works in Servlet MVC only! -->
	<mvc:annotation-driven />

	<!-- Maps resources path to webapp/resources -->
	<mvc:resources mapping="/resources/**" location="/resources/" />

	<!-- Provides internationalization of messages -->
	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"
	p:basename="messages" />

	<!-- Imports Spring Social configuration -->
	<import resource="spring-social.xml"/>

	<!-- Imports datasource configuration -->
	<import resource="spring-data.xml"/>

	<!-- Imports logging configuration -->
	<import resource="trace-context.xml"/>

	<bean id="deployProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean"
	p:location="/WEB-INF/spring.properties" />

	</beans>

view raw applicationContext.xml hosted with ❤ by GitHub

DataConfig.java

The DataConfig.java contains our Spring Data configuration. This is where we declare our data source, transaction manager, and JPA entity manager.

	package org.krams.config;

	import javax.sql.DataSource;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.core.env.Environment;
	import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
	import org.springframework.orm.jpa.JpaTransactionManager;
	import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
	import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
	import org.springframework.transaction.annotation.EnableTransactionManagement;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
	import com.mchange.v2.c3p0.ComboPooledDataSource;

	@Configuration
	@EnableTransactionManagement
	@EnableJpaRepositories("org.krams.repository")
	public class DataConfig extends WebMvcConfigurerAdapter {

	@Autowired
	private Environment env;

	@Bean
	public DataSource dataSource() {
	try {
	ComboPooledDataSource ds = new ComboPooledDataSource();
	ds.setDriverClass(env.getRequiredProperty("app.jdbc.driverClassName"));
	ds.setJdbcUrl(env.getRequiredProperty("app.jdbc.url"));
	ds.setUser(env.getRequiredProperty("app.jdbc.username"));
	ds.setPassword(env.getRequiredProperty("app.jdbc.password"));
	ds.setAcquireIncrement(5);
	ds.setIdleConnectionTestPeriod(60);
	ds.setMaxPoolSize(100);
	ds.setMaxStatements(50);
	ds.setMinPoolSize(10);
	return ds;
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}

	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
	HibernateJpaVendorAdapter vendor = new HibernateJpaVendorAdapter();
	vendor.setShowSql(false);

	LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
	em.setPersistenceXmlLocation("classpath*:META-INF/persistence.xml");
	em.setPersistenceUnitName("hibernatePersistenceUnit");
	em.setDataSource(dataSource());
	em.setJpaVendorAdapter(vendor);
	return em;
	}

	@Bean
	public JpaTransactionManager transactionManager() {
	JpaTransactionManager transactionManager = new JpaTransactionManager();
	transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
	return transactionManager;
	}
	}

view raw DataConfig.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/jdbc
	http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
	http://www.springframework.org/schema/data/jpa
	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

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

	<!-- Activate Spring Data JPA repository support -->
	<jpa:repositories base-package="org.krams.repository" />

	<!-- Declare a datasource that has pooling capabilities-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
	destroy-method="close"
	p:driverClass="${app.jdbc.driverClassName}"
	p:jdbcUrl="${app.jdbc.url}"
	p:user="${app.jdbc.username}"
	p:password="${app.jdbc.password}"
	p:acquireIncrement="5"
	p:idleConnectionTestPeriod="60"
	p:maxPoolSize="100"
	p:maxStatements="50"
	p:minPoolSize="10" />

	<!-- Declare a JPA entityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
	p:persistenceXmlLocation="classpath*:META-INF/persistence.xml"
	p:persistenceUnitName="hibernatePersistenceUnit"
	p:dataSource-ref="dataSource"
	p:jpaVendorAdapter-ref="hibernateVendor"/>

	<!-- Specify our ORM vendor -->
	<bean id="hibernateVendor" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
	p:showSql="false"/>

	<!-- Declare a transaction manager-->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
	p:entityManagerFactory-ref="entityManagerFactory"/>

	</beans>

view raw spring-data.xml hosted with ❤ by GitHub

ThymeleafConfig.java

The ThymeleafConfig.java contains our Thymeleaf configuration. This is where we declare our Thymeleaf view resolver.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.thymeleaf.spring3.SpringTemplateEngine;
	import org.thymeleaf.spring3.view.ThymeleafViewResolver;
	import org.thymeleaf.templateresolver.ServletContextTemplateResolver;

	@Configuration
	public class ThymeleafConfig {

	@Bean
	public ServletContextTemplateResolver templateResolver() {
	ServletContextTemplateResolver resolver = new ServletContextTemplateResolver();
	resolver.setPrefix("/WEB-INF/templates/");
	resolver.setSuffix(".html");
	resolver.setTemplateMode("HTML5");
	resolver.setOrder(1);

	// Declare virtual paths
	resolver.addTemplateAlias("connect/facebookConnect","facebook/connect");
	resolver.addTemplateAlias("connect/twitterConnect","twitter/connect");
	resolver.addTemplateAlias("connect/facebookConnected","facebook/connected");
	resolver.addTemplateAlias("connect/twitterConnected","facebook/connected");

	// Disable cache for testing purposes
	resolver.setCacheable(false);
	return resolver;
	}

	@Bean
	public SpringTemplateEngine templateEngine() {
	SpringTemplateEngine engine = new SpringTemplateEngine();
	engine.setTemplateResolver(templateResolver());
	return engine;
	}

	@Bean
	public ThymeleafViewResolver thymeleafViewResolver() {
	ThymeleafViewResolver resolver = new ThymeleafViewResolver();
	resolver.setTemplateEngine(templateEngine());
	return resolver;
	}

	}

view raw ThymeleafConfig.java hosted with ❤ by GitHub

We've declared some special settings on our Thymeleaf configuration:

// Declare virtual paths
resolver.addTemplateAlias("connect/facebookConnect","facebook/connect");
resolver.addTemplateAlias("connect/twitterConnect","twitter/connect");
resolver.addTemplateAlias("connect/facebookConnected","facebook/connected");
resolver.addTemplateAlias("connect/twitterConnected","facebook/connected");

// Disable cache for testing purposes
resolver.setCacheable(false);

These allows to redirect virtual path requests to specific templates within our application. We need to do this because the ConnectController from Spring Social has its own built-in controller path requests. And we need to redirect the resulting views that matches our template path.

For example, when connecting to Facebook, ConnectController will use the connect/facebookConnect path and you are required to provide a view. Using the addTemplateAlias() method, we can provide a custom view, in this case, the view points to the directory in the WEB-INF/templates/facebook/connect.

Also, we've disabled the caching feature so that we can easily update and test our html pages.

Here's the equivalent XML configuration:

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

	<!-- Declare a Thymeleaf resolver -->
	<bean id="templateResolver" class="org.thymeleaf.templateresolver.ServletContextTemplateResolver"
	p:prefix="/WEB-INF/templates/"
	p:suffix=".html"
	p:templateMode="HTML5"
	p:order="1"
	p:cacheable="false"
	p:templateAliases-ref="templateAliases"/>

	<util:map id="templateAliases">
	<entry key="connect/facebookConnect" value="facebook/connect"/>
	<entry key="connect/twitterConnect" value="twitter/connect"/>
	<entry key="connect/facebookConnected" value="facebook/connected"/>
	<entry key="connect/twitterConnected" value="twitter/connected"/>
	</util:map>

	<bean id="templateEngine" class="org.thymeleaf.spring3.SpringTemplateEngine"
	p:templateResolver-ref="templateResolver" />

	<bean class="org.thymeleaf.spring3.view.ThymeleafViewResolver"
	p:templateEngine-ref="templateEngine"/>

	</beans>

view raw spring-servlet.xml hosted with ❤ by GitHub

SecurityConfig.java

The SecurityConfig.java contains a single bean DelegatingFilterProxy. This is required for Spring Security.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.web.filter.DelegatingFilterProxy;

	@Configuration
	@ImportResource({"classpath:spring-security.xml"})
	public class SecurityConfig {

	@Bean
	public DelegatingFilterProxy springSecurityFilterChain() {
	DelegatingFilterProxy filterProxy = new DelegatingFilterProxy();
	return filterProxy;
	}

	}

view raw SecurityConfig.java hosted with ❤ by GitHub

spring.properties

spring.properties contains the property settings of our application. You need to declare your Facebook and Twitter OAuth settings here. Here's also where you declare your database.

	# database properties
	app.jdbc.driverClassName=com.mysql.jdbc.Driver
	app.jdbc.url=jdbc\:mysql\://localhost/spring_social_tutorial
	app.jdbc.username=root
	app.jdbc.password=

	# social properties
	facebook.clientId=YOUR-FACEBOOK-CLIENT-ID
	facebook.clientSecret=YOUR-FACEBOOK-CLIENT-SECRET
	twitter.consumerKey=YOUR-TWITTER-CONSUMER-KEY
	twitter.consumerSecret=YOUR-TWITTER-CONSUMER-SECRET
	application.url=http://localhost:8080/spring-social-tutorial

view raw spring.properties hosted with ❤ by GitHub

messages_en.properties

This is for internationalization of messages. The default language is English. If you need to provide custom language, create a new properties file and replace the values according to the language you've chosen. Please see the Spring documentation for more info on internationalization.

	app.name=TestApp

	#login.html
	login.title=Sign in
	login.legend=Sign in
	login.username=Username
	login.password=Password
	login.button=Sign in
	login.noaccount=No account? Create one now!

	#signup.html
	signup.title=Sign up
	signup.legend=Sign up
	signup.button=Sign up
	signup.hasaccount=Already have an account? Sign in!

	#welcome.html
	welcome.title=Welcome

	#post.html
	post.title.fb=Post to Facebook
	post.title.tw=Post to Twitter
	post.form.legend.fb=Update your status:
	post.form.legend.tw=Tweet a message:
	post.form.action.fb=/fb/post
	post.form.action.tw=/tw/post
	post.form.submit.fb=Post it!
	post.form.submit.tw=Tweet it!

	#posted.html
	posted.title.fb=Facebook
	posted.title.tw=Twitter
	posted.success.fb=The following message has been posted:
	posted.success.tw=The following message has been tweeted:
	posted.failure.fb=Unable to post to your Facebook account!
	posted.failure.tw=Unable to post to your Twitter account!

	#profile.html
	profile.title.fb=Facebook Profile
	profile.title.tw=Twitter Profile
	profile.h3.fb=Facebook Profile
	profile.h3.tw=Twitter Profile
	profile.id.fb=Facebook ID:
	profile.id.tw=Twitter ID:
	profile.name.fb=Name:
	profile.name.tw=Screen Name
	profile.loc.fb=Email:
	profile.loc.tw=Location:
	profile.url.fb=Profile Url:
	profile.url.tw=Profile Url:

	#connect.html
	connect.title.fb=Connect to Facebook
	connect.title.tw=Connect to Twitter
	connect.h3.fb=Connect to Facebook
	connect.h3.tw=Connect to Twitter
	connect.form.action.fb=/connect/facebook
	connect.form.action.tw=/connect/twitter
	connect.message.fb=You haven't created any connections with Facebook yet. Click the button to create a connection between your account and your Facebook profile. (You'll be redirected to Facebook where you'll be asked to authorize the connection)
	connect.message.tw=You haven't created any connections with Twitter yet. Click the button to create a connection between your account and your Twitter profile. (You'll be redirected to Twitter where you'll be asked to authorize the connection)
	connect.button.fb=Connect with Facebook
	connect.button.tw=Connect with Tweeter

	#connected.html
	connected.title.fb=Facebook Connected
	connected.title.tw=Twitter Connected
	connected.h3.fb=Facebook Connected
	connected.h3.tw=Twitter Connected
	connected.message.fb=is now connected to your Facebook account. Click the button if you wish to disconnect. Try loading your profile or posting a message to test your connection.
	connected.message.tw=is now connected to your Tweeter account. Click the button if you wish to disconnect. Try loading your profile or posting a message to test your connection.

	#include.html
	disconnect.url.fb=/connect/facebook
	disconnect.url.tw=/connect/twitter
	disconnect.button.fb=Disconnect from Facebook
	disconnect.button.tw=Disconnect from Twitter

	#users.html
	users.title=User Management
	users.table.caption=Site Users
	user.id.label=Id
	user.firstname.label=First Name
	user.lastname.label=Last Name
	user.username.label=Username
	user.password.label=Password
	user.role.label=Role
	user.role.1=admin
	user.role.2=regular
	new.user.table.caption=New User
	new.user.button.label=add
	update.user.table.caption=Existing User
	update.user.button.label=update

	error.profile.fb=Failure! An error has occurred while trying to retrieve your profile!
	error.profile.tw=Failure! An error has occurred while trying to retrieve your profile!
	error.post.fb=Failure! We are unable to process your request!
	error.post.tw=Failure! We are unable to process your request!

	#errors
	error.access.denied=Access denied! You're not allowed to access that!
	status.login.failure=Unable to login. Invalid credentials!
	status.logout.success=You have successfully logged out!
	status.signup.invalid.username.duplicate=Username already exist!
	status.signup.invalid.password.notmatching=Passwords do not match!

view raw messages_en.properties hosted with ❤ by GitHub

In the next section, we will discuss the Domain, Service, Controller, and View layers. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 6)

Review

In the previous section, we have discussed the remaining JavaConfig configurations. In this section, we will discuss the View layer along with Thymeleaf.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

View with Thymeleaf

The goal of this section is not to teach you everything about Thymeleaf but to point out the important sections. If you need a full Thymeleaf documentation, please see the official docs.

What is Thymeleaf?

Thymeleaf is a Java library. It is an XML / XHTML / HTML5 template engine (extensible to other formats) that can work both in web and non-web environments. It is better suited for serving XHTML/HTML5 at the view layer of web applications, but it can process any XML file even in offline environments.

It provides an optional module for integration with Spring MVC, so that you can use it as a complete substitute of JSP in your applications made with this technology, even with HTML5.

The main goal of Thymeleaf is to provide an elegant and well-formed way of creating templates. Its Standard and SpringStandard dialects allow you to create powerful natural templates, that can be correctly displayed by browsers and therefore work also as static prototypes. You can also extend Thymeleaf by developing your own dialects.

Source: Thymeleaf.org

Since we have numerous html pages with duplicate setup, I will focus on the ones that are most instructive.

Facebook profile.html
This displays our Facebook profile information.

	<!DOCTYPE html>
	<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:th="http://www.thymeleaf.org">

	<head th:fragment="header">
	<meta charset="utf-8" />
	<link rel="stylesheet" href="../../../resources/css/style.css" th:href="@{/resources/css/style.css}" />
	<title th:text="#{'profile.title.' + ${source}}">Title</title>
	</head>

	<body>
	<div class="skin">
	<div class="content">
	<div th:include="include :: menu"></div>
	<div th:include="include :: logo"></div>

	<div class="profile">
	<h3 th:text="#{'profile.h3.' + ${source}}">Your Social Media Profile</h3>
	<div class="pic">
	<img src="#" th:src="@{'http://graph.facebook.com/' + ${profileInfo.id}} + '/picture'" alt="profile image"/>
	<span th:text="${profileInfo.name}">John Smith</span>
	</div>

	<div class="detail">
	<dl>
	<dt th:text="#{'profile.id.' + ${source}}">Social ID:</dt>
	<dd th:text="${profileInfo.id}">12345678</dd>
	<dt th:text="#{'profile.name.' + ${source}}">Social Name:</dt>
	<dd th:text="${profileInfo.name}">John Smith</dd>
	<dt th:text="#{'profile.loc.' + ${source}}">Social Area:</dt>
	<dd th:if="${#strings.isEmpty(profileInfo.email)}" th:text="'no email listed'">john@email.com</dd>
	<dt th:text="#{'profile.url.' + ${source}}">Profile Url:</dt>
	<dd><a href="#" th:href="@{${profileLink}}" th:text="${profileLink}">http://profile-url</a></dd>
	</dl>
	</div>
	<div th:include="include :: disconnect"></div>
	</div>
	</div>
	<div th:include="include :: footer"></div>
	</div>
	</body>
	</html>

view raw profile.html hosted with ❤ by GitHub

Let's discuss the important attributes

The # means to resolve the attribute from the messages bundle
The $ means to resolve the attribute from the model
The # and $ can be combined together so that messages can be dynamically generated from the model and internationalized from the messages bundle
th:href attribute
```
<link rel="stylesheet" href="../../../resources/css/style.css"  th:href="@{/resources/css/style.css}" />
```
Declares a resource relative to the context of the app. When testing the html mockup, the th:href attribute is ignored by the browser. When running the app, Thymeleaf's preprocessor will ignore the value of the href attribute and use the value in the th:ref attribute.
th:text attribute
```
<title th:text="#{'profile.title.' + ${source}}">Title</title>
```
Declares the usual title element. When testing the html mockup, the th:text attribute is ignored by the browser. When running the app, Thymeleaf's preprocessor will ignore the value of the title and use the value in the th:text attribute.

This is a common attribute. So pay attention to this one.
th:include attribute
```
<div th:include="include :: menu"></div>
```
Includes an html fragment. The fragment is declared in the include.html

th:src attribute

<img src="#" th:src="@{'http://graph.facebook.com/' +  ${profileInfo.id}} + '/picture'" alt="profile image"/>

Declares an image element. The attribute th:src is similar with the th:href behavior.

The value of th:src contains two parts: 'http://graph.facebook.com/' which is a literal string and ${profileInfo.id} is a model attribute. The value is sent by our Spring controller (see below):

	@RequestMapping(value="/profile")
	public String getProfile(ModelMap model) {
	try {
	Facebook facebook = connectionRepository.getPrimaryConnection(Facebook.class).getApi();
	model.addAttribute("profileLink", facebook.userOperations().getUserProfile().getLink());
	model.addAttribute("profileInfo", facebook.userOperations().getUserProfile());
	return "facebook/profile";
	}
	...
	}

view raw FacebookController.java hosted with ❤ by GitHub

th:if attribute
```
<dd th:if="${#strings.isEmpty(profileInfo.email)}" th:text="'no email listed'">john@email.com</dd>     
```
A conditional expression. This states "if the profileInfo.email attribute is empty, print out 'no email listed', but if it's not empty, then print out the value.

Note: To see the remaining html pages, please visit the Github repository. I've omitted them here because most of the Thymeleaf tags we've discussed here are also the same ones we've used on those pages.

login.html
This is the login page. We've shown it here because this is used by Spring Security for rendering the login page.

	<!DOCTYPE html>
	<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:th="http://www.thymeleaf.org">

	<head th:fragment="header">
	<meta charset="utf-8" />
	<link rel="stylesheet" href="../../../resources/css/style.css" th:href="@{/resources/css/style.css}" />
	<title th:text="#{login.title}">Sign in</title>
	</head>

	<body>
	<div class="skin">
	<div class="content">
	<div th:include="include :: banner"></div>

	<div class="login">
	<form action="#" th:action="@{/j_spring_security_check}" method="post" >
	<fieldset>
	<label for="j_username" th:text="#{login.username}">Username</label>
	<input id="j_username" name="j_username" type="text"/>
	<label for="j_password" th:text="#{login.password}">Password</label>
	<input id="j_password" name="j_password" type="password"/>
	<button type="submit" th:text="#{login.button}">Submit</button>
	</fieldset>
	</form>
	<p><a href="#" th:href="@{/signup}" th:text="#{login.noaccount}">No account? Create one now!</a></p>
	</div>

	<p class="status" th:if="${not #strings.isEmpty(status)}" th:text="#{'status.' + ${status}}">Status</p>
	</div>
	<div th:include="include :: footer"></div>
	</div>
	</body>
	</html>

view raw login.html hosted with ❤ by GitHub

For more info, please see Spring Security 3.1 - Implement UserDetailsService with Spring Data JPA tutorial.

In the next section, we will focus on the Domain, Repository, Service, and Controller classes Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 7)

Review

In the previous section, we have discussed the View layer along with Thymeleaf. In this section, we will focus on the Domain, Repository, Service, and Controller classes.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Layers

Domain

Our domain layer consists of two simple classes: User.java and Role.java. By annotating these classes with @Entity we're declaring these classes as JPA entities and consequently will be persisted to a database.

The User class contains the following properties: first name, last name, username, role, and password. For the Role class, we only have two values: an admin and a regular user.

	package org.krams.domain;

	import javax.persistence.CascadeType;
	import javax.persistence.Column;
	import javax.persistence.Entity;
	import javax.persistence.GeneratedValue;
	import javax.persistence.GenerationType;
	import javax.persistence.Id;
	import javax.persistence.OneToOne;
	import org.codehaus.jackson.annotate.JsonManagedReference;

	@Entity(name="user")
	public class User {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	private String firstName;
	private String lastName;

	@Column(unique=true)
	private String username;

	private String password;

	@JsonManagedReference
	@OneToOne(mappedBy="user", cascade={CascadeType.ALL})
	private Role role;

	public User() {}

	...getters/setters
	}

view raw User.java hosted with ❤ by GitHub

	package org.krams.domain;

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

	import org.codehaus.jackson.annotate.JsonBackReference;

	@Entity(name="role")
	public class Role {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	@JsonBackReference
	@OneToOne
	private User user;

	private Integer role;

	public Role() {}

	...getters/setters
	}

view raw Role.java hosted with ❤ by GitHub

Although this is not part of the domain layer, we've included the UserDto here. This DTO is used for transferring user information to the view layer.

	package org.krams.response;

	import java.io.Serializable;

	public class UserDto implements Serializable {

	private static final long serialVersionUID = -5488702255320352709L;
	private Long id;
	private String firstName;
	private String lastName;
	private String username;
	private String password;
	private String repassword;
	private Integer role;

	...getters/setters
	}

view raw UserDto.java hosted with ❤ by GitHub

Controller

We have five controllers:

AccessController is responsible for managing login and signup requests
FacebookController is responsible for handling Facebook requests
TwitterController is responsible for handling Twitter requests
UserController is responsible for handling User CRUD operations
MediatorController simply handles call to the root page

AccessController.java

	package org.krams.controller;

	import org.krams.domain.Role;
	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.krams.response.UserDto;
	import org.krams.util.RoleUtil;
	import org.krams.util.UserMapper;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Controller;
	import org.springframework.ui.ModelMap;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;

	@Controller
	@RequestMapping
	public class AccessController {

	@Autowired
	private UserRepository userRepository;

	@RequestMapping("/login")
	public String login() {
	return "access/login";
	}

	@RequestMapping("/denied")
	public String denied(ModelMap model) {
	model.addAttribute("error", "access.denied");
	return "error";
	}

	@RequestMapping("/login/failure")
	public String loginFailure(ModelMap model) {
	model.addAttribute("status", "login.failure");
	return "access/login";
	}

	@RequestMapping("/logout/success")
	public String logoutSuccess(ModelMap model) {
	model.addAttribute("status", "logout.success");
	return "access/login";
	}

	@RequestMapping("/signup")
	public String signup() {
	return "access/signup";
	}

	@RequestMapping(value="/signup", method=RequestMethod.POST)
	public String createAccount(UserDto dto, ModelMap model) {
	if (userRepository.findByUsername(dto.getUsername()) != null) {
	model.addAttribute("status", "signup.invalid.username.duplicate");
	return "access/signup";
	}

	if (dto.getPassword().equals(dto.getRepassword()) == false) {
	model.addAttribute("status", "signup.invalid.password.notmatching");
	return "access/signup";
	}

	User user = UserMapper.map(dto);
	user.setRole(new Role(RoleUtil.ROLE_USER, user));
	user = userRepository.save(user);
	return "redirect:/";
	}
	}

view raw AccessController.java hosted with ❤ by GitHub

FacebookController.java

	package org.krams.controller;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.social.connect.ConnectionRepository;
	import org.springframework.social.connect.NotConnectedException;
	import org.springframework.social.facebook.api.Facebook;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.ModelAttribute;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.ui.ModelMap;

	@Controller
	@RequestMapping("/fb")
	public class FacebookController {

	@Autowired
	private ConnectionRepository connectionRepository;

	@ModelAttribute("source")
	public String source() {
	return "fb";
	}

	@RequestMapping(value="/profile")
	public String getProfile(ModelMap model) {
	try {
	Facebook facebook = connectionRepository.getPrimaryConnection(Facebook.class).getApi();
	model.addAttribute("profileLink", facebook.userOperations().getUserProfile().getLink());
	model.addAttribute("profileInfo", facebook.userOperations().getUserProfile());
	return "facebook/profile";
	} catch (NotConnectedException e) {
	return "facebook/connect";
	}
	}

	@RequestMapping(value="/post", method=RequestMethod.GET)
	public String composer(ModelMap model) {
	try {
	connectionRepository.getPrimaryConnection(Facebook.class).getApi();
	} catch (NotConnectedException e) {
	return "facebook/connect";
	}
	return "post";
	}

	@RequestMapping(value="/post", method=RequestMethod.POST)
	public String post(String message, ModelMap model) {
	try {
	Facebook facebook = connectionRepository.getPrimaryConnection(Facebook.class).getApi();
	facebook.feedOperations().updateStatus(message);
	model.addAttribute("status", "success");
	model.addAttribute("message", message);
	return "posted";
	} catch (Exception e) {
	model.addAttribute("status", "failure");
	return "posted";
	}
	}
	}

view raw FacebookController.java hosted with ❤ by GitHub

MediatorController.java

	package org.krams.controller;

	import org.springframework.security.core.context.SecurityContextHolder;
	import org.springframework.stereotype.Controller;
	import org.springframework.ui.ModelMap;
	import org.springframework.web.bind.annotation.RequestMapping;

	@Controller
	@RequestMapping("/")
	public class MediatorController {

	@RequestMapping
	public String getHomePage(ModelMap model) {
	model.addAttribute("authname", SecurityContextHolder.getContext().getAuthentication().getName());
	return "welcome";
	}
	}

view raw MediatorController.java hosted with ❤ by GitHub

TwitterController.java

	package org.krams.controller;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.social.connect.ConnectionRepository;
	import org.springframework.social.connect.NotConnectedException;
	import org.springframework.social.twitter.api.Twitter;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.ModelAttribute;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.ui.ModelMap;

	@Controller
	@RequestMapping("/tw")
	public class TwitterController {

	@Autowired
	private ConnectionRepository connectionRepository;

	@ModelAttribute("source")
	public String source() {
	return "tw";
	}

	@RequestMapping(value="/profile")
	public String getProfile(ModelMap model) {
	try {
	Twitter twitter = connectionRepository.getPrimaryConnection(Twitter.class).getApi();
	model.addAttribute("profileLink", twitter.userOperations().getUserProfile().getUrl());
	model.addAttribute("profileInfo", twitter.userOperations().getUserProfile());
	return "twitter/profile";
	} catch (NotConnectedException e) {
	return "twitter/connect";
	}
	}

	@RequestMapping(value="/post", method=RequestMethod.GET)
	public String composer(ModelMap model) {
	try {
	connectionRepository.getPrimaryConnection(Twitter.class).getApi();
	} catch (NotConnectedException e) {
	return "twitter/connect";
	}
	return "post";
	}

	@RequestMapping(value="/post", method=RequestMethod.POST)
	public String post(String message, ModelMap model) {
	try {
	Twitter twitter = connectionRepository.getPrimaryConnection(Twitter.class).getApi();
	twitter.timelineOperations().updateStatus(message);
	model.addAttribute("status", "success");
	model.addAttribute("message", message);
	return "posted";
	} catch (Exception e) {
	model.addAttribute("status", "failure");
	return "posted";
	}
	}
	}

view raw TwitterController.java hosted with ❤ by GitHub

UserController.java

	package org.krams.controller;

	import java.util.List;

	import org.krams.domain.Role;
	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.krams.response.UserDto;
	import org.krams.service.UserService;
	import org.krams.util.RoleUtil;
	import org.krams.util.UserMapper;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.data.domain.Page;
	import org.springframework.data.domain.PageRequest;
	import org.springframework.data.domain.Pageable;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.ModelAttribute;
	import org.springframework.web.bind.annotation.RequestBody;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.web.bind.annotation.ResponseBody;
	import org.springframework.ui.ModelMap;

	@Controller
	@RequestMapping("/users")
	public class UserController {

	@Autowired
	private UserRepository repository;

	@Autowired
	private UserService service;

	@ModelAttribute("allRoles")
	public List<Integer> getAllRoles() {
	return RoleUtil.roles();
	}

	@RequestMapping
	public String getUsersPage(ModelMap model) {
	Pageable pageRequest = new PageRequest(0, 100);
	Page<User> users = repository.findAll(pageRequest);
	model.addAttribute("users", UserMapper.map(users));
	model.addAttribute("commanduser", new UserDto());
	model.addAttribute("usertype", "new");
	return "users";
	}

	@RequestMapping(value="/get", produces="application/json")
	public @ResponseBody UserDto get(@RequestBody UserDto user) {
	return UserMapper.map(repository.findByUsername(user.getUsername()));
	}

	@RequestMapping(value="/create", produces="application/json", method=RequestMethod.POST)
	public String create(UserDto dto) {
	if (dto.getId() != null) {
	User existingUser = UserMapper.map(dto);
	existingUser.setRole(new Role(dto.getRole(), existingUser));
	service.update(existingUser);
	} else {
	User newUser = UserMapper.map(dto);
	newUser.setRole(new Role(dto.getRole(), newUser));
	service.create(newUser);
	}
	return "redirect:/users";
	}

	@RequestMapping(value="/edit")
	public String edit(Long id, ModelMap model) {
	Pageable pageRequest = new PageRequest(0, 100);
	Page<User> users = repository.findAll(pageRequest);
	model.addAttribute("users", UserMapper.map(users));
	model.addAttribute("commanduser", UserMapper.map(repository.findOne(id)));
	model.addAttribute("usertype", "update");
	return "users";
	}

	@RequestMapping(value="/delete")
	public String delete(Long id) {
	User existingUser = new User();
	existingUser.setId(id);
	service.delete(existingUser);
	return "redirect:/users";
	}
	}

view raw UserController.java hosted with ❤ by GitHub

Repository

We have a simple repository. There's nothing much to explain here.

UserRepository.java

	package org.krams.repository;

	import org.krams.domain.User;
	import org.springframework.data.jpa.repository.JpaRepository;

	public interface UserRepository extends JpaRepository<User, Long> {

	User findByUsername(String username);
	}

view raw UserRepository.java hosted with ❤ by GitHub

Service

We have two services:

UserService is used for handling user-related CRUD operations
RepositoryBasedUserDetailsService is used for retrieving user details for authentication purposes

UserService.java

	package org.krams.service;

	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Service;
	import org.springframework.transaction.annotation.Transactional;

	@Service
	@Transactional
	public class UserService {

	@Autowired
	private UserRepository repository;

	public Boolean create(User user) {
	User existingUser = repository.findByUsername(user.getUsername());
	if (existingUser != null)
	return false;

	user.getRole().setUser(user);
	User saved = repository.save(user);
	if (saved == null)
	return false;

	return true;
	}

	public Boolean update(User user) {
	User existingUser = repository.findByUsername(user.getUsername());
	if (existingUser == null)
	return false;

	// Only firstName, lastName, and role fields are updatable
	existingUser.setFirstName(user.getFirstName());
	existingUser.setLastName(user.getLastName());
	existingUser.getRole().setRole(user.getRole().getRole());

	User saved = repository.save(existingUser);
	if (saved == null)
	return false;

	return true;
	}

	public Boolean delete(User user) {
	User existingUser = repository.findOne(user.getId());
	if (existingUser == null)
	return false;

	repository.delete(existingUser);
	User deletedUser = repository.findOne(user.getId());
	if (deletedUser != null)
	return false;

	return true;
	}
	}

view raw UserService.java hosted with ❤ by GitHub

RepositoryBasedUserDetailsService.java

	package org.krams.service;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import org.krams.repository.UserRepository;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.security.core.GrantedAuthority;
	import org.springframework.security.core.authority.SimpleGrantedAuthority;
	import org.springframework.security.core.userdetails.User;
	import org.springframework.security.core.userdetails.UserDetails;
	import org.springframework.security.core.userdetails.UserDetailsService;
	import org.springframework.security.core.userdetails.UsernameNotFoundException;
	import org.springframework.stereotype.Service;
	import org.springframework.transaction.annotation.Transactional;

	@Service
	@Transactional(readOnly = true)
	public class RepositoryBasedUserDetailsService implements UserDetailsService {

	@Autowired
	private UserRepository userRepository;

	/**
	* Returns a populated {@link UserDetails} object. The username is first retrieved from
	* the database and then mapped to a {@link UserDetails} object.
	*/
	@Override
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
	try {
	org.krams.domain.User domainUser = userRepository.findByUsername(username);

	boolean enabled = true;
	boolean accountNonExpired = true;
	boolean credentialsNonExpired = true;
	boolean accountNonLocked = true;

	return new User(
	domainUser.getUsername(),
	domainUser.getPassword().toLowerCase(),
	enabled,
	accountNonExpired,
	credentialsNonExpired,
	accountNonLocked,
	getAuthorities(domainUser.getRole().getRole()));

	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}

	/**
	* Retrieves a collection of {@link GrantedAuthority} based on a numerical role.
	*
	* @param role the numerical role
	* @return a collection of {@link GrantedAuthority
	*/
	public Collection<? extends GrantedAuthority> getAuthorities(Integer role) {
	List<GrantedAuthority> authList = getGrantedAuthorities(getRoles(role));
	return authList;
	}

	/**
	* Converts a numerical role to an equivalent list of roles.
	*
	* @param role the numerical role
	* @return list of roles as as a list of {@link String}
	*/
	public List<String> getRoles(Integer role) {
	List<String> roles = new ArrayList<String>();

	if (role.intValue() == 1) {
	roles.add("ROLE_USER");
	roles.add("ROLE_ADMIN");

	} else if (role.intValue() == 2) {
	roles.add("ROLE_USER");
	}

	return roles;
	}

	/**
	* Wraps {@link String} roles to {@link SimpleGrantedAuthority} objects.
	*
	* @param roles {@link String} of roles
	* @return list of granted authorities
	*/
	public static List<GrantedAuthority> getGrantedAuthorities(List<String> roles) {
	List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
	for (String role : roles) {
	authorities.add(new SimpleGrantedAuthority(role));
	}
	return authorities;
	}
	}

view raw RepositoryBasedUserDetailsService.java hosted with ❤ by GitHub

In the next section, we will study how to build and run our application. We will use Maven, Tomcat, and Jetty to run the app. We'll also study how to import the project in Eclipse. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring Social with JavaConfig (Part 8)

Review

In the previous section, we have discussed the Domain, Repository, Service, Controller layers. In this section, we will build and run our sample application. We will verify if our application is able to communicate with Facebook and Twitter. We will also show how to import the project in Eclipse.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Running the Application

Clone from GitHub

To clone from GitHub, follow these instructions:

Open a Git terminal
Enter the following command:
```
git clone https://github.com/krams915/spring-social-javaconfig.git
```
This will clone the JavaConfig-based application.

If you prefer the XML-based version,
```
git clone https://github.com/krams915/spring-social-xmlconfig.git
```
Remember:
There are two versions of our application: a JavaConfig-based and an XML config-based app. Both versions are identical in their feature set.
- spring-social-javaconfig
- spring-social-xmlconfig

Create the Database

Run MySQL
Create a new database:
```
spring_social_tutorial
```
Import the following SQL files:
```
spring_social_tutorial.sql
JdbcUsersConnectionRepository.sql
```
These files can be found at the src/main/resources path

Run with Maven and Tomcat 7

Ensure Maven is installed first, and you have created the MySQL database

Open a terminal
Browse to the directory where you've cloned the project
Enter the following command:
```
mvn tomcat7:run
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-social-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> tomcat7-maven-plugin:2.0:run (default-cli) @ spring-social-tutorial >>>
...
...
...
Dec 10, 2012 9:50:56 AM org.apache.coyote.AbstractProtocol init
INFO: Initializing ProtocolHandler ["http-bio-8080"]
Dec 10, 2012 9:50:56 AM org.apache.catalina.core.StandardService startInternal
INFO: Starting service Tomcat
Dec 10, 2012 9:50:56 AM org.apache.catalina.core.StandardEngine startInternal
INFO: Starting Servlet Engine: Apache Tomcat/7.0.30
Dec 10, 2012 9:51:07 AM org.apache.catalina.core.ApplicationContext log
INFO: Spring WebApplicationInitializers detected on classpath: [org.krams.config.ApplicationInitializer@73b8cdd5]
Dec 10, 2012 9:51:08 AM org.apache.catalina.core.ApplicationContext log
INFO: Initializing Spring root WebApplicationContext
Dec 10, 2012 9:51:18 AM org.apache.catalina.core.ApplicationContext log
INFO: Initializing Spring FrameworkServlet 'dispatcher'
Dec 10, 2012 9:51:18 AM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["http-bio-8080"]

Open a browser

Visit the entry page:

http://localhost:8080/spring-social-tutorial

The primary admin credentials are the following:
```
username: john
password: admin
```
You can create a new account but by default it doesn't have any admin powers.

Run with Maven and Jetty 8

Ensure Maven is installed first, and you have created the MySQL database.

Open a terminal
Browse to the directory where you've cloned the project
Enter the following command:
```
mvn jetty:run
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-social-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> jetty-maven-plugin:8.1.5.v20120716:run (default-cli) @ spring-social-tutorial >>>
...
...
...
2012-12-10 09:53:55.980:INFO:/spring-social-tutorial:Initializing Spring FrameworkServlet 'dispatcher'
2012-12-10 09:53:56.140:INFO:oejs.AbstractConnector:Started SelectChannelConnector@0.0.0.0:8080
[INFO] Started Jetty Server

Open a browser

Visit the entry page:

http://localhost:8080/spring-social-tutorial

The primary admin credentials are the following:
```
username: john
password: admin
```
You can create a new account but by default it doesn't have any admin powers.

Import to Eclipse

Ensure Maven is installed first

Open a terminal
Enter the following command:
```
mvn eclipse:eclipse -Dwtpversion=2.0
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-social-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> maven-eclipse-plugin:2.9:eclipse (default-cli) @ spring-social-tutorial >>>
...
...
... 
[INFO] -------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -------------------------------------------------------------
[INFO] Total time: 9.532s
[INFO] Finished at: Mon Dec 10 09:55:31 PHT 2012
[INFO] Final Memory: 17M/81M
[INFO] -------------------------------------------------------------

This command will add the following files to your project:

.classpath
.project
.settings
target

You may have to enable "show hidden files" in your file explorer to view them.

Run Eclipse and import the application as Maven project

Validate with W3C Markup Validation Service

One of the promises of using Thymeleaf is it produces valid HTML pages. Let's test that out using W3C validation service.

Run the application
Open a browser

Visit the following URLs and validate them all:

http://localhost:8080/spring-social-tutorial/
http://localhost:8080/spring-social-tutorial/login
http://localhost:8080/spring-social-tutorial/users
http://localhost:8080/spring-social-tutorial/fb/profile
http://localhost:8080/spring-social-tutorial/tw/profile
http://localhost:8080/spring-social-tutorial/fb/post
http://localhost:8080/spring-social-tutorial/tw/post

View the HTML source (right-click or go to menu)
Copy the HTML source
Open W3C Markup Validation Service at http://validator.w3.org/#validate_by_input
Paste the HTML source and wait for the validation result

You should see a similar output:

Conclusion

We've have completed our Spring Social-based application using JavaConfig. We're able to post and retrieve profile information from Facebook and Twitter. To provide authentication and security we've added Spring Security. For managing the view layer, we've integrated Thymeleaf as our template engine. As a bonus, we've also provided an XML-based application.

I hope you've enjoyed this tutorial. Don't forget to check my other tutorials at the Tutorials section.

Revision History

Revision	Date	Description
1	Dec 10 2012	Uploaded tutorial and GitHub repositories
2	Dec 21 2012	Update to Spring 3.2.0.RELEASE

Share the joy:

Subscribe by reader

Subscribe by email Share

Sunday, December 2, 2012

Spring and Thymeleaf with JavaConfig (Part 1)

In this tutorial, we will create a CRUD application based on Spring MVC 3.x and Spring Data JPA. We will utilize JavaConfig instead of XML to configure our application. For the view layer, we will use Thymeleaf as our template engine instead of JSP to process our html pages.

Click on a link to jump to that section:

Functional Specs
Creating the View

HTML Mockup
Thymeleaf Integration

JavaConfig

ApplicationContext.java
SpringDataConfig.java
ThymeleafConfig.java
ApplicationInitializer.java

Layers

Domain
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Dependencies

These are the main Maven dependencies:

Spring 3.2.0.RC1
Spring Data JPA 1.2.0.RELEASE
Thymeleaf 2.0.14
Hibernate 3.6.3.Final
See pom.xml for full details

Required Tools

These are the minimum required tools:

Git
Maven 3.0.4
MySQL
Eclipse IDE or SpringSource Tool Suite (STS)

GitHub Repository

There are two versions of the application: a JavaConfig-based and an XML config-based app. Both versions are identical in their feature set.

Functional Specs

Our application's requirements are quite straightforward:

Create a simple form to manage user information
Provide the following fields: first name, last name, username, role
Username must be unique
Provide CRUD operations
Provide table to view all users

Here's our Use Case diagram:

[User]-(Add)
[User]-(View)
[User]-(Update)
[User]-(Delete)

//http://yuml.me/

Here's a screenshot of our working application:

In the next section, we will focus on the view layer. We'll start writing the HTML mockup template; then we'll integrate it with Thymeleaf. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring and Thymeleaf with JavaConfig (Part 2)

Review

In the previous section, we have read the functional specs of the application. In this section, we will focus on the view layer, create an HTML mockup, and integrate our mockup with Thymeleaf.

Click on a link to jump to that section:

Functional Specs
Creating the View

HTML Mockup
Thymeleaf Integration

JavaConfig

ApplicationContext.java
SpringDataConfig.java
ThymeleafConfig.java
ApplicationInitializer.java

Layers

Domain
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Creating the View

In designing our application we'll start with the view layer because we can. Thanks to Thymeleaf creating HTML mockups is easy. Thymeleaf allows us to use these mockups as our HTML templates without any aesthetic changes. In addition, it passes W3C Markup Validation Service with flying colors.

What is Thymeleaf?

Thymeleaf is a Java library. It is an XML / XHTML / HTML5 template engine (extensible to other formats) that can work both in web and non-web environments. It is better suited for serving XHTML/HTML5 at the view layer of web applications, but it can process any XML file even in offline environments.

It provides an optional module for integration with Spring MVC, so that you can use it as a complete substitute of JSP in your applications made with this technology, even with HTML5.

The main goal of Thymeleaf is to provide an elegant and well-formed way of creating templates. Its Standard and SpringStandard dialects allow you to create powerful natural templates, that can be correctly displayed by browsers and therefore work also as static prototypes. You can also extend Thymeleaf by developing your own dialects.

Source: Thymeleaf.org

HTML Mockup

Let's create our HTML mockup. You can see the final mockup below:

First, we create a new HTML page. Note that this is a very simple HTML document that validates with W3C Markup Validation Service.

	<!DOCTYPE html>
	<html xmlns="http://www.w3.org/1999/xhtml">

	<head>
	<meta charset="utf-8" />
	<link rel="stylesheet" href="../../resources/css/style.css"/>
	<title>Title</title>
	</head>

	<body>
	<div>
	<table class="box-table-a">
	<caption>Site Users</caption>
	<thead>
	<tr>
	<th scope="col">Id</th>
	<th scope="col">First Name</th>
	<th scope="col">Last Name</th>
	<th scope="col">Username</th>
	<th scope="col">Role</th>
	<th scope="col">Actions</th>
	</tr>
	</thead>
	<tbody>
	<tr>
	<td>1</td>
	<td>George</td>
	<td>Washington</td>
	<td>gwash</td>
	<td>admin</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>

	<tr>
	<td>2</td>
	<td>John</td>
	<td>Adams</td>
	<td>jadam</td>
	<td>user</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr>
	<td>3</td>
	<td>Thomas</td>
	<td>Jefferson</td>
	<td>tjeff</td>
	<td>user</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr>
	<td>4</td>
	<td>James</td>
	<td>Madison</td>
	<td>jmadi</td>
	<td>admin</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr>
	<td>5</td>
	<td>James</td>
	<td>Monroe</td>
	<td>jmonr</td>
	<td>admin</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	</tbody>
	</table>

	<form action="#" method="post">
	<table class="box-table-a">
	<caption>New User</caption>
	<thead>
	<tr>
	<th>First Name</th>
	<th>Last Name</th>
	<th>Username</th>
	<th>Role</th>
	</tr>
	</thead>
	<tbody>
	<tr>
	<td><input type="text" hidden="hidden"/>
	<input type="text"/></td>
	<td><input type="text"/></td>
	<td><input type="text"/></td>
	<td><select>
	<option value="1">Access Type 1</option>
	<option value="2">Access Type 2</option>
	</select></td>
	</tr>
	<tr>
	<td>
	<button type="submit">Action</button>
	</td>
	<td></td>
	<td></td>
	<td></td>
	</tr>
	</tbody>
	</table>
	</form>
	</div>
	</body>
	</html>

view raw users.html hosted with ❤ by GitHub

Next, we create an external CSS file. Because I'm not really a designer, I have scoured the web for a simple but elegant table style. I found one from Top 10 CSS Table Designs.

	body {
	font-family: Arial, sans-serif;
	font-size: 1em;
	}

	caption {
	font-size: 18px;
	}

	/**
	* Table style from Top 10 CSS Table Designs
	* http://coding.smashingmagazine.com/2008/08/13/top-10-css-table-designs/
	*/

	.box-table-a {
	font-family: "Lucida Sans Unicode", "Lucida Grande", Sans-Serif;
	font-size: 12px;
	margin: 45px;
	width: 700px;
	text-align: left;
	border-collapse: collapse;
	}

	.box-table-a th {
	font-size: 13px;
	font-weight: normal;
	padding: 8px;
	background: #b9c9fe;
	border-top: 4px solid #aabcfe;
	border-bottom: 1px solid #fff;
	color: #039;
	}

	.box-table-a td {
	padding: 8px;
	background: #e8edff;
	border-bottom: 1px solid #fff;
	color: #669;
	border-top: 1px solid transparent;
	}

	.box-table-a tr:hover td {
	background: #d0dafd;
	color: #339;
	}

view raw styles.css hosted with ❤ by GitHub

Then, open a browser and test the HTML mockup. You should see something similar to the following image:

Thymeleaf Integration

It's time to integrate Thymeleaf with our HTML mockup template. To integrate Thymeleaf we'll use its attribute-based template engine. Browsers will normally ignore unknown HTML attributes, so it won't affect our mockups.

Before we proceed, let me provide you a short description of the specific Thymeleaf attributes we'll be using:

The important attributes

The # means to resolve the attribute from the messages bundle
The $ means to resolve the attribute from the model
The # and $ can be combined together so that messages can be dynamically generated from the model and internationalized from the messages bundle
th:fragment="header"

This allows us to include template fragments from other templates. For example, we can reuse them in footers, headers, and menus. For this tutorial, we won't be reusing the header, but I've added it anyway for future tutorials.
th:each="u : ${users}

This allows us to loop a list of records. This is equivalent to Java's for-loop construct.
th:text="${u.id}"

This allows to dynamically set the label of an element.
th:href="@{/users/delete(id=${u.id})}">

This allows us to define a dynamic URL.
th:field="*{id}"

This allows us to define the field where an input's field will be attached to.
th:remove="all"

This allows us to setup mockup data. Thymeleaf will automatically remove any element contained within this attribute.

Let's now apply these attributes. Here's our updated HTML mockup template:

users.html

	<!DOCTYPE html>
	<html xmlns="http://www.w3.org/1999/xhtml"
	xmlns:th="http://www.thymeleaf.org">

	<head th:fragment="header">
	<meta charset="utf-8" />
	<link rel="stylesheet" href="../../resources/css/style.css" th:href="@{/resources/css/style.css}" />
	<title th:text="#{user.page.title}">Title</title>
	</head>

	<body>
	<div>
	<table class="box-table-a">
	<caption th:text="#{user.table.caption}">Site Users</caption>
	<thead>
	<tr>
	<th scope="col" th:text="#{user.id.label}">Id</th>
	<th scope="col" th:text="#{user.firstname.label}">First Name</th>
	<th scope="col" th:text="#{user.lastname.label}">Last Name</th>
	<th scope="col" th:text="#{user.username.label}">Username</th>
	<th scope="col" th:text="#{user.role.label}">Role</th>
	<th scope="col">Actions</th>
	</tr>
	</thead>
	<tbody>
	<tr th:each="u : ${users}">
	<td th:text="${u.id}">1</td>
	<td th:text="${u.firstName}">George</td>
	<td th:text="${u.lastName}">Washington</td>
	<td th:text="${u.username}">gwash</td>
	<td th:text="#{${'user.role.' + u.role}}">admin</td>
	<td><a href="#" th:href="@{/users/delete(id=${u.id})}">del</a> \|
	<a href="#" th:href="@{/users/edit(id=${u.id})}">edit</a>
	</td>
	</tr>

	<tr th:remove="all">
	<td>2</td>
	<td>John</td>
	<td>Adams</td>
	<td>jadam</td>
	<td>user</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr th:remove="all">
	<td>3</td>
	<td>Thomas</td>
	<td>Jefferson</td>
	<td>tjeff</td>
	<td>user</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr th:remove="all">
	<td>4</td>
	<td>James</td>
	<td>Madison</td>
	<td>jmadi</td>
	<td>admin</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	<tr th:remove="all">
	<td>5</td>
	<td>James</td>
	<td>Monroe</td>
	<td>jmonr</td>
	<td>admin</td>
	<td><a href="#">del</a> \| <a href="#">edit</a></td>
	</tr>
	</tbody>
	</table>

	<form action="#" th:action="@{/users/create}" th:object="${commanduser}" method="post">
	<table class="box-table-a">
	<caption th:text="#{${usertype + '.user.table.caption'}}">New User</caption>
	<thead>
	<tr>
	<th th:text="#{user.firstname.label}">First Name</th>
	<th th:text="#{user.lastname.label}">Last Name</th>
	<th th:text="#{user.username.label}">Username</th>
	<th th:text="#{user.role.label}">Role</th>
	</tr>
	</thead>
	<tbody>
	<tr>
	<td><input type="text" hidden="hidden" th:field="*{id}"/>
	<input type="text" th:field="*{firstName}"/></td>
	<td><input type="text" th:field="*{lastName}"/></td>
	<td><input type="text" th:field="*{username}"/></td>
	<td><select th:field="*{role}">
	<option th:each="role : ${allRoles}" th:value="${role}"
	th:text="#{${'user.role.' + role}}">Access Type 1</option>
	<option th:remove="all" value="2">Access Type 2</option>
	</select></td>
	</tr>
	<tr>
	<td>
	<button type="submit" th:text="#{${usertype + '.user.button.label'}}">Action</button>
	</td>
	<td></td>
	<td></td>
	<td></td>
	</tr>
	</tbody>
	</table>
	</form>
	</div>
	</body>
	</html>

view raw users.html hosted with ❤ by GitHub

Internationalization

The th:text attribute allows us to externalize text and with the support of Spring's MessageSource, we are able to parameterize and provide internationalization support.

What is MessageSource?

Strategy interface for resolving messages, with support for the parameterization and internationalization of such messages.

Spring provides two out-of-the-box implementations for production:

ResourceBundleMessageSource, built on top of the standard ResourceBundle

ReloadableResourceBundleMessageSource, being able to reload message definitions without restarting the VM

Source: Spring 3 Docs: MessageSource

Notice the th:text attributes. Some of them refer to a dot notation object. Where does Thymeleaf retrieve this information?

The information is retrieved from the messages_en.properties resource bundle:

	user.page.title=User Management
	user.table.caption=Site Users

	user.id.label=Id
	user.firstname.label=First Name
	user.lastname.label=Last Name
	user.username.label=Username
	user.role.label=Role

	user.role.1=admin
	user.role.2=regular

	new.user.table.caption=New User
	new.user.button.label=Add User
	update.user.table.caption=Existing User
	update.user.button.label=Update User

view raw messages_en.properties hosted with ❤ by GitHub

We've declared that in the ApplicationContext.java configuration (see next section):

	// Provides internationalization of messages
	@Bean
	public ResourceBundleMessageSource messageSource() {
	ResourceBundleMessageSource source = new ResourceBundleMessageSource();
	source.setBasename("messages");
	return source;
	}

view raw ApplicationContext.java hosted with ❤ by GitHub

The Data transfer object (DTO)

In order for our html page to display data from the Controller, we need to pass a Model attribute. The model attribute is represented by the UserDto.

	package org.krams.response;

	import java.io.Serializable;

	public class UserDto implements Serializable {

	private Long id;
	private String firstName;
	private String lastName;
	private String username;
	private Integer role;

	...getters/setters...
	}

view raw UserDto.java hosted with ❤ by GitHub

The fields we declared on the users.html form is based from the fields of the UserDto:

	<form action="#" th:action="@{/users/create}" th:object="${commanduser}" method="post">
	....
	<tr>
	<td><input type="text" hidden="hidden" th:field="*{id}"/>
	<input type="text" th:field="*{firstName}"/></td>
	<td><input type="text" th:field="*{lastName}"/></td>
	<td><input type="text" th:field="*{username}"/></td>
	<td><select th:field="*{role}">
	<option th:each="role : ${allRoles}" th:value="${role}"
	th:text="#{${'user.role.' + role}}">Access Type 1</option>
	<option th:remove="all" value="2">Access Type 2</option>
	</select></td>
	</tr>
	....
	</form>

view raw users.html hosted with ❤ by GitHub

Notice the form has a form-backing object declared named commanduser. Using Thymeleaf's attribute th:object, we're able to declare this form-backing object.

This object passed from the UserController.

	@Controller
	@RequestMapping("/users")
	public class UserController {

	@RequestMapping
	public String getUsersPage(ModelMap model) {
	Pageable pageRequest = new PageRequest(0, 10);
	Page<User> users = repository.findAll(pageRequest);
	model.addAttribute("users", UserMapper.map(users));
	model.addAttribute("commanduser", new UserDto());
	model.addAttribute("usertype", "new");
	return "users";
	}
	}

view raw UserController.java hosted with ❤ by GitHub

In the next section, we will focus on the configuration layer. We'll study how to declare a JavaConfig-based configuration. We'll also provide an XML-based configuration for comparison purposes. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring and Thymeleaf with JavaConfig (Part 3)

Review

In the previous section, we focused on the view layer and created an HTML mockup template. In this section, we will focus on configuration and declare them using JavaConfig. We will also provide an XML-based config.

Click on a link to jump to that section:

Functional Specs
Creating the View

HTML Mockup
Thymeleaf Integration

JavaConfig

ApplicationContext.java
SpringDataConfig.java
ThymeleafConfig.java
ApplicationInitializer.java

Layers

Domain
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

JavaConfig

As stated in the introduction, we will be using JavaConfig-based configuration instead of the usual XML config. However, I don't want to alienate our readers who are used to XML. As a result, I've decided to provide both implementations. However, our focus here is still on JavaConfig.

Note: With JavaConfig, we can now omit the ubiquitous web.xml. But in order to that, we need to run a Servlet 3.0 web container. For this tutorial, I have tested the application with Tomcat 7.0.30 (Maven plugin), 7.0.33 (standalone Tomcat), and Jetty 8.1.5.v20120716 (Maven plugin).

ApplicationContext.java

The ApplicationContext.java contains our main configuration. It's responsible for loading other configurations, either as JavaConfig or XML config.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.ComponentScan;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Import;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.context.annotation.PropertySource;
	import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
	import org.springframework.context.support.ResourceBundleMessageSource;
	import org.springframework.core.io.ClassPathResource;
	import org.springframework.core.io.Resource;
	import org.springframework.web.servlet.config.annotation.EnableWebMvc;
	import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

	@Configuration
	@ComponentScan(basePackages = {"org.krams"})
	@EnableWebMvc
	@Import({SpringDataConfig.class, ThymeleafConfig.class})
	@ImportResource("classpath:trace-context.xml")
	@PropertySource("classpath:spring.properties")
	public class ApplicationContext extends WebMvcConfigurerAdapter {

	// Maps resources path to webapp/resources
	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
	registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
	}

	// Only needed if we are using @Value and ${...} when referencing properties
	@Bean
	public static PropertySourcesPlaceholderConfigurer properties() {
	PropertySourcesPlaceholderConfigurer propertySources = new PropertySourcesPlaceholderConfigurer();
	Resource[] resources = new ClassPathResource[] {
	new ClassPathResource("spring.properties") };
	propertySources.setLocations(resources);
	propertySources.setIgnoreUnresolvablePlaceholders(true);
	return propertySources;
	}

	// Provides internationalization of messages
	@Bean
	public ResourceBundleMessageSource messageSource() {
	ResourceBundleMessageSource source = new ResourceBundleMessageSource();
	source.setBasename("messages");
	return source;
	}

	}

view raw ApplicationContext.java hosted with ❤ by GitHub

Let's describe each annotation:

@Configuration
- Marks a class as a JavaConfig
@ComponentScan(basePackages = {"org.krams"})
- Configures scanning of Spring components

This is equivalent in XML as:

<context:annotation-config />

<context:component-scan base-package="org.krams" />

view raw context-annotation-config.xml hosted with ❤ by GitHub
@EnableWebMvc
- Activates Spring's MVC support

This is equivalent in XML as:

<mvc:annotation-driven />

view raw mvc-annotation-driven.xml hosted with ❤ by GitHub
@Import({SpringDataConfig.class, ThymeleafConfig.class})
- This allows us to import JavaConfig-based config. Notice we are importing two external configuration classes: SpringDataConfig and ThymeleafConfig
@ImportResource("classpath:trace-context.xml")
- This allows us to import XML-based config files. (As a side note why can't we just declare this as a JavaConfig? It turns out there's no direct translation for the trace-context.xml, so we'll have to import it as XML).

This is equivalent in XML as:

<import resource="trace-context.xml"/>

view raw import-resource.xml hosted with ❤ by GitHub
@PropertySource("classpath:spring.properties")
- This allows us to import property files
@Bean
- Declares a Spring bean

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

	<!-- Activates various annotations to be detected in bean classes -->
	<context:annotation-config />

	<!-- Scans the classpath for annotated components that will be auto-registered as Spring beans.
	For example @Controller and @Service. Make sure to set the correct base-package -->
	<context:component-scan base-package="org.krams" />

	<!-- Configures the annotation-driven Spring MVC Controller programming model.
	Note that, with Spring 3.0, this tag works in Servlet MVC only! -->
	<mvc:annotation-driven />

	<!-- Maps resources path to webapp/resources -->
	<mvc:resources mapping="/resources/**" location="/resources/" />

	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"
	p:basename="messages" />

	<!-- Imports logging configuration -->
	<import resource="trace-context.xml"/>

	<!-- Imports datasource configuration -->
	<import resource="spring-data.xml"/>

	<bean id="deployProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean"
	p:location="/WEB-INF/spring.properties" />

	</beans>

view raw applicationContext.xml hosted with ❤ by GitHub

SpringDataConfig.java

The SpringDataConfig.java contains our Spring Data configuration. This is where we declare our data source, transaction manager, and JPA entity manager.

	package org.krams.config;

	import javax.sql.DataSource;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.core.env.Environment;
	import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
	import org.springframework.orm.jpa.JpaTransactionManager;
	import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
	import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
	import org.springframework.transaction.annotation.EnableTransactionManagement;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
	import com.mchange.v2.c3p0.ComboPooledDataSource;

	@Configuration
	@EnableTransactionManagement
	@EnableJpaRepositories("org.krams.repository")
	public class SpringDataConfig extends WebMvcConfigurerAdapter {

	@Autowired
	private Environment env;

	// Declare a datasource that has pooling capabilities
	@Bean
	public DataSource dataSource() {
	try {
	ComboPooledDataSource ds = new ComboPooledDataSource();
	ds.setDriverClass(env.getRequiredProperty("app.jdbc.driverClassName"));
	ds.setJdbcUrl(env.getRequiredProperty("app.jdbc.url"));
	ds.setUser(env.getRequiredProperty("app.jdbc.username"));
	ds.setPassword(env.getRequiredProperty("app.jdbc.password"));
	ds.setAcquireIncrement(5);
	ds.setIdleConnectionTestPeriod(60);
	ds.setMaxPoolSize(100);
	ds.setMaxStatements(50);
	ds.setMinPoolSize(10);
	return ds;
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}

	// Declare a JPA entityManagerFactory
	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
	LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
	em.setPersistenceXmlLocation("classpath*:META-INF/persistence.xml");
	em.setPersistenceUnitName("hibernatePersistenceUnit");
	em.setDataSource(dataSource());

	HibernateJpaVendorAdapter vendor = new HibernateJpaVendorAdapter();
	vendor.setShowSql(false);
	em.setJpaVendorAdapter(vendor);

	return em;
	}

	// Declare a transaction manager
	@Bean
	public JpaTransactionManager transactionManager() {
	JpaTransactionManager transactionManager = new JpaTransactionManager();
	transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
	return transactionManager;
	}
	}

view raw SpringDataConfig.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/jdbc
	http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
	http://www.springframework.org/schema/data/jpa
	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

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

	<!-- Activate Spring Data JPA repository support -->
	<jpa:repositories base-package="org.krams.repository" />

	<!-- Declare a datasource that has pooling capabilities-->
	<bean id="jpaDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
	destroy-method="close"
	p:driverClass="${app.jdbc.driverClassName}"
	p:jdbcUrl="${app.jdbc.url}"
	p:user="${app.jdbc.username}"
	p:password="${app.jdbc.password}"
	p:acquireIncrement="5"
	p:idleConnectionTestPeriod="60"
	p:maxPoolSize="100"
	p:maxStatements="50"
	p:minPoolSize="10" />

	<!-- Declare a JPA entityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
	p:persistenceXmlLocation="classpath*:META-INF/persistence.xml"
	p:persistenceUnitName="hibernatePersistenceUnit"
	p:dataSource-ref="jpaDataSource"
	p:jpaVendorAdapter-ref="hibernateVendor"/>

	<!-- Specify our ORM vendor -->
	<bean id="hibernateVendor" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
	p:showSql="false"/>

	<!-- Declare a transaction manager-->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
	p:entityManagerFactory-ref="entityManagerFactory"/>

	</beans>

view raw spring-data.xml hosted with ❤ by GitHub

ThymeleafConfig.java

The ThymeleafConfig.java contains our Thymeleaf configuration. This is where we declare our Thymeleaf view resolver.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.thymeleaf.spring3.SpringTemplateEngine;
	import org.thymeleaf.spring3.view.ThymeleafViewResolver;
	import org.thymeleaf.templateresolver.ServletContextTemplateResolver;

	@Configuration
	public class ThymeleafConfig {

	@Bean
	public ServletContextTemplateResolver templateResolver() {
	ServletContextTemplateResolver resolver = new ServletContextTemplateResolver();
	resolver.setPrefix("/WEB-INF/templates/");
	resolver.setSuffix(".html");
	resolver.setTemplateMode("HTML5");
	resolver.setOrder(1);
	return resolver;
	}

	@Bean
	public SpringTemplateEngine templateEngine() {
	SpringTemplateEngine engine = new SpringTemplateEngine();
	engine.setTemplateResolver(templateResolver());
	return engine;
	}

	@Bean
	public ThymeleafViewResolver thymeleafViewResolver() {
	ThymeleafViewResolver resolver = new ThymeleafViewResolver();
	resolver.setTemplateEngine(templateEngine());
	return resolver;
	}

	}

view raw ThymeleafConfig.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

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

	<!-- Declare a Thymeleaf resolver -->
	<bean id="templateResolver" class="org.thymeleaf.templateresolver.ServletContextTemplateResolver"
	p:prefix="/WEB-INF/templates/"
	p:suffix=".html"
	p:templateMode="HTML5"
	p:order="1"/>

	<bean id="templateEngine" class="org.thymeleaf.spring3.SpringTemplateEngine"
	p:templateResolver-ref="templateResolver" />

	<bean class="org.thymeleaf.spring3.view.ThymeleafViewResolver"
	p:templateEngine-ref="templateEngine"/>

	</beans>

view raw spring-thymeleaf.xml hosted with ❤ by GitHub

ApplicationInitializer.java

The ApplicationInitializer.java is the equivalent of web.xml. Here's where we declare the DispatcherServlet.

	package org.krams.config;

	import javax.servlet.ServletContext;
	import javax.servlet.ServletException;
	import javax.servlet.ServletRegistration;

	import org.springframework.web.WebApplicationInitializer;
	import org.springframework.web.context.ContextLoaderListener;
	import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
	import org.springframework.web.servlet.DispatcherServlet;

	public class ApplicationInitializer implements WebApplicationInitializer {

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
	//Load application context
	AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
	rootContext.register(ApplicationContext.class);
	rootContext.setDisplayName("Spring Thymeleaf Tutorial");

	//Context loader listener
	servletContext.addListener(new ContextLoaderListener(rootContext));

	//Dispatcher servlet
	ServletRegistration.Dynamic dispatcher =
	servletContext.addServlet("dispatcher", new DispatcherServlet(rootContext));
	dispatcher.setLoadOnStartup(1);
	dispatcher.addMapping("/");
	}

	}

view raw ApplicationInitializer.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<web-app xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">
	<display-name>Spring Thymeleaf Tutorial</display-name>

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

	<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	</servlet>

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

	</web-app>

view raw web.xml hosted with ❤ by GitHub

In the next section, we will focus on the remaining layers of our Java application. We'll study the Domain, Repository, Service, and Controller layers. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring and Thymeleaf with JavaConfig (Part 4)

Review

In the previous section, we declared our configuration using JavaConfig and compared it side-by-side with an XML-based configuration. In this section, we will discuss the remaining layers of our application.

Click on a link to jump to that section:

Functional Specs
Creating the View

HTML Mockup
Thymeleaf Integration

JavaConfig

ApplicationContext.java
SpringDataConfig.java
ThymeleafConfig.java
ApplicationInitializer.java

Layers

Domain
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Layers

Here we'll discuss the Domain, Repository, Service and Controller layers.

Domain

Our domain layer consists of two simple classes: User.java and Role.java. If you'd been following my previous tutorials, you will notice that these are the same domain classes we'd been using before. Both classes had been annotated with @Entity which means these are JPA entities and will be persisted to a database.

These classes represent a user with the following properties: first name, last name, username, role, and password (we're not actively using the password field).

For role, we only have two values: an admin or a regular user.

User.java

	package org.krams.domain;

	import javax.persistence.CascadeType;
	import javax.persistence.Column;
	import javax.persistence.Entity;
	import javax.persistence.GeneratedValue;
	import javax.persistence.GenerationType;
	import javax.persistence.Id;
	import javax.persistence.OneToOne;
	import org.codehaus.jackson.annotate.JsonManagedReference;

	@Entity(name="user")
	public class User {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	private String firstName;
	private String lastName;

	@Column(unique=true)
	private String username;

	private String password;

	@JsonManagedReference
	@OneToOne(mappedBy="user", cascade={CascadeType.ALL})
	private Role role;

	public User() {}

	...getters/setters...
	}

view raw User.java hosted with ❤ by GitHub

Role.java

	package org.krams.domain;

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

	import org.codehaus.jackson.annotate.JsonBackReference;

	@Entity(name="role")
	public class Role {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;

	@JsonBackReference
	@OneToOne
	private User user;
	private Integer role;

	public Role() {}

	...getters/setters...
	}

view raw Role.java hosted with ❤ by GitHub

Controller

Our controller is a standard controller providing CRUD requests. The most important lines here are the following:

// Create
model.addAttribute("users", UserMapper.map(users));
model.addAttribute("commanduser", new UserDto());
model.addAttribute("usertype", "new");

// Update
model.addAttribute("users", UserMapper.map(users));
model.addAttribute("commanduser", UserMapper.map(repository.findOne(id)));
model.addAttribute("usertype", "update");

These lines adds three attributes to the model:

users - contains all users
commanduser - the form backing object or the command object of the form
usertype - an attribute to determine if the request is a new user or existing user

UserController.java

	package org.krams.controller;

	import java.util.ArrayList;
	import java.util.List;

	import org.krams.domain.Role;
	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.krams.response.UserDto;
	import org.krams.service.UserService;
	import org.krams.util.UserMapper;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.data.domain.Page;
	import org.springframework.data.domain.PageRequest;
	import org.springframework.data.domain.Pageable;
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.ModelAttribute;
	import org.springframework.web.bind.annotation.RequestBody;
	import org.springframework.web.bind.annotation.RequestMapping;
	import org.springframework.web.bind.annotation.RequestMethod;
	import org.springframework.web.bind.annotation.ResponseBody;
	import org.springframework.ui.ModelMap;

	@Controller
	@RequestMapping("/users")
	public class UserController {

	@Autowired
	private UserRepository repository;

	@Autowired
	private UserService service;

	@ModelAttribute("allRoles")
	public List<Integer> getAllRoles() {
	List<Integer> roles = new ArrayList<Integer>();
	roles.add(1);
	roles.add(2);
	return roles;
	}

	@RequestMapping
	public String getUsersPage(ModelMap model) {
	Pageable pageRequest = new PageRequest(0, 10);
	Page<User> users = repository.findAll(pageRequest);
	model.addAttribute("users", UserMapper.map(users));
	model.addAttribute("commanduser", new UserDto());
	model.addAttribute("usertype", "new");
	return "users";
	}

	@RequestMapping(value="/get", produces="application/json")
	public @ResponseBody UserDto get(@RequestBody UserDto user) {
	return UserMapper.map(repository.findByUsername(user.getUsername()));
	}

	@RequestMapping(value="/create", produces="application/json", method=RequestMethod.POST)
	public String create(UserDto dto) {
	if (dto.getId() != null) {
	User existingUser = new User(dto.getUsername(),
	dto.getFirstName(),
	dto.getLastName(),
	new Role(dto.getRole()));
	service.update(existingUser);
	} else {
	User newUser = new User(dto.getUsername(),
	null,
	dto.getFirstName(),
	dto.getLastName(),
	new Role(dto.getRole()));
	service.create(newUser);
	}

	return "redirect:/users";
	}

	@RequestMapping(value="/edit")
	public String edit(Long id, ModelMap model) {
	Pageable pageRequest = new PageRequest(0, 10);
	Page<User> users = repository.findAll(pageRequest);
	model.addAttribute("users", UserMapper.map(users));
	model.addAttribute("commanduser", UserMapper.map(repository.findOne(id)));
	model.addAttribute("usertype", "update");
	return "users";
	}

	@RequestMapping(value="/delete")
	public String delete(Long id) {

	User existingUser = new User();
	existingUser.setId(id);
	service.delete(existingUser);
	return "redirect:/users";
	}
	}

view raw UserController.java hosted with ❤ by GitHub

Repository

We have created two repositories: UserRepository and RoleRepository(not shown). We will be using UserRepository as our primary data access object. Notice we have declared a custom method findByUsername but beyond that, this repository is pretty much standard. UserRepository.java

	package org.krams.repository;

	import org.krams.domain.User;
	import org.springframework.data.jpa.repository.JpaRepository;

	public interface UserRepository extends JpaRepository<User, Long> {

	User findByUsername(String username);
	}

view raw UserRepository.java hosted with ❤ by GitHub

Service

Our service layer basically delegates to the repository. It provides an extra logic to filter out duplicate usernames. UserService.java

	package org.krams.service;

	import org.krams.domain.User;
	import org.krams.repository.UserRepository;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Service;
	import org.springframework.transaction.annotation.Transactional;

	@Service
	@Transactional
	public class UserService {

	@Autowired
	private UserRepository repository;

	public Boolean create(User user) {
	User existingUser = repository.findByUsername(user.getUsername());
	if (existingUser != null)
	return false;

	user.getRole().setUser(user);
	User saved = repository.save(user);
	if (saved == null)
	return false;

	return true;
	}

	public Boolean update(User user) {
	User existingUser = repository.findByUsername(user.getUsername());
	if (existingUser == null)
	return false;

	// Only firstName, lastName, and role fields are updatable
	existingUser.setFirstName(user.getFirstName());
	existingUser.setLastName(user.getLastName());
	existingUser.getRole().setRole(user.getRole().getRole());

	User saved = repository.save(existingUser);
	if (saved == null)
	return false;

	return true;
	}

	public Boolean delete(User user) {
	User existingUser = repository.findOne(user.getId());
	if (existingUser == null)
	return false;

	repository.delete(existingUser);
	User deletedUser = repository.findOne(user.getId());
	if (deletedUser != null)
	return false;

	return true;
	}
	}

view raw UserService.java hosted with ❤ by GitHub

In the next section, we will study how to build and run our application. We will be using Maven, Tomcat, and Jetty to run the app. We'll also study how to import the project in Eclipse. Click here to proceed.

Share the joy:

Subscribe by reader

Subscribe by email Share

Spring and Thymeleaf with JavaConfig (Part 5)

Review

In the previous section, we have discussed the Domain, Repository, Service, and Controller classes. In this section, we will build and run our app. We will also study how to import the project in Eclipse.

Click on a link to jump to that section:

Functional Specs
Creating the View

HTML Mockup
Thymeleaf Integration

JavaConfig

ApplicationContext.java
SpringDataConfig.java
ThymeleafConfig.java
ApplicationInitializer.java

Layers

Domain
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

Running the Application

Clone from GitHub

To clone from GitHub, follow these instructions:

Open a Git terminal
Enter the following command:
```
git clone https://github.com/krams915/spring-thymeleaf-javaconfig.git
```
This will clone the JavaConfig-based application.

If you prefer the XML-based version,
```
git clone https://github.com/krams915/spring-thymeleaf-xmlconfig.git
```
Remember:
There are two versions of the application: a JavaConfig-based and an XML config-based app. Both versions are identical in their feature set.
- spring-thymeleaf-javaconfig
- spring-thymeleaf-xmlconfig

Create the Database

Run MySQL
Create a new database:
```
spring_thymeleaf_tutorial
```
Import the spring_thymeleaf_tutorial.sql from the src/main/resources path

Run with Maven and Tomcat 7

Ensure Maven is installed first, and you have created the MySQL database

Open a terminal
Browse to the directory where you've cloned the project
Enter the following command:
```
mvn tomcat7:run
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-thymeleaf-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> tomcat7-maven-plugin:2.0:run (default-cli) @ spring-thymeleaf-tutorial >>>
...
...
...
Dec 2, 2012 5:38:31 PM org.apache.coyote.AbstractProtocol init
INFO: Initializing ProtocolHandler ["http-bio-8080"]
Dec 2, 2012 5:38:31 PM org.apache.catalina.core.StandardService startInternal
INFO: Starting service Tomcat
Dec 2, 2012 5:38:31 PM org.apache.catalina.core.StandardEngine startInternal
INFO: Starting Servlet Engine: Apache Tomcat/7.0.30
Dec 2, 2012 5:38:42 PM org.apache.catalina.core.ApplicationContext log
INFO: Spring WebApplicationInitializers detected on classpath: [org.krams.config.ApplicationInitializer@1cc33893]
Dec 2, 2012 5:38:43 PM org.apache.catalina.core.ApplicationContext log
INFO: Initializing Spring root WebApplicationContext
Dec 2, 2012 5:38:52 PM org.apache.catalina.core.ApplicationContext log
INFO: Initializing Spring FrameworkServlet 'dispatcher'
Dec 2, 2012 5:38:52 PM org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["http-bio-8080"]

Open a browser

Visit the following URL:

http://localhost:8080/spring-thymeleaf-tutorial/users

Run with Maven and Jetty 8

Ensure Maven is installed first, and you have created the MySQL database.

Open a terminal
Browse to the directory where you've cloned the project
Enter the following command:
```
mvn jetty:run
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-thymeleaf-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> jetty-maven-plugin:8.1.5.v20120716:run (default-cli) @ spring-thymeleaf-tutorial >>>
...
...
...
2012-12-02 17:42:56.556:INFO:/spring-thymeleaf-tutorial:Initializing Spring FrameworkServlet 'dispatcher'
2012-12-02 17:42:56.760:INFO:oejs.AbstractConnector:Started SelectChannelConnector@0.0.0.0:8080
[INFO] Started Jetty Server

Open a browser

Visit the following URL:

http://localhost:8080/spring-thymeleaf-tutorial/users

Import to Eclipse

Ensure Maven is installed first

Open a terminal
Enter the following command:
```
mvn eclipse:eclipse -Dwtpversion=2.0
```

You should see the following output:

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] -------------------------------------------------------------
[INFO] Building spring-thymeleaf-tutorial Maven Webapp 0.0.1-SNAPSHOT
[INFO] -------------------------------------------------------------
[INFO] 
[INFO] >>> maven-eclipse-plugin:2.9:eclipse (default-cli) @ spring-thymeleaf-tutorial >>>
...
...
... 
[INFO] -------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -------------------------------------------------------------
[INFO] Total time: 9.356s
[INFO] Finished at: Sun Dec 02 17:46:43 PHT 2012
[INFO] Final Memory: 15M/81M
[INFO] -------------------------------------------------------------

This command will add the following files to your project:

.classpath
.project
.settings
target

You may have to enable "show hidden files" in your file explorer to view them.

Run Eclipse and import the application as Maven project

Validate with W3C Markup Validation Service

One of the promises of Thymeleaf is it produces valid HTML pages. Let's test that out using W3C validation service.

Run the application
Open a browser

Visit the following URL:

http://localhost:8080/spring-thymeleaf-tutorial/users

View the HTML source (right-click or go to menu)
Copy the HTML source
Open W3C Markup Validation Service at http://validator.w3.org/#validate_by_input
Paste the HTML source and wait for the validation result

You should see a similar output:

Conclusion

We've have completed our Spring MVC application with Thymeleaf as our template engine . We've studied how to convert our HTML mockup into a Thymeleaf template that validates with W3C validator service. We've also discussed how to create a JavaConfig-based application. As a bonus, we've also provided an XML-based application.

I hope you've enjoyed this tutorial. Don't forget to check my other tutorials at the Tutorials section.

Revision History

Revision	Date	Description
1	Dec 2 2012	Uploaded tutorial and GitHub repositories
2	Dec 3 2012	Updated table of contents
3	Dec 12 2012	Updated Part 2

Share the joy:

Subscribe by reader

Subscribe by email Share

Monday, November 26, 2012

Book Review: Spring Data

I'm currently reviewing the book Spring Data from Packt Publishing. You can find the book at http://www.packtpub.com/spring-data/book.

Overview
This book is about Spring Data JPA and Spring Data Redis

Implement JPA repositories with lesser code
Includes functional sample projects that demonstrate the described concepts in action and help you start experimenting right away
Provides step-by-step instructions and a lot of code examples that are easy to follow and help you to get started from page one

Full review
My initial impression of this book is that it's too short and lacks full coverage because it only focuses on Spring Data JPA and Spring Data Redis. We all know how big the Spring Data umbrella projects are. But it turns out this is the strength of the book. By focusing on a subset of Spring Data umbrella projects, it's able to focus better on what matters most.

As I read the book, I slowly realized that this book is a gem. If you need a solid understanding of Spring Data JPA, read this book. It tells you step-by-step all the possible query technologies, usage patterns, and their pros and cons. The book gradually prepares the reader to the value of Spring Data.

The Spring Data JPA coverage is quite extensive. It teaches you how to download and install the necessary libraries. Configuration is based on programmatic configuration instead of the usual XML configuration files. I think this is good but also bad. It would be great if the book offers sample configuration both in XML and Java-based config. Since most users are familiar with XML configuration, translating from Java-based config would require extra effort to comprehend for most Spring users. Anyway, that's a minor weakness that we can live-up with.

The book is successful in demonstrating how to provide CRUD support through Spring Data JPA and how to implement your own custom repository. There are various way to perform queries in Spring Data JPA, and I think the book has managed to cover all of them, including QueryDSL.

The book's coverage on Spring Data Redis is extensive. It covers installation and configuration, connector types, Redis data structures, and of course, Spring Data support for Redis. The book teaches how to save relational data and perform CRUD operations in a NoSQL manner. It also covers messaging and caching support with Redis. Overall it's a pleasant read. It's interesting how the book has smoothly transitioned from Spring Data JPA to Redis.

Overall, Spring Data from Packt Publishing is a solid book that I recommend to everyone to read.

Share the joy:

Subscribe by reader

Subscribe by email Share

Top Tabs

Monday, December 10, 2012

Table of Contents

Dependencies

Required Tools

GitHub Repository

Functional Specs

Screenshots

Next

Review

Table of Contents

Generate OAuth keys

Facebook

Twitter

Next

Review

Table of Contents

Spring Social configuration

What is Spring Social?

Next

Review

Table of Contents

Spring Security

What is Spring Security?

Next

Review

Table of Contents

JavaConfig

Next

Review

Table of Contents

View with Thymeleaf

What is Thymeleaf?

Next

Review

Table of Contents

Layers

Domain

Controller

Repository

Service

Next

Review

Table of Contents

Running the Application

Clone from GitHub

Remember:

Create the Database

Run with Maven and Tomcat 7

Run with Maven and Jetty 8

Import to Eclipse

Validate with W3C Markup Validation Service

Conclusion

Revision History

Sunday, December 2, 2012

Table of Contents

Dependencies

Required Tools

GitHub Repository

Functional Specs

Next

Review

Table of Contents

Creating the View

What is Thymeleaf?

HTML Mockup

Thymeleaf Integration

Internationalization

What is MessageSource?

The Data transfer object (DTO)

Next

Review

Table of Contents

JavaConfig

ApplicationContext.java

SpringDataConfig.java

ThymeleafConfig.java

ApplicationInitializer.java

Next

Review