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: