DEV Community: NDONGO TONUX SAMB

JavaScript est un Langage de Programmation

NDONGO TONUX SAMB — Sun, 24 Dec 2023 04:19:46 +0000

Introduction

Dans cet article, nous examinons en profondeur la nature scientifique de JavaScript, un langage omniprésent dans le développement web. En disséquant les concepts fondamentaux de l'informatique, nous comprenons comment JavaScript incarne et met en œuvre ces principes, affirmant ainsi son statut de langage de programmation à part entière.

Turing Complétude

Un langage de programmation est dit Turing complet s'il peut simuler n'importe quelle machine de Turing. Cela signifie qu'il est capable de calculer tout ce qui est calculable, étant donné assez de temps et de mémoire.
JavaScript est Turing complet. Il peut implémenter des algorithmes récursifs et des boucles indéfinies, des caractéristiques clés de la complétude de Turing.

Paradigmes de Programmation

Un paradigme de programmation est un style ou une approche de la programmation qui suit un ensemble de concepts et de pratiques.
JavaScript prend en charge plusieurs paradigmes de programmation, y compris la programmation impérative, fonctionnelle et orientée objet. Cette polyvalence est démontrée par ses fonctions de première classe, sa capacité à créer et manipuler des objets, et son héritage basé sur les prototypes.

Systèmes de Types

Un système de types est un cadre conceptuel qui définit comment un langage de programmation catégorise les types de données et leurs interactions.
JavaScript utilise un système de types dynamiques et faiblement typés, offrant une flexibilité significative dans la manipulation des données. Les variables en JavaScript peuvent contenir différents types de données, et ces types peuvent changer dynamiquement.

Théorie des Langages Formels

Cette branche de l'informatique traite des langages formels, y compris la syntaxe et la sémantique des langages de programmation.
JavaScript a une grammaire formellement définie (ECMAScript) qui spécifie sa syntaxe et sa structure. La spécification ECMAScript décrit comment les instructions sont interprétées et exécutées.

Complexité Algorithmique

La complexité algorithmique mesure l'efficacité des algorithmes en termes de temps d'exécution et d'utilisation de la mémoire.
Des algorithmes peuvent être écrits en JavaScript, et leur complexité peut être analysée en utilisant la notation Big O, un aspect fondamental de l'analyse algorithmique en informatique.

Modèle d'Exécution et Environnement d'Exécution

Le modèle d'exécution décrit comment le code est exécuté dans un environnement donné.
JavaScript utilise un modèle d'exécution mono-thread avec une boucle d'événements (event loop), caractéristique dans des environnements comme les navigateurs web et Node.js. Ce modèle influence la façon dont JavaScript gère l'asynchronisme, la concurrence et les opérations d'entrée/sortie.

Interopérabilité et API

L'interopérabilité se réfère à la capacité d'un système à travailler avec ou à utiliser des parties d'autres systèmes.
JavaScript peut interagir avec de nombreuses API et systèmes externes, comme le DOM dans les navigateurs web, ou diverses bibliothèques et frameworks.

Conclusion

L'alignement de JavaScript avec ces principes scientifiques non seulement consolide son rôle en tant que langage de programmation polyvalent, mais met également en évidence son influence profonde dans le domaine du développement logiciel. Comprendre ces aspects offre une appréciation plus profonde des capacités de JavaScript et de son rôle central dans l'informatique moderne.

Construire une Usine Logicielle Agile et Performante pour une Gestion Efficace du Projet

NDONGO TONUX SAMB — Wed, 19 Jul 2023 04:20:54 +0000

Introduction

Lorsqu'une équipe de développement logiciel est impliquée dans un projet, il est essentiel de mettre en place une usine logicielle bien organisée pour assurer une gestion efficace du projet. Une usine logicielle bien conçue permet de gérer le backlog de tâches, de garantir la qualité du code, de faciliter la collaboration entre les membres de l'équipe et de suivre l'avancement du projet. Dans cet article, nous explorerons les principaux éléments d'une usine logicielle et les outils associés pour une gestion de projet réussie.

Gestion du Backlog

La gestion d'un backlog clair et organisé est essentielle pour suivre les tâches à réaliser tout au long du projet. Les équipes agiles utilisent souvent des outils tels que Jira, Trello ou Asana pour gérer leur backlog. Ces outils permettent de prioriser les tâches, d'ajouter des descriptions détaillées et d'attribuer des tâches à des membres spécifiques de l'équipe.

Exemple:

Utilisation de Jira pour suivre et gérer les tâches du backlog, en assignant les tickets à des membres de l'équipe et en définissant les priorités en fonction des exigences du projet.

Livraison Continue

Une usine logicielle efficace doit permettre la mise à disposition automatique d'une version fonctionnelle du logiciel à tout moment. Pour cela, l'intégration continue (CI) et le déploiement continu (CD) sont mis en place à l'aide d'outils tels que Jenkins, GitLab CI/CD ou Travis CI. Ces outils automatisent le processus de construction, de test et de déploiement, réduisant ainsi les risques d'erreurs et raccourcissant le cycle de développement.

Exemple:

Utilisation de GitLab CI/CD pour automatiser la compilation, les tests unitaires et le déploiement automatique vers un environnement de test ou de production après chaque fusion de code réussie.

Tests Unitaires

Une usine logicielle solide nécessite la mise en place de tests unitaires dès le début du projet. Les tests unitaires permettent de détecter les erreurs et les régressions rapidement, ce qui assure la stabilité et la fiabilité du code. Les frameworks de test comme Jest, NUnit ou JUnit sont souvent utilisés pour écrire et exécuter ces tests.

Exemple:

Utilisation de Jest pour effectuer des tests unitaires sur les composants d'une application Angular, garantissant ainsi que les changements apportés n'affectent pas les fonctionnalités existantes.

Rôles et Organisation du Projet

Une usine logicielle bien structurée comprend des rôles clairement définis, tels que le Scrum Master, le Product Owner, les architectes et les développeurs. Chaque membre de l'équipe a des responsabilités spécifiques, ce qui facilite la communication et la prise de décision.

Exemple:

L'équipe suit une méthodologie Scrum, où le Scrum Master facilite les réunions, le Product Owner gère le backlog et les architectes guident les choix techniques.

Organisation du Projet

Une organisation rigoureuse est essentielle pour suivre l'avancement du projet. Les réunions quotidiennes, telles que les Daily Standups, permettent à l'équipe de discuter des progrès, des obstacles et des priorités. De plus, des réunions d'itération régulières, comme les Sprint Reviews et les Sprint Retrospectives, offrent des opportunités d'amélioration continue.

Exemple:

L'équipe se réunit tous les matins pour une Daily Standup rapide de 15 minutes pour discuter des tâches effectuées la veille, des obstacles rencontrés et des tâches prévues pour la journée.

Suivi de l'Avancée du Backlog

Pour suivre l'avancement du backlog, l'équipe peut utiliser des outils de suivi tels que burndown charts ou Kanban boards. Ces outils permettent de visualiser le travail effectué et restant, facilitant ainsi la planification future.

Exemple:

L'utilisation d'un tableau Kanban pour visualiser les tâches du backlog, de leur état actuel à leur achèvement, aidant l'équipe à suivre l'avancement global du projet.

Conclusion

La mise en place d'une usine logicielle efficace est essentielle pour assurer une gestion de projet réussie. En intégrant une gestion du backlog organisée, des processus d'intégration et de déploiement continus, des tests unitaires robustes, une organisation d'équipe bien définie et des outils de suivi appropriés, l'équipe de développement peut gérer efficacement les projets tout en maintenant la qualité et la performance du logiciel. Avec ces éléments en place, l'équipe est prête à relever les défis du développement logiciel de manière efficace et collaborative.

Guide étape par étape pour intégrer JPA dans une application JEE avec JSF

NDONGO TONUX SAMB — Fri, 14 Jul 2023 01:42:18 +0000

Introduction

L'intégration de JPA (Java Persistence API) dans une application JEE (Java Enterprise Edition) avec JSF (JavaServer Faces) est essentielle pour la persistance des données dans les applications web. Dans cet article, nous allons explorer les étapes clés pour intégrer JPA dans une application JEE avec JSF. Nous aborderons les aspects tels que l'ajout des dépendances, la configuration de la source de données, le mapping des entités, la gestion des transactions, l'utilisation des requêtes JPA et l'intégration avec JSF.

Prérequis

Avant de commencer, assurez-vous d'avoir une connaissance de base de JEE, JPA et JSF. Vous devriez également avoir une application JEE existante avec JSF prête à être améliorée avec la persistance des données à l'aide de JPA.

Points à couvrir :

1. Ajouter les dépendances

Pour intégrer JPA et JSF dans votre application, vous devez ajouter les dépendances appropriées. Dans votre fichier de configuration de projet (par exemple, pom.xml pour Maven), spécifiez les dépendances pour JPA et JSF, en utilisant les versions compatibles avec votre environnement. Voici un exemple de dépendances :

<!-- Dépendances JPA -->
<dependency>
    <groupId>javax.persistence</groupId>
    <artifactId>javax.persistence-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.6.1.Final</version>
</dependency>

<!-- Dépendances JSF -->
<dependency>
    <groupId>javax.faces</groupId>
    <artifactId>javax.faces-api</artifactId>
    <version>3.0</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.faces</artifactId>
    <version>3.0.1</version>
</dependency>

2. Configuration de la source de données (DataSource)

Pour utiliser JPA, vous devez configurer une source de données (base de données) dans le fichier de configuration de votre serveur d'application. Selon votre serveur d'application, vous pouvez utiliser différents fichiers de configuration, tels que persistence.xml ou context.xml. Voici un exemple de configuration pour une source de données MySQL :

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd"
    version="2.2">

    <persistence-unit name="my-persistence-unit" transaction-type="JTA">
        <jta-data-source>jdbc/MyDataSource</jta-data-source>
        <class>com.example.MyEntity</class>
        <!-- Autres classes d'entités à inclure -->

        <properties>
            <property name="javax.persistence.schema-generation.database.action" value="update" />
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/mydb" />
            <property name="javax.persistence.jdbc.user" value="myuser" />
            <property name="javax.persistence.jdbc.password" value="mypassword" />
        </properties>
    </persistence-unit>
</persistence>

3. Mapping des entités

Définissez vos entités (objets persistants) en utilisant les annotations JPA. Utilisez les annotations telles que @Entity, @Table, @Column, @id, etc. pour mapper les entités aux tables de la base de données. Assurez-vous de mapper correctement les relations entre les entités en utilisant les annotations appropriées comme @OneToOne, @OneToMany, @ManyToOne, etc.

4. Gestion des transactions

Utilisez les annotations JPA (@Transactional) ou les API de gestion des transactions pour délimiter les opérations de persistance dans des transactions. Cela garantit que les opérations de lecture et d'écriture dans la base de données sont cohérentes et atomiques.

5. Utilisation des requêtes JPA

Utilisez les requêtes JPA pour interagir avec la base de données. Vous pouvez utiliser des requêtes JPQL (Java Persistence Query Language) ou des requêtes nommées pour récupérer, filtrer et manipuler les données persistantes. Assurez-vous de comprendre les différents types de requêtes disponibles et leur utilisation appropriée.

6. Intégration avec JSF

Dans vos beans de gestion de vues JSF, injectez ou utilisez les classes de gestion des données pour effectuer les opérations de persistance nécessaires. Les entités peuvent être utilisées pour lier les données de la vue JSF aux objets persistants dans la base de données. Assurez-vous de comprendre comment utiliser les objets EntityManager et les méthodes CRUD pour effectuer les opérations de persistance.

Un exemple avec un entité User:

1. Création de l'entité User

@Entity
@Table(name = "users")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String nom;
    private String prenom;
    private int age;

    // Getters and setters
    // ...
}

2. Configuration de la source de données (persistence.xml)

<persistence-unit name="my-persistence-unit" transaction-type="JTA">
    <!-- ... -->
    <class>com.example.User</class>
    <!-- ... -->
</persistence-unit>

3. Création du service de gestion des données(UserService)

@Stateless
public class UserService {
    @PersistenceContext(unitName = "my-persistence-unit")
    private EntityManager em;

    public void createUser(User user) {
        em.persist(user);
    }

    public List<User> getAllUsers() {
        TypedQuery<User> query = em.createQuery("SELECT u FROM User u", User.class);
        return query.getResultList();
    }
}

4. Création du bean de gestion de vue JSF (UserBean)

@ManagedBean
@RequestScoped
public class UserBean {
    private User user = new User();
    private List<User> users;

    @EJB
    private UserService userService;

    public void saveUser() {
        userService.createUser(user);
        user = new User(); 
// Réinitialiser l'utilisateur après la sauvegarde
    }

    public List<User> getUsers() {
        if (users == null) {
            users = userService.getAllUsers();
        }
        return users;
    }

    // Getters and setters
    // ...
}

5. Création de la page JSF pour afficher les utilisateurs(users.xhtml)

<h:html xmlns="http://www.w3.org/1999/xhtml"
        xmlns:h="http://java.sun.com/jsf/html"
        xmlns:f="http://java.sun.com/jsf/core">
    <h:head>
        <title>Liste des utilisateurs</title>
    </h:head>
    <h:body>
        <h:form>
            <h:panelGrid columns="3">
                <h:outputLabel for="nomInput" value="Nom:"/>
                <h:inputText id="nomInput" value="#{userBean.user.nom}"/>
                <h:message for="nomInput"/>

                <h:outputLabel for="prenomInput" value="Prénom:"/>
                <h:inputText id="prenomInput" value="#{userBean.user.prenom}"/>
                <h:message for="prenomInput"/>

                <h:outputLabel for="ageInput" value="Âge:"/>
                <h:inputText id="ageInput" value="#{userBean.user.age}"/>
                <h:message for="ageInput"/>

                <h:commandButton value="Enregistrer" action="#{userBean.saveUser}"/>
            </h:panelGrid>
        </h:form>

        <h:dataTable value="#{userBean.users}" var="user">
            <h:column>
                #{user.nom}
            </h:column>
            <h:column>
                #{user.prenom}
            </h:column>
            <h:column>
                #{user.age}
            </h:column>
        </h:dataTable>
    </h:body>
</h:html>

Conclusion

Intégrer JPA dans une application JEE avec JSF est une étape importante pour assurer la persistance des données. En suivant les étapes décrites dans cet article, vous pouvez commencer à utiliser JPA dans votre application et bénéficier de ses fonctionnalités puissantes pour la gestion des données.

Documentations:

JEE

JPA

JSF

Choisir la bonne approche de package management dans les projets Spring Boot

NDONGO TONUX SAMB — Fri, 21 Apr 2023 07:02:34 +0000

Lorsqu'il s'agit d'organiser les composants du code dans un projet Spring Boot, la gestion des packages est un élément clé. Ah oui la structure des packages peut avoir un impact significatif sur la maintenabilité et l'évolutivité du projet, ainsi que sur la facilité avec laquelle les développeurs peuvent naviguer dans le code.

Il existe deux approches principales de la gestion des packages dans les projets Spring Boot : technical et domain-driven. Faut dire que chaque approche a ses propres avantages et inconvénients, et la meilleure approche dépendra des exigences spécifiques du projet et des besoins de l'équipe de développement. "Taan sa boula neex"

Technical Approach

Cette approche de la gestion des packages organise les composants du code en fonction des aspects techniques du projet, tels que les controllers, models, repositories, et services. Cette approche présente plusieurs avantages :

Il est plus facile de localiser des composants de code spécifiques : en organisant les packages en fonction des aspects techniques du projet, les développeurs peuvent trouver rapidement des composants de code spécifiques.
Cohérence entre les projets : l'utilisation d'une structure de packages cohérente dans plusieurs projets peut permettre aux développeurs de passer plus facilement d'un projet à l'autre et de comprendre la base de code.
Familiarité avec les concepts techniques : les développeurs qui connaissent les aspects techniques du projet peuvent facilement comprendre la structure du package et trouver les composants de code dont ils ont besoin.

Toutefois, cette approche peut également présenter certains inconvénients :

Manque d'intérêt pour la logique métier : en organisant les packages sur la base des seuls aspects techniques, la structure des packages peut ne pas refléter le domaine d'activité du projet, ce qui rend plus difficile la compréhension de l'aspect fonctionnel.
Évolutivité limitée : au fur et à mesure que le projet gagne en complexité et en taille, la structure des packages peut devenir moins utile et difficile à maintenir, ce qui entraîne des problèmes d'évolutivité.
Risque de confusion : dans certains cas, des composants de code similaires peuvent se trouver dans différents packages, ce qui entraîne une certaine confusion et une difficulté à trouver un code spécifique. On se lance dans du refactoring sans fin.

Domain-Driven Approach

Cette approche, qui devient de plus en plus populaire, organise les composants en fonction des concepts du domaine du projet, tels que le customer, order, et product. Cette approche présente plusieurs avantages :

Focalisation sur le domaine d'activité : en organisant les packages sur la base des concepts du domaine du projet, la structure des packages reflète le domaine d'activité du projet, ce qui facilite la compréhension de la logique métier.
Meilleure évolutivité : au fur et à mesure que la complexité et la taille du projet augmentent, l'approche par domaine permet de maintenir une structure de package logique qui évolue avec le projet, ce qui facilite la maintenance et l'extension.

Convivialité pour les développeurs : l'approche par domaine peut permettre aux développeurs qui ne sont pas familiarisés avec les aspects techniques du projet de comprendre plus facilement le code, en organisant les composants du code autour de concepts fonctionnels.
Cependant, Ah oui 😂, l'approche par domaine peut également présenter certains inconvénients :

Risque d'ambiguïté : cette approche peut être source d'ambiguïté lorsque plusieurs packages peuvent être pertinents pour un composant spécifique, ce qui entraîne une confusion et une difficulté à trouver un code spécifique.
Difficulté de réutilisation : elle peut ne pas être bien adaptée à la réutilisation dans plusieurs projets, car la structure des Domain-Driven peut être très spécifique au domaine d'activité du projet. Faut pas réinventer la roue vu que nous aussi on est parfois paresseux 😴.
Plus difficile à apprendre : elle peut être plus difficile à apprendre pour les nouveaux développeurs, car elle nécessite une compréhension plus approfondie du domaine d'activité et de la manière dont les composants du code s'y rapportent.

Enfin Bref!!!

Le choix de la bonne approche de package management dans les projets Spring Boot nécessite un examen attentif des exigences spécifiques du projet et des besoins de l'équipe de développement. Alors que l'approche Technical peut être plus appropriée pour les projets fortement axés sur les aspects techniques, l'approche Domain-Driven peut être plus efficace pour les projets fortement axés sur des domaines d'activité spécifiques.
En fin de compte, l'essentiel est de choisir une structure de packages qui soit maintenable, évolutive et conviviale pour les développeurs.

Tonux

TakkJokk

Spring Security avec JWT pour REST API

NDONGO TONUX SAMB — Fri, 06 May 2022 23:26:45 +0000

Spring est considéré comme un framework de confiance dans l'écosystème Java et est largement utilisé. Il n'est plus valable de parler de Spring comme d'un framework, car il s'agit plutôt d'un terme générique qui couvre divers frameworks. L'un de ces frameworks est Spring Security, qui est un framework d'authentification et d'autorisation puissant et personnalisable. Il est considéré comme la norme de facto pour la sécurisation des applications basées sur Spring.

Malgré sa popularité, je dois admettre que lorsqu'il s'agit d'applications monopages, il n'est pas simple et direct à configurer. Je soupçonne que la raison en est qu'il s'agissait à l'origine d'un cadre orienté application MVC, où le rendu des pages Web se fait côté serveur et la communication est basée sur la session.

Si le back-end est basé sur Java et Spring, il est logique d'utiliser Spring Security pour l'authentification/autorisation et de le configurer pour une communication sans état. J'ai décidé d'écrire cet article, dans lequel j'essaierai de résumer et de couvrir tous les détails subtils et les difficultés que vous pouvez rencontrer au cours du processus de configuration.

- Définir la terminologie

Avant de plonger dans les détails techniques, je souhaite définir explicitement la terminologie utilisée dans le contexte de Spring Security, afin d'être sûr que nous parlons tous le même langage.

Voici les termes que nous devons aborder :

Authentication désigne le processus de vérification de l'identité d'un utilisateur, sur la base des informations d'identification fournies. Un exemple courant est la saisie d'un nom d'utilisateur et d'un mot de passe lorsque vous vous connectez à un site web. On peut le considérer comme une réponse à la question "Qui êtes-vous ?
Authorization désigne le processus consistant à déterminer si un utilisateur a l'autorisation d'effectuer une action particulière ou de lire des données particulières, en supposant que l'utilisateur a été authentifié avec succès. Il s'agit en fait d'une réponse à la question suivante : "Un utilisateur peut-il faire ou lire ceci ?
Principle fait référence à l'utilisateur actuellement authentifié.
Granted authority fait référence à la permission de l'utilisateur authentifié.
Role fait référence à un groupe de permissions de l'utilisateur authentifié.

- Création d'une application Spring de base

Avant de passer à la configuration du framework Spring Security, créons une application web Spring de base. Pour cela, nous pouvons utiliser un Initializr Spring et générer un projet modèle. Pour une application web simple, seule une dépendance au framework web Spring est suffisante :

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Une fois que nous avons créé le projet, nous pouvons y ajouter un contrôleur REST simple comme suit :

@RestController @RequestMapping("hello")
public class HelloRestController {

    @GetMapping("user")
    public String helloUser() {
        return "Hello User";
    }

    @GetMapping("admin")
    public String helloAdmin() {
        return "Hello Admin";
    }

}

Après cela, si nous construisons et exécutons le projet, nous pouvons accéder aux URLs suivants dans le navigateur web :

http://localhost:8080/hello/user => Hello User

http://localhost:8080/hello/admin => Hello Admin

Maintenant, nous pouvons ajouter le framework Spring Security à notre projet, et nous pouvons le faire en ajoutant la dépendance suivante à notre fichier pom.xml :

<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
</dependencies>

L'ajout d'autres dépendances du framework Spring n'a normalement pas d'effet immédiat sur une application tant que nous n'avons pas fourni la configuration correspondante, mais Spring Security est différent en ce sens qu'il a un effet immédiat, ce qui déroute généralement les nouveaux utilisateurs. Après l'avoir ajouté, si nous reconstruisons et exécutons le projet, puis essayons d'accéder à l'une des URL susmentionnées au lieu de visualiser le résultat, nous serons redirigés vers http://localhost:8080/login . Il s'agit d'un comportement par défaut, car Spring Sécurité exige d'emblée une authentification pour toutes les URL.

Pour passer l'authentification, nous pouvons utiliser le nom d'utilisateur par défaut user et trouver un mot de passe auto-généré dans notre console :

Using generated security password: 1fc10045-dfaa-4baq-a119-e32ez32c99ez

N'oubliez pas que le mot de passe change chaque fois que nous réexécutons l'application. Si nous voulons changer ce comportement et rendre le mot de passe statique, nous pouvons ajouter la configuration suivante à notre fichier application.properties :

spring.security.user.password=Passer123@

Maintenant, si nous entrons les informations d'identification dans le formulaire de connexion, nous serons redirigés vers notre URL et nous verrons le résultat correct. Veuillez noter que le processus d'authentification prêt à l'emploi est basé sur la session, et que si nous voulons nous déconnecter, nous pouvons accéder à l'URL suivante :
http://localhost:8080/logout

Ce comportement prêt à l'emploi peut être utile pour les applications web MVC classiques où nous disposons d'une authentification basée sur la session, mais dans le cas d'applications à page unique, il n'est généralement pas utile car dans la plupart des cas d'utilisation, nous avons un rendu côté client et une authentification sans état basée sur JWT. Dans ce cas, nous devrons fortement personnaliser le framework Spring Security, ce que nous ferons dans la suite de l'article.

A titre d'exemple, nous allons implémenter une application web classique de boutique et créer un back-end qui fournira des API CRUD pour créer des fournisseurs et des produits ainsi que des API pour la gestion et l'authentification des utilisateurs.

Présentation de l'architecture de Spring Security

Avant de commencer à personnaliser la configuration, voyons d'abord comment l'authentification Spring Security fonctionne en coulisses.

Le diagramme suivant présente le flux et montre comment les demandes d'authentification sont traitées :

- Architecture de Spring Security

Maintenant, décomposons ce diagramme en composants et discutons de chacun d'entre eux séparément.

Chaîne de filtres de Spring Security

Lorsque vous ajoutez le framework Spring Security à votre application, il enregistre automatiquement une chaîne de filtres qui intercepte toutes les requêtes entrantes. Cette chaîne se compose de plusieurs filtres, et chacun d'entre eux gère un cas d'utilisation particulier.

Par exemple :

Vérifier si l'URL demandée est accessible publiquement, en fonction de la configuration.
En cas d'authentification basée sur la session, vérifier si l'utilisateur est déjà authentifié dans la session en cours.
Vérifier si l'utilisateur est autorisé à effectuer l'action demandée, et ainsi de suite.
Un détail important que je veux mentionner est que les filtres de Spring Security sont enregistrés avec l'ordre le plus bas et sont les premiers filtres invoqués. Pour certains cas d'utilisation, si vous voulez placer votre filtre personnalisé devant eux, vous devrez ajouter du remplissage à leur ordre. Ceci peut être fait avec la configuration suivante :

spring.security.filter.order=10

Une fois cette configuration ajoutée à notre fichier application.properties, nous aurons de la place pour 10 filtres personnalisés devant les filtres de Spring Security.

AuthenticationManager

Vous pouvez considérer l'AuthenticationManager comme un coordinateur où vous pouvez enregistrer plusieurs fournisseurs et, en fonction du type de demande, il transmettra une demande d'authentification au bon fournisseur.

AuthenticationProvider

AuthenticationProvider traite des types d'authentification spécifiques. Son interface n'expose que deux fonctions :

authenticate effectue l'authentification avec la demande.
supports vérifie si ce fournisseur prend en charge le type d'authentification indiqué.

Une implémentation importante de l'interface que nous utilisons dans notre projet d'exemple est DaoAuthenticationProvider, qui récupère les détails de l'utilisateur à partir d'un UserDetailsService .

UserDetailsService

UserDetailsService est décrit comme une interface de base qui charge les données spécifiques à l'utilisateur dans la documentation de Spring.

Dans la plupart des cas d'utilisation, les fournisseurs d'authentification extraient les informations d'identité de l'utilisateur à partir des informations d'identification d'une base de données, puis effectuent la validation. Ce cas d'utilisation étant très courant, les développeurs de Spring ont décidé de l'extraire sous la forme d'une interface distincte, qui expose la seule fonction :

loadUserByUsername accepte le nom d'utilisateur comme paramètre et renvoie l'objet d'identité de l'utilisateur.
Authentification à l'aide de JWT avec Spring Security

Après avoir discuté des aspects internes du framework Spring Security, configurons-le pour une authentification sans état avec un jeton JWT.

Pour personnaliser Spring Security, nous avons besoin d'une classe de configuration annotée avec l'annotation @EnableWebSecurity dans notre classpath. En outre, pour simplifier le processus de personnalisation, le framework expose une classe WebSecurityConfigurerAdapter . Nous allons étendre cet adaptateur et surcharger ses deux fonctions afin de :

1 - Configurer le gestionnaire d'authentification avec le bon fournisseur.
2 - Configurer la sécurité web (URLs publics, URLs privés, autorisation, etc.)

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // TODO configure authentication manager
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // TODO configure web security
    }

}

Dans notre application d'exemple, nous stockons les identités des utilisateurs dans une base de données H2, dans la collection users. Ces identités sont mappées par l'entité User, et leurs opérations CRUD sont définies par le référentiel UserRepo Spring Data.

Maintenant, lorsque nous acceptons la demande d'authentification, nous devons récupérer l'identité correcte de la base de données en utilisant les informations d'identification fournies, puis la vérifier. Pour cela, nous avons besoin de l'implémentation de l'interface UserDetailsService, qui est définie comme suit :

public interface UserDetailsService {

    UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException;

}

Ici, nous pouvons voir qu'il est nécessaire de retourner l'objet qui implémente l'interface UserDetails, et notre entité User l'implémente (pour les détails de l'implémentation, veuillez consulter le référentiel du projet d'exemple). Étant donné qu'elle n'expose que le prototype à fonction unique, nous pouvons la traiter comme une interface fonctionnelle et fournir l'implémentation sous forme d'expression lambda.

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserRepo userRepo;

    public SecurityConfig(UserRepo userRepo) {
        this.userRepo = userRepo;
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(username -> userRepo
            .findByUsername(username)
            .orElseThrow(
                () -> new UsernameNotFoundException(
                    format("User: %s, not found", username)
                )
            ));
    }

    // Details omitted for brevity

}

Ici, l'appel de fonction auth.userDetailsService va initier l'instance de DaoAuthenticationProvider en utilisant notre implémentation de l'interface UserDetailsService et l'enregistrer dans le gestionnaire d'authentification.

Avec le fournisseur d'authentification, nous devons configurer un gestionnaire d'authentification avec le schéma correct de codage de mot de passe qui sera utilisé pour la vérification des informations d'identification. Pour cela, nous devons exposer l'implémentation préférée de l'interface PasswordEncoder comme un bean.

Dans notre projet d'exemple, nous utiliserons l'algorithme de hachage de mot de passe bcrypt.

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserRepo userRepo;

    public SecurityConfig(UserRepo userRepo) {
        this.userRepo = userRepo;
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(username -> userRepo
            .findByUsername(username)
            .orElseThrow(
                () -> new UsernameNotFoundException(
                    format("User: %s, not found", username)
                )
            ));
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // Details omitted for brevity

}

Après avoir configuré le gestionnaire d'authentification, nous devons maintenant configurer la sécurité web. Nous implémentons une API REST et avons besoin d'une authentification sans état avec un jeton JWT ; par conséquent, nous devons définir les options suivantes :

Activer CORS et désactiver CSRF.
Définir la gestion de session comme étant sans état.
Définir le gestionnaire d'exception des demandes non autorisées.
Définir les permissions sur les points de terminaison.
Ajouter un filtre pour les jetons JWT.

Cette configuration est implémentée comme suit :

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final UserRepo userRepo;
    private final JwtTokenFilter jwtTokenFilter;

    public SecurityConfig(UserRepo userRepo,
                          JwtTokenFilter jwtTokenFilter) {
        this.userRepo = userRepo;
        this.jwtTokenFilter = jwtTokenFilter;
    }

    // Details omitted for brevity

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // Enable CORS and disable CSRF
        http = http.cors().and().csrf().disable();

        // Set session management to stateless
        http = http
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and();

        // Set unauthorized requests exception handler
        http = http
            .exceptionHandling()
            .authenticationEntryPoint(
                (request, response, ex) -> {
                    response.sendError(
                        HttpServletResponse.SC_UNAUTHORIZED,
                        ex.getMessage()
                    );
                }
            )
            .and();

        // Set permissions on endpoints
        http.authorizeRequests()
            // Our public endpoints
            .antMatchers("/api/public/**").permitAll()
            .antMatchers(HttpMethod.GET, "/api/author/**").permitAll()
            .antMatchers(HttpMethod.POST, "/api/author/search").permitAll()
            .antMatchers(HttpMethod.GET, "/api/book/**").permitAll()
            .antMatchers(HttpMethod.POST, "/api/book/search").permitAll()
            // Our private endpoints
            .anyRequest().authenticated();

        // Add JWT token filter
        http.addFilterBefore(
            jwtTokenFilter,
            UsernamePasswordAuthenticationFilter.class
        );
    }

    // Used by spring security if CORS is enabled.
    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source =
            new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }

}

Veuillez noter que nous avons ajouté le filtre JwtTokenFilter avant le filtre interne UsernamePasswordAuthenticationFilter de Spring Security. Nous faisons cela parce que nous avons besoin d'accéder à l'identité de l'utilisateur à ce stade pour effectuer l'authentification/autorisation, et son extraction se fait dans le filtre JWT token basé sur le jeton JWT fourni. Ceci est implémenté comme suit :

@Component
public class JwtTokenFilter extends OncePerRequestFilter {

    private final JwtTokenUtil jwtTokenUtil;
    private final UserRepo userRepo;

    public JwtTokenFilter(JwtTokenUtil jwtTokenUtil,
                          UserRepo userRepo) {
        this.jwtTokenUtil = jwtTokenUtil;
        this.userRepo = userRepo;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain)
            throws ServletException, IOException {
        // Get authorization header and validate
        final String header = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (isEmpty(header) || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            return;
        }

        // Get jwt token and validate
        final String token = header.split(" ")[1].trim();
        if (!jwtTokenUtil.validate(token)) {
            chain.doFilter(request, response);
            return;
        }

        // Get user identity and set it on the spring security context
        UserDetails userDetails = userRepo
            .findByUsername(jwtTokenUtil.getUsername(token))
            .orElse(null);

        UsernamePasswordAuthenticationToken
            authentication = new UsernamePasswordAuthenticationToken(
                userDetails, null,
                userDetails == null ?
                    List.of() : userDetails.getAuthorities()
            );

        authentication.setDetails(
            new WebAuthenticationDetailsSource().buildDetails(request)
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);
        chain.doFilter(request, response);
    }

}

Avant d'implémenter notre fonction API de connexion, nous devons nous occuper d'une étape supplémentaire : nous devons avoir accès au gestionnaire d'authentification. Par défaut, il n'est pas accessible au public, et nous devons l'exposer explicitement comme un bean dans notre classe de configuration.

Cela peut être fait comme suit :

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // Details omitted for brevity

    @Override @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

}

Et maintenant, nous sommes prêts à mettre en œuvre notre fonction API de connexion :

@Api(tags = "Authentication")
@RestController @RequestMapping(path = "api/public")
public class AuthApi {

    private final AuthenticationManager authenticationManager;
    private final JwtTokenUtil jwtTokenUtil;
    private final UserViewMapper userViewMapper;

    public AuthApi(AuthenticationManager authenticationManager,
                   JwtTokenUtil jwtTokenUtil,
                   UserViewMapper userViewMapper) {
        this.authenticationManager = authenticationManager;
        this.jwtTokenUtil = jwtTokenUtil;
        this.userViewMapper = userViewMapper;
    }

    @PostMapping("login")
    public ResponseEntity<UserView> login(@RequestBody @Valid AuthRequest request) {
        try {
            Authentication authenticate = authenticationManager
                .authenticate(
                    new UsernamePasswordAuthenticationToken(
                        request.getUsername(), request.getPassword()
                    )
                );

            User user = (User) authenticate.getPrincipal();

            return ResponseEntity.ok()
                .header(
                    HttpHeaders.AUTHORIZATION,
                    jwtTokenUtil.generateAccessToken(user)
                )
                .body(userViewMapper.toUserView(user));
        } catch (BadCredentialsException ex) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

}

Ici, nous vérifions les informations d'identification fournies à l'aide du gestionnaire d'authentification, et en cas de succès, nous générons le jeton JWT et le renvoyons comme en-tête de réponse avec les informations d'identité de l'utilisateur dans le corps de la réponse.

Autorisation avec Spring Security

Dans la section précédente, nous avons mis en place un processus d'authentification et configuré des URLs publiques/privées. Cela peut être suffisant pour les applications simples, mais pour la plupart des cas d'utilisation réels, nous avons toujours besoin de politiques d'accès basées sur les rôles pour nos utilisateurs. Dans ce chapitre, nous allons aborder cette question et mettre en place un schéma d'autorisation basé sur les rôles en utilisant le framework Spring Security.

Dans notre application d'exemple, nous avons défini les trois rôles suivants :

USER_ADMIN nous permet de gérer les utilisateurs de l'application.
PARTNER_ADMIN nous permet de gérer les fournisseurs.
PRODUCT_ADMIN nous permet de gérer les produits.
Maintenant, nous devons les appliquer aux URLs correspondants :

api/public est accessible au public.
api/admin/user peut accéder aux utilisateurs avec le rôle USER_ADMIN.
api/partner peut accéder aux utilisateurs avec le rôle PARTNER_ADMIN.
api/product peut accéder aux utilisateurs avec le rôle PRODUCT_ADMIN.
Le framework Spring Security nous offre deux options pour configurer le schéma d'autorisation :

Configuration basée sur l'URL
Configuration basée sur les annotations
Tout d'abord, voyons comment fonctionne la configuration basée sur les URL. Elle peut être appliquée à la configuration de la sécurité web comme suit :

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // Details omitted for brevity

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // Enable CORS and disable CSRF
        http = http.cors().and().csrf().disable();

        // Set session management to stateless
        http = http
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and();

        // Set unauthorized requests exception handler
        http = http
            .exceptionHandling()
            .authenticationEntryPoint(
                (request, response, ex) -> {
                    response.sendError(
                        HttpServletResponse.SC_UNAUTHORIZED,
                        ex.getMessage()
                    );
                }
            )
            .and();

        // Set permissions on endpoints
        http.authorizeRequests()
            // Our public endpoints
            .antMatchers("/api/public/**").permitAll()
            .antMatchers(HttpMethod.GET, "/api/partner/**").permitAll()
            .antMatchers(HttpMethod.POST, "/api/partner/search").permitAll()
            .antMatchers(HttpMethod.GET, "/api/product/**").permitAll()
            .antMatchers(HttpMethod.POST, "/api/product/search").permitAll()
            // Our private endpoints
            .antMatchers("/api/admin/user/**").hasRole(Role.USER_ADMIN)
            .antMatchers("/api/partner/**").hasRole(Role.PARTNER_ADMIN)
            .antMatchers("/api/product/**").hasRole(Role.PRODUCT_ADMIN)
            .anyRequest().authenticated();

        // Add JWT token filter
        http.addFilterBefore(
            jwtTokenFilter,
            UsernamePasswordAuthenticationFilter.class
        );
    }

    // Details omitted for brevity

}

Comme vous pouvez le constater, cette approche est simple et directe, mais elle présente un inconvénient. Le schéma d'autorisation de notre application peut être complexe, et si nous définissons toutes les règles en un seul endroit, il deviendra très gros, complexe et difficile à lire. Pour cette raison, je préfère généralement utiliser une configuration basée sur des annotations.

Le framework Spring Security définit les annotations suivantes pour la sécurité web :

@PreAuthorize supporte le langage d'expression Spring et est utilisé pour fournir un contrôle d'accès basé sur l'expression avant l'exécution de la méthode.
@PostAuthorize supporte le langage d'expression Spring et est utilisé pour fournir un contrôle d'accès basé sur l'expression après l'exécution de la méthode (fournit la possibilité d'accéder au résultat de la méthode).
@PreFilter supporte le langage d'expression Spring et est utilisé pour filtrer la collection ou les tableaux avant l'exécution de la méthode en fonction des règles de sécurité personnalisées que nous définissons.
@PostFilter supporte le langage d'expression Spring et est utilisé pour filtrer la collection ou les tableaux retournés après l'exécution de la méthode en fonction des règles de sécurité personnalisées que nous définissons (fournit la possibilité d'accéder au résultat de la méthode).
@Secured ne supporte pas le Spring Expression Language et est utilisé pour spécifier une liste de rôles sur une méthode.
@RolesAllowed ne supporte pas le langage d'expression de Spring et est l'annotation JSR 250 équivalente à l'annotation @Secured.
Ces annotations sont désactivées par défaut et peuvent être activées dans notre application comme suit :

@EnableWebSecurity
@EnableGlobalMethodSecurity(
    securedEnabled = true,
    jsr250Enabled = true,
    prePostEnabled = true
)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // Details omitted for brevity

}

securedEnabled = true active l'annotation @Secured.
jsr250Enabled = true active l'annotation @RolesAllowed.
prePostEnabled = true active les annotations @PreAuthorize, @PostAuthorize, @PreFilter, @PostFilter.

Après les avoir activées, nous pouvons appliquer des politiques d'accès basées sur les rôles sur nos points de terminaison d'API comme ceci :

@Api(tags = "UserAdmin")
@RestController @RequestMapping(path = "api/admin/user")
@RolesAllowed(Role.USER_ADMIN)
public class UserAdminApi {

    // Details omitted for brevity

}

@Api(tags = "Partner")
@RestController @RequestMapping(path = "api/partner")
public class AuthorApi {

    // Details omitted for brevity

    @RolesAllowed(Role.PARTNER_ADMIN)
    @PostMapping
    public void create() { }

    @RolesAllowed(Role.PARTNER_ADMIN)
    @PutMapping("{id}")
    public void edit() { }

    @RolesAllowed(Role.PARTNER_ADMIN)
    @DeleteMapping("{id}")
    public void delete() { }

    @GetMapping("{id}")
    public void get() { }

    @GetMapping("{id}/product")
    public void getProducts() { }

    @PostMapping("search")
    public void search() { }

}

@Api(tags = "Product")
@RestController @RequestMapping(path = "api/product")
public class BookApi {

    // Details omitted for brevity

    @RolesAllowed(Role.PRODUCT_ADMIN)
    @PostMapping
    public BookView create() { }

    @RolesAllowed(Role.PRODUCT_ADMIN)
    @PutMapping("{id}")
    public void edit() { }

    @RolesAllowed(Role.PRODUCT_ADMIN)
    @DeleteMapping("{id}")
    public void delete() { }

    @GetMapping("{id}")
    public void get() { }

    @GetMapping("{id}/partner")
    public void getPartners() { }

    @PostMapping("search")
    public void search() { }

}

Veuillez noter que les annotations de sécurité peuvent être fournies tant au niveau de la classe qu'au niveau de la méthode.

Les exemples démontrés sont simples et ne représentent pas des scénarios réels, mais Spring Security fournit un ensemble riche d'annotations, et vous pouvez gérer un schéma d'autorisation complexe si vous choisissez de les utiliser.

Nom du rôle Préfixe par défaut

Dans cette sous-section distincte, je veux souligner un autre détail subtil qui déroute beaucoup de nouveaux utilisateurs.

Le framework Spring Security différencie deux termes :

Autorité représente une permission individuelle.
Le rôle représente un groupe de permissions.
Les deux peuvent être représentés par une interface unique appelée GrantedAuthority et vérifiés ultérieurement avec le langage d'expression de Spring dans les annotations de Spring Security comme suit :

Authority : @PreAuthorize("hasAuthority('EDIT_PRODUCT')")
Role : @PreAuthorize("hasRole('PRODUCT_ADMIN')")
Pour rendre plus explicite la différence entre ces deux termes, le framework Spring Security ajoute par défaut un préfixe ROLE_ au nom du rôle. Ainsi, au lieu de vérifier la présence d'un rôle nommé PRODUCT_ADMIN, il vérifiera la présence de ROLE_PRODUCT_ADMIN.

Personnellement, je trouve ce comportement déroutant et je préfère le désactiver dans mes applications. Il peut être désactivé dans la configuration de Spring Security comme suit :

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // Details omitted for brevity

    @Bean
    GrantedAuthorityDefaults grantedAuthorityDefaults() {
        return new GrantedAuthorityDefaults(""); // Remove the ROLE_ prefix
    }

}

Les instructions répétitives avec For

NDONGO TONUX SAMB — Mon, 31 May 2021 12:31:02 +0000

Imaginez que vous ayez une partie du code que vous devez répéter plusieurs fois. Vous pouvez l’écrire autant de fois en mettant le même traitement dans le code. Cela pourrait faire l'affaire. Parfois vous ne connaissez pas la condition pour arrêter de faire ce traitement.
Les boucles permettent de résoudre ce problème !
En programmation, une boucle est une technique qui permet de répéter une ou plusieurs instructions sans avoir à écrire à nouveau le même ensemble d'instructions plusieurs fois.
Les itérations ( une boucle for) nous permette de répéter un traitement en bouclant ou itérant.
L'instruction boucle for permet d'exécuter un traitement de manière répétitive, mais en spécifiant différemment la condition d'arrêt. La boucle for définit trois types d’instructions séparées par des points-virgules. La première déclaration est la déclaration d’initialisation. La seconde définit la condition de terminaison. La dernière déclaration est la clause de mise à jour.
Si on veut exécuter une instruction ou un bloc de code un nombre précis et connu de fois, on va préférer utiliser l'instruction for.

 System.out.println(1);
 System.out.println(2);
 System.out.println(3);
 System.out.println(4);
 System.out.println(5);
 System.out.println("Done");

Commençons avec le même exemple que précédemment, c'est-à-dire le programme qui affiche les nombres entiers de 1 à 5, mais faisons le avec l'instruction for :

for (int i = 1; i <= 5; i++) {
   System.out.println(i);
}
System.out.println("Done");

l'instruction for commence par le mot réservé for suivi de trois éléments séparés par des points-virgules, le tout mis entre parenthèses, suivi du le corps de la boucle.

for (initialization; condition; increment/decrement)

Une variable de compteur est utilisée dans toutes ces parties. Cette variable garde la trace de la répétition en cours, et est typiquement nommée i.
La partie d'initialisation initialise la variable de compteur à une valeur de départ.
Dans ce cas (int i = 1), la valeur initiale est 1.
La partie condition indique à l'ordinateur s'il doit continuer à répéter ou non. L'ordinateur évalue la condition à chaque fois, et si l'expression est vraie, il exécute les instructions intérieures. Dans le cas contraire, il sort entièrement de la boucle.
Dans ce cas (i <= 5), la condition vérifie si la variable compteur est inférieure ou égale à 5.
La partie incrémentation/décrémentation modifie la variable du compteur après chaque répétition.

La boucle la plus courante que vous verrez en programmation commencera à 0, s'arrêtera avant un certain nombre et s'incrémentera de un à chaque fois. Cependant, en variant les parties de la boucle, nous pouvons créer des boucles qui se répètent de nombreuses autres façons.
Par exemple, ce programme utilise une boucle for pour décompter de 10 à 1 :

for (int i = 10; i > 0; i--) {
   System.out.println(i);
}

Remarquez les différences :

Dans l'initialisation, nous donnons à la variable compteur la valeur 10.
Dans la condition, nous vérifions si la variable compteur est supérieure à 0.
Cela signifie que la dernière répétition aura lieu lorsque la variable compteur sera égale à 1, et l'ordinateur quittera alors la boucle.
Dans la dernière partie, nous diminuons de 1 la variable compteur.

Voici un autre exemple, une boucle for qui affiche les nombres pairs de 0 à 40 :

for (int i = 0; i <= 40; i += 2) {
    System.out.println(i);
}

Cette boucle démarre à 0, mais diffère autrement :
La condition vérifie si la variable compteur est inférieure ou égale à 40. Cela signifie que cette boucle affichera 40. Si elle était seulement inférieure à, elle s'arrêterait à 39.
La dernière partie ajoute 2 à la variable compteur, et non 1 comme d'habitude.
La flexibilité de la boucle for signifie que nous pouvons programmer de nombreux types de répétitions avec elle. Mais attention, cette flexibilité facilite aussi les erreurs !

Boucles imbriquées

Une boucle imbriquée nous permet de répéter selon deux dimensions.
Explorons cela dans un exemple de codage. Que faire si nous devons apprendre tous les tables de multiplication des chiffres de 1 à 10 ? Les boucles imbriquées à la rescousse !

for (int i = 1; i <= 10; i++) {
  for (int j = 1; j <= 10; j++) {
    System.out.println(i+"x"+j+"="+ i * j);
  }
}

Dans notre prochain cours, on va voir une autre manière de faire une instruction répétitive. Pour le moment, vous pouvez rendre plus joli l'affichage du résultat. A vous de jouer.

Cours : Débuter avec le Langage Java

NDONGO TONUX SAMB — Mon, 31 May 2021 12:08:48 +0000

À la fin de ce tutoriel, vous aurez les premières bases nécessaire pour débuter la programmation avec Java et d'écrire vos premiers programmes en Java.

Chapitre 1 : Introduction à Java
Chapitre 2 : Variables et type de données
Chapitre 3 : Récupérer les informations saisies au clavier
Chapitre 4 : les conditions
Chapitre 5 : Les instructions répétitives 1/2

------ A venir ----------
Chapitre 6 : Les instructions répétitives 2/2
Chapitre 7 : Les tableaux
Chapitre 8 : Les tableaux à plusieurs dimension
Chapitre 9 : Les Fonctions/Méthodes
Chapitre 10: Conclusion

Les Conditions

NDONGO TONUX SAMB — Mon, 31 May 2021 12:07:17 +0000

Nous prenons sans arrêt des décisions dans la vie : Si tu prend cette voiture, je ferais ceci ; sinon, je ferai autre chose. Java possède une clause qui évalue une expression donnée pour savoir si sa valeur est true ou false.
Selon la valeur de cette expression, l'exécution de votre programme prend une direction ou une autre ; seule la portion de code correspondante est exécutée.
Si l'expression retourne true, Java exécute le code compris entre les deux premières accolades, sinon, il va directement au code suivant la clause else.

Par exemple, si un visiteur a un température supérieur à 37 degrés il sera refusé l’accès au magasin sinon il sera autorisé à entrer dans le magasin.

// Tester qui va rentrer dans le magasin suivant sa température
if (temperature > 37) {
    System.out.println("Tu as trop de fièvre. Va faire un test covid");
   }
else {
       System.out.println("Tu peux rentrer dans le magasin");
   }

Parfois, pour prendre une décision, il peut être nécessaire de vérifier plus d'une expression conditionnelle.

Par exemple, si la marque de voiture est "Renault" ou "Peugeot", ne pas ajouter de taxe d'Etat au prix du voiture. C'est un cas d'emploi du ou logique.
En Java, un ou logique est représenté par une ou deux barres verticales (| ou ||) . Ca fonctionne comme ceci : si l'une quelconque des conditions est vraie, le résultat de l'expression dans son ensemble vaut true.

if (marque.equals("Renault") | marque.equals("Peugeot"))

Tu peux aussi écrire ceci en utilisant deux barres verticales :

if (marque.equals("Renault") || marque.equals("Peugeot"))

Le et logique (logical and) est représenté par un ou deux "et commercial" (&&) et l'expression dans son ensemble vaut true si
chacune de ses parties vaut true.
Par exemple, imputer les taxes
commerciales uniquement dans le cas où la marque est "Ford" et où le
prix est supérieur à 12500. Les deux conditions doivent être vraies en
même temps :

if (marque.equals("Ford") && prix > 12500)

if (marque.equals("Ford") & prix > 12500)

Le non logique (logical not) est représenté par le point d'exclamation et donne à l'expression le sens opposé. Par exemple, si tu veux effectuer certaines actions uniquement si la marque n'est pas "Mercedes", utilise cette syntaxe :

if (!marque.equals("Mercedes")){
//
}

Voici un autre exemple: les deux expressions suivantes produiront le même résultat :

if (prix < 12500){
//
}

if (!(prix >= 12500)){
//
}

Le non logique est ici appliqué à l'expression entre parenthèses.

Opérateur ternaire

Il existe une autre forme de la clause if : l'opérateur conditionnel ou opération ternaire. On l'utilise pour affecter une valeur à une variable en fonction d'une expression terminée par un point d'interrogation. Si l'expression est vraie, la valeur suivant le point d'interrogation est utilisée ; sinon, la valeur suivant les deux points est affectée à la variable située à gauche du signe égal.

String name = "WERNER"; // Le nom d'un joueur
String playerName = name.equals("WERNER") ? " Not Found" : name ;
System.out.println("Player is : "+playerName);

L'opérateur ternaire Java fonctionne comme une instruction if Java simplifiée

remise = prix > 50 ? 10 : 5;

Si le prix est supérieur à 50, la variable remise prend la valeur 10 ;
sinon, elle vaut 5. C'est juste un raccourci pour exprimer une clause if normale :

if (prix > 50) {
   remise = 10;
}
else {
   remise = 5;
}

Tu peux construire des clauses if plus complexes avec plusieurs blocs else if

if (noteDevoir >= 18) {
   niveau = 'E';
}
else if (noteDevoir >= 16 && noteDevoir < 18) {
   niveau = 'T';
}
else if (noteDevoir >= 14 && noteDevoir < 16) {
   niveau = 'B';
}
else if (noteDevoir >= 12 && noteDevoir < 14) {
   niveau = 'A';
}
else if (noteDevoir >= 10 && noteDevoir < 12) {
   niveau = 'P';
}
else {
   niveau = 'I';
}

La clause switch peut parfois être utilisée comme alternative à if.
L'expression après le mot-clé switch est évaluée et le programme va directement au case (cas) correspondant

switch (tonNiveau) {
   case 'E':
       System.out.println("Excellent travail !");
       break;
   case 'T':
       System.out.println("Très bon travail !");
       break;
   case 'B':
       System.out.println("Bon travail !");
       break;
   case 'A':
       System.out.println("Tu peux mieux faire !");
       break;
   case 'P':
       System.out.println("Tu dois travailler plus !");
       break;
   case 'I':
       System.out.println("Change d'attitude !");
       break;
}

prochain chapitre: Les instructions répétitives avec For

Introduction à Java

NDONGO TONUX SAMB — Mon, 31 May 2021 12:05:01 +0000

Bienvenue à ce tutoriel Introduction à la programmation Java.
Nous allons voir pas à pas comment créer des programmes avec Java.
Ce tutoriel est pour tous ceux qui débutent en programmation ou pour ceux qui cherchent à assimiler les bases de Java.

À la fin de ce tutoriel, vous serez capable d’écrire un programme avec l’aide de Java pour résoudre un problème donné.
Vous serez en mesure de réfléchir à la solution à mettre en place pour le traduire en programme et dérouler l'exécution pour voir si ça répond bien à votre besoin. Un programme est tout simplement une liste d’instructions écrites pour résoudre un problème, ou pour effectuer une action.

Il faut savoir que l’ordinateur ne comprend que des 1 et des 0 donc difficile de parler avec lui. Il faut dans ce cas utiliser un traducteur qui est un langage de programmation. Un langage, qui comprend ce que vous lui dites, convertit tout cela en 0 et 1 parfaitement compréhensible par l’ordinateur.

Et Java fait partie de cette famille de langage de programmation.

Il a été créé en 1995 par Sun racheté par Oracle en 2009. Le langage est créé à la base pour être utilisé dans des systèmes embarqués. Mais on le retrouve actuellement plus dans les logiciels, les applications web, les applications mobiles, etc.
Le langage bénéficie d’une excellente portabilité : une fois le programme créé, il fonctionne automatiquement partout (Windows, Mac, Linux, etc.). En fait, les programmes Java ne savent même pas où ils s’exécutent, car ils le font à l’intérieur d’une enveloppe logicielle spéciale appelée Machine Virtuelle Java.

Java est passé en 2006 sous Licence open source Licence GPL.

Pourquoi apprendre Java :

- Son grand succès dans les années 90 ;

- les outils très riches, variés et matures dont ils disposent ;

- Sa très grande communauté, qui permet de facilement trouver de l'aide si besoin ;

- Sa facilité de prise en main.

Pour créer un programme Java qui marche, vous devez passer par les 3 étapes suivantes :

- Ecrire le programme et l’enregistrer sur un fichier.

- Compiler le programme pour le transformé en code compréhensible par votre ordinateur

- Exécuter le programme.

On va écrire notre premier programme qui sera de demander à l’ordinateur de dire bonjour.

class HelloWorld {
   public static void main( String []args ) {
       System.out.println( "Hello World!" );
   }
}

Ne vous en faites pas j’expliquerai comment fonctionne ce programme un peu plus tard dans le tutoriel.

On va compiler le programme. Si tout se passe bien on aura un fichier helloWord.class qui sera généré et contiendra le code binaire communément appelé bytecode. S’il y a des erreurs de syntaxe dans ton programme, par exemple si vous avez oublié la dernière accolade fermante, le compilateur Java affichera un message d’erreur. Il te faudra alors corriger l’erreur et recompiler le programme. S’il y a plusieurs erreurs, vous pouvez avoir besoin de répéter ces actions à plusieurs reprises
Maintenant on peut exécuter notre programme qui affichera Hello World!.

On va utiliser aussi le JShell qui va nous permettre de facilement tester différentes fonctionnalités de Java, sans avoir à créer tout un programme pour cela. C'est un gros gain de temps !

jshell> System.out.println("Hello Tonux");
Hello Tonux
jshell>

Dans ce tutoriel on a mis en place les outils de base permettant d'écrire, de compiler et d'exécuter du code Java. Dans notre prochaine chapitre nous allons voir comment débuter avec Java en commençant par les variables et les types de données.

prochain chapitre: Les variables et type de données en java

Récupérer les informations saisies au clavier

NDONGO TONUX SAMB — Mon, 31 May 2021 11:10:12 +0000

Dans ce tutoriel, nous allons voir comment accepter les entrées de l'utilisateur. Nous utilisons la classe Scanner pour obtenir l'entrée. Dans l'exemple ci-dessous, nous recevons une entrée de type String, integer et float. Pour cela, nous utilisons les méthodes suivantes :

1) public String nextLine() : Pour obtenir l'entrée String
2) public int nextInt() : Pour l'entrée d'un nombre entier
3) public float nextFloat() : Pour l'entrée des flottants

import java.util.Scanner;

class GetInputData
{
  public static void main(String args[])
  {
     int num;
     float fnum;
     String str;

     Scanner in = new Scanner(System.in);

     //Obtenir la chaîne d'entrée
     System.out.println("Saisir une chaine: ");
     str = in.nextLine();
     System.out.println("La chaine saisie est: "+str);

     //Get input Integer
     System.out.println("Saisir un entier: ");
     num = in.nextInt();
     System.out.println("L'entier saisi est: "+num);

     //Get input float number
     System.out.println("Entrez un numéro de flottant: ");
     fnum = in.nextFloat();
     System.out.println("Le numéro de flottant est : "+fnum); 
  }
}

Sortie sur la console.

Saisir une chaine: 
Astou
La chaine saisie est: Astou
Saisir un entier: 
313
L'entier saisi est: 313
Entrez un numéro de flottant: 
12.56
Le numéro de flottant est: 12.56

Sans plus tardé, on va maintenant voir comment faire des conditions avec Java.

prochain chapitre: les conditions

Les variables et type de données en java

NDONGO TONUX SAMB — Mon, 31 May 2021 10:55:49 +0000

Commençons par mettre en place les bases qui vont nous permettre d’écrire petit à petit un programme Java.
Nous allons commencer par les variables, notion fondamentale en développement. Le but d'un programme est de faire quelque chose avec des données ou, en d'autres termes, avec les choses que vous mettez dans votre programme. Souvent, votre programme utilisera une ou plusieurs variables pour manipuler les données. Les variables sont des éléments essentiels à tout programme. Une variable est un contenant utilisé pour stocker une information dont votre programme pourrait avoir besoin plus tard.

Le nom d'une variable doit refléter la signification de son contenu. En Java, les noms de variables ne peuvent pas commencer par un chiffre ni contenir d’espaces.

Une variable est composée de trois éléments : nom, valeur et type.
Les valeurs des variables peuvent être modifiées.
Les variables à valeurs constantes sont appelées constantes.
Les variables de nom doivent respecter les conventions de dénomination courantes.

Les types des données.

Vous avez vu qu’on peut stocker des valeurs dans des variables et qu’on peut les manipuler facilement. Mais avec toutes les variables “typées”, il n’est pas possible de réaliser des opérations arithmétiques.
Il y a huit types de données simples, ou primaires en Java, et vous devez décider lequel utiliser en fonction du type et de la taille des données que vous avez l’intention de stocker dans chaque variable :

Quatre types de données pour les valeurs entières: byte, *short, *int et *long.
Deux types de données pour les valeurs décimales: float et double.
Un type de données qui permet de stocker un caractère isolé: char.
Un type de données logique nommé boolean qui autorise seulement deux valeurs : true (vrai) ou false (faux).

On peut affecter une valeur initiale à une variable lors de sa déclaration. On parle alors d’initialisation de la variable

char lettre = 'B';
int filles = 12;
boolean estMajeur = false;
double budgetNational = 50063494965745.78;
float prixVoiture = 12500.50f;
long totalPopulation = 4637283648392l;

Il y a aussi le mot-clé spécial final ; s’il est utilisé dans la déclaration d’une variable, on ne peut affecter de valeur à cette variable qu’une fois, cette valeur ne pouvant plus être modifiée par la suite. Dans certains langages, les variables invariantes sont appelées constantes.
En Java les noms des variables invariantes sont généralement écrits en lettres majuscules :

final String CAPITALE = "DAKAR";

Outre les types de données primaires, on peut aussi utiliser les classes Java pour déclarer des variables. A chaque type de données primaires correspond une classe enveloppe, par exemple Integer, Double, Boolean, etc. Ces classes possèdent des méthodes utiles pour convertir les données d’un type à un autre. Alors que le type de données char est utilisé pour stocker un caractère isolé, Java a aussi une classe String permettant de manipuler un texte plus long, par exemple :

String ville = "Touba";

Vous pouvez continuer à utiliser jshell pour essayer les différentes opérations et vous familiariser avec les variables et les types de données. On se retrouve dans notre prochaine chapitre pour voir comment récupérer les informations saisies par l’utilisateur depuis le clavier.

prochain chapitre: Récupérer les informations saisies au clavier

Python, the 5 libraries that make the buzz

NDONGO TONUX SAMB — Mon, 14 Dec 2020 19:51:41 +0000

Python is a powerful science package fair, the choice of the Python Big Data couple is justified by its robust packages that meet the data science and analytical needs of programs.

Some of the top libraries that contribute to the popularity of Python include :

1. Tensorflow

Tensorflow is the best known library for high performance computing.

This library deals with calculations involving tensors and is used in various scientific fields.

Applications of tensorflow include :

* Image and Voice Recognition.
* Video detection.
* Text based applications.

This library is mainly characterised by :

* Parallel Computing to run complex programs.
* Error reduction with a rate of up to 60% for machine  learning problems.
* Updating and resolution of very frequent bugs.

2. Numpy

It is the fundamental module of numerical calculation in Python.

It enables the processing of high-performance multidimensional arrays of objects.

Numpy also manages the problem of slowness by providing functionalities and methods that work efficiently on these arrays.

The numpy module's applications are numerous, such as :

* Data analysis.
* Father module of some other libraries such as Scipy or matplotlib .
* Creates powerful N dimensional tables.
* Application with Matlab.

The strength of the numpy module is justified by :

* Fast precompiled functions for basic calculations.
* Supports the object-oriented approach.
* Table programming oriented for better results.

3. Scipy

Here we are at the Scipy library, it is more Data Science oriented.

It comes from the numpy module.

SciPy is a library widely used in Big Data for scientific and technical computing.

This library contains different modules for :

* Optimisation.
* Linear algebra.
* Interpolation.
* Image and signal processing.

Scipy is characterized by :

* Multidimensional image processing tools.
* Predefined functions to solve differential equation problems.
* Advanced features for data manipulation and visualisation.

4. Pandas

Pandas is an essential module in data processing.

It is one of the most popular libraries in Data Science.

Pandas provides a wide variety of data structures that are easy to manipulate.

Among the applications of this library are :

* ETL: the process of extracting, transforming and storing data.
* Data cleansing and visualisation.
* Widely used in studies of customer behaviour in marketing.

5. Matplotlib

Finally we present you Matplotlib, or the library of your tracings.

It allows you to draw 2D diagrams so that you can visualise the results.

These diagrams can be plots, bar charts, histograms, power spectra, diffusion plots or more.

This module has several applications including :

* The visualisation of the correlation between variables.
* Visualisation of the distribution of data .
* Visualisation of model confidence intervals up to the 95% level .

NB : A tip, try to understand what is in every library it is not enough to use only