mybatis

Mybatis est un excellent framework de persistance qui prend en charge SQL personnalisés, des procédures stockées et applications avancées. Mybatis évite presque tout le code JDBC et les paramètres de réglage manuel et l'obtention du jeu de résultats. Mybatis peut utiliser XML simples ou annotation pour configurer et cartographier les informations natives, les interfaces et Java POJO (objets Java ordinaire ordinaire, objets Java ordinaire) aux enregistrements de bases de données.

caractéristique

• Facile à apprendre: elle-même est petit et simple. Ne vous fiez pas à un tiers, tant que le plus facile à installer deux fichiers jar + configurer plusieurs fichiers de mappage SQL est facile à apprendre, facile à utiliser, grâce à la documentation et le code source, vous pouvez comparer saisir pleinement sa conception et la mise en uvre.
• Flexible: mybatis n'imposera aucune influence sur la conception d'applications ou de bases de données existantes. sql écrit en XML, pour faciliter la gestion et l'optimisation unifiée. Par instruction SQL pour répondre à tous les besoins de l'exploitation de la base de données.
• Sql libérer le couplage Code programme: couche de DAO en fournissant la logique d'accès aux données et la logique métier séparée de la conception du système plus clair, plus facile à entretenir, faciliter les tests unitaires. sql et le code, ce qui améliore la maintenabilité.
• Fournir une étiquette de mise en correspondance, le support de champ objet orm base de données de mappage de la relation
• Balises fournissent mapping objet-relationnel, le soutien à la forme objet-relationnel entretien
• Fournir des balises xml, soutenir la préparation de sql dynamique.

cadre ORM Hibernate & mybatis

Nature cadre Orm est codé pour simplifier le fonctionnement de la programmation de la base de données, développée à fond reste-deux, et on est déclaré ne peut pas écrire un Sql Hibernate, on est Sql dynamique mybatis de débogage flexible, qui ont tous deux leurs propres caractéristiques , il peut être utilisé avec souplesse dans le développement des systèmes d'entreprise basée sur la demande. Trouvé un phénomène intéressant: les entreprises les plus traditionnelles préfèrent utiliser Hibernate, l'industrie Internet utilisent généralement mybatis.

Sql Hibernate caractéristique est que tous sont utilisés pour générer le code Java, ne sautez pas du programme d'écriture (voir) sql, l'intégrité du programme a mis au point au sommet est le Jpa données du printemps ce modèle, peut essentiellement être généré en fonction du nom de la méthode correspondant Sql, et il ne comprend pas peut lire mon article précédent Spring Boot (e): à l'aide de données Jpa printemps.

lourd de mybatis initial comparatif, ce qui nécessite différents fichiers de configuration, la classe d'entité, association cartographie couche Dao, il y a une grande poussée d'autres configurations. Bien sûr, aussi nous avons constaté que les inconvénients mybatis, au début du développement de la classe d'entité génératrice de production automatisée peut entraîner le tableau, les codes de profil, et la couche Dao, une partie du montant des développeurs peut être réduit, plus tard aussi beaucoup d'optimisation peut être utilisé annotée, gestion automatique Dao couche et fichiers de configuration, au développement de ce modèle est le sommet de la conférence d'aujourd'hui sur le, mybatis-printemps-boot-démarreur est Spring boot + mybatis fichier ne peut pas entièrement de configuration de commentaires, vous pouvez simplement configurer facilement commencer.

mybatis-ressort-boot-démarreur

Description officielle: mybatis Printemps-Boot-Starter vous aidera à utiliser mybatis avec Spring Boot

En fait, si chaud mybatis regarder Spring Boot a également développé un ensemble de solutions pour la balade, mais cela ne résout beaucoup de problèmes Minato, vraiment utiliser une plus lisse beaucoup. mybatis-printemps-démarrage de démarrage Il existe deux solutions, on est d'utiliser des annotations pour résoudre tous les problèmes, on est l'ancien traditionnel simplifié.

Bien sûr, tout modèle commencera par l'introduction de mybatis-printemps-démarrage de démarrage de fichier Pom, et la version actuelle est 2.0.0

< dépendance >

< groupId > org.mybatis.spring.boot < / GroupId >

< artifactId > mybatis-ressort-boot-démarreur < / ArtifactId >

< version > 2.0.0 < / version >

< / dépendance >

WELL deux modèles de développement sont introduits

Aucune version fichier de configuration commentaire

Utilisez des annotations est tout fait.

1 Ajouter des fichiers liés Maven

< dépendances >

< dépendance >

  < groupId > org.springframework.boot < / GroupId >

  < artifactId > printemps-boot-démarreur Web < / ArtifactId >

  < / dépendance >

< dépendance >

< groupId > org.mybatis.spring.boot < / GroupId >

< artifactId > mybatis-ressort-boot-démarreur < / ArtifactId >

< version > 2.0.0 < / version >

< / dépendance >

  < dépendance >

  < groupId > mysql < / GroupId >

  < artifactId > mysql-connector-java < / ArtifactId >

  < / dépendance >

< / dépendances >

2, application.properties ajouter la configuration

mybatis.type-alias-paquet = com.neo.model

spring.datasource.url = jdbc: mysql: // localhost 3306 :? / test serverTimezone = UTC & useUnicode = true & CharacterEncoding = utf-8 & usessl = true

spring.datasource.username = racine

spring.datasource.password = racine

spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver

Configuration. Spring Boot se charge automatiquement de spring.datasource *, la source de données est automatiquement injectée dans le sqlSessionFactory en sqlSessionFactory injecté automatiquement dans le Mapper, oui, tout ce que vous ne contrôlez pas, prenez directement l'utilisation de la ligne.

Ajouter un mappeur de paquets de balayage de début de classe @MapperScan

@SpringBootApplication

@MapperScan ( "com.neo.mapper")

public class {MybatisAnnotationApplication

public static void main (String args) {

SpringApplication.run (MybatisAnnotationApplication.class, args);

}

}

Ou ajouter des annotations directement dans la classe Mapper ci-dessus @Mapper, le type recommandé ci-dessus, ou d'ajouter un commentaire à chaque mappeur très gênant

3, le développement Mapper

La troisième étape est la plus élément essentiel, la production Sql sont tous ici

interface publique UserMapper {

@Select ( "SELECT * FROM utilisateurs")

@Results ({

@Result (property = "userSex", colonne = "user_sex", javaType = UserSexEnum.class),

@Result (property = "nickname", colonne = "NICK_NAME")

})

liste < UserEntity >  getAll ();

@Select ( "SELECT * FROM utilisateurs WHERE id = # {id}")

@Results ({

@Result (property = "userSex", colonne = "user_sex", javaType = UserSexEnum.class),

@Result (property = "nickname", colonne = "NICK_NAME")

})

UserEntity getOne (id Long);

@Insert ( "INSERT INTO utilisateurs (NomUtilisateur, MotDePasse, user_sex) VALUES (# {username}, {#} passWord, # {} userSex)")

void insert (utilisateur UserEntity);

@Update ( "utilisateurs UPDATE SET USERNAME = # {username}, NICK_NAME = # {} nickName WHERE id = # {id}")

mise à vide (utilisateur UserEntity);

@Delete ( "DELETE FROM utilisateurs WHERE id = # {id}")

annuler delete (id Long);

}

Pour se rapprocher de la production que je suis venu à user_sex, NICK_NAME deux attributs dans la base de données ont souligné les noms de classes d'entités et attributs incohérents, en utilisant l'énumération autre user_sex

• classe @select est des requêtes annotées, toutes les requêtes utilisent ce
• jeu de résultats @result modifié est retourné, les propriétés connexes de classe d'entités et les champs de la base de données correspondent, si les attributs de classe d'entités et le nom de la base de données d'attribut reste le même, il n'y a pas besoin de modifier cette propriété.
• @Insert dans la base de données utilisée, directement dans la valeur de la classe d'entité correspondant à l'attribut automatiquement décide
• @Update responsable de la modification ou directement objet entrant
• @delete responsable de l'effacement

En savoir plus ici Référence de propriété

Notez que l'utilisation du symbole # et symboles différemment $:

// Cet exemple crée une déclaration préparée, quelque chose comme select * de maître où name = ?;

@Select ( "Select * de maître où name = # {name}")

Maître selectTeachForGivenName (@param ( "nom") Nom de chaîne);

// Cet exemple crée la déclaration n inline, quelque chose comme select * de maître où name = « UnNom »;

@Select ( "Select * de maître où name = '$ {name}'")

Maître selectTeachForGivenName (@param ( "nom") Nom de chaîne);

4, en utilisant

Ce qui précède trois étapes pratiquement achevé couche Mapper liée au développement, l'utilisation du temps comme une classe ordinaire sera en mesure d'injecter dans le

@RunWith (SpringRunner.class)

@SpringBootTest

public class {UserMapperTest

@Autowired

privé UserMapper userMapper;

@test

testInsert public void () throws Exception {

userMapper.insert (nouvel utilisateur ( "Aa1", "a123456", UserSexEnum.MAN));

userMapper.insert (nouvel utilisateur ( "BB1", "b123456", UserSexEnum.WOMAN));

userMapper.insert (nouvel utilisateur ( "CC1", "b123456", UserSexEnum.WOMAN));

Assert.assertEquals (3, taille userMapper.getAll () ().);

}

@test

TestQuery public void () throws Exception {

liste < utilisateur >  utilisateurs = userMapper.getAll ();

System.out.println (users.toString ());

}

@test

testUpdate public void () throws Exception {

l'utilisateur de l'utilisateur = userMapper.getOne (30l);

System.out.println (user.toString ());

user.setNickName ( "néo");

userMapper.update (utilisateur);

Assert.assertTrue ((.equals "néo" (userMapper.getOne (30l) .getNickName ())));

}

}

Version Minimaliste xml

fichiers de mappage Xml gardé la version minimaliste de la tradition ancienne, la couche d'interface seulement besoin de définir une méthode vide, le système trouvera automatiquement la Sql correspondante dans le fichier de mappage en fonction du nom de la méthode.

1, la configuration

fichier pom et la version précédente, il suffit d'ajouter les application.properties de configuration suivantes

mybatis.config-location = classpath: mybatis / mybatis-config.xml

mybatis.mapper-locations = classpath: mybatis / Mapper / * xml.

Indique une adresse de fichier de configuration de base mybatis et l'entité fichier de mappage de classe

configuration mybatis-config.xml

< configuration >

< typeAliases >

< alias de typeAlias = "entier" type = "java.lang.Integer" / >

< alias de typeAlias = "Long" type = "java.lang.Long" / >

< alias de typeAlias = "HashMap" type = "java.util.HashMap" / >

< alias de typeAlias = "LinkedHashMap" type = "java.util.LinkedHashMap" / >

< alias de typeAlias = "ArrayList" type = "java.util.ArrayList" / >

< alias de typeAlias = "LinkedList" type = "java.util.LinkedList" / >

< / TypeAliases >

< / Configuration >

Vous pouvez également ajouter quelques mybatis de configuration de base

2, Ajouter un fichier de mappage utilisateur

< Mapper namespace = "com.neo.mapper.UserMapper" >

  < resultMap id = "BaseResultMap" type = "com.neo.entity.UserEntity" >

  < colonne id = "id" property = "id" jdbcType = "BIGINT" / >

  < résultat colonne = "userName" property = "userName" jdbcType = "VARCHAR" / >

  < résultat colonne = "PASSWORD" property = "PASSWORD" jdbcType = "VARCHAR" / >

  < résultat colonne = "user_sex" property = "userSex" javaType = "com.neo.enums.UserSexEnum" / >

  < résultat colonne = "NICK_NAME" property = "nickname" jdbcType = "VARCHAR" / >

  < / resultmap >

  < sql id = "Base_Column_List" >

 id, NomUtilisateur, MotDePasse, user_sex, NICK_NAME

  < / Sql >

  < select id = "getAll" resultMap = "BaseResultMap" >

 SELECT

  < inclure refid = "Base_Column_List" / >

 FROM utilisateurs

  < / Sélectionnez >

  < select id = "getOne" parameterType = "java.lang.Long" resultMap = "BaseResultMap" >

 SELECT

  < inclure refid = "Base_Column_List" / >

 FROM utilisateurs

 WHERE id = # {id}

  < / Sélectionnez >

  < insérer id = "insert" parameterType = "com.neo.entity.UserEntity" >

 INSERT INTO

 utilisateurs

 (UserName, mot de passe, user_sex)

 VALEURS

 (# {Username}, {#} passWord, # {} userSex)

  < / Insérer >

  < mise à jour id = "update" parameterType = "com.neo.entity.UserEntity" >

 Mise à jour

 utilisateurs

 SET

  < si le test = "userName! = null" > USERNAME = # {} userName, < / Si >

  < si le test = "passWord! = null" > = # {passWord passWord}, < / Si >

 NICK_NAME = # {} nickName

 OÙ

 id = # {id}

  < / Mise à jour >

  < Supprimer id = "Supprimer" parameterType = "java.lang.Long" >

 SUPPRIMER DE

 utilisateurs

 OÙ

 id = # {id}

  < / Supprimer >

< / Mapper >

En fait, la version précédente de Sql Mapper déplacé ici dans le xml

3, la couche de codage Mapper

interface publique UserMapper {

liste < UserEntity >  getAll ();

UserEntity getOne (id Long);

void insert (utilisateur UserEntity);

mise à vide (utilisateur UserEntity);

annuler delete (id Long);

}

Step, où seulement vous devez définir la comparaison de la méthode d'interface

4, en utilisant

Et en utilisant la version précédente sans distinction, nous voyons l'exemple de code article correspondant il

Comment choisir

Deux modèles ont des caractéristiques différentes, notes version pour simple et mode rapide, en fait, car ils sont maintenant un modèle de micro-service populaire, un micro correspondra à un service de leur propre base de données, multi-tables requête de jointure demande sera grandement réduite, il sera plus plus apte à ce modèle.

Plus que le modèle traditionnel pour des projets à grande échelle, la flexibilité de Sql, Sql pour ajuster facilement généré dynamiquement, mais aussi très bien l'amour, l'écriture éloquente du sentiment Sql.

Voir ici, vous pouvez soutenir ce que les petites séries, en avant, pouces vers le haut, une vague d'attention maintenant!