Spring Security: Database implementatie

In de vorige tutorial heb ik voor een eerste keer gesproken over Spring Security. In die tutorial heb ik het gehad over authenticatie/autorisatie en de mogelijkheden van het framework. In die tutorial hebben we echter gebruik gemaakt van de meest eenvoudige manier van authenticatie en het toekennen van rollen, namelijk via de Spring bean configuratie zelf.
In deze tutorial echter gaan we dat aanpassen en gaan we gebruik maken van een database.

Heads up!

In deze tutorial wordt met regelmaat verwezen naar mijn vorige Java tutorials. Het is dus handig dat je deze (zeker de eerste) eens doorneemt.

Database opzetten

Om de credentials op te slaan gaan we gebruik maken van een database. In dit voorbeeld gebruik ik zelf MySQL, maar in principe kies je gewoon zelf welke database je gebruikt.
We gaan ook gebruik maken van een bepaald schema dat je in onderstaande afbeelding ziet. De benaming van de tabellen/velden ligt niet vast, maar er moet wel een gelijkaardige structuur opgezet worden (waarbij een één-op-meer relatie tussen gebruikers en rollen te vinden is).

users_erd

De SQL die nodig is om dat schema te bekomen is het volgende schema:

CREATE TABLE users (
	username VARCHAR(50) NOT NULL PRIMARY KEY,
	password VARCHAR(50) NOT NULL,
	enabled BOOLEAN NOT NULL
);

CREATE TABLE authorities (
	username VARCHAR(50) NOT NULL,
	authority VARCHAR(50) NOT NULL,

	CONSTRAINT fk_authorities_users
		FOREIGN KEY(username) REFERENCES users(username)
);
CREATE UNIQUE INDEX ix_auth_username ON authorities(username,authority);

Uiteraard heb je niet veel aan tabellen als er geen records in te vinden zijn. Als gebruikers/rollen ga ik gewoon dezelfde waardes gebruiken als uit vorige tutorial, het enige verschil hier is echter dat ik gebruik ga maken van een SHA1 password encryptie waardoor je de wachtwoorden dus ook niet meer zomaar kan uitlezen. De SQL query’s hiervoor zijn:

INSERT INTO users (username, password, enabled) VALUES
    ('admin', 'f865b53623b121fd34ee5426c792e5c33af8c227', true),
    ('user', '95c946bf622ef93b0a211cd0fd028dfdfcf7e39e', true);

INSERT INTO authorities (username, authority) VALUES
    ('admin', 'ROLE_USER'),
    ('admin', 'ROLE_ADMIN'),
    ('user', 'ROLE_USER');

Project opzetten

Deze tutorials is een uitbreiding op voorgaande tutorial, ik raad je dus aan om die tutorial eerst te volgen en op basis van die code verder te werken. Zelf ga ik een kopie nemen van het project en op basis daarvan verder gaan.
Verder hoef je niets toe te voegen of te verwijderen, het enige wat we in deze tutorial namelijk gaan doen is de configuratie aanpassen.

Maven configuratie

Omdat we gebruik gaan maken van een database hebben we uiteraard ook een JDBC connector nodig. De dependency die je nodig hebt voor een MySQL database is de volgende:

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.24</version>
</dependency>

Spring security configuratie

De volgende (en tevens laatste) stap in deze tutorial is dat we de security implementatie moeten wijzigen, hiervoor halen we de oorspronkelijke user service weg, onderstaande configuratie moet je dus verwijderen uit je configuratie bestand.

<security:user-service>
	<security:user name="user" password="user123" authorities="ROLE_USER" />
	<security:user name="admin" password="admin123" authorities="ROLE_ADMIN,ROLE_USER" />
</security:user-service>

In plaats daarvan plaatsen we de volgende service:

<security:password-encoder hash="sha" />
<security:jdbc-user-service
	data-source-ref="dataSource"
	users-by-username-query="select username,password, enabled from users where username=?"
	authorities-by-username-query="select u.username, a.authority from users u, authorities a where a.username=?" />

We hebben hier twee dingen gedaan, ten eerste hebben we een password encoder opgezet, namelijk sha (dit is sha1 encryptie).
Tevens hebben we een user service aangemaakt die een datasource zal gebruiken en de query’s die je vermeldt heb gebruiken om te authenticeren en om de rollen van de gebruiker te achterhalen. Doordat je zelf de query’s kan opgeven, kan je dus zelf het schema kiezen waar je je aan wilt houden, zolang je maar in staat bent een gelijkaardig resultaat te retourneren.

Wat we nu uiteraard wel nog nodig hebben is de data source die we vermeldt hebben in de user service. Maak daarvoor de volgende bean aan:

<bean id="dataSource"
	class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="url" value="jdbc:mysql://localhost:3306/spring" />
	<property name="username" value="root" />
	<property name="password" value="123456" />
</bean>

Wat je zelf uiteraard wel nog moet doen is de datasource gegevens (connection URL, username, password en JDBC driver) aanpassen naar jouw gegevens.
Als je dat gedaan hebt ben je klaar met de configuratie voor deze tutorial en kan je overgaan tot het testen ervan.

Builden

Builden doen we nog steeds met de volgende commando’s:

mvn clean install

en:

mvn tomcat:run

.

De applicatie zou nu even goed moeten werken als vorige keer, het enige verschil nu echter is dat de wachtwoorden uit een database komen en niet meer zomaar in je configuratie staan.
Hiermee zijn we dan ook aan het einde van deze vrij korte tutorial gekomen. In de volgende tutorial rond Spring security ga ik authenticatie via RESTful webservices uitleggen.

Download project

Download – spring-security-db-example.tar.gz (11 kB)

Tagged , , , , .

g00glen00b

Consultant at Cronos and Tech lead at Aquafin. Usually you can find me trying out new libraries and technologies. Loves both Java and JavaScript.