Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD (partie 1)

Bon après-midi. Dans cet article, j'aimerais partager ma première rencontre avec des éléments comme Maven, Spring, Hibernate, MySQL et Tomcat en train de créer une application CRUD simple. Ceci est la première partie de 4. L'article est principalement destiné à ceux qui ont déjà terminé 30 à 40 niveaux ici, mais qui ne se sont pas encore aventurés au-delà du Java pur et qui commencent tout juste (ou sont sur le point de commencer) à entrer dans le monde ouvert avec toutes ces technologies, frameworks et autres mots inconnus.

Contenu:

• Introduction
• Créer un projet
• Connexion MVC à ressort
• Création de pages et de contrôleur
• Configuration
• Modèle
• Modèle Vue Contrôleur

Introduction

J'ai commencé à me familiariser avec des technologies et des frameworks qui étaient nouveaux pour moi en étudiant divers exemples dans lesquels ils ont été utilisés, car généralement je comprends mieux quelque chose lorsque je le vois en action en utilisant un exemple d'application à part entière. En règle générale, ces exemples sont des applications CRUD ( Créer , Lire , Mettre à jour, Supprimer ), Internet regorge de tels exemples de différents degrés de complexité. Le problème est qu'ils n'expliquent généralement pas en détail comment, quoi et pourquoi cela a été fait là-bas, pourquoi telle ou telle dépendance a été ajoutée, pourquoi telle ou telle classe est nécessaire, etc. Dans la plupart des cas, ils prennent une application complètement terminée, avec un fichier POM final, avec les versions finales des classes, et les parcourent simplement, sans se concentrer sur les petites choses qui semblent probablement évidentes à une personne expérimentée. J'ai examiné de nombreux exemples de ce type et la manière dont tout fonctionne est généralement claire, mais la manière dont ils en sont arrivés à cela n'est pas tout à fait claire. Par conséquent, j'ai décidé qu'un tel exemple serait utile non pas du point de vue d'un développeur expérimenté, mais du point de vue d'un débutant qui n'a jamais eu affaire à Spring, Hibernate et autres. Je vais essayer de décrire le plus en détail possible (dans la mesure où ma compréhension me le permet) tout mon parcours de création d'une application CRUD, en commençant par quelque chose au niveau Hello World le plus simple. Tout d'abord, je fais cela pour moi, car lorsque vous essayez de décrire, de raconter, d'expliquer quelque chose, cela est beaucoup mieux absorbé et organisé dans votre tête. Mais si cela est utile à quelqu'un et l'aide à comprendre quelque chose, j'en serai très heureux. Dans cet exemple, essayons de créer une application CRUD simple en utilisant Maven , Tomcat , Spring , Hibernate et MySQL . Étapes préliminaires telles que l'installation de Maven , MySQL , l'utilisation de la version Ultimate de l'idée, etc. Je pense qu'il n'est pas nécessaire de décrire en détail, cela ne devrait poser aucun problème. Il est à noter que dans cet exemple, la configuration sera configurée à l'aide de classes Java (appelées JavaConfig) sans utiliser XML.

Créer un projet

Donc, puisque je suis un débutant, nous n’utiliserons aucun archétype obscur. Spring initializr semble toujours trop effrayant. Par conséquent, nous allons créer le projet Maven simple le plus ordinaire. Je n'ai pas de nom de domaine, donc dans groupid j'écrirai juste testgroup, et dans artificialid j'écrirai le nom, par exemple filmography(ce sera une liste de films). Nous créons un projet et choisissons Enable auto-importquand l'idée le suggère. Grâce à cela, chaque fois que nous apportons des modifications au fichier POM (Project Object Model, ce fichier décrit toute la structure du projet Maven), tout sera immédiatement automatiquement appliqué au projet. Les bibliothèques seront extraites de notre référentiel local si nous les avons déjà, ou si nous utilisons de nouvelles dépendances que nous n'avons pas traitées auparavant, Maven les téléchargera simplement via Internet depuis le référentiel central. Maven dispose également d'une fonction pour télécharger des sources et de la documentation (Télécharger les sources et/ou la documentation). C'est également très pratique, si quelque chose n'est pas clair avec une classe ou une méthode, vous pouvez accéder au code source et voir comment tout cela fonctionne à l'intérieur. Ajoutons quelques détails. Ce sera une application Web et nous utiliserons Tomcat . Pour déployer une application sur Tomcat, vous devez y transférer sous la forme d'une archive de guerre (Web Application Resource, un format spécial pour les applications Web). Pour cela, ajoutez la ligne suivante au fichier POM afin que l'application soit compilée dans une archive war :

<packaging>war</packaging>

Eh bien, vous aurez également besoin d'un répertoire spécial pour les sources Web, dans notre cas, il y aura des pages jsp et quelques ressources Web. Créons un mainrépertoire webapp. Il doit s'appeler exactement ainsi et être localisé exactement de mainla même manière que java, resourcescar il s'agit de la structure de répertoires Maven standard. Une fois que nous aurons installé le package waret déterminé qu'il s'agit d'un projet Web, le répertoire webappsera automatiquement marqué comme sources d'application Web (il y aura un point bleu dessus) et tout ce qui concerne le Web sera recherché dans ce dossier. Et un instant. Par défaut, Maven utilise la version 1.5 du langage, mais je souhaite utiliser, par exemple, la version 1.8 - Java 8 (vous pouvez prendre 10 ou 11, mais il n'est toujours pas prévu d'utiliser des fonctionnalités à partir de là, alors que ce soit 8 ). Cela peut être résolu très simplement, nous écrivons dans Google quelque chose comme « Maven java 8 » et voyons ce qui doit être ajouté au fichier POM pour que Maven compile nos classes pour la version requise. En conséquence, nous avons ce qui suit :

Connexion MVC à ressort

Tu dois commencer quelque part. Selon le plan, nous connecterons la base de données et utiliserons Hibernate, mais tout cela semble un peu trop effrayant pour l'instant. Nous devons d’abord faire quelque chose de plus simple. Spring MVC, c'est déjà mieux, nous connaissons le modèle MVC depuis longtemps, il a été utilisé dans la moitié des grosses tâches du cours. De là, nous commencerons à danser. Pour créer une application Web avec Spring MVC, nous avons également besoin d'une Servlet-API, c'est-à-dire cette chose à l'aide de laquelle l'interaction demande-réponse aura lieu. Essayons de relier cela. Nous allons sur Google, recherchons les dépendances nécessaires dans le référentiel Maven et les ajoutons au fichier pom.xml. Dans la section Bibliothèques externes, vous pouvez voir que non seulement spring-webmvc a été chargé , mais aussi un tas d'autres choses. Ceux. nous n'avons pas besoin d'inclure en plus des dépendances pour spring core , context , beans , etc. dont nous avons besoin, tout ce dont nous avions besoin a été récupéré avec spring-webmvc . Encore une remarque. Que signifie provideddépendre javax.servlet-api? Scope est la portée de la dépendance, providedce qui signifie que la dépendance sera disponible au stade de la compilation et du test de l'application, mais elle ne sera pas archivée. Le fait est que pour déployer l'application, nous utiliserons un conteneur de servlet, Tomcat, et il contient déjà de telles bibliothèques, il n'est donc pas nécessaire de les transférer là-bas et de surcharger l'archive d'une charge inutile. Pour l’avenir, pour la même raison, nous nous passerons de la méthode habituelle main, car elle existe déjà dans Tomcat.

Création de pages et de contrôleur

Essayons maintenant de concocter quelque chose de simple. Tout d'abord, créons un webapprépertoire supplémentaire, par exemple pages, dans lequel nos vues seront stockées, c'est-à-dire jsp pages et créez quelques pages. Nous aurons besoin d'une page sur laquelle, à l'avenir, une liste de films sera affichée, par exemple films.jsp, et peut-être pourrons-nous créer une page séparée pour le montage, qu'il en soit ainsi editPage.jsp. Nous ne les remplirons pas de choses sérieuses pour l’instant ; juste pour tester, nous ferons un lien d’une page à une autre. Nous avons maintenant besoin d'une classe qui traitera les requêtes, c'est-à-dire manette. Ajoutons un nouveau package controlleret créons une classe dedans FilmController(en général, il n'est pas nécessaire de tout empaqueter dans différents packages, cette application sera très petite et simple, mais dans un projet normal, il peut y avoir de nombreux contrôleurs, classes de configuration, modèles , etc., donc même en commençant par de petits projets, il vaut mieux s'habituer immédiatement à tout faire de manière ordonnée et structurée pour qu'il n'y ait pas de gâchis). Dans ce cours, nous créerons des méthodes qui renverront nos vues en réponse aux requêtes.

package testgroup.filmography.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class FilmController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        return modelAndView;
    }

    @RequestMapping(value = "/edit", method = RequestMethod.GET)
    public ModelAndView editPage() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("editPage");
        return modelAndView;
    }
}

À quoi ça sert? Spring MVC a quelque chose appelé DispatcherServlet. C'est comme le contrôleur principal, toutes les requêtes entrantes transitent par lui et il les transmet ensuite à un contrôleur spécifique. L'annotation @Controllerindique simplement à Spring MVC que cette classe est un contrôleur (enfin, logique en général), le répartiteur vérifiera les annotations @RequestMappingpour appeler la méthode appropriée. L'annotation @RequestMappingvous permet de définir des adresses pour les méthodes du contrôleur, par lesquelles elles seront disponibles dans le client (navigateur). Il peut également être appliqué à la classe du contrôleur pour définir, pour ainsi dire, l'adresse racine de toutes les méthodes. allFilms()Le paramètre de la méthode valueest défini sur " /", elle sera donc appelée immédiatement lorsque la combinaison http://host:port/ sera saisie dans le navigateur (c'est-à-dire que par défaut il s'agit de http://localhost:8080/ ou http ://127.0 .0.1:8080/ ). Le paramètre methodspécifie quel type de requête est pris en charge (GET, POST, PUT, etc.). Comme ici nous ne recevons que des données, GET est utilisé. Plus tard, lorsque les méthodes d'ajout et d'édition apparaîtront, il y aura déjà des requêtes POST. (D'ailleurs, au lieu d'une annotation @RequestMappingindiquant une méthode, vous pouvez utiliser des annotations @GetMapping, @PostMappingetc. @GetMappingde manière équivalente @RequestMapping(method = RequestMethod.GET)). Dans nos méthodes, nous créons un objet ModelAndViewet définissons le nom de la vue qui doit être renvoyée.

Configuration

Passons à la mise en place de la configuration. configCréons une classe dans le paquet WebConfig. Il n'aura qu'une seule méthode qui renvoie un objet de type ViewResolver, c'est l'interface nécessaire pour trouver une représentation par nom.

package testgroup.filmography.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "testgroup.filmography")
public class WebConfig {

    @Bean
    ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/pages/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

@Configurationindique à Spring que cette classe est une classe de configuration et contient les définitions et les dépendances beandes composants. Les beans sont des objets gérés par Spring. L'annotation est utilisée pour définir un bean @Bean. @EnableWebMvcvous permet d'importer la configuration Spring MVC à partir du fichier WebMvcConfigurationSupport. Vous pouvez également implémenter, par exemple, une interface WebMvcConfigurerqui comporte tout un tas de méthodes, et tout personnaliser à votre guise, mais nous n'avons pas besoin d'entrer dans les détails pour l'instant, les paramètres standards suffiront. @ComponentScanindique à Spring où rechercher les composants qu'il doit gérer, c'est-à-dire classes marquées d'une annotation @Componentou de ses dérivés tels que @Controller, @Repository, @Service. Ces annotations définissent automatiquement le bean de classe. Dans la méthode, viewResolver()nous créons son implémentation et déterminons où exactement chercher les représentations dans webapp. Par conséquent, lorsque dans la méthode du contrôleur nous définissons le nom " films" la vue sera trouvée comme " /pages/films.jsp" Nous avons donc une classe de configuration, mais pour l'instant, il s'agit simplement d'une sorte de classe séparée, cela n'affecte en rien notre application . Nous devons enregistrer cette configuration dans le contexte Spring. Pour cela, vous avez besoin d'une classe AbstractAnnotationConfigDispatcherServletInitializer. Dans le package, confignous créons son successeur, par exemple AppInitializer , et implémentons ses méthodes.

package testgroup.filmography.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

La dernière méthode enregistre les adresses et il existe 2 autres méthodes pour enregistrer les classes de configuration. Les configurations Web, où ViewResolverles ' et autres sont définis, sont placées dans getServletConfigClasses(). Il est préférable de lire tout cela dans la documentation et divers guides, mais dans notre cas, il n'est pas encore nécessaire d'approfondir cela, le nôtre, WebConfigen principe, peut être RootClassesdéfini dans les deux, vous pouvez même définir les deux à la fois, cela fonctionnera toujours . Encore une chose. Il peut y avoir des problèmes d'encodage lorsque, lors de l'envoi de valeurs avec des caractères russes à partir du formulaire, le résultat sera des gribouillis. Pour résoudre ce problème, nous ajouterons un filtre qui prétraitera les demandes. Nous allons dans la classe AppInitializer et remplaçons la méthode getServletFilters, dans laquelle nous indiquons l'encodage souhaité, il doit bien sûr être le même que partout ailleurs, comme sur les pages et dans la base de données :

protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        return new Filter[] {characterEncodingFilter};
    }

Eh bien, tout semble être configuré, vous pouvez essayer de l'exécuter et voir ce qui se passe. Exécuter -> Exécuter -> Modifier les configurations -> Ajouter une nouvelle configuration -> Serveur Tomcat -> Local Ensuite, vous devez sélectionner un artefact à déployer. L'idée elle-même donnera un indice. Attention : aucun artefact marqué pour le déploiement . Cliquez sur le bouton Réparer et sélectionnez ... : la guerre a explosé . Ou vous pouvez aller dans Déploiement -> ajouter -> Artefact -> ...: la guerre a explosé . Et vous devez également accéder à Déploiement et définir le champ contextuel Applecation (cela fera partie de l'adresse URL où l'application sera disponible dans le navigateur) sur " /". Notre application sera alors immédiatement disponible sur http://localhost:8080/ (mais vous pouvez également y spécifier quelque chose, par exemple " /filmography", et il vous suffira ensuite de l'ajouter à toutes les adresses, c'est-à-dire par exemple qu'il n'y aura pas " http://localhost:8080/edit" , mais ce sera "http://localhost:8080/filmography/edit" ). Cliquez sur Exécuter et attendez qu'il démarre. Voici ce que j'ai obtenu : tout semble aller bien, mais il y a une mise en garde. Le fait est que nos pages sont désormais accessibles au public et sont accessibles directement en écrivant le chemin dans la barre d'adresse. Nous entrons http://localhost:8080/pages/films.jsp et maintenant nous avons reçu notre page à l'insu du contrôleur. D'une manière ou d'une autre, ce n'est pas très correct, nous allons donc créer un webapprépertoire spécial WEB-INF. Ce qu'il y a à l'intérieur sera caché au public et ne sera accessible que via un contrôleur. Nous plaçons le répertoire avec nos vues ( pages) dans WEB-INF, et ViewResolverl'ajoutons en conséquence au préfixe :

viewResolver.setPrefix("/WEB-INF/pages/");

Maintenant, nous obtenons notre page à l'adresse http://localhost:8080 , mais si nous essayons directement d'accéder à http://localhost:8080/WEB-INF/pages/films.jsp, nous obtenons une erreur 404. Eh bien, super, nous avons le l'application web la plus simple, Hello World comme on dit. La structure du projet ressemble actuellement à ceci :

Modèle

Nous avons déjà des vues et un contrôleur, mais dans MVC il y a aussi une 3ème lettre, donc pour compléter le tableau, nous ajouterons également un modèle. Dans le package, modelcréons Filmpar exemple une classe avec les champs suivants : int id, String title(titre), int year(année de sortie), String genre(genre) et boolean watched(c'est-à-dire avez-vous déjà regardé ce film ou non).

package testgroup.filmography.model;

public class Film {
    private int id;
    private String title;
    private int year;
    private String genre;
    private boolean watched;
// + Getters and setters
}

Rien de spécial, juste une classe ordinaire, des champs privés, des getters et setters. Les objets de ces classes sont également appelés POJO(Plain Old Java Object), eh bien, c'est-à-dire "objet Java simple". Essayons maintenant de créer un tel objet et de l'afficher sur la page. Pour l’instant, nous ne nous soucierons pas trop de la façon de le créer et de l’initialiser. Pour l’essayer, créons-le bêtement directement dans le contrôleur, par exemple, comme ceci :

public class FilmController {
    private static Film film;

    static {
        film = new Film();
        film.setTitle("Inception");
        film.setYear(2010);
        film.setGenre("sci-fi");
        film.setWatched(true);
    }

Et ajoutez cet objet au nôtre ModelAndViewen utilisant la méthode addObject:

@RequestMapping(method = RequestMethod.GET)
    public ModelAndView allFilms() {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("films");
        modelAndView.addObject("film", film);
        return modelAndView;
    }

Nous pouvons maintenant afficher cet objet sur notre page. Au films.jsplieu de Hello World, nous écrirons ${film}et l'objet correspondant au nom de l'attribut " film" sera remplacé ici. Essayons de l'exécuter et voyons ce qui s'est passé (pour une sortie claire de l'objet, la classe Filma été redéfinie toString()) :

Modèle Vue Contrôleur

À ce stade, il semble que nous disposions déjà d'une application Spring MVC à part entière. Avant de continuer, il serait bon de tout revoir et de comprendre comment tout cela fonctionne. Sur Internet, vous pouvez trouver de nombreuses photos et schémas à ce sujet, j'aime bien celui-ci : Lorsque nous écrivons une demande dans la ligne du navigateur, elle est acceptée Dispatcher Servlet, puis il trouve un contrôleur approprié pour traiter cette demande HandlerMapping(il s'agit d'une interface pour sélectionner un contrôleur, vérifie lequel des contrôleurs disponibles a une méthode qui accepte une telle adresse) , appelle une méthode appropriée et Controllerrenvoie des informations sur la vue, puis le répartiteur trouve la vue souhaitée par son nom en utilisant ViewResolver'a, après quoi les données du modèle sont transférées vers cette vue et nous obtenons notre page en sortie. Quelque chose comme ça. A suivre... Présentation de Maven, Spring, MySQL, Hibernate et de la première application CRUD (partie 1) Présentation de Maven, Spring, MySQL, Hibernate et de la première application CRUD (partie 2) Présentation de Maven, Spring, MySQL, Hibernate et de première application CRUD (partie 3) Introduction à Maven, Spring, MySQL, Hibernate et la première application CRUD (partie 4)