Spring Boot + JWT(Json Web Token)

Afin de sécuriser une application le framework spring security offre plusieurs solutions.

Parmi ces solutions est l'utilisation de Jeton (JWT) qui facilite l’authentification au serveur avec les différents types de clients, soit client mobile développé avec android par exemple ,soit un client léger développé en java comme spring mvc ou bien en angular .

Dans ce tutoriel, nous allons développer une application Spring Boot qui utilise JWT lors de l’authentification.

Tout d'abord commençons par la création d'un simple projet avec Spring Boot comme nous avons fait dans ce vidéo ;




La structure de projet crée est comme ceci :

Le fichier pom.xml est comme ceci :

Après il faut créer la classe TokenUtil dans la quelle nous allons gérer le jeton et donner les valeurs avant de le générer:

La classe MyFilter va filtrer les accès selon les valeurs contenues dans le jeton envoyé. Ce filtre sera appelé dans la classe de configuration de spring securité nommée WebSecurityConfig Les annotations @Configuration et @EnableWebSecurity sont utilisées afin d'activer la sécurité des accès aux controllers.

 Dans ce projet spring boot nous avons deux contrôleurs: HelloWorldController et AuthenticationController.
La classe service qui implémente l'interface UserDetailsService qui contient une seule méthode appelée loadUserByUsername
L'interface UserRepository en spring data qui interagit avec la base de donnée Mysql. Dans la base de donnée nous avons besoin de deux tables users et roles qui correspondent aux entités suivantes: Voici la classe CustomUserDetails utilisé dans la méthode loadUserByUsername de l'interface UserDetailsService . Le fichier de configuration de spring boot est Le projet complet est dans ce lien .

Spring Boot CRUD avec Mysql

Dans cet article, je vais vous montrer comment developper une application CRUD avec spring boot et Mysql.

Tout d'abord,il faut créer "NEW Spring Starter Project"

Il faut choisir les dependencies de JPA et de MYSQL.
Voici le pom.xml qui j'ai obtenu:



La classe Employee.java



La classe EmployeeRepository qui contient les methodes d'accés à la base



La classe EmployeeController.java



Voici la video de cet exemple ici

Ceci le lien de code source complet github

Spring MVC CRUD

Après avoir vu le traitement du formulaire avec Spring  ici , je vous présente aujourd’hui une petite application qui permet d’ajouter, lire, modifier et supprimer un employe de la base de données. 

Pour débuter, Apres avoir créé un projet maven nommé  SpringMvcCrud.

il faut ajouter les dependencies dans le fichier pom.xml.

Voici aussi le fichier de configuration de la base de données:

La classe Employe.java

Créer l'interface IEmployeDao

Créer la classe EmployeDao qui implémente l'interface IEmployeDao





La page d'ajout EmployeForm.jsp

La page de consultation Home.jsp

Il ne faut pas oublier la modification dans le fichier web.xml

Voici une vidéo pour cet exemple:

Code source complet  github

Spring ORM tutorial avec JPA, Hibernate, Transactions

Dans ce tutorial ,nous allons montrer comment travailler avec Spring ORM ,JPA,hibernate.
Voici la structure de notre projet.

Fichier pom.xml

La classe User.java

L'interface UserDAO.java

L'implementation de l'interface est la classe suivante:

La classe de test Main.java:

L'annotation @Service permet de déclarer un bean de service, c'est à dire de la couche métier.L'annotation @Transactional peut être utilisée pour indiquer au conteneur les méthodes qui doivent s'exécuter dans un contexte transactionnel.
Et finalement voici le fichier de configuration:

spring mvc avec annotation

Nous allons vous montrer un petit exemple simple de SpringMVC.

Apres avoir créer un projet maven , je vais configuer spring ,en ajoutant les dependances qu'il faut dans le ficher pom.xml

Dans le fichier web.xml, nous devons ajouter la servlet de spring:

org.springframework.web.servlet.DispatcherServlet

Nous allons aussi ajouter contextConfigLocation dans le fichier web.xml

Dans la valeur nous allons mettre le chemin de fichier de configuration de spring.

Ce fichier nommé dispatcher-servlet.xml,doit respecter la regle de son nomination qui le nom de la servlet +-servlet.xml.
Voici le fichier de configuration

Nous allons créer la classe controleur nomme HelloWorldController

Nous devons ajouter @RequestMapping pour indiquer que la methode est mappé sur le chemin d'URI
Nous allons ajouter @RequestParam.@RequestParam permet d'extraire un paramètre de type String et de nom "nom".
Nous allons developper maintenant la page index.jsp et helloworld.jsp

Voici le contenu dela page helloworld

Nous devons créer un repertoire views dans lequel nous mettons la page helloworld
Configurons le fichier de spring dispatcher-servlet.xml
Le video suivant vous aider à mieux comprendre les etapes.

Tutoriel sur Spring Data :intéraction avec la base de donnée

Cet article s'intéresse à « Spring Data ». Il permet l'accès aux données et d'avoir une couche d'abstraction commune à de multiples sources de données.

voici notre classe entité




On doit créer l'interface,





dans le fichier database.properties on doit mettre ces lignes:

jdbc.url=jdbc:mysql://localhost:3306/Banque_SpringData_DB?createDatabaseIfNotExist=true
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=

et ceci le fichier de configuration de spring



La classe de test est :


Voici le video de l'exemple:

Spring annotation

• Dans cet exemple, on va montrer comment utiliser les fonctionnalités de Spring annotation Autowired  pour injecter des beans dans d'autres . 

• Tout d'abord on crée une classe nommé Pays.

• Puis on developpe  une classe Client en relation avec la classe pays comme ceci:

• L'annotation @Autowired :va faire l'injection automatique de bean pays vers le bean Client.Cette annotation peut étre mis au dessus de propriété ou bien au dessus de constructeur.

• On peut ajouter l'annotation  e @Qualifier avec@Autowired dessus pour éviter les conflits en cas ou on a deux beans de meme type .

• Dans le fichier XML de spring on déclare les deux classes comme de bean:

• Dans le fichier xml il ne faut pas oublier d'ajouter <context:annotation-config /> ou bien on ajoute ce bean <beanclass="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/> au lieu de ca.

• Finalement ,pour  tester l'exemple voici le code:

SpringSecurity

Dans cet article, on va montrer comment utiliser spring security dans une application web.


Le plus important est de configurer le fichier XML du spring security suivant:

security:intercept-url indique les pages qui peut y accéeder les utilisateurs ayant le role ROLE_USER.
security:form-login login-page indique la page de login.
authentication-failure-url indique la page qu'on va se rediriger ,en cas ou il y a échec d'authentification.
security:logout logout-success-url indique la page qu'on va se rediriger ,en cas ou on a fait déconnexion.

Le fichier Web.xml modifié sera comme suit : Le code de la page d'accueil pour cet exemple est le suivant:

SpringMVC

Dans le cas de SpringMVC le conteneur va servir à créer:

-Le contexte de l’application Web
-Les objets traitant les requêtes (Controller)
-Les objets créant les pages HTML (View)
-Les objets données des formulaires (Command)
-Les liens avec les couches métiers et BD
-Et pleins d’autres
-Le mapping des URL vers les contrôleurs
-Le mapping des vues , etc.

Voici le shéma qui montre intervention de spring MVC dans la couche présenation de l'application

En effet  spring mvc fonctionne par certains aspects de façon similaire à Struts : une servlet frontale va prendre l’ensemble des requêtes et les dispatcher à ses contrôleurs, ces contrôleurs sont des singletons issus d’une fabrique Spring.

Le Controller

•La org.srinframework.web.servlet.DisatcherServlet est le point d’entrée générique qui délègue les requêtes à des Controller.

•Un org.springframework.web.servlet.mvc.Controller prend en charge une requête, et utilise la couche métier pour y répondre.

•Un Controller fabrique un modèle sous la forme d’une java.util.Map contenant les éléments de la réponse.

•Un Controller choisit une org.springframework.web.servlet.View qui sera paramétrée par la Map pour donner la page qui sera affichée.  

web.xml 

Le fichier web.xml va contenir :

1.        Une servlet pour dispatcher les requêtes aux contrôleurs.
2.         Un mapping de servlet

•On aboutit à ce fichier:

<!DOCTYPE web-app

PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd" >

  <web-app>

 <display-name> Created Web Application</display-name>

on déclare la servlet frontale 

 <servlet>

 <servlet-name>spring-mvc-webapp</servlet-name>

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

 <load-on-startup>1</load-on-startup>

 </servlet>  

Toutes les requêtes se terminant par .html seront servis par la servlet frontal

<servlet-mapping>

 <servlet-name>spring-mvc-webapp</servlet-name>

 <url-pattern>*.html</url-pattern>

 </servlet-mapping>

  </web-app>

    

Dans un contexte Web avec Spring MVC, il faut comprendre qu'il y a en générale 2 contexte différents.

Le premier est créée par le ContextLoaderListener, et par défaut il va chercher un applicationContext.xml.Ce contexte est général à l'application et est chargé lors du démarrage de celle-ci.
Ensuite, tu as un contexte propre à la servlet, créé par la DispatcherServlet.
Si dans ton mapping celle-ci porte le nom maservlet, alors elle cherchera un fichier maservlet-servlet.xml

Il faut editer le fichier de configuration de spring:

/WEB-INF/ maservlet-servlet.xml

Dans ce fichier on doit déclarer ceci:

Voici la structure du projet springmvc:

Dans le fichier xml de configuration,on doit ajouter la déaclaration du controller HelloWorldController comme suit:

 Voici la classe HelloWorldController  qui implemente le controller

       Nous allons ajouter une autre page pour afficher le résultat au lieux de PrintWriter  pour cela nous devons créer ModelAndView et lui passer le nom de model et sa valeur

ModelAndView(String viewName, String modelName, Object modelObject)

                        

Dans la page finale hello.jsp , on recupere la valuer envoye dans la variable txt.

logout spring security

Dans cet exemple nous allons montrer comment effecture la  déconnexion en
utilisant spring security dans une page utilisant le framework JSF:

Dans la page ou on vuet faire la deconnexion nous ajoutons le composant outputLink avec comme value:     j_spring_security_logout

Dans le fichier de configuration de spring security nous ajoutons la balise de logout comme suit:

la  properiete  logout-success-url  indique l'url de la page qu'on  veut y aller apres avoir cliqué sur la valeur Deconnextion.

Finalement voici le fichier web.xml complet:

spring security

Dans cet article nous allons montrer comment travailler avec spring security dans une application j2ee utilisant jsf et primefaces.

1)voici notre page d'authentification login.xhtml qui contient le formulaire suivant:

  




2)Dans ce qui le fichier spring_security.xml

<?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:security="http://www.springframework.org/schema/security"
        xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-2.0.xsd">
   


    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>jdbc:mysql://localhost/bd?useUnicode=true&amp;characterEncoding=UTF-8&amp;characterSetResults=UTF-8</value>
        </property>
        <property name="username">
            <value>root</value>
        </property>
        <property name="password">
            <value></value>
        </property>
        
    </bean>


<security:http access-denied-page="/faces/denied.xhtml" auto-config="true">
  <security:intercept-url pattern="/faces/login.xhtml" access="IS_AUTHENTICATED_ANONYMOUSLY" filters="none"/>
  <security:intercept-url pattern="/faces/resources/**" access="IS_AUTHENTICATED_ANONYMOUSLY" filters="none"/>
  <security:intercept-url pattern="/faces/pages/**" access="ROLE_ADMIN"/>

   
  <security:form-login login-page="/faces/login.xhtml"  authentication-failure-url="/faces/login.xhtml?error=true" default-target-url="/faces/accueil.xhtml"   always-use-default-target="true"/>
 <security:remember-me />
</security:http>


    <!-- Configure the authentication provider -->
    <security:authentication-provider>
  <security:jdbc-user-service data-source-ref="dataSource" 
                              users-by-username-query="SELECT username,password,enabled FROM utilisateur WHERE username = ?"
                              authorities-by-username-query="SELECT username,role FROM profil WHERE username = ?"/>
</security:authentication-provider>
</beans>


-Ce fichier de configuration de spring doit etre visible pour notre application Web.
Pour cela nous devons le déclarer dans le fichier Web.xml



 <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
/WEB-INF/ spring_security.xml
        </param-value>
    </context-param>


et ajouter les listener suivant:


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

    </listener>
et les filtressuivant:

 <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <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>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>

    </filter-mapping>


Le fichier Web.xml complet est comme ceci:


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name></display-name>
  <welcome-file-list>
    <welcome-file>login.xhtml</welcome-file>
  </welcome-file-list>
  <context-param>
    <param-name>javax.faces.PARTIAL_STATE_SAVING</param-name>
    <param-value>false</param-value>
  </context-param>
  <context-param>
    <param-name>javax.faces.DATETIMECONVERTER_DEFAULT_TIMEZONE_IS_SYSTEM_TIMEZONE</param-name>
    <param-value>true</param-value>
</context-param>
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>/faces/*</url-pattern>
  </servlet-mapping>

     <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
/WEB-INF/spring_security.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <listener>
        <listener-class>
org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <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>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
    </filter-mapping>
   

</web-app>