Un nouveau projet a été lancé au cours des deux derniers jours parce que les membres de l'équipe de projet ont toujours utilisé Mybatis. Bien que je préfère personnellement le modèle minimaliste de JPA, MyBatis est toujours déterminé à maintenir la sélection de technologies unifiées afin de maintenir le projet. Je suis allé en ligne pour trouver des informations pertinentes sur la combinaison de Spring Boot et Mybatis. Il existe différentes formes, ce qui rend les gens fatigués de le lire. En combinant la démo et les documents officiels de MyBatis, j'ai finalement trouvé les deux modes les plus simples. J'ai passé une journée à le résumer et à le partager.
L'essence du cadre ORM est de simplifier le codage des bases de données de fonctionnement dans la programmation. Maintenant, il reste essentiellement deux sociétés. L'un est de prétendre que vous ne pouvez pas écrire une phrase de SQL Hibernate, et l'autre est de déboguer avec flexible Mybatis de Dynamic SQL. Les deux ont leurs propres caractéristiques et peuvent être utilisés de manière flexible en fonction des besoins dans le développement du système au niveau de l'entreprise. J'ai trouvé un phénomène intéressant: la plupart des entreprises traditionnelles aiment utiliser Hibernate, et l'industrie Internet utilise généralement Mybatis.
La caractéristique de Hibernate est que tout SQL est généré à l'aide du code Java, et il n'est pas nécessaire d'écrire (lire) SQL sans sauter du programme. Il a une intégrité de programmation. Il se développe au sommet du modèle. Fondamentalement, le SQL correspondant peut être généré en fonction du nom de la méthode. Si vous ne savez pas grand-chose, vous pouvez lire mon article précédent sur l'utilisation de Spring Data JPA.
MyBatis est très gênant au début, nécessitant divers fichiers de configuration, des classes d'entités, des associations de mappage de couche DAO et de nombreuses autres configurations. Bien sûr, Mybatis a également découvert ce désavantage. Au début, le générateur a été développé, qui peut produire automatiquement des classes d'entités, des fichiers de configuration et du code de couche DAO en fonction des résultats du tableau, ce qui peut réduire une partie du volume de développement; Dans la dernière étape, de nombreuses optimisations peuvent être utilisées pour utiliser des annotations, gérer automatiquement les couches DAO et les fichiers de configuration, etc., et le développement vers le haut est le modèle dont nous allons parler aujourd'hui. MyBatis-Spring-Boot-Starter est Springboot + MyBatis peut annoter complètement sans fichiers de configuration, et peut également être une configuration simple et facile à démarrer.
Pensez-y maintenant, Spring Boot est génial. Tant que vous associez n'importe quoi à Spring Boot, cela le simplifiera.
Mybatis-Spring-Boot-Starter
Description officielle: MyBatis Spring-Boot-Starter vous aidera à utiliser MyBatis avec Spring Boot
En fait, Mybatis a développé une solution pour se joindre au plaisir à cause de Spring Boot si populaire, mais celui-ci a en effet résolu de nombreux problèmes et est en effet beaucoup plus fluide à utiliser. Il existe deux solutions principales pour MyBatis-Spring-Boot-Starter. L'un consiste à utiliser des annotations pour résoudre tous les problèmes, et l'autre est l'ancienne tradition simplifiée.
Bien sûr, tout mode doit d'abord introduire le fichier POM de MyBatis-Spring-Boot-Starter. Maintenant, la dernière version est 1.1.1 (il se trouve que c'est sur Double 11 :))
<dependency> <proupId> org.mybatis.spring.boot </proupId> <Artifactid> Mybatis-Spring-boot-starter </ artifactId> <version> 1.1.1 </-version> </Dependance>
Je vais présenter deux modèles de développement
Aucune version d'annotation du fichier de configuration
Cela se fait avec des annotations.
1 Ajouter des fichiers maven pertinents
<Dependances> <Dependency> <GroupId> org.springframework.boot </rombandid> <ArtifActid> printemps-boot-starter </ artifactid> </dependency> <dependency> <proupId> org.springframework.boot </proupId> <artifactisid </proupId> <artifactidwork. > Spring-Boot-Starter-Test </ ArfactId> <Cope> Test </ccope> </Dependency> <Dependency> <GroupId> org.springFramework.boot </prouprid> <petifactid> Spring-boot-starter-web </ artifactid> </dependency> <depen Dency> <ProupId> org.mybatis.spring.boot </proupId> <Artifactid> Mybatis-Spring-Boot-Starter </ Artifactid> <Dersion> 1.1.1 </DERNIFRIENT> </DENDENCEND> <Dependance> <ProupId> MySQL </proupId> <Artifactid> Mysql-C onnector-java </ artifactid> </ dépendance> <dependency> <proupId> org.springframework.boot </rombasid> <ArtifActid> printemps-boot-devtools </ artifactid> <ochotéal> true </ optional> </peedency> </peedences>
Je ne publierai pas le pack POM complet ici, veuillez lire directement le code source
2. Application.properties Ajouter des configurations pertinentes
mybatis.type-aliases-package = com.neo.entityspring.datasource.driverclassname = com.mysql.jdbc.driverspring.datasource.url = jdbc: mysql: // localhost: 3306 / test1? useucode = true & worseencoding = rootspring.datasource.password = root
Springboot chargera automatiquement la configuration pertinente de Spring.datasource. *, Et la source de données sera automatiquement injectée dans le SQLSessionFactory. Le SQLSessionFactory sera automatiquement injecté dans le mappeur. Soit dit en passant, vous n'avez pas à vous soucier de tout, il suffit de le récupérer et de l'utiliser.
Ajoutez une analyse de package de mappeur dans la classe de démarrage @MapperScan
@ SpringbootApplication @ MAPPERSCAN ("com.neo.mapper") Application de classe publique {public static void main (String [] args) {SpringApplication.Run (application.class, args);}}Ou ajoutez simplement annotation @mapper sur la classe de mappeur. Il est recommandé d'utiliser celui ci-dessus, sinon il sera assez difficile d'ajouter l'annotation à chaque mappeur.
3. Développer du mappeur
La troisième étape est la partie la plus critique, et la production de SQL est ici
interface publique UserMapper {@Select ("SELECT * FROM Users") @ Results ({@ result (propriété = "usex", colonnes = "user_sex", javatype = userexenum.class), @ result (propriété = "nautique" # {id} ") @ Results ({@ result (propriété =" usex ", colonnel =" user_sex ", javatype = userexenum.class), @ result (propriété =" nautique ", colonnes =" nick_name ")}) Userentity getOne (long id); @ insert (" insert in userse # {mot de passe}, # {usexEx}) ") void insert (utilisateur de l'utilisateur); @ update (" Update les utilisateurs set username = # {username}, nick_name = # {nickname} où id = # {id} ") void Update (Userentity User); @ delete (" supprimer des utilisateurs où id = # {id} ") void delete (Long);}Afin d'être plus proche de la production, j'ai spécialement souligné les deux attributs de user_sex et nick_name dans la base de données et les noms d'attribut de classe d'entité sont incohérents. De plus, user_sex utilise des énumérations
@Select est une annotation de la classe de requête, et toutes les requêtes utilisent ceci
@Result Modifiez l'ensemble de résultats renvoyé et les attributs de classe d'entité associés et les champs de base de données correspondent un par un. Si les attributs de classe d'entité et les noms d'attribut de base de données sont cohérents, cet attribut n'est pas nécessaire pour modifier.
@Insert Insérer la base de données à utiliser, le passage directement de la classe d'entité analysera automatiquement l'attribut à la valeur correspondante
@Update est responsable de la modification et peut également être directement transmis dans l'objet
@Delete est responsable de la suppression
Pour plus de propriétés, veuillez consulter ici: http://www.mybatis.org/mybatis-3/zh/java-api.html
Notez que la différence entre l'utilisation de # symbole et $ symbole:
// Cet exemple crée une déclaration préparée, quelque chose comme select * from enseign where name = ?; @ select ("SELECT * from enseign where where = # {name}") enseignant selectTeachForGivenName (@param ("name") name de chaîne); // cet exemple crée n déclaration inclinée, quelque chose comme SELECT * selectTeachForGivenName (@param ("name") Nom de la chaîne);4. Utiliser
Les trois étapes ci-dessus complètent essentiellement le développement de la couche pertinent. Lorsque vous l'utilisez, utilisez-le simplement comme classe ordinaire et il peut y être injecté.
@Runwith (springrunner.class) @springboottestpublic class userMappentTest {@AutowiredPrivate userperper userapper; @Testpublic void TestiNsert () lance l'exception {userpert.insert (New Userentity ("aa", "A123456", userexenum.man); "b123456", usersexenum.woman)); userMapper.insert (New Userentity ("CC", "B123456", UsersExEnum.woman)); Assert.AsseserTequals (3, userpert UserMapper.getall (); System.out.println (User UserMapper.getOne (3L); System.out.println (user.toString ()); user.setNickName ("neo"); userMapper.update (user); assert.assertTrue (("neo" .equals (userMapper.getOne (3L) .GetNICKNAME ()));}}Il y a des ajouts, des suppressions, des modifications et des recherches complets dans le code source, donc je ne les publierai pas ici
Version XML minimaliste
La version XML minimaliste maintient l'ancienne tradition de mappage des fichiers. L'optimisation se reflète principalement dans la couche d'implémentation qui n'a pas besoin d'être implémentée. Le système trouvera automatiquement le SQL correspondant dans le fichier de mappage en fonction du nom de la méthode.
1. Configuration
Le fichier POM est le même que la version précédente, sauf que la configuration suivante est ajoutée à application.properties
MyBatis.Config-Locations = CLASSPATH: MyBatis / Mybatis-Config.xmlmybatis.mapper-Locations = ClassPath: MyBatis / Mappe
Spécifie l'adresse du fichier de configuration de base MyBatis et du fichier de mappage de classe d'entité
Configuration mybatis-config.xml
<Inconguration> <Cypealiases> <typealias alias = "Integer" type = "java.lang.integer" /> <tycias alias = "long" type = "java.lang.long" /> <typias alias = "hashmap" type = "java.util.hashmap" /> <tycias alias = "liendhashmap" type = "java.util.linkedhashmap" /> <tycias alias = "arrayList" type = "java.util.arraylist" /> <tycias alias = "lienList" type = "java.util.linkedlist" /> </ typealiases> </ configuration>
Ici, vous pouvez également ajouter une configuration de base MyBatis
2. Ajouter le fichier de mappage de l'utilisateur
<mapper namespace = "com.neo.mapper.usermapper"> <resultmap id = "basserresultmap" type = "com.neo.entity.userentity"> <id column = "id" Property = "id" jdbcType = "bigint" /> <result Column = "username" property = "username" jdbcType = "Varse propriété = "mot de passe" jdbcType = "varChar" /> <result Column = "user_sex" propriété = "userEx" javatype = "com.neo.enums.usersExenum" /> <result Column = "nick_name" Property = "Nickname" JDBCTYPE = "Varchar" /> </ ResultMap> <sql id = "Base_clumn_list_c mot de passe, user_sex, nick_name </ql> <select id = "getall" resultMap = "BaseResultMap"> SELECT <inclure refid = "base_column_list" /> From User userswhere id = # {id} </lect> <insert id = "insert" ParameterType = "com.neo.entity.Userentity"> Insérez dans les utilisateurs (nom d'utilisateur, mot de passe, user_sex) (# {username}, # {mot de passe}, # {userEx}) </sert> <updated id = "update" Paramettype = "com.neo. > Mettre à jour les utilisateurs set <if test = "username! = Null"> username = # {username}, </ if> <if test = "mot de passe! = Null"> mot de passe = # {mot de passe}, </ if> nick_name = # {naulla} où id = # {id} </fatedate> <delete id = "Delete" ParametType = "Java.Lang.> Où id = # {id} </ delete> </ mapper>En fait, il ne faisait que déplacer le mappeur SQL de la version précédente au XML ici
3. Écrivez le code de couche DAO
Interface publique UserMapper {list <userentity> getAll (); Userentity getOne (Long ID); void insert (utilisateur de l'utilisateur); void Update (utilisateur de l'utilisateur); void delete (ID long);}Par rapport à l'étape précédente, il ne reste que des méthodes d'interface.
4. Utiliser
Il n'y a pas de différence entre l'utiliser et la version précédente, veuillez consulter le code
Comment choisir
Les deux modes ont leurs propres caractéristiques. La version annotée convient aux modes simples et rapides. En fait, comme le modèle de microservice populaire de nos jours, un microservice correspondra à sa propre base de données. La demande de requête de connexion multi-table sera considérablement réduite et deviendra de plus en plus adaptée à ce mode.
L'ancien modèle traditionnel est plus adapté aux grands projets. Il peut générer de manière dynamique SQL de manière flexible, ce qui est pratique pour ajuster SQL, et a également la sensation d'écrire SQL avec un grand plaisir et une élégance.
Exemple de code - github: https://github.com/ityouknow/spring-boot-examples
Exemple de code - Cloud Cloud: https://gitee.com/ityouknow/spring-boot-examples