Spring Boot Security - Creating Users Programmatically using JdbcUserDetailsManager | JavaInUse

Spring Boot Security - Creating Users Programmatically using JdbcUserDetailsManager

In a previous post we had implemented Spring Boot Security - Database authentication using JDBC.
We authenticated users and roles against database tables. But the entries for users and the roles in the table were added using script file. In this example we will see how this can be done programmatically.

Spring Boot Security - Table Of Contents

Spring Boot + Simple Security Configuration Spring Boot Form Security Login Hello World Example Spring Boot Security - Custom Login Page Example Spring Boot Security - JDBC Authentication Example Spring Boot Security - Creating Users Programmatically Using JdbcUserDetailsManager Spring Boot Security - Password Encoding Using Bcrypt Spring Boot Security - Enabling CSRF Protection Spring Boot Security - Authentication Handler Example Spring Boot Security - Introduction to OAuth Spring Boot OAuth2 Part 1 - Getting The Authorization Code Spring Boot OAuth2 Part 2 - Getting The Access Token And Using it to Fetch Data.


This tutorial is explained in the below Youtube Video.

Lets Begin-

We will be modifying the code we developed in the previous Spring Boot Security - Database authentication using JDBC
Maven Project will be as follows-
By default spring security expects tables named users table for storing username, passwords and authorities table for storing the associated roles. In the schema-mysql.sql add these schemas but not the insert statements

CREATE TABLE employee (
  empName VARCHAR(100) NOT NULL

create table users (
    username varchar(50) not null primary key,
    password varchar(120) not null,
    enabled boolean not null

create table authorities (
    username varchar(50) not null,
    authority varchar(50) not null,
    foreign key (username) references users (username)

Spring Boot JDBC runs this script before starting the application Next add the model class for user registration.
package com.javainuse.model;

public class UserRegistration {

	private String username;
	private String password;

	public String getUsername() {
		return username;

	public void setUsername(String username) {
		this.username = username;

	public String getPassword() {
		return password;

	public void setPassword(String password) {
		this.password = password;


Next add the controller methods for the user registration. Using the GET method we return the registration page. Using the Spring form tag with the modelAttribute we specify the backing bean for this form. Each input field we make use of the form:input tag, this automatically binds the field value to the corresponding value of the backing bean object. When the user clicks submit the POST method call is made to the controller and the form is automatically bound to the user argument we passed. Using the bounded user object we then create the database entries using JdbcUserDetailsManager.
JdbcUserDetailsManager provides CRUD operations for both users and authorities granted.
package com.javainuse.controllers;

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

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.provisioning.JdbcUserDetailsManager;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.javainuse.model.Employee;
import com.javainuse.model.UserRegistration;
import com.javainuse.service.EmployeeService;

public class EmployeeController {

	EmployeeService employeeService;

	JdbcUserDetailsManager jdbcUserDetailsManager;

	public ModelAndView firstPage() {
		return new ModelAndView("welcome");

	@RequestMapping(value = "/register", method = RequestMethod.GET)
	public ModelAndView register() {
		return new ModelAndView("registration", "user", new UserRegistration());

	@RequestMapping(value = "/register", method = RequestMethod.POST)
	public ModelAndView processRegister(@ModelAttribute("user") UserRegistration userRegistrationObject) {
		// authorities to be granted
		List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
		authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));

		User user = new User(userRegistrationObject.getUsername(), userRegistrationObject.getPassword(), authorities);
		return new ModelAndView("redirect:/welcome");

	@RequestMapping(value = "/addNewEmployee", method = RequestMethod.GET)
	public ModelAndView show() {
		return new ModelAndView("addEmployee", "emp", new Employee());

	@RequestMapping(value = "/addNewEmployee", method = RequestMethod.POST)
	public ModelAndView processRequest(@ModelAttribute("emp") Employee emp) {

		List<Employee> employees = employeeService.getAllEmployees();
		ModelAndView model = new ModelAndView("getEmployees");
		model.addObject("employees", employees);
		return model;

	public ModelAndView getEmployees() {
		List<Employee> employees = employeeService.getAllEmployees();
		ModelAndView model = new ModelAndView("getEmployees");
		model.addObject("employees", employees);
		return model;

	@RequestMapping(value = "/login", method = RequestMethod.GET)
	public String login(Model model, String error, String logout) {
		if (error != null)
			model.addAttribute("errorMsg", "Your username and password are invalid.");

		if (logout != null)
			model.addAttribute("msg", "You have been logged out successfully.");

		return "login";


Next we modify the security configuration to-
  • Create a bean of type JdbcUserDetailsManager
  • allow /register page without any security
package com.javainuse.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.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.provisioning.JdbcUserDetailsManager;

public class EmployeeSecurityConfiguration extends WebSecurityConfigurerAdapter {

	DataSource dataSource;

	// Enable jdbc authentication
	public void configAuthentication(AuthenticationManagerBuilder auth) throws Exception {

	public JdbcUserDetailsManager jdbcUserDetailsManager() throws Exception {
		JdbcUserDetailsManager jdbcUserDetailsManager = new JdbcUserDetailsManager();
		return jdbcUserDetailsManager;

	public void configure(WebSecurity web) throws Exception {

	protected void configure(HttpSecurity http) throws Exception {
				.hasAnyRole("USER", "ADMIN").antMatchers("/getEmployees").hasAnyRole("USER", "ADMIN")


	// @Autowired
	// public void configureGlobal(AuthenticationManagerBuilder authenticationMgr)
	// throws Exception {
	// authenticationMgr.inMemoryAuthentication().withUser("admin").password("admin").authorities("ROLE_USER").and()
	// .withUser("javainuse").password("javainuse").authorities("ROLE_USER",
	// "ROLE_ADMIN");
	// }

Next we will create a new registration page with modelAttribute tag.
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Register User</title>
	<h3 style="color: red;">Register New User</h3>

	<div id="registerEmployee">
		<form:form action="/register" method="post" modelAttribute="user">
				<label>Enter username</label>
				<form:input path="username" />
				<label>Enter password</label>
				<form:input path="password" />
			<input type="SUBMIT" value="Submit" />

Add the Register link in the login page.
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

<c:set var="contextPath" value="" />

<!DOCTYPE html>
<html lang="en">
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="description" content="">
<meta name="author" content="">

<title>Log in with your credentials</title>

<link rel="stylesheet"


	<div class="container">

		<form method="POST" action="/login" class="form-signin">
			<h2 class="form-heading">Log in</h2>

			<div class="form-group ">
				<span></span> <input name="username" type="text"
					class="form-control" placeholder="Username" autofocus="true" /> <input
					name="password" type="password" class="form-control"
					placeholder="Password" /> <span></span>

				<button class="btn btn-lg btn-primary btn-block" type="submit">Log

		<a href="/register">Register New

	<!-- /container -->
Start the application -
  • Go to localhost:8080/welcome, we will be redirected to the custom login page.
  • Click in register new user and enter the user javainuse and password javainuse
    We are redirected to the login page.The credentials are now saved in the database tables and we can now login using the saved credentials.

    Download Source Code

    Download it -
    Spring Boot Security - Create Database Users Programmatically