1.ResultMap
Les fichiers XML mappés SQL sont là où toutes les instructions SQL sont placées. Vous devez définir un espace de travail, qui est généralement défini comme le chemin de la classe d'interface correspondante. Après avoir écrit le fichier de mappage d'instructions SQL, vous devez le référencer dans la balise MyBatis de fichiers de fichiers de configuration, par exemple:
<mapper ressource = "com / liming / manager / data / mappers / userMapper.xml" /> <mapper ressource = "com / liming / manager / data / mappers / studentmapper.xml" /> <mapper ressource = "com / liming / manager / data / mappers / classmapper.xml" /> <masper ressource = "com / ling /> </ mappers>
Lorsque l'interface Java est dans un chemin relatif vers le fichier XML, il ne peut pas être déclaré dans les mappeurs du fichier de configuration MyBatis.
SQL mappe certains éléments élémentaires des fichiers XML:
(1). Le cache configure le cache pour un motif donné (2). Cache-Ref fait référence à un cache d'un autre motif (3). ResultMap C'est l'élément le plus complexe mais puissant, qui décrit comment charger des objets à partir de l'ensemble de résultats (4). SQL A SQL Block qui peut être multiplexé par d'autres instructions (5). Insérer l'instruction d'insertion de carte (6). Mise à jour de l'instruction de mise à jour de la carte (7). Supprimer l'instruction de Deleete Map (8). Sélectionnez - MAP SELECT CONSEILLE
1.1 ResultMap
ResultMap est l'élément le plus important et le plus puissant de Mybatis. Vous pouvez économiser 90% de votre code que les ensembles de résultats d'appel avec JDBC, ou vous pouvez faire beaucoup de choses que JDBC ne prend pas en charge. En fait, il peut prendre des milliers de lignes de code pour écrire une déclaration complexe équivalente à une mappage similaire à une interaction. Le but de ResultMaps est une déclaration si simple sans mappage de résultats inutile. Des déclarations plus complexes ne nécessitent pas d'autre que quelques déclarations absolument nécessaires pour décrire la relation.
ResultMap Attribut: Type est la classe d'entité Java; ID est l'identifiant de ce résultat.
Le mappage que ResultMap peut être défini:
(1). Le constructeur est utilisé pour refléter le résultat à un constructeur de classe instancié
a) Paramètre ID IDARG; Marquez l'ensemble de résultats comme ID pour faciliter l'appel global
b) Réflexion moyenne au constructeur
(2). Résultat d'identification d'identification, marquez le résultat des résultats comme ID pour faciliter l'appel global
(3). Le résultat reflète des résultats normaux aux propriétés de Javabean
(4). association la combinaison de types complexes; Types de synthèses de résultats multiples
a) mappages de résultats imbriqués plusieurs résultats cartonnent eux-mêmes les associations imbriquées et peuvent également être référencées à une autre
(5). Collection une collection de types complexes
(6). La collection de mappages de résultats imbriqués peut également être référencé à un autre
(7). Discriminator utilise une valeur de résultat pour décider quel résultat map utiliser
a) cas de cas de cas de la carte des résultats de certaines valeurs de base
je. Mappings de résultats imbriqués Un scénario de cas est lui-même une carte de résultats, il peut également inclure certains des mêmes éléments, ou référence à un résultat externe.
1.1.1 ID, résultat
L'ID et le résultat sont les mappages les plus simples, l'ID est le mappage de clé principal; Les cartes de résultat des autres champs de table de base de données de base aux attributs de classe d'entité.
L'exemple le plus simple:
<resultmap type = "liming.student.manager.data.model.studententity" id = "StudentResultMap"> <id Property = "StudentId" Column = "Student_id" Javatype = "String" JDBCTYPE = " JDBCTYPE = "VARCHAR" /> <Result Property = "StudentSex" Column = "Student_SEX" Javatype = "int" JDBCTYPE = "INTEGER" /> <Result Property = "StudentBirthday" Column = "Student_Birthday" Javatype = "Date" JDBCTYPE = "Date" /> <Result Property = "StudentPhoto" javatype = "byte []" jdbcType = "blob" typehandler = "org.apache.ibatis.type.blobtypehandler" /> </ résultatmap>
Détails de la configuration des propriétés de l'instruction ID et Résultat:
propriété | décrire | |
propriété | Le nom d'attribut qui doit être mappé au JavaBean. | |
colonne | Le nom de colonne ou l'étiquette Alias de la table de données. | |
javatype | Un nom de classe complet ou un alias de type. Si vous correspondez à un Javabean, Mybatis le détectera généralement par lui-même. Ensuite, si vous mappez un hashmap, vous devez spécifier l'objectif à atteindre par Javatype. | |
jdbcType | Une liste de types pris en charge par le tableau de données. Cette propriété n'est utile que pour les colonnes qui permettent vide lors de l'insertion, de la mise à jour ou de la suppression. JDBC l'exige, mais MyBatis ne le fait pas. Si vous encodiez directement pour JDBC et que vous avez des colonnes qui permettent vide, vous souhaitez spécifier cet élément. | |
type de type | Utilisez cette propriété pour remplacer le processeur de type. Cette valeur peut être un nom de classe complet ou un alias de type. |
<resultMap type = "StudentEntity" id = "StudentResultMap"> <constructor> <idarg javatype = "String" colonnen = "student_id" /> <arg javatype = "string" chronn = "student_name" /> <arg javatype = "string" column = "student_sex" /> <arg javatype = "date" column = "student_birth" /> </groty </sultMap>
Bien sûr, nous devons définir la méthode du constructeur de la classe d'entité étudiante:
Public StudentEntity (String StudentId, String StudentName, String StudentSex, Date StudentBirthday) {this.Studentid = StudentId; this.studentName = StudentName; this.studentSex = StudentSex; this.StudentBirthday = StudentBirthday; } 1.1.3 Association
L'élément syndical est utilisé pour faire face à une relation "un à un". Vous devez spécifier les propriétés de la classe d'entité Java mappée et le javatype de l'attribut (généralement Mybatis le reconnaîtra vous-même). Le nom de colonne de la table de base de données correspondante. Si vous souhaitez remplacer, renvoyez la valeur du résultat, vous devez spécifier le TypeHandler.
Différentes situations doivent dire à Mybatis comment charger un syndicat. Mybatis peut être chargé de deux manières:
(1). SELECT: Exécutez une autre instruction SQL de mappage pour renvoyer un type d'entité Java. Plus flexible;
(2). RésultatsMap: utilisez une carte de résultat imbriquée pour traiter les ensembles de résultats de requête via la jointure et les mappez-les sur les types d'entités Java.
Par exemple, une classe correspond à un enseignant de classe.
Tout d'abord, définissez les attributs du professeur de classe dans la classe:
professeur privé professeur de professeur;
1.1.3.1 Utilisez SELECT pour implémenter Union
Exemple: il y a l'attribut d'un enseignant de classe dans la catégorie des entités de classe. Lorsqu'une entité de classe est obtenue par le biais d'efforts conjoints, l'entité de l'enseignant de classe est cartographiée en même temps.
Cela peut réutiliser directement les instructions de sélection définies dans le fichier TeacherMapper.xml pour l'interrogation du professeur en fonction de son identifiant. Et vous n'avez pas besoin de modifier les instructions SQL écrites, il vous suffit de modifier directement le résultat.
Une partie du contenu du fichier classmapper.xml:
<resultMap type = "Classity" id = "classResultMap"> <id propriété = "classid" chronn = "class_id" /> <résultat propriété = "classname" colonnel = "class_name" /> <result Property = "classyear" column = "class_year" /> <association) id = "getClassById" ParameterType = "String" resultMap = "classResultMap"> SELECT * FROM CLASS_TBL CT où ct.class_id = # {classid}; </lect>Une partie du fichier TeacherMapper.xml:
<resultMap type = "enseignante" id = "TeacherResultMap"> <id Property = "TeacherId" Column = "Teacher_id" /> <Result Property = "TeachName" Column = "Teacher_name" /> <Result Property = "TeachersEx" Column = "Teacher_Sex" /> <Result Property = "WorkDate" Column = "Teacher_Birthday" Column = "Work_Date" /> <Result Property = "WorkDate" Column = "Work_Date" /> <Result Property = "Professional" Column = "Professionnel" /> </ ResultMap> <Select Id = "GetTeacher" ParameterType = "String" ResultMap = "TeachErSultMap"> SELECT * FROM Teacher_TBL TT WHERE TT.
1.1.3.2 Utiliser le résultat pour atteindre un syndicat
La même fonction que ci-dessus est d'interroger la classe et également d'interroger le professeur de classe. Vous devez ajouter ResultMap (défini dans le fichier XML de l'enseignant) dans l'association, écrivez un nouveau SQL (interrogez la table de classe de la classe à gauche) et n'avez pas besoin de se sélectionner l'enseignant.
Modifiez le contenu du fichier classmapper.xml:
<resultMap type = "Classity" id = "classResultMap"> <id propriété = "classid" chronn = "class_id" /> <result Property = "className" column = "class_name" /> <result Property = "classyear" column = "class_year" /> <association property = "enseignentity" column = "enseign_id" resultMap = "TeenOrSultMap" id = "getClassandTeacher" ParameterType = "String" resultMap = "classResultMap"> SELECT * FROM CLASS_TBL CT Left Join Teacher_tbl TT sur ct.teacher_id = tt.teacher_id où ct.class_id = # {classid}; </lect>Pour le TeachErresultMap, veuillez consulter le contenu ci-dessus dans le fichier TeacherMapper.xml.
1.1.4 Collection
Les éléments d'agrégation sont utilisés pour gérer les relations "un à plusieurs". Vous devez spécifier les attributs de la classe d'entité Java de mappage, le javatype de l'attribut (généralement ArrayList); le type de l'objet dans la liste de l'objet (classe d'entité Java); le nom de colonne de la table de base de données correspondante;
Différentes situations doivent dire à Mybatis comment charger une agrégation. Mybatis peut être chargé de deux manières:
(1). SELECT: Exécutez une autre instruction SQL de mappage pour renvoyer un type d'entité Java. Plus flexible;
(2). RésultatsMap: utilisez une carte de résultat imbriquée pour traiter les ensembles de résultats de requête via la jointure et les mappez-les sur les types d'entités Java.
Par exemple, une classe a plusieurs élèves.
Définissez d'abord les attributs de la liste des étudiants dans la classe:
Liste privée <Suppurty> StudentList;
1.1.4.1 Utilisez Sélectionner pour implémenter l'agrégation
L'utilisation est très similaire à l'Union, la différence est que c'est un à plusieurs, donc généralement les listes cartographiées sont répertoriées. Ici, vous devez donc définir Javatype comme ArrayList, vous devez également définir le type de l'objet dans la liste, et le nom de l'instruction du Select qui doit être défini (il convient de noter que la condition de déclaration de sélection pour l'élève de requête ici doit être la clé étrangère classique).
Une partie du contenu du fichier classmapper.xml:
<resultMap type = "Classity" id = "classResultMap"> <id propriété = "classid" chronn = "class_id" /> <result Property = "className" column = "class_name" /> <result Property = "classyear" column = "class_year" /> <association property = "enseignenttity" column = "enseign_id" select = "GetTeacher" /> <collection = "property =" property = "studentLiS colonnes = "class_id" javatype = "arrayList" ofType = "StudentEntity" select = "getStudentByClassId" /> </ resultMap> <select id = "getClassbyid" ParameterType = "String" resultMap = "classResultMap"> SELECT * From class_tbl ct where ct.class_id = # {classid}; </lect>Partie du fichier StudentMapper.xml:
<! - Propriétés Java, cartographie de la définition entre les champs de table de base de données -> <resultMap type = "StudentEntity" id = "StudentResultMap"> <id Property = "StudentId" Column = "Student_id" /> <Result Property = "StudentName" Column = "Student_name" /> <Result Property = "StudentSex" Column = "Student_SEX" /> <Result Property = "StudentBirth" colonnes = "Student_Birthday" /> </ ResultMap> <! - Recherchez la liste des étudiants, en fonction de la classe ID -> <select id = "getStudentByClassId" ParameterType = "String" resultMap = "StudentResultMap"> <include refid = "selectStudEntall" /> WHERET ST.Class_id = # {Classid} </ Select> 1.1.4.2 Utilisez le résultat pour obtenir l'agrégation
En utilisant le résultat, vous devez réécrire un SQL, la table étudiante à gauche.
<resultMap type = "Classity" id = "classResultMap"> <id propriété = "classid" chronn = "class_id" /> <résultat propriété = "classname" collumn = "class_name" /> <result Property = "classyear" column = "class_year" /> <association property = "enseignenttity" column = "enseign_id" resultMap = "TeenOrSultMap" Column = "class_id" javatype = "arrayList" ofType = "StudentEntity" resultMap = "StudentResultMap" /> </ resultMap> <select id = "getClassandTeachersTudent" ParameterType = "String" resultMap = "classResultMap"> SELECT * From class_tbl Ct Left id Enseignante_tbl tt sur ct.teacher_id = tt.teacher_id où ct.class_id = # {classid}; </lect>
Pour le TeachErresultMap, veuillez consulter le contenu ci-dessus dans le fichier TeacherMapper.xml. Veuillez consulter le StudentResultMap dans la section ci-dessus du fichier StudentMapper.xml.
1.1.5Discriminator Discriminator <BR /> Parfois, une requête de base de données distincte peut renvoyer un ensemble de résultats de nombreux types de données différents (mais espérons-le, de la corrélation). L'élément de discriminateur est conçu pour gérer cette situation, y compris la hiérarchie de succession des classes. Le discriminateur est très facile à comprendre car il se comporte un peu comme les instructions de commutation en Java.
Le discriminateur de définition spécifie les propriétés de la colonne et du javatype. Les colonnes sont l'endroit où MyBatis recherche des valeurs de comparaison. Javatype est le bon type à utiliser pour assurer des tests équivalents (bien que les chaînes soient utiles dans de nombreux cas).
L'exemple suivant est que lorsque Classid est 20000001, l'attribut Classid est mappé.
<resultmap type = "liming.student.manager.data.model.studententity" id = "resultmap_studententity_discriminator"> <id Property = "StudentId" column = "Student_id" javatype = "String" jdbcType = "varChar" /> <résultat = "StudentName" Column = "Student_name" Javaty JDBCTYPE = "VARCHAR" /> <Result Property = "StudentSex" Column = "Student_SEX" Javatype = "int" JDBCTYPE = "INTEGER" /> <Result Property = "StudentBirthday" Column = "Student_Birthday" Javatype = "Date" JDBCTYPE = "Date" /> <Result Property = "StudentPhoto" javatype = "byte []" jdbcType = "blob" typehandler = "org.apache.ibatis.type.blobtypeHandler" /> <résultat propriété = "PlaceId" colonnel = "Place_id" javatype = "String" JDBCTYPE = "VARCHAR" jdbcType = "varchar"> <case valeur = "20000001" resultType = "liming.student.manager.data.model.studententity"> <result Property = "Classid" column = "class_id" javatype = "string" jdbcType = "varchar" /> </safer> </scriminator>
2. Ajouter, supprimer, modifier et vérifier, paramètres et cache
2.1 Sélectionner
Un élément sélectionné est très simple. Par exemple:
<! - interroge l'étudiant, selon ID -> <select id = "getStudent" ParameterType = "String" resultMap = "StudentResultMap"> SELECT St.Student_id, St.Student_name, St.Student_Sex, St.Student_Birthday, ST.CLASS_ID DE
Cette instruction est appelée 'GetStudent, a un paramètre de chaîne et renvoie un objet de type d'étudiant.
Notez que l'identification des paramètres est: # {StudentID}.
Sélectionnez les détails de la configuration de l'attribut:
| propriété | décrire | Obtenez la valeur | défaut |
| identifiant | Dans ce mode, un identifiant unique peut être référencé par d'autres déclarations | ||
| paramètre | Le nom ou le pseudonyme de la classe pour le paramètre transmis à cette déclaration | ||
| résultat | L'instruction renvoie le nom ou l'alias de la classe entier du type de valeur. Notez que s'il s'agit d'une collection, le nom ou l'alias de la classe entière de l'élément de la collection est rempli ici, plutôt que le nom de classe de la collection elle-même. (ResultType et ResultMap ne peuvent pas être utilisés ensemble) | ||
| ResultMap | Le nom de résultat externe référencé. La cartographie des résultats de résultats est la fonctionnalité la plus puissante de Mybatis. De nombreux mappages complexes peuvent être facilement résolus. (ResultType et ResultMap ne peuvent pas être utilisés ensemble) | ||
| cache | S'il est défini sur true, le cache sera effacé chaque fois que l'instruction est appelée. L'instruction SELECT est définie sur false par défaut | VRAI | FAUX | FAUX |
| user | S'il est défini sur true, l'ensemble de résultats de l'instruction sera mis en cache. L'instruction SELECT est définie sur false par défaut True | False False Le délai d'expiration définit le temps maximum que le lecteur attend la réponse avant de lancer une exception. La valeur par défaut est sans valeur et le lecteur se décide. | VRAI | FAUX | FAUX |
| temps mort | Réglez le temps maximum que le lecteur attend une réponse avant de lancer une exception. La valeur par défaut doit être définie sans valeur, et le lecteur lui-même décide | Entier positif | Pas réglé |
| récupérer | Après avoir réglé une valeur, le lecteur sera ravi de retourner après que le nombre d'ensembles de résultats atteigne cette valeur. La valeur par défaut n'est pas définie et le lecteur se décide. | Entier positif | Décision de conduite |
| ConstatType StatementType | déclaration, déclaration préparée, déclaration appelée. Déclarations préparées, déclarations appelés | DÉCLARATION PRÉPARÉ Appelant | PRÉPARÉ |
| ResultSetType | Forward_only, Scroll_Sensitive, Scroll_INSENSITION Transfert uniquement, défilement de défilement sensible et insensible à la casse | Avant_only Scroll_sentif Scroll_insensitive | Décision de conduite |
2.2 INSERT
Une déclaration d'insertion simple:
<! - INSERT Student -> <insert id = "insertstudent" ParameterType = "StudentEntity"> Insérer dans Student_tbl (Student_id, Student_Name, Student_Sex, Student_Birthday, Class_id) (# {StudentId}, # {StudentName}, # {StudentSex}, # # {StudentBirthday}, # # # # # # # # #class}) </sère>L'insert peut utiliser la stratégie de clé primaire automatique prise en charge par la base de données, définir useGeneratedKeys = "true", puis définir KeyProperty à la colonne correspondante, et cela est fait. Par exemple, l'étudiant ci-dessus utilise auto-généré pour générer une clé primaire pour la colonne ID. Vous pouvez également utiliser l'élément SelectKey. L'exemple suivant utilise la base de données MySQL NextVal («Student») comme fonction personnalisée pour générer une clé.
<! - INSERT Student Automatic Primary Key -> <insert id = "insertStudentAutokey" ParameterType = "StudentEntity"> <SelectKey KeyProperty = "StudentId" resultType = "String" Order = "Before"> SELECT NextVal ('Student') </ SelectKey> INSERT INTERD_TBL_ID) (# {StudentId}, # {StudentName}, # {StudentSex}, # {StudentBirthday}, # {Classity.classid}) </serser>| propriété | décrire | Obtenez la valeur | défaut |
| identifiant | Dans ce mode, un identifiant unique peut être référencé par d'autres déclarations | ||
| paramètre | Le nom ou le pseudonyme de la classe pour le paramètre transmis à cette déclaration | ||
| cache | S'il est défini sur true, le cache sera effacé chaque fois que l'instruction est appelée. L'instruction SELECT est définie sur false par défaut | VRAI | FAUX | FAUX |
| user | S'il est défini sur true, l'ensemble de résultats de l'instruction sera mis en cache. L'instruction SELECT est définie sur false par défaut True | False False Le délai d'expiration définit le temps maximum que le lecteur attend la réponse avant de lancer une exception. La valeur par défaut est sans valeur et le lecteur se décide. | VRAI | FAUX | FAUX |
| temps mort | Réglez le temps maximum que le lecteur attend une réponse avant de lancer une exception. La valeur par défaut doit être définie sans valeur, et le lecteur lui-même décide | Entier positif | Pas réglé |
| récupérer | Après avoir réglé une valeur, le lecteur sera ravi de retourner après que le nombre d'ensembles de résultats atteigne cette valeur. La valeur par défaut n'est pas définie et le lecteur se décide. | Entier positif | Décision de conduite |
| ConstatType StatementType | déclaration, déclaration préparée, déclaration appelée. Déclarations préparées, déclarations appelés | DÉCLARATION PRÉPARÉ Appelant | PRÉPARÉ |
| useGeneratedKeys | Dites à MyBatis d'utiliser la méthode GetGeneratedKeys de JDBC pour obtenir la clé principale générée par la base de données (MySQL, SQLServer, etc. Les bases de données relationnelles auront des champs générés automatiquement). Par défaut: faux | VRAI | FAUX | FAUX |
| député | Identifiez une valeur à retourner par la clé qui est définie sur MyBatis dans GetGeneratedKeys, ou utilisez un SelectKey pour l'instruction INSERT Sous-élément. |
| propriété | décrire | Obtenez la valeur |
| député | L'attribut qui doit être défini pour le résultat généré par l'instruction SelectKey. | |
| résultat | Générer des types de résultats. MyBatis permet l'utilisation de types de données de base, y compris les types de chaîne et INT. | |
| Commande | Il peut être réglé avant ou après. S'il est défini auparavant, il sélectionnera d'abord la clé primaire, puis définira le KeyProperty, puis exécutera l'instruction INSERT; S'il est défini sur After, il exécutera d'abord l'instruction INSERT, puis exécutera l'instruction SelectKey, qui est généralement le mécanisme de séquence intégré dans l'instruction INSERT dans la base de données d'appels interne (telle que Oracle). | AVANT APRÈS |
| ConstatType StatementType | Comme ci-dessus, MyBatis prend en charge les formulaires de déclaration de déclaration, préparés et appelés, correspondant aux réponses de déclaration, de mise en scène et de callablestatement. | DÉCLARATION PRÉPARÉ Appelant |
2.3 Mise à jour, supprimer
Une mise à jour simple:
<! - Mise à jour des informations sur les étudiants -> <Update id = "UpdateStudent" ParameterType = "StudentEntity"> Update Student_TBL Set Student_TBL.STUDENT_NAME = # {StudentName}, Student_TBL.Student_Sex = # {StudentSEX}, Student_TBL.Student_Birthday = # {StudentBirthday}, Student_tblass_id = # {StudentBirthday}, Student_Tbl. # {Classity.classid} où student_tbl.student_id = # {StudentId}; </fatedate>Une simple suppression:
<! - Delete Student -> <Delete id = "DeleteStudent" ParameterType = "StudentEntity"> Supprimer de Student_TBL WHERE Student_id = # {StudentId} </preete>
Mise à jour et supprimer les détails de la configuration de l'attribut:
| propriété | décrire | Obtenez la valeur | défaut |
| identifiant | Dans ce mode, un identifiant unique peut être référencé par d'autres déclarations | ||
| paramètre | Le nom ou le pseudonyme de la classe pour le paramètre transmis à cette déclaration | ||
| cache | S'il est défini sur true, le cache sera effacé chaque fois que l'instruction est appelée. L'instruction SELECT est définie sur false par défaut | VRAI | FAUX | FAUX |
| user | S'il est défini sur true, l'ensemble de résultats de l'instruction sera mis en cache. L'instruction SELECT est définie sur false par défaut True | False False Le délai d'expiration définit le temps maximum que le lecteur attend la réponse avant de lancer une exception. La valeur par défaut est sans valeur et le lecteur se décide. | VRAI | FAUX | FAUX |
| temps mort | Réglez le temps maximum que le lecteur attend une réponse avant de lancer une exception. La valeur par défaut doit être définie sans valeur, et le lecteur lui-même décide | Entier positif | Pas réglé |
| récupérer | Après avoir réglé une valeur, le lecteur sera ravi de retourner après que le nombre d'ensembles de résultats atteigne cette valeur. La valeur par défaut n'est pas définie et le lecteur se décide. | Entier positif | Décision de conduite |
| ConstatType StatementType | déclaration, déclaration préparée, déclaration appelée. Déclarations préparées, déclarations appelés | DÉCLARATION PRÉPARÉ Appelant | PRÉPARÉ |
<! - Instruction SQL multiplex pour interroger tous les champs de la table étudiante -> <sql id = "selectStudentall"> SELECT St.Student_id, St.Student_name, St.Student_Sex, St.Student_Birthday, St.Class_id From Student_TBL ST </ sql>
De cette façon, vous pouvez dire directement et l'utiliser dans l'instruction SELECT. Modifiez l'instruction SELECT ci-dessus en:
<! - Interrogez l'étudiant, selon ID -> <select id = "getStudent" ParameterType = "String" resultMap = "StudentResultMap"> <include refid = "selectStudentall" /> où St.Student_id = # {StudentId} </ELECT> 2.5 paramètres
Des paramètres ont été utilisés dans de nombreux endroits ci-dessus, tels que la requête, la modification, les conditions de suppression, l'insertion, les données modifiées, etc. Les types de données de base que MyBatis peuvent utiliser et les types de données complexes de Java.
Types de données de base, chaîne, int, date, etc.
Cependant, l'utilisation des types de données de base ne peut fournir qu'un seul paramètre, vous devez donc utiliser la classe d'entité Java ou le type de carte comme type de paramètre. Ses attributs peuvent être obtenus directement via # {}.
2.5.1 Paramètres de type de base
Recherchez la liste des étudiants en fonction du temps d'admission:
<! - Recherchez la liste des étudiants, selon le temps d'admission -> <select id = "getStudentListByDate" ParameterType = "Date" resultMap = "StudentResultMap"> SELECT * FROM Student_tbl St Left Join Class_tbl CT sur St.Class_id = CT.Class_id WHERE CT.Class_year = # {Classyear}; </lect> List <StudentEntity> StudentList = StudentMapper.getStudentListByClassyEar (StringUtil.Parse ("2007-9-1")); for (StudentEntity EntityTemp: StudentList) {System.out.println (entityTemp.ToString ()); } 2.5.2 Paramètres de type entité Java
Recherchez la liste des étudiants par nom et sexe. Utilisez des classes d'entités comme paramètres:
<! - Query Student List, Like Name, = Gender, Paramet Entity Type -> <Select Id = "GetStudentLindWherentity" ParameterType = "StudentEntity" resultMap = "StudentResultMap"> SELECT * FROM Student_tbl St WHERE ST.Student_name comme Concat (Concat ('%', # # # #), '%') et St.STUDENT_ </lect> StudentEntity Entity = New StudentEntity (); entity.setStudentName ("li"); entity.setStudentSex ("mâle"); List <StudentEntity> StudentList = StudentMapper.getStudentListwhereNtity (Entity); for (StudentEntity EntityTemp: StudentList) {System.out.println (entityTemp.ToString ()); } 2.5.3 MAUTRE
Recherchez la liste des étudiants par nom et sexe. Utilisez la carte comme paramètres:
<! - Query Student List, = Gender, Type de carte des paramètres -> <Select id = "GetStudentListWheremap" ParameterType = "Map" resultMap = "StudentResultMap"> SELECT * FROM Student_tbl St Where St.Student_Sex = # {Sex} et St.Student_Sex = # {sexe} </lect> Map <string, string> map = new hashmap <string, string> (); Map.put ("Sex", "Femme"); map.put ("name", "li"); List <StudentEntity> StudentList = StudentMapper.getStudentList WHEREMAP (MAP); for (StudentEntity EntityTemp: StudentList) {System.out.println (entityTemp.ToString ()); } 2.5.4 Implémentation de multi-paramètres
Si vous souhaitez transmettre plusieurs paramètres, vous devez ajouter une annotation @param aux paramètres de l'interface. Étant donné un exemple:
Écriture d'interface:
Public List <StudentEntity> getStudentListwhereParam (@param (value = "name") Nom de la chaîne, @param (value = "sexe") String Sex, @param (value = "anniversaire") Date Anniversaire, @param (value = "Classity") Classentity Classentity);
Méthode d'écriture SQL:
<! - Liste des étudiants de requête, comme le nom, = genre, = anniversaire, = classe, méthode multi-paramètre -> <select id = "getStudentLhereParam" resultMap = "StudentResultMap"> SELECT * FROM Student_tbl st <Where> Where> Test = "Name! = Null and Name! = ''"> St.Student_name comme Concat (Concat ('%', # {#), '),'% ') </ if> <if test = "Sex! = null and Sex! = ''"> Et st.Student_sex = # {sexe} </ if> <if test = "anniversaire! = null"> Et saint-est-centé_birthday = # {anniversaire} </ if> <if test = "classitity! = null and classentity.classid! = null and null = # {Classity.classid} </ if> </ Where> </ Select>Faites une requête:
List <StudentEntity> StudentList = StudentMapper.getStudentListWhereParam ("," ", stringUtil.parse (" 1985-05-28 "), classmapper.getClassByid (" 20000002 ")); pour (EntityTemp.ToString (StudentList) {System.out.Println (EntityTemp.Tostring ());};}; 2.5.5 Méthode de substitution de chaînes
Par défaut, l'utilisation de la syntaxe # {} amène MyBatis à générer la propriété PréparedStatement et utilise le paramètre PreadStatement (=?) Pour définir la valeur en toute sécurité. Essayez d'être rapide et sûr et sont également fréquemment utilisés. Mais parfois, vous voudrez peut-être remplacer directement les chaînes inchangées dans les instructions SQL. Par exemple, pour l'ordre par, vous pouvez utiliser ceci: Commande par $ {Columnname} mais MyBatis ne modifiera pas et ne contournera pas cette chaîne.
Remarque: il est très dangereux de recevoir et d'appliquer une entrée utilisateur dans une instruction inchangée de cette manière. Cela permettra à l'utilisateur d'implanter le code corrompu, donc soit nécessite le champ de ne pas permettre au client d'entrer, soit vous vérifiez directement sa légitimité.
2.6 Cache Cache
MyBatis contient un mécanisme de cache puissant, configurable et personnalisable. La mise en œuvre du cache de MyBatis 3 a été améliorée à plusieurs reprises, ce qui est à la fois puissant et plus facile à configurer. Par défaut, le cache n'est pas activé. En plus du cache de session, il peut améliorer les performances et résoudre les dépendances globales. Allumez le cache de niveau 2, il vous suffit d'ajouter une ligne simple au fichier de mappage SQL: <cache />
La fonction de cette phrase simple est la suivante:
(1). Toutes les instructions de sélection du fichier de mappage seront mises en cache.
(2). Toutes les instructions d'insertion, de mise à jour et de suppression du fichier de mappage effaceront le cache.
(3). Le cache est recyclé à l'aide de l'algorithme "rarement utilisé récemment" (4). Le cache ne sera pas effacé par l'heure définie.
(5). Chaque cache peut stocker 1024 listes ou références à des objets (quel que soit le résultat de la requête).
(6). Le cache sera utilisé comme un cache "lire / écrire", ce qui signifie que l'objet récupéré n'est pas partagé et est sûr pour l'appelant. Il n'y aura pas d'autres appels (7). ou des modifications potentielles du fil.
Par exemple, créez un cache FIFO pour effacer une fois en 60 secondes, stocker 512 résultats d'objets ou référence de référence et renvoyer les résultats en lecture seule. Parce que les modifications dans des threads inutilisés peuvent entraîner des conflits de référence.
<cache epiction = "fifo" flushinterval = "60000" size = "512" readonly = "true"> </cache>
Vous pouvez également partager la même configuration ou instance de cache dans différents espaces de noms. Dans ce cas, vous pouvez utiliser Cache-Ref pour référencer un autre cache.
<cache-ref namespace = "com.liming.manager.data.studentmapper" />
Détails de configuration de l'attribut de l'instruction de cache:
| propriété | illustrer | Obtenez la valeur | valeur par défaut |
| Expulsion | Politique de mise en cache: LRU - le moins récent utilisation: supprimer les objets qui n'ont pas été utilisés au cours de la dernière longue période. FIFI- First-in First-Out: Déplacez l'objet précédent dans la file d'attente Soft - Soft Reference: Basé sur des règles de référence souples, utilisez le mécanisme de collecte des ordures pour supprimer les objets Faible - Référence faible: Utilisez le mécanisme de collecte des ordures pour supprimer avec force des objets basés sur des règles de référence faibles | LRU FiFi DOUX FAIBLE | LRU |
| chasser | Représente un temps total raisonnable en millisecondes. La valeur par défaut n'est pas définie, donc si vous utilisez une compensation Uninterval, vous ne pouvez appeler que des instructions pour l'effacer. | Entier positif | Pas réglé |
| taille | La taille de l'objet mis en cache | Entier positif | 1024 |
| lire en lecture | Le cache en lecture seule renverra la même instance à tous les appelants. Par conséquent, aucun d'entre eux ne peut être modifié, ce qui peut considérablement améliorer les performances. Le cache écrit passera à travers la séquence Pour retourner une copie d'un objet mis en cache. Ce sera plus lent, mais plus sûr. La valeur par défaut est donc fausse. | VRAI | FAUX | FAUX |