Introduction à Mybatis
MyBatis est un excellent cadre de couche de persistance qui prend en charge les requêtes SQL simples, les procédures stockées et la cartographie avancée. MyBatis élimine les paramètres manuels de presque tous les code et paramètres JDBC et l'encapsulation de recherche de l'ensemble de résultats. MyBatis peut utiliser du XML ou des annotations simples pour la configuration et la cartographie originale, les interfaces de cartographie et les Pojos de Java (Old Java objets) en enregistrements dans la base de données.
L'architecture fonctionnelle de Mybatis est divisée en trois couches (l'image est empruntée à Baidu Encyclopedia):
1) Couche de l'interface de l'API: fournit des API d'interface pour une utilisation externe, à travers laquelle les développeurs manipulent des bases de données. Une fois que la couche d'interface aura reçu la demande d'appel, elle appellera la couche de traitement des données pour terminer le traitement spécifique des données.
2) Couche de traitement des données: responsable de la recherche SQL spécifique, de l'analyse SQL, de l'exécution SQL et du traitement de cartographie des résultats d'exécution, etc. Son objectif principal est de terminer une opération de base de données en fonction de la demande de l'appel.
3) Couche de support de base: responsable de la prise en charge fonctionnelle la plus élémentaire, y compris la gestion des connexions, la gestion des transactions, le chargement de configuration et le traitement du cache. Ce sont toutes des choses courantes, les extraits comme les composants les plus élémentaires. Fournit la prise en charge la plus élémentaire pour la couche supérieure de la couche de traitement des données.
Lors de la sélection du mappage dans MyBatis, le type de retour peut être utilisé avec ResultType ou ResultMap. ResultType représente directement le type de retour, tandis que le résultat est une référence au résultat externe, mais le résultat et le résultat ne peuvent pas exister en même temps. Lorsque MyBatis interroge le mappage, en fait, chaque requête d'attribut est placée dans une carte correspondante, où la clé est le nom d'attribut et la valeur est sa valeur correspondante. Lorsque l'attribut de type retour fourni est ResultType, MyBatis supprimera les paires de valeur de clé dans la carte et les attribuera aux attributs correspondants de l'objet spécifié par resultType. Ainsi, en fait, le type de retour de chaque carte de requête de MyBatis est un résultat. Cependant, lorsque l'attribut de type retour que nous fournissons est ResultType, MyBatis attribue automatiquement la valeur correspondante aux attributs de l'objet spécifié par resultType. Lorsque le type de retour que nous fournissons est ResultMap, car la carte ne peut pas bien représenter le modèle de domaine, nous devons le convertir davantage en l'objet correspondant nous-mêmes, qui est souvent très utile dans les requêtes complexes.
Il y a un tel blog.java fichier
import java.util.List;public class Blog {private int id;private String title;private String content;private String owner;private List<Comment> comments;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getContent() {return Contenu;} public void setContent (String Content) {this.content = contenu;} public String getowner () {return propriétaire;} public void setOnner (String propriétaire) {this.owner = propriétaire;} public list <commentaire> getComments () {return commentaires;} public void setComments (list <commentaire) {this.comments = comment "---------------- 博客 ----------------- / N ID:" + ID + "/ n Titre:" + Titre + "/ n Contenu:" + Contenu + "/ n propriétaire:" + propriétaire;}}La table de base de données correspondante contient des attributs ID, titre, contenu et propriétaire. Lorsque nous effectuons la cartographie des requêtes suivante
<typealias alias = "blog" type = "com.tiantian.mybatis.model.blog" /> <! - Fichier de configuration à partir de Mybatis Mybatis_config.xml -> <select id = "selectBlog" ParameterType = "int" resultType = "Blog"> SELECT * From t_blog where id = # {id} </ select> Blogmapper.xml ->MyBatis créera automatiquement un objet ResultMap, puis encapsulera la paire de valeurs de clé en fonction du nom d'attribut trouvé. Ensuite, vous verrez que le type de retour est un objet de blog, puis retirez la paire de valeurs de clé correspondant à l'objet de blog à partir du résultat et attribuez-le.
Il est également très utile lorsque le type de retour est directement un résultat de résultat, qui est principalement utilisé pour les requêtes conjointes complexes, car il n'est pas nécessaire de mener des requêtes simples. Regardons d'abord une requête simple avec un type de rendement résultat, puis examinons l'utilisation de requêtes complexes.
Comment écrire une question simple
<resultMap type = "blog" id = "blogResult"> <id colonnel = "id" propriété = "id" /> <résultat chronn = "title" propriété = "title" /> <result Column = "contenu" propriété = "contenu" /> <result Column = "propriétaire" Property = "propriétaire" /> <résultat Column = "propriétaire" propriété = "propriétaire" /> <sult Column = "propriétaire" Property = "Property =" propriétaire " propriété = "propriétaire" /> << / resultMap> <sélectionnez id = "selectBlog" ParameterType = "int" resultMap = "BlogResult"> SELECT * FROM T_BLOG WHERE ID = # {id} </ select>La valeur de ResultMap dans la carte de sélection est l'ID d'un résultat externe, indiquant quel résultat est mappé. L'attribut de type du résultat externe indique quel type le résultat du résultat est. Voici le type de blog, donc Mybatis le supprimera comme un objet de blog. L'ID du nœud enfant du nœud ResultMap est utilisé pour identifier l'ID de l'objet, tandis que le nœud enfant résultat est utilisé pour identifier certaines propriétés simples. La propriété de colonne représente les attributs interrogés à partir de la base de données, et la propriété représente la propriété que la valeur correspondante de la propriété interrogée est attribuée à l'objet entité. C'est comment écrire ResultMap pour une requête simple. Ensuite, jetons un coup d'œil à une requête plus compliquée.
Il y a une classe de commentaires, qui a une référence de blog, indiquant à quel blog il s'agit. Lors de l'interrogation des commentaires, nous devons également trouver le blog correspondant et l'avoir attribué à son attribut de blog.
Importer java.util.date; commentaire de classe publique {private int id; contenu de chaîne privée; contenu privé date commentDate = new Date (); blog public blog; public int getID () {return id;} public void setid (int id) {this.id = id;} public string getContent () {return contenu;} public void setContent (strict contenu) {this.Content = contenu; {return commentDate;}public void setCommentDate(Date commentDate) {this.commentDate = commentDate;}public Blog getBlog() {return blog;}public void setBlog(Blog blog) {this.blog = blog;}public String toString() {return blog + "/n ----------------评论-----------------/n id: " + id + "/n content: " + content + "/ n commentdate:" + commentdate;}}C'est écrit comme ça
<! - From commentmapper.xml fichier -> <resultMap type = "comment" id = "commentResult"> <association propriété = "blog" select = "selectBlog" colonnel = "blog" javatype = "blog" /> </ résultatmap> <select id = "selectComment" ParametType = "int" ResultMap = "commentResult"> SELECT * à partir de T_Comment où id = # #} </ commentResult "> SELECT * à partir de T_Comment où id = #}} </ commentResult"> SELECT * à partir de T_comment où ID = # #} </ commentaire> SELECT * id = "selectBlog" ParameterType = "int" resultType = "blog"> sélectionner * dans T_Comment où id = # {id} </ select> <select id = "selectBlog" ParameterType = "int" resultType = "Blog"> SELECT * FROM T_BLOG WHERE ID = # {id} </ select>La situation d'accès est comme ça. Tout d'abord, vous demandez la carte de sélection avec l'ID de SelectComment, puis vous obtenez un objet ResultMap avec l'ID de CommentResult. Nous pouvons voir que le type de retour du résultat correspondant est un objet de commentaire, qui n'a qu'un seul nœud d'association, et il n'y a pas de nœud d'enfant ID et résultat correspondant à la question simple mentionnée ci-dessus, mais il affectera toujours l'ID correspondant et d'autres attributs à l'objet de commentaire. C'est ce que MyB a mentionné plus tôt. ATI a une fonction d'encapsulation automatique. Tant que vous fournissez un type de retour, MyBatis utilisera les résultats de la requête pour encapsuler l'objet correspondant en fonction de son propre jugement. Par conséquent, dans la requête simple ci-dessus, si vous n'indiquez pas clairement quel champ correspond à ID et quel champ correspond au titre dans le résultat, MyBatis le résumera également en fonction de son propre jugement. Le jugement de Mybatis est de comparer le champ de la requête ou son alias correspondant aux attributs de l'objet de retour. S'il correspond et que le type correspond également, MyBatis l'affectera. Un attribut de blog est associé dans le résultat correspondant ci-dessus, et son type Java correspondant est un blog. Dans la méthode d'écriture ci-dessus, l'objet associé est associé à des sous-requêtes, et bien sûr, il peut également être associé directement par le biais de la requête d'association. Dans le nœud enfant d'association ci-dessus, l'attribut de propriété indique quelle propriété associée est le type de retour ResultMap. Pour l'exemple ci-dessus, l'attribut de blog géré par commentaire; SELECT indique quelle sélection de la carte pour mapper l'attribut associé correspondant, c'est-à-dire qu'il demandera une carte de sélection avec la valeur correspondant à sélectionner pour interroger l'objet d'attribut associé; La colonne indique la paire de valeurs de clé correspondant au résultatmap avec id commentResult. Cette paire de valeurs clés sera utilisée comme paramètre pour la sous-requête de l'objet associé, c'est-à-dire que la valeur de la requête d'attribut de blog dans SelectComment est transmise en tant que paramètre à la sous-requête du blog d'objets associé à la sous-requête du blog d'objets associé; Javatype indique le type de l'objet associé actuel en Java.
Ce qui précède introduit une requête de relation un à un ou un-à-plusieurs avec un seul parti dans le cas d'un à plusieurs. Dans les applications réelles, il existe une autre application qui utilise plus fréquemment. Il est nécessaire de découvrir les plus de parties correspondantes par le biais d'une partie. Lorsque vous éliminez plus les parties, une partie doit également être associée à une partie. Autrement dit, dans l'exemple ci-dessus, lors de la suppression de l'objet du blog, tous les commentaires correspondants sont supprimés. Lorsque vous retirez le commentaire, il doit encore éliminer le blog correspondant. Ceci est supprimé par une demande en Java. La méthode d'écriture est la suivante:
<! - From BlogMapper.xml File -> <resultMap type = "blog" id = "blogResult"> <id column = "id" propriété = "id" /> <collection propriété = "commentaires" select = "selectCommentsByBlog" colonnes = " javatype = "blog" column = "blog" select = "selectBlog" /> </ resultMap> <select id = "selectBlog" ParametType = "int" resultMap = "BlogResult"> SELECT * FROM T_BLOG WHERE ID = # {id} </ select> <! - Recherchez les commentaires par blog -> <select id = "selectCommentsByBlog" ParametType = "Int" resultMap = "commentResult"> Sélectionner * dans T_Comment où blog = # {blogid} </lect>L'entrée de la demande ci-dessus est une carte sélectionnée avec ID SelectBlog, et le résultat de retour est un résultat avec ID BlogResult. Le type d'ID BlogResult est le blog, qui spécifie les attributs et les champs de l'ID. La spécification de l'ID aura un grand effet sur la construction interne de Mybatis. Il est associé à un objet de commentaires. Parce qu'un blog peut avoir de nombreux commentaires, qui sont une collection, il est donc cartographié avec une collection de collection. Le Select indique toujours quelle sous-requête est effectuée pour interroger les commentaires correspondants. La colonne signifie quelle valeur de champ trouvée ci-dessus est transmise à la sous-requête en tant que paramètre. OFTYPE représente également le type de retour. Le type de retour ici est le type à l'intérieur de la collection. La raison pour laquelle le type OFF est utilisé à la place du type est qu'il est utilisé dans Mybatis pour le distinguer de l'association d'association.
Code de test:
@TestPublic void SelectCommentsByBlogTest () {SqlSession Session = util.getsqlSessionFactory (). OpenSession (); commentmapper commentmapper = session.getMapper (commentmapper.class); list <commentaire> commentaire = commentaire commentaires) System.out.println (commentaire); session.close ();} / *** requête un seul enregistrement * / @ testpublic void testSelectone () {SqlSession Session = util.getsqlSessionFactory (). OpenSession (); blogmapper blogmapper = session.getMapper (lister> commentaire = commentaires = commentaires = commentaires = blog Blog. blog.getComments (); if (commentaires! = null) {System.out.println ("-------------- Les commentaires Taille ------------" + commentaire.size ()); pour (commentaire commentaire: commentaires) System.out.println (commentaire);} session.close ();};Ce qui précède est un bref aperçu du résultat ResultMap dans Mybatis qui vous est présenté par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!