Spring intègre MyBatis et SpringMVC
SpringMVC est un framework de couche de présentation qui traite les requêtes envoyées par le navigateur au serveur, répond avec des données au navigateur et gère les composants de la couche de contrôle. D'autres composants doivent être gérés par Spring, comme la couche de service.
MyBatis est un framework de couche de persistance qui nous aide à nous connecter à la base de données, à accéder à la base de données et à exploiter la base de données ;
Spring est un framework intégré IOC et AOP. Par exemple, SqlSession de SpringMVC peut être géré par Spring.
La non-intégration signifie laisser SpringMVC et Spring créer le même conteneur. L'intégration signifie que chacun gère ses propres composants.
Le composant de la couche Contrôleur de SpringMVC dépend de Spring. Spring gère le composant Service, il devrait donc y avoir un Service avant que la couche Contrôleur ne soit créée pour l'assembler automatiquement.
4.1、ContextLoaderListener
Les écouteurs et les filtres sont exécutés avant le servlet, ils peuvent donc être configurés
L'écouteur est la première méthode exécutée au démarrage du serveur, avant DispatcherServlet. Le conteneur IOC de Spring peut être créé via l'écouteur. Lorsque DispatcherServlet termine l'initialisation, obtenez le conteneur IOC et terminez l'initialisation du contrôleur.
Chargez le fichier de configuration Spring lorsque le serveur démarre pour obtenir le conteneur Spring IOC
Spring fournit l'écouteur ContextLoaderListener, qui implémente l'interface ServletContextListener et peut écouter
L'état de ServletContext, lorsque le serveur Web est démarré, lit le fichier de configuration Spring et crée le conteneur Spring IOC. la toile
L'application doit être configurée en web.xml
Il s'agit du code écrit par d'autres et l'emplacement est uniformément spécifié.
Configuré dans web.xml, classpath:spring.xml correspond au composant d'analyse configuré dans le spring.xml que nous avons créé.
Pourquoi des beans peuvent-ils être créés pour Spring dans SpringMVC (différents IOC peuvent-ils accéder les uns aux autres ?) ?
Dans le code source WebApplicationContext, il crée Spring comme conteneur parent
Le conteneur enfant peut accéder aux beans du conteneur parent (IOC dans SpringMVC peut accéder à IOC dans Spring)
<auditeur> <!--web.xml est configuré ici Configurer l'écouteur de Spring et charger le fichier de configuration de Spring au démarrage du serveur Emplacement et nom par défaut du fichier de configuration Spring :/WEB-INF/applicationContext.xml L'emplacement et le nom du fichier de configuration Spring peuvent être personnalisés via les paramètres de contexte ---> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </auditeur> <!--Personnalisez l'emplacement et le nom du fichier de configuration Spring. Le nom est le même que celui utilisé pour configurer SpringMVC--> <paramètre-contexte> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring.xml</param-value> </paramètre-contexte>
4.2. Travaux de préparation
①Créer un module Maven
②Importer les dépendances pom
<emballage>guerre</emballage>
<!--Il s'agit de la version Spring, la plus utilisée, elle gère les versions de chaque dépendance de manière unifiée-->
<propriétés>
<spring.version>5.3.1</spring.version>
</propriétés>
<dépendances>
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dépendance>
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>haricots de printemps</artifactId>
<version>${spring.version}</version>
</dépendance>
≪!--springmvc-->
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dépendance>
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dépendance>
<!--Pourquoi importez-vous toujours ce package jdbc Jar lorsque vous utilisez MyBatis ? Parce que le gestionnaire de transactions est dans Spring-jdbc-->
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dépendance>
<dépendance>
<!--aspects de la gestion du printemps-->
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dépendance>
<dépendance>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dépendance>
<!--Dépendances principales de Mybatis -->
<dépendance>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dépendance>
<!--Le package d'intégration de mybatis et spring (spring intègre le package d'intégration de MyBatis, par exemple en fournissant SqlSessionFactoryBean)-->
<dépendance>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dépendance>
<!-- Pool de connexions -->
<dépendance>
<groupId>com.alibaba</groupId>
<artifactId>druide</artifactId>
<version>1.0.9</version>
</dépendance>
<!-- test junit -->
<dépendance>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<portée>test</portée>
</dépendance>
<!--Pilote MySQL --->
<dépendance>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dépendance>
<!-- journal log4j --->
<dépendance>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dépendance>
<!--Plug-in de pagination https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dépendance>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dépendance>
<!-- Implémentation du log slf4j (façade) -->
<dépendance>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dépendance>
<!-- Le contrôleur frontal DispatcherServlet de ServletAPI SpringMVC hérite indirectement du HttpServlet dans Servlet,-->
<dépendance>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<portée>fourni</portée>
</dépendance>
<!--Dépendances pour le traitement de json dans SpringMVC-->
<dépendance>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.1</version>
</dépendance>
<!--Téléchargement de fichiers-->
<dépendance>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dépendance>
<!-- Package d'intégration Spring5 et Thymeleaf (Spring intègre le package d'intégration Thymeleaf) -->
<dépendance>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
<version>3.0.12.RELEASE</version>
</dépendance>
</dépendances>
③Créer un tableau
CRÉER UNE TABLE `t_emp` ( `emp_id` int(11) NON NULL AUTO_INCREMENT, `emp_name` varchar(20) NULL PAR DÉFAUT, `age` int(11) NULL PAR DÉFAUT, `sex` char(1) NULL PAR DÉFAUT, `email` varchar(50) NULL PAR DÉFAUT, CLÉ PRIMAIRE (`emp_id`) ) MOTEUR=InnoDB CHARSET PAR DÉFAUT=utf8
4.3. Configurer web.xml
<?version XML="1.0" encodage="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- Configurez le filtre d'encodage de Spring, et les requêtes et les réponses peuvent être filtrées --> <filtre> <nom-filtre>CharacterEncodingFilter</nom-filtre> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <nom-param>encodage</nom-param> <valeur-param>UTF-8</valeur-param> </init-param> <init-param> <nom-param>forceEncoding</nom-param> <valeur-param>true</valeur-param> </init-param> </filtre> <cartographie de filtre> <nom-filtre>CharacterEncodingFilter</nom-filtre> <modèle-url>/*</modèle-url> </filtrage-mapping> <!-- Configurer les filtres pour le traitement des méthodes de requête PUT et DELETE --> <filtre> <nom-filtre>HiddenHttpMethodFilter</nom-filtre> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filtre> <cartographie de filtre> <nom-filtre>HiddenHttpMethodFilter</nom-filtre> <modèle-url>/*</modèle-url> </filtrage-mapping> <!-- Configurer le contrôleur frontal SpringMVC --> <servlet> <nom-servlet>DispatcherServlet</nom-servlet> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--Définir l'emplacement et le nom du fichier de configuration SpringMVC --> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc.xml</param-value> </init-param> <chargement au démarrage>1</chargement au démarrage> </servlet> <servlet-mapping> <nom-servlet>DispatcherServlet</nom-servlet> <modèle-url>/</modèle-url> </servlet-mapping> <!-- Configurer l'écouteur de Spring et charger automatiquement le fichier de configuration de Spring au démarrage du serveur --> <auditeur> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </auditeur> <!-- Définir l'emplacement et le nom du fichier de configuration spécifié par Spring --> <paramètre-contexte> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring.xml</param-value> </paramètre-contexte> </application Web>
4.4. Créez le fichier de configuration SpringMVC et configurez-le
Seule la couche de contrôle doit être gérée par SpringMVC et le reste doit être géré par Spring.
<!--Analyser les composants (la couche de contrôle est gérée)--> <context:component-scan base-package="com.atguigu.ssm.controller"> </context:analyse des composants> <!--Configurer l'analyseur de vue--> <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver"> <property name="commande" valeur="1"/> <property name="characterEncoding" valeur="UTF-8"/> <nom de la propriété="templateEngine"> <bean class="org.thymeleaf.spring5.SpringTemplateEngine"> <property name="templateResolver"> <haricot class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver"> <nom de la propriété="préfixe" valeur="/WEB-INF/templates/"/> <nom de la propriété="suffixe" value=".html"/> <nom de la propriété="templateMode" valeur="HTML5"/> <property name="characterEncoding" valeur = "UTF-8" /> </haricot> </propriété> </haricot> </propriété> </haricot> <!-- Configurez le contrôle d'affichage pour accéder à la page d'accueil. Si DispatcherServlet ne peut pas le gérer, le gestionnaire de servlet par défaut suivant sera exécuté --> <mvc:chemin du contrôleur de vue="/" view-name="index"></mvc:view-controller> <!-- Configurer le servlet par défaut pour traiter les ressources statiques --> <mvc:gestionnaire-de-servlet par défaut /> <!-- Activer le pilote d'annotation MVC --> <mvc:piloté par annotations /> <!-- Configurer le contrôle d'affichage pour accéder à la page d'accueil --> <mvc:chemin du contrôleur de vue="/" view-name="index"></mvc:view-controller> <!--Traitement du téléchargement du fichier ; le fichier doit être analysé par l'analyseur de fichier pour le convertir en un objet MultipartFile. L'identifiant doit être défini sur cette valeur et le bean sous-jacent correspond à l'identifiant--> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> </haricot>
4.5. Créer l'environnement MyBatis
①Créez le fichier de propriétés jdbc.properties
jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC jdbc.username=root jdbc.password=132456
②Créez le fichier de configuration principal mybatis-config.xml de MyBatis
Tout le reste est configuré par Spring. Le plug-in peut cartographier le cas Camel ou être géré par Spring.
<?version XML="1.0" encodage="UTF-8" ?> <!Configuration DOCTYPE PUBLIC "-//mybatis.org//DTD Config 3.0//FR" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <paramètres> < <setting name="mapUnderscoreToCamelCase" valeur="vrai"/> </paramètres> <plugins> <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin> </plugins> </configuration>
MonBatis-config.xml
MyBatis est orienté vers les déclarations d'implémentation d'interface. Il vous suffit de créer une interface.
<?version XML="1.0" encodage="UTF-8" ?>
<!Configuration DOCTYPE
PUBLIC "-//mybatis.org//DTD Config 3.0//FR"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--
Les balises du fichier de configuration principal MyBatis doivent être configurées dans l'ordre spécifié :
propriétés ?, paramètres ?, typeAliases ?, typeHandlers ?,
objectFactory?,objectWrapperFactory?,reflectorFactory?,
plugins ?, environnements ?, databaseIdProvider ?, mappeurs ?
--->
<properties ressource="jdbc.properties"/>
<paramètres>
<setting name="mapUnderscoreToCamelCase" valeur="vrai"/>
</paramètres>
<typeAlias>
<nom du package=""/>
</typeAlias>
<!--
Environnements : Configurer l'environnement de connexion à la base de données
Attribut : default : définit l'identifiant de l'environnement utilisé par défaut
--->
<environnements par défaut="développement">
<!--environment : définir un environnement spécifique pour la connexion à la base de données-->
<environment id="développement">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<nom de la propriété="pilote" value="${jdbc.driver}"/>
<nom de la propriété="url" value="${jdbc.url}"/>
<property name="nom d'utilisateur" value="${jdbc.username}"/>
<nom de la propriété="mot de passe" value="${jdbc.password}"/>
</sourcededonnées>
</environnement>
<identifiant de l'environnement="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<nom de la propriété="pilote" value="com.mysql.cj.jdbc.Driver"/>
<nom de la propriété="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
<property name="nom d'utilisateur" value="racine"/>
<nom de la propriété="mot de passe" valeur="123456"/>
</sourcededonnées>
</environnement>
</environnements>
<!--Présentez le fichier de mappage de mybatis-->
<cartographes>
<nom du package=""/>
</cartographes>
</configuration>
<!-- Ce qui suit est une explication détaillée et des commentaires
<?version XML="1.0" encodage="UTF-8" ?>
<!Configuration DOCTYPE
PUBLIC "-//mybatis.org//DTD Config 3.0//FR"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!–
Les balises du fichier de configuration principal MyBatis doivent être configurées dans l'ordre spécifié :
propriétés ?, paramètres ?, typeAliases ?, typeHandlers ?,
objectFactory?,objectWrapperFactory?,reflectorFactory?,
plugins ?, environnements ?, databaseIdProvider ?, mappeurs ?
–>
<!–Introduisez le fichier de propriétés, puis vous pourrez accéder à la valeur de la même manière que celle utilisée dans le fichier actuel–>
<properties ressource="jdbc.properties"/>
<!–
TypeAliases : définir des alias de type, c'est-à-dire définir un alias pour un type spécifique
Dans le cadre de MyBatis, vous pouvez utiliser des alias pour représenter un type spécifique
–>
<typeAlias>
<!– type : définissez le type qui doit être alias. alias : définissez l'alias d'un certain type –>
<!–<typeAlias type="com.atguigu.mybatis.pojo.User" alias="abc"></typeAlias>–>
<!–Si l'alias n'est pas défini, le type actuel a un alias par défaut, qui est le nom de la classe et n'est pas sensible à la casse–>
<!–<typeAlias type="com.atguigu.mybatis.pojo.User"></typeAlias>–>
<!–Définissez l'alias de type via le package (écrivez uniquement typeAlias, sans écrire d'alias), tous les types sous le package spécifié auront tous des alias par défaut, qui sont des noms de classe et ne sont pas sensibles à la casse (il est recommandé d'écrire le nom de la classe)
Dans le développement futur, une table correspondra à une classe d'entité, une interface de mappage et un fichier de mappage, ce qui sera également gênant.
Bien qu'il existe de nombreuses classes d'entités, elles seront certainement placées sous le même package à l'avenir. À ce stade, vous pouvez définir le package correspondant à la classe d'entité sur la balise package. À ce stade, toutes les classes de ce package seront toutes avoir l'alias par défaut - c'est-à-dire que le nom de la classe n'est pas sensible à la casse (par exemple, lorsque l'utilisateur est utilisé, il peut être modifié)
–>
<nom du package="com.atguigu.mybatis.pojo"/>
</typeAlias>
<!–
Environnements : Configurer l'environnement de connexion à la base de données
Les attributs:
Par défaut : définir l'identifiant de l'environnement utilisé par défaut
–>
<environnements par défaut="développement">
<!–
Environnement : Mettre en place un environnement spécifique pour la connexion à la base de données
Les attributs:
ID : définit le logo unique de l'environnement, ne peut pas être répété
–>
<environment id="développement">
<!–
transactionManager : configurer le gestionnaire de transactions
Les attributs:
Type : Définir la méthode de gestion des transactions
type="JDBC|GÉRÉ"
JDBC : indique l'utilisation de méthodes natives de gestion des transactions dans JDBC
GÉRÉ : géré, tel que Spring
–>
<transactionManager type="JDBC"/>
<!–
dataSource : définir la source de données
Les attributs:
Type : définissez le type de source de données
type="POOLED|UNPOOLED|JNDI"
POOLED : indique l'utilisation du pool de connexions à la base de données
UNPOOLED : Indique que le pool de connexions à la base de données n'est pas utilisé
JNDI : représente la source de données dans le contexte d'utilisation
–>
<dataSource type="POOLED">
<nom de la propriété="pilote" value="${jdbc.driver}"/>
<nom de la propriété="url" value="${jdbc.url}"/>
<property name="nom d'utilisateur" value="${jdbc.username}"/>
<nom de la propriété="mot de passe" value="${jdbc.password}"/>
</sourcededonnées>
</environnement>
<identifiant de l'environnement="test">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<nom de la propriété="pilote" value="com.mysql.cj.jdbc.Driver"/>
<nom de la propriété="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/>
<property name="nom d'utilisateur" value="racine"/>
<nom de la propriété="mot de passe" valeur="123456"/>
</sourcededonnées>
</environnement>
</environnements>
<!–Présentez le fichier de mappage de mybatis–>
<cartographes>
<!–<mapper resource="mappers/UserMapper.xml"/>–>
<!–
Introduction des fichiers de cartographie sous forme de packages, mais deux conditions doivent être remplies :
1. L'interface du mappeur et le package où se trouve le fichier de mappage doivent être cohérents
2. Le nom de l'interface du mappeur et le nom du fichier de mappage doivent être cohérents.
–>
<nom du package="com.atguigu.mybatis.mapper"/>
</cartographes>
</configuration>
--->
③Créer une interface Mapper et un fichier de mappage
La couche de persistance n'a besoin que d'une interface et les instructions sont placées dans le fichier de mappage.
interface publique EmployeeMapper {
Liste<Employé> getEmployeeList();
}
<?version XML="1.0" encodage="UTF-8" ?> <!Mappeur DOCTYPE PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.atguigu.ssm.mapper.EmployeeMapper"> <select id="getEmployeeList" resultType="Employé"> sélectionnez * dans t_emp </sélectionner> </mappeur>
④Créer le fichier journal log4j.xml
<?version XML="1.0" encodage="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTÈME "log4j.dtd">
<!--Vous pouvez signaler du rouge-->
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encodage" valeur = "UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-jj HH:mm:ss,SSS} %m (%F:%L) \n" />
</mise en page>
</appender>
<nom de l'enregistreur="java.sql">
<level value="debug" />
</enregistreur>
<nom de l'enregistreur="org.apache.ibatis">
<level value="info" />
</enregistreur>
<racine>
<level value="debug" />
<appender-ref ref="STDOUT" />
</racine>
</log4j:configuration>
4.6. Créez le fichier de configuration Spring et configurez-le
Tant qu'il s'agit d'un objet, il peut être géré par Spring.
<!--<typeAlias type="com.atguigu.mybatis.pojo.User"></typeAlias>--> <!--En fonction du package, définissez l'alias de type par défaut pour tous les types sous le package, qui est le nom de la classe et n'est pas sensible à la casse-->
<?version XML="1.0" encodage="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--Analyser les composants (à l'exception de la couche de contrôle)-->
<context:component-scan base-package="com.atguigu.ssm">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:analyse des composants>
<!--Introduisez jdbc.properties, le chemin de classe est sous ressources, c'est-à-dire les classes sous WEB-INF sous cible -->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!-- Configurer la source de données Druid. La source de données Druid est un objet et peut être gérée par Spring. Lorsque Spring intègre MyBatis, MyBatis peut également utiliser la source de données dans Spring -->
<!--Créez jdbc.properties sous ressources (même répertoire)-->
<identifiant du bean="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<nom de la propriété="url" value="${jdbc.url}"></property>
<property name="nom d'utilisateur" value="${jdbc.username}"></property>
<nom de la propriété="mot de passe" value="${jdbc.password}"></property>
</haricot>
<!--Configuration du gestionnaire de transactions - généralement pour les objets de connexion, toutes les sources de données doivent être configurées ; cela dépend du package jar de spring-jdbc-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<nom de la propriété="dataSource" ref="dataSource"></property>
</haricot>
<!--
Activez le pilote d'annotation de la transaction. Si l'identifiant peut être omis comme le gestionnaire de transactions, il est recommandé de ne pas l'omettre.
--->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
<!--L'objet fourni par SqlSessionFactory est SqlSessionFactory. S'il ne s'agit pas d'un bean usine, nous devons d'abord obtenir l'IOC puis obtenir le bean usine.
Ensuite, récupérez l'objet que nous avons fourni via l'usine --->
<!--En utilisant ce bean factory, nous pouvons omettre les étapes d'obtention de l'usine et obtenir directement l'objet SqlSessionFactory fourni par l'usine dans le conteneur IOC-->
<!-- Configurez le bean factory utilisé pour créer SqlSessionFactory (obtenez l'objet fourni par l'usine, pas l'objet réel), fourni par le package jar de MyBatis-spring -->
<!--Pour créer une SqlSession auparavant, vous devez obtenir le flux d'entrée via le fichier de configuration principal et obtenir la SqlSession basée sur le flux d'entrée ; il reste le même, et il est toujours le même s'il est laissé à l'état initial. Gestion du printemps-->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- Définissez le chemin d'accès au fichier de configuration MyBatis (vous n'êtes pas obligé de le définir - si vous utilisez Spring pour tout, vous n'avez pas du tout besoin de cette configuration, n'importe qui fera l'affaire. Le fichier de configuration principal de MyBatis est défini ici et peut être configuré à la fois dans MyBatis et Spring) - ->
<property name="configLocation" value="classpath:mybatis-config.xml"> </propriété>
<!--Définissez la source de données. Si vous la définissez ici, vous n'avez pas besoin de la configurer dans MyBatis-->
<nom de la propriété="dataSource" ref="dataSource"></property>
<!--Définissez le package correspondant à l'alias de type -->
<property name="typeAliasesPackage" value="com.atguigu.ssm.pojo">
</propriété>
</haricot>
<!--
Définissez le chemin du fichier de mappage. Si MyBatis est défini, il n'est pas nécessaire d'introduire le fichier de mappage.
Si le chemin du fichier de mappage est le même que celui de l'interface du mappeur, aucun paramètre n'est requis ;
L'emplacement est un chemin, pas un package, il ne peut donc pas être utilisé. Dot, utilisez /
--->
<!--
<property name="mapperLocations" value="classpath:mapper/*.xml">
</propriété>
--->
& Lt;!-ConfigurationProperties doit transmettre l'objet Properties et mapper le scratch inférieur de MyBates à l'ensemble NAME de la bosse, et le mappage des valeurs en vaut la peine ; mybatis ne peut pas écrire-& gt;
<!--
(Vous pouvez imaginer que si vous ne le configurez pas, vous pouvez assembler un objet SqlSessionFactory dans l'annotation de la couche Service, créer une SqlSession via celui-ci, puis obtenir l'objet d'interface Mapper via la méthode getMapping ; c'est également assez gênant)
Configurer la configuration de numérisation de l'interface du mappeur
Créez des objets de classe d'implémentation proxy de ces interfaces Mapper via l'objet SqlSession fourni par SqlSessionFactory, puis transmettez-les au conteneur IOC pour la gestion.
Fourni par mybatis-spring, vous pouvez créer des proxys dynamiques pour toutes les interfaces du mappeur sous le package spécifié
Et gérez ces proxys dynamiques en tant que beans du conteneur IOC
--->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--Utilisez toutes les interfaces sous om.atguigu.ssm.mapper pour créer une SqlSession via le SqlSessionFactory fourni par Spring.
Obtenez tous les objets de classe d'implémentation de proxy sous ce package via ces SqlSession et transférez ces objets à la gestion des conteneurs IOC
Ce mappeur est configuré. Il s'agit d'un package commun pour l'interface du mappeur et les fichiers de mappage.
--->
<property name="basePackage" value="com.atguigu.ssm.mapper"></property>
</haricot>
</haricots>
Vous pouvez également laisser le plug-in à Spring :
4.7. Fonction de test
①Créer des composants
Classe d'entité Employé
Employé de classe publique {
privé Entier empId ;
chaîne privée empName ;
âge entier privé ;
sexe en chaîne privé;
e-mail de chaîne privé ;
employé public() {
}
employé public (Integer empId, String empName, Integer age, String sex,
Chaîne e-mail) {
this.empId = empId;
this.empName = empName;
this.age = âge;
this.sex = sexe ;
this.email = email ;
}
public entier getEmpId() {
retourner empId ;
}
public void setEmpId (Integer empId) {
this.empId = empId;
}
chaîne publique getEmpName() {
retourner empName ;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public entier getAge() {
âge de retour;
}
public void setAge (âge entier) {
this.age = âge;
}
chaîne publique getSex() {
retourner le sexe;
}
public void setSex (String sexe) {
this.sex = sexe ;
}
chaîne publique getEmail() {
retourner l'e-mail ;
}
public void setEmail(String email) {
this.email = email ;
}
}
Créer le composant de couche de contrôle EmployeeController
/**
* Date : 2022/7/11
*Auteur : ybc
* Description:
* Interroger toutes les informations sur les employés-->/employé-->obtenir
* Interroger les informations de radiomessagerie de l'employé-->/employee/page/1-->get
* Interroger les informations sur les employés en fonction de leur ID-->/employee/1-->get
* Accédez à la page d'ajout-->/to/add-->get
* Ajouter des informations sur l'employé-->/employé-->post
* Modifier les informations sur l'employé-->/employé-->mettre
* Supprimer les informations sur l'employé-->/employee/1-->delete
*/
@Manette
classe publique EmployeeController {
@Autowired
employéService privé EmployeeService ;
//La requête est obtenue dans le style RESTful. Si vous partagez cette page, vous ne pouvez pas utiliser la méthode suivante pour interroger tous les employés en même temps, car les données que nous partageons sont des pages et les informations sur les employés de la page actuelle sont dans le attribut de liste dans la page.
@RequestMapping(value = "/employee/page/{pageNum}", méthode = RequestMethod.GET)
public String getEmployeePage (@PathVariable("pageNum") Integer pageNum, modèle modèle){
//Obtenir des informations sur la pagination des employés
PageInfo<Employé> page = employeService.getEmployeePage(pageNum);
//Partager les données de pagination dans le domaine de requête
model.addAttribute("page", page);
//Aller à Employee_list.html
renvoyer "liste_employés" ;
}
@RequestMapping(value = "/employee", method = RequestMethod.GET)
public String getAllEmployee (modèle modèle) {
// Interroger toutes les informations sur les employés
Liste<Employé> list = employeService.getAllEmployee();
//Partager les informations sur les employés dans le champ de demande
model.addAttribute("liste", liste);
//Aller à Employee_list.html
renvoyer "liste_employés" ;
}
}
Créer une interface EmployeeService
interface publique EmployeeService {
/**
* Interroger toutes les informations sur les employés
* @retour
*/
Liste<Employé> getAllEmployee();
/**
* Obtenez des informations sur la pagination des employés
* @param numéro de page
* @retour
*/
PageInfo<Employé> getEmployeePage (numéro de page entier);
}
Créer une classe d'implémentation EmployeeServiceImpl
@Service
@Transactionnel
classe publique EmployeeServiceImpl implémente EmployeeService {
@Autowired
employéMapper privé employéMapper ;
/* @Passer outre
Liste publique<Employé> getAllEmployee() {
return employeMapper.getAllEmployee();
}
*/
@Passer outre
public PageInfo<Employé> getEmployeePage (numéro de page entier) {
//Activer la fonction de pagination
PageHelper.startPage(pageNum, 4);
// Interroger toutes les informations sur les employés
Liste<Employé> list = employeMapper.getAllEmployee();
//Obtenir les données relatives à la pagination
PageInfo<Employé> page = new PageInfo<>(liste, 5);
page de retour ;
}
}
②Créer une page
<!DOCTYPE html>
<html lang="fr" xmlns:th="http://www.thymeleaf.org">
<tête>
<meta charset="UTF-8">
<title>Informations sur les employés</title>
<link rel="feuille de style" th:href="@{/static/css/index_work.css}">
≪/tête>
<corps>
<tableau>
<tr>
<th colspan="6">Informations sur les employés</th>
≪/tr>
<tr>
<th>emp_id</th>
<th>emp_name</th>
<th>âge</th>
<th>sexe</th>
<th>e-mail</th>
<th>options</th>
≪/tr>
<!--Ceci devrait être page.list, le domaine partagé est page et list est l'un de ses attributs-->
<tr th:each="employé : ${page.list}">
<td th:text="${employee.empId}"></td>
<td th:text="${employee.empName}"></td>
<td th:text="${employee.age}"></td>
<td th:text="${employee.sex}"></td>
<td th:text="${employee.email}"></td>
<td>
<a href="">supprimer</a>
<a href="">mise à jour</a>
</td>
≪/tr>
<tr>
<td colspan="6">
<span th:if="${page.hasPreviousPage}">
<a th:href="@{/employee/page/1}">首页</a>
<a th:href="@{'/employee/page/' ;+${page.prePage}}">Page précédente</a>
</envergure>
<span th:each="num : ${page.navigatepageNums}"">
<a th:if="${page.pageNum==num}"
th:href="@{'/employee/page/'+${num}}" th:text="'['+${num}+']'" style="couleur:rouge;"></a>
<a th:if="${page.pageNum!=num}"
th:href="@{'/employee/page/'+${num}}" th:text="${num}"></a>
</envergure>
<span th:if="${page.hasNextPage}">
<a th:href="@{'/ employe/page/'+${page.nextPage}}">Page suivante</a>
<a th:href="@{'/employee/page/'+${page.pages}}">末页</a>
</envergure>
</td>
≪/tr>
</tableau>
</corps>
</html>
fichier source de la nouvelle version employe_list.html :
<!DOCTYPE html>
<html lang="fr" xmlns:th="http://www.thymeleaf.org">
<tête>
<meta charset="UTF-8">
<title>Liste des employés</title>
<link rel="feuille de style" th:href="@{/static/css/index_work.css}">
≪/tête>
<corps>
<tableau>
<tr>
<th colspan="6">Liste des employés</th>
≪/tr>
<tr>
" "
≪/tr>
<!--Ici, vous pouvez définir un statut (n'importe quel nom tel que : status, un objet auxiliaire fourni par Thymeleaf pour nous aider à obtenir des informations sur le cycle), qui a certains attributs. Ici, afin de créer une colonne pour chaque page commencer à partir de 1- ->
<tr th:each="employé,statut : ${page.list}">
<td th:text="${status.count}"></td>
<td th:text="${employee.empName}"></td>
<td th:text="${employee.age}"></td>
<td th:text="${employee.gender}"></td>
<td th:text="${employee.email}"></td>
<td>
<a href="">Supprimer</a>
</td>
≪/tr>
</tableau>
<div style="text-align: center;">
<a th:if="${page.hasPreviousPage}" th:href="@{/employee/page/1}">首页</a>
<a th:if="${page.hasPreviousPage}" th:href="@{'/employee/page/'+${page.prePage}}">上一页</a>
<!--num est le numéro de page affiché dans la pagination de navigation actuelle. Le numéro du tableau actuel bouclé sera donné à num, afin que la page puisse afficher le numéro-->
<span th:each="num : ${page.navigatepageNums}"">
<!--Définissez le numéro de page que nous visitons actuellement pour changer la couleur+[]-->
<a th:if="${page.pageNum == num}" style="couleur : rouge;" th:href="@{'/employee/page/'+${num}}" th:text="'['+${num}+']'"></a>
<a th:if="${page.pageNum != num}" th:href="@{'/employee/page/'+${num}}" th:text="${num}"></a>
</envergure>
<a th:if="${page.hasNextPage}" th:href="@{'/employee/page/'+${page.nextPage}}">下一页</a>
<a th:if="${page.hasNextPage}" th:href="@{'/employee/page/'+${page.pages}}">末页</a>
</div>
</corps>
</html>
③Accéder à la fonction de pagination de test
hôte local : 8080/employé/page/1