Processus d'exécution du cadre MyBatis:
1. Configurer le fichier de configuration MyBatis, sqlmapconfig.xml (le nom n'est pas corrigé)
2. Chargez l'environnement exécutant MyBatis via des fichiers de configuration et créez l'usine de session SQLSessionFactory
SQLSessionFactory est utilisé de manière singleton lorsqu'elle est réellement utilisée.
3. Créez une SQLSession via SQLSessionFactory
SQLSession est une interface axée sur l'utilisateur (fournissant des méthodes de base de données de fonctionnement). L'objet d'implémentation est insensible à thread. Il est recommandé que le scénario d'application de SQLSession soit dans le corps de la méthode.
4. Appelez la méthode SQLSession pour manipuler les données.
Si vous devez commettre une transaction, vous devez exécuter la méthode commit () de SQLSession.
5. Libérer les ressources et fermer SQLSession
Méthode de développement de l'agent de mappeur (recommandé)
Seuls les programmeurs doivent écrire une interface de mapper (c'est-à-dire l'interface DAO)
Les programmeurs doivent suivre une spécification de développement lors de la rédaction de mapper.xml (fichiers de mappage) et de mapper.java:
1. Espace de noms dans Mapper.xml est le chemin complet de la classe Mapper.java.
2. L'ID de l'instruction dans Mappper.xml est le même que le nom de la méthode dans Mappper.java.
3. Le paramètre de l'instruction dans Mapper.xml spécifie le type du paramètre d'entrée et le type du paramètre d'entrée de la méthode Mappel.java.
4. Le Type de résultat de l'instruction dans Mapper.xml spécifie le type de sortie et le type de valeur de retour de la méthode mappen.java.
Contenu de cet article:
Analyser le modèle de données du produit de commande.
Cartographie avancée: (apprendre)
Mettez en œuvre une requête individuelle, une à plusieurs requêtes de plusieurs à plusieurs.
Chargement de retard
Cache de requête
Cache de niveau 1
Cache de niveau 2 (comprendre les scénarios d'utilisation de MyBatis Level 2 Cache)
Intégration Mybatis et Spirng (Master)
Ingénierie inverse (peut utiliser)
Commandez du modèle de données du produit
Idées d'analyse du modèle de données
1. Contenu de données enregistré dans chaque tableau
Familier le contenu enregistré dans chaque tableau par module équivaut au processus d'apprentissage des exigences du système (fonctions).
2. Paramètres de champ importants pour chaque table
Champs non vides, champs de clés étrangers
3. La relation entre les tables au niveau de la base de données
Relation de clé étrangère
4. Relation commerciale entre les tables
Lors de l'analyse de la relation commerciale entre les tables, il est nécessaire de l'analyser en fonction d'une certaine signification commerciale.
Analyse du modèle de données
Table utilisateur utilisateur:
Enregistrer les informations utilisateur du produit acheté
Table de commande: commandes
Enregistre la commande créée par l'utilisateur (commande pour acheter des articles)
Détail de commande: OrderDetail:
Enregistrez les informations détaillées de la commande, à savoir les informations de l'achat
Liste des produits: articles
Informations sur les produits enregistrés
Relation commerciale entre les tables:
Lors de l'analyse de la relation commerciale entre les tables, il est nécessaire de l'analyser en fonction d'une certaine signification commerciale.
Analysez d'abord la relation commerciale entre les tableaux qui ont des relations entre les niveaux de données:
usre et ordres:
Utilisateur ``-> ORDERS: Un utilisateur peut créer plusieurs commandes, une à plusieurs
ORDERS–> Utilisateur: une commande est créée par un seul utilisateur, un à un
commandes et ordonnance:
Commandes> CommandeDetail: Une commande peut inclure plusieurs détails de commande, car une commande peut acheter plusieurs articles et les informations d'achat de chaque article sont enregistrées dans OrderDetail, une relation un-à-plusieurs
OrderDetail> Ordres: un détail de commande ne peut être inclus que dans un seul ordre, un à un
OrderDetail et ItemsM:
ORDERDETAIL RED> Éléments: les détails d'une commande ne correspondent qu'à une seule information de produit, un à un
Articles> OrderDetail: Un produit peut être inclus dans plusieurs détails de commande, un pour beaucoup
Analysez ensuite s'il existe une relation commerciale entre les tableaux qui ne sont pas liés au niveau de la base de données:
commandes et articles:
La relation entre les commandes et les éléments peut être établie via le tableau OrderDetail.
Utilisateur et éléments: constituent une relation plusieurs à plusieurs à travers d'autres tables
Requête individuelle
Exigences: Informations sur les commandes de requête et associer les informations sur les utilisateurs de requête pour la création de commandes
Utilisez ResultType pour interroger
Considération sur l'utilisation des instructions SQL
Déterminez le tableau principal de la requête: Tableau de commande
Déterminez la table d'association pour la requête: table utilisateur
La requête d'association utilise-t-elle un lien interne ou un lien externe?
Puisqu'il y a une clé étrangère (user_id) dans le tableau des commandes, un seul enregistrement peut être trouvé en interrogeant le tableau utilisateur via une association de clé étrangère, et des liens internes peuvent être utilisés.
Sélectionnez les commandes. *, User.userName, user.sex, user.address fromorders, utilisateur où les commandes.user_id = user.id
Créer Pojo (orderscustom.java)
Carte les résultats de la requête SQL ci-dessus dans POJO, qui doit inclure tous les noms de colonne de requête.
Les ordres originaux ne peuvent pas cartographier tous les champs et un pojo nouvellement créé est requis.
Créez une classe PO qui hérite d'une classe PO qui comprend de nombreux champs de requête.
Ordersmapperstom.xml
Ordersmapperstom.java
Écrire des classes de test
Cliquez avec le bouton droit sur le fichier ORDERSMAPERCUSTUCH.JAVA> Sélectionnez Nouveau> Autres> Cas de test JUnit> Sélectionnez la fonction à tester
Écrivez le code suivant dans ORDERSMAPERCUSTOMTEST.JAVA:
classe publique ordersmapperstomTest {private sqlSessionFactory sqlSessionFactory; // Cette méthode consiste à exécuter @Beforepublic void setup () lance une exception de la chaîne de configuration SQLMAPConFig.xml "; // obtenir une configuration de configuration de la configuration de la configuration de la configuration de la configuration des fichiers de fichiers de configuration. Resources.getResourceSstream (ressource); // Créer une usine de session et passer dans les informations de fichier de configuration MyBatis SqlSessionFactory = new SqlSessionFactoryBuilder (). Build (InputStream);} @ TestPublic Void testFinDordersUser () Throws exception {sqlsession sqlSession = objet proxy ordersmapperstom ordersMapperTustom = sqlSession.getMapper (ordersmapperstom.class); // appelle la méthode de mappeur <Commante.pristom> list = ordersmapperstom.finDordersuser ();} system.out.println (list);Utilisez ResultMap pour interroger
Instruction SQL: SQL implémenté dans le même résultat
Idées d'utilisation de la mappage des résultats
Utilisez ResultMap pour mapper les informations de commande dans le résultat de la requête dans l'objet Ordors, ajoutez l'attribut utilisateur dans la classe Orders et mappez les informations utilisateur de requête associées à l'attribut utilisateur dans l'objet Orders.
Ajouter un attribut utilisateur à la classe des commandes
Ordersmapperstom.xml
Définir ResultMap
Tyep: signifie cartographier les résultats de la requête entière à une certaine classe par exemple: cn.itcast.mybatis.po.orders
ID: représente l'identifiant unique de la colonne de requête dans la table de la base de données, l'identifiant unique dans les informations de commande. S'il existe plusieurs colonnes qui forment un identifiant unique, configurez plusieurs ID.
Colonne: une colonne d'identification unique pour les informations de commande dans le tableau de la base de données
Propriété: Quelle propriété est mappée aux commandes par la colonne d'identification unique des informations de commande?
Association: utilisé pour cartographier les informations pour interroger les objets individuels
propriété: quelle propriété dans les ordres de cartographier les informations utilisateur de la requête associée
Javatype: quelle propriété a mappé à l'utilisateur
<! - Le résultat de l'utilisateur associé mappe le résultat de la requête entière à cn.itcast.mybatis.po.orders -> <resultmap type = "cn.itcast.mybatis.po.orders" id = "OrderSuserResultMap"> <! - Configurez les informations sur l'ordre mappées - ID: ID: Spécifie information. S'il y a plusieurs colonnes pour former un identifiant unique, configurez plusieurs idColumn: colonne d'identification unique des informations de commande Property: quelle propriété dans les ordres est mappée par la colonne d'identificateur unique des informations de commande -> <id column = "id" propriété = "id" /> <résultat colonnes = "user_id" propriété = "userrid" /> <résultat colonne = "nombre" Property = "numéro" /> <résultat = " Property = "CreateTime" /> <Result Column = "Note" Property = Note /> <! - Configurez les informations utilisateur associées mappées -> <! - Association: Informations utilisées pour cartographier la requête associée Propriété unique: quelle propriété dans les commandes pour cartographier les informations utilisateur de la requête associée à -> <association Property = "User" javatype = "CN.itcast.mybatis.po.User" Colonne: spécifiez la colonne qui identifie uniquement les informations utilisateur Javatype: quelle propriété est mappée à l'utilisateur -> <id column = "user_id" propriété = "id" /> <le résultat chronn = "username" propriété = "username" /> <result Column = "Sex" Property = "Sex" /> <résultat Column = "Address" Property = "Address" /> << / Association>
Définition de déclaration
Ordersmapperstom.java
Code de test
@TestPublic void testFinDordersUserResultMap () lève une exception {sqlSession sqlSession = SqlSessionFactory.OpenSession (); // Créer un objet proxy ORDERSMAPPERCUSTUANT. ordersmapperstom.FinDordersUserResultMap (); System.out.println (list); sqlSession.close ();}ResultType et ResultMap Implémentez le résumé de la requête individuelle
ResultType: il est relativement simple à implémenter à l'aide de ResultType. Si le nom de la colonne de requête n'est pas inclus dans le POJO, vous devez ajouter les attributs correspondants du nom de la colonne pour terminer le mappage.
S'il n'y a pas d'exigences particulières pour les résultats de la requête, il est recommandé d'utiliser ResultType.
ResultMap: le résultat doit être défini séparément, ce qui est un peu gênant. S'il existe des exigences particulières pour les résultats de la requête, l'utilisation de ResultMap peut compléter les attributs du pojo de mappage de requête associé.
ResultMap peut implémenter le chargement paresseux, ResultType ne peut pas implémenter le chargement paresseux.
Requête un-à-plusieurs
Exigences: Informations sur les commandes de requête et les détails des commandes.
déclaration SQL
Déterminez la table de requête principale: Tableau de commande
Déterminer la table de requête associée: Tableau des détails de la commande
Il suffit d'ajouter l'association de la liste des détails de commande en fonction de la requête individuelle.
SelectOrders. *, User.userName, user.sex, user.address, orderdetail.id orderdetail_id, orderDetail.items_id, commanderdetail.items_num, ordonnance.
Analyse: Utilisez ResultType pour cartographier les résultats de la requête ci-dessus dans POJO, et les informations de commande sont la duplication.
Exigence: les enregistrements en double ne peuvent pas se produire pour la cartographie des commandes.
Ajoutez la propriété List <ordDetail> OrderDetails dans la classe ORDERS.Java.
Enfin, les informations de commande seront mappées en commandes et les détails de la commande correspondant à l'ordre sont mappés dans la propriété OrderDetails par ordre.
Le nombre de commandes enregistrées en mappé est de deux (les informations sur les commandes ne sont pas répétées)
La propriété OrderDetails dans chaque commande stocke les détails de la commande correspondant à l'ordre.
Ajouter la liste des détails de la commande Attribut dans orders.java
Ordersmapperstom.xml
ResultMap Définition
L'utilisation prolonge l'héritage sans configurer le mappage des informations de commande et des informations utilisateur dans
Collection: requête plusieurs enregistrements à mapper à l'objet de collection pour la requête d'association
Propriété: Carte la requête de l'association à plusieurs enregistrements à cn.itcast.mybatis.po.orders quelle propriété est cartographiée à cn.itcast.mybatis.po.orders
OFTYPE: Spécifie le type qui mappe à Pojo dans l'attribut de collection de liste
<! - Le résultat pour les commandes et les détails des commandes est hérité à l'aide des étendues, et n'a pas besoin de configurer le mappage des informations de commande et des informations utilisateur -> <resultMap type = "cn.itcast.mybatis.po.orders" id = "comtersandorderDetailResultMap" étend des informations sur les informations pour les commandes "> <! - Ordre -> <! Héritage, n'a pas besoin de configurer le mappage des informations de commande et des informations utilisateur -> <! - Informations sur les détails de la commande Une requête d'association de commande a plusieurs détails. Pour utiliser Collection to Map Collection: Map plusieurs enregistrements vers la propriété de l'objet de collection: Map Association Query to plusieurs enregistrements à cn.itcast.mybatis.po.orders quelle propriété de Type: Spécifiez le type de carte Pojo pour répertorier les propriétés de collection -> <Collection Property) L'identifiant unique des détails de la commande à cn.itcast.mybatis.po.orderDetail -> <id chronn = "OrderDetail_id" propriété = "id" /> <result Column = "items_id" propriété = "itemSID" /> <résultat Column = " Property = "OrdersId" /> </ Collection> </ ResultMap>
Ordersmapperstom.java
Code de test:
@TestPublic void testFinDordersAndOrderDetailResultMap () lève une exception {SqlSession SqlSession = SqlSessionFactory.OpenSession (); // Créer un objet proxy OrderSmapperstustom OrdersMapperTustom = SQLSESSESSE.GETMPER ordersmapperstom.FinDordersandOrderDetailResultMap (); System.out.println (list); sqlSession.close ();}résumé
MyBatis utilise la collection de ResultMap pour cartographier plusieurs enregistrements de la requête associée dans une propriété de collection de liste.
Implémentation à l'aide de ResultType:
Mappage des détails des commandes dans OrderDetails dans les commandes, vous devez le gérer vous-même, utiliser une boucle double pour traverser, supprimer des enregistrements en double et placer les détails des commandes dans OrderDetails.
Query de plusieurs à plusieurs
Exigences: interroger les utilisateurs et les informations d'achat d'utilisateurs.
déclaration SQL
La table principale de requête est: Tableau utilisateur
Tableau d'association: Étant donné que l'utilisateur et le produit ne sont pas directement liés, ils sont liés par les commandes et les détails des commandes, donc le tableau d'association: commandes, commandes
Sélectionnez les commandes. *, User.Username, User.Sex orders.user_id = user.id et orderdetail.orders_id = orders.id et orderdetail.items_id = items.id
Idées de cartographie
Cartez les informations de l'utilisateur dans l'utilisateur.
Ajoutez la liste d'attributs de la liste de commandes <Dorse> OrdersListe dans la classe d'utilisateurs pour cartographier les commandes créées par l'utilisateur à la liste de commandes
Ajouter la liste des détails de la liste des propriétés de la liste des propriétés <CommanderDetail> OrderDetials dans les commandes pour cartographier l'OrdreDetials
Ajoutez la propriété des éléments dans OrderDetail pour mapper les éléments correspondant aux détails de la commande aux éléments
Ordersmapperstom.xml
ResultMap Définition
<! - Interroge l'utilisateur et acheté des produits -> <resultmap type = "cn.itcast.mybatis.po.user" id = "userAnditemsResultMap"> <! - Informations utilisateur -> <id column = "user_id" property = "id" /> <result Column = "username" propriété = "username" /> <résultat colonne propriété = "adresse" /> <! - Informations de commande Un utilisateur correspond à plusieurs commandes et utilise le mappage de collecte -> <collection propriété = "OrdersList" ofType = "cn.itcast.mybatis.po.orders"> <id Column = "id" propriété = "id" /> <sult Column = "user_id" Property = "userrid" /> <résultat Colun Column = "CreateTime" Property = "CreateTime" /> <Result Column = "Remarque" Property = "Remarque" /> <! - Détails de la commande Un ordre comprend plusieurs détails -> <Collection Property = "OrderDetails" OFTYPE = "CN.itcast.mybatis.po.Orderdetail"> <id Column = "OrderDetail_id" Property = "id" /> <résultat Column = "Itemd_id" propriété = "itemsId" /> <résultat chronn = "items_num" propriété = "itemsnum" /> <result Column = "Orders_id" propriété = "OrdersId" /> <! - Informations de produit Un détail de commande correspond à un produit -> <association propriété = "items" javatype = "cn.itcast.mybatis.po.items"> <id Column = "Items_id" property = "id" colonnes = "items_name" propriété = "name" /> <résultat chronn = "items_detail" propriété = "Détail" /> <résultat chronn = "items_price" propriété = "Price" /> </ association> </ collection> </ collection> </ resultmap>
Ordersmapperstom.java
Code de test:
@TestPublic void TestFindUserAnSermSResultMap () lève une exception {SqlSession SqlSession = SQLSessionFactory.OpenSession (); // Créer un objet proxy OrdreSmapperTustom OrdersMappectomy ordersmapperstom.FindUseranDiTemsResultMap (); System.out.println (list); sqlSession.close ();} Résumé de la requête plusieurs à plusieurs
La liste détaillée des informations sur les produits achetées par l'utilisateur sera vérifiée (nom d'utilisateur, adresse utilisateur, nom de produit, heure d'achat, quantité d'achat)
En réponse aux exigences ci-dessus, nous utilisons ResultType pour cartographier les enregistrements de requête dans un POJO étendu, qui est très simple pour implémenter la fonction d'une liste détaillée.
Un-à-plusieurs est un cas particulier de plusieurs à plusieurs, comme suit:
Lors de l'interrogation des informations sur le produit achetées par les utilisateurs, la relation entre l'utilisateur et le produit est une relation de plusieurs à plusieurs.
Exigence 1:
Champs de requête: compte d'utilisateur, nom d'utilisateur, sexe de l'utilisateur, nom de produit, prix du produit (le plus courant)
Listes détaillées courantes dans le développement des entreprises, listes détaillées de produits achetés par les utilisateurs,
Utilisez ResultType pour cartographier la colonne de requête ci-dessus à la sortie POJO.
Exigence 2:
Champs de requête: compte d'utilisateur, nom d'utilisateur, quantité d'articles achetés, détails du produit (souris ON pour afficher les détails)
Utilisez ResultMap pour cartographier la liste des détails des produits achetés par l'utilisateur dans l'objet utilisateur.
Résumer:
L'utilisation de ResultMap est destinée aux fonctions qui ont des exigences particulières pour la cartographie des résultats de requête, telles que la cartographie des exigences spéciales dans des listes, y compris plusieurs listes.
Résumé de ResultType et ResultMap
ResultType:
effet:
Map que les résultats de la requête dans POJO en fonction du nom de colonne SQL POJO Nom de l'attribut.
occasion:
Affichage commun des enregistrements détaillés, par exemple lorsque les utilisateurs achètent les détails du produit et affichent toutes les informations de requête associées sur la page, vous pouvez directement utiliser ResultType pour cartographier chaque enregistrement.
Tirez dans le pojo et traversez la liste (Pojo dans la liste) sur la page frontale.
ResultMap:
Utiliser l'association et la collecte pour compléter la cartographie avancée individuelle et un à plusieurs (il existe des exigences de cartographie spéciales pour les résultats).
association:
effet:
Cartez les informations de requête associées dans un objet PoJO.
occasion:
Afin de faciliter l'interrogation des informations associées, vous pouvez utiliser l'association pour cartographier les informations de commande associées dans les attributs POJO des objets utilisateur, tels que: interroger les commandes et les informations utilisateur associées.
L'utilisation de ResultType ne peut pas cartographier les résultats de la requête à l'attribut POJO de l'objet PoJO. Choisissez d'utiliser ResultType ou ResultMap en fonction des besoins de traversant la requête Set Set.
Collection:
effet:
Cartez les informations de requête associées dans une collection de liste.
occasion:
Afin de faciliter l'interrogation des informations d'association de traversée, vous pouvez utiliser la collection pour cartographier les informations d'association à la collection de liste, telles que: interroger le module de portée de l'autorisation de l'utilisateur et le menu sous le module, vous pouvez utiliser la collection pour cartographier la liste des modules pour cartographier les attributs de liste de menu de l'objet module. Le but de cela est également de faciliter la traversée de la traversée de l'ensemble de résultats de requête.
Si vous utilisez ResultType, vous ne pouvez pas cartographier les résultats de la requête à la collection de liste.
Chargement de retard
ResultMap peut implémenter un mappage avancé (en utilisant l'association et la collection pour implémenter un mappage individuel et un à plusieurs). L'association et la collection ont des fonctions de chargement paresseuses.
besoin:
Si la commande est interrogée et que les informations utilisateur sont associées. Si nous interrogeons d'abord les informations de commande pour répondre aux exigences, nous interrogerons les informations de l'utilisateur lorsque nous devons interroger les informations de l'utilisateur. Interroger les informations de l'utilisateur à la demande est un chargement retardé.
Chargement de retard: première requête à partir d'une seule table, puis à partir de la table associée en cas de besoin, améliorant considérablement les performances de la base de données, car la question de l'interrogation d'une seule table est plus rapide que de l'interrogation de plusieurs tables.
Utiliser l'association pour implémenter un chargement paresseux
Exigences: les commandes de requête et les informations de requête d'associé
Ordresmapperstom.xml
Il est nécessaire de définir l'instruction correspondant aux deux méthodes de mappeur.
1. Informations sur les commandes de requête uniquement
Sélectionner * parmi les commandes
Utiliser Association pour retarder le chargement (exécuter) la satisfaction suivante (Informations utilisateur de requête d'association) dans l'énoncé de l'ordre de requête
2. Informations sur les utilisateurs de requête connexes
User_id est utilisé pour interroger les informations de l'utilisateur en suivant le user_id dans la requête d'informations de commande ci-dessus
Utilisez FindUserByid dans userMapper.xml
Ce qui précède exécute d'abord findOrdersUserlazyloading, et lorsque vous devez interroger l'utilisateur, exécutez FindUserById, et le chargement et l'exécution retardés sont configurés via la définition de ResultMap.
Resultage de chargement ResultMap
Utilisez SELECT dans l'association pour spécifier l'ID de l'instruction à exécuter par chargement paresseux.
<! - LAZY LOFED ResultMap -> <resultMap type = "cn.itcast.mybatis.po.orders" id = "OrderSuserlazyLoadingResultMap"> <! - Mapping Configuration des informations de commande -> <id Column = "id" Property = "id" /> <résultat Column = "user_id" Property = "userrid" /> <le résultat Column = "Numéro" Column = "CreateTime" Property = "CreateTime" /> <Result Column = "Remarque" Property = "Remarque" /> <! - Mapping Configuration des informations de commande -> <id Column = "Number" Property = "Number" /> <Remarm Informations sur l'utilisateur
SELECT: Spécifiez l'ID de l'instruction à exécuter pour le chargement paresseux (l'instruction qui demande des informations utilisateur basées sur user_id)
Pour utiliser FindUserById dans userMapper.xml pour compléter la requête en fonction des informations utilisateur de l'ID utilisateur (user_id). Si FindUserByid n'est pas dans ce mapper, vous devez ajouter un espace de noms avant lui.
Colonne: La colonne des informations de commande associées à la requête d'informations utilisateur est user_id
La requête SQL pour l'association est comprise comme:
Sélectionnez Orders. *, (Sélectionnez Nom d'utilisateur à partir de l'utilisateur où les ordres.user_id = user.id) Nom d'utilisateur, (sélectionnez Sex à partir de l'utilisateur où ordres.user_id = user.id) SexFrom Orders -> <Association Property = "User" javatype = "cn.itcast.mybatis.po.user" SELECT = "CN.itcast.mybatis.mather Column = "user_id"> <! - Implémentez le chargement paresseux des informations utilisateur -> </ association> </sultMap>
Commandesmapperstom.java
Idées de test:
1. Exécutez la méthode de mappeur ci-dessus (findOrdersUserlazyLoading) et appelez FindOrdersUserlazyLoading dans cn.itcast.mybatis.mapper.ordersmapperstom pour interroger uniquement les informations de commande (table unique).
2. Dans le programme, traversez la liste <Dorse> interrogées à l'étape précédente. Lorsque nous appelons la méthode GetUser dans les commandes, nous commençons le chargement paresseux.
3. Retarder le chargement, appelez la méthode FindUserByid dans userMapper.xml pour obtenir des informations utilisateur.
Configuration de chargement paresseux
MyBatis n'activait pas le chargement paresseux par défaut, et il doit être configuré dans sqlmapconfig.xml.
Configurer dans MyBatis Core Configuration Fichier:
Définir la description de la valeur autorisée Valeur par défaut
LazyLoadingEnabled Set Set Lazy Loading. S'ils sont définis sur «False», tous les associés seront initialisés et chargés. Vrai ou faux
Agressivelazyloading Lorsqu'il est réglé sur «True», les objets de chargement paresseux peuvent être chargés par toutes les propriétés paresseuses. Sinon, chaque propriété est chargée au besoin. Vrai ou faux vrai
Config in sqlmapconfig.xml:
Code de test
Penser au chargement retardé
Comment réaliser un chargement paresseux sans utiliser l'association et la collection fournies par MyBatis?
La méthode d'implémentation est la suivante:
Définissez deux méthodes de mappeur:
1. Interroger la liste de commandes
2. Interroger les informations de l'utilisateur en fonction de l'ID utilisateur
Idées de mise en œuvre:
Vérifiez d'abord la première méthode de mappeur et obtenez la liste des informations de commande
Dans le programme (service), appelez la deuxième méthode de mappel au besoin pour interroger les informations utilisateur.
En bref: utilisez la méthode de chargement paresseuse pour interroger SQL simple (de préférence une seule table, vous pouvez également associer des requêtes), puis charger d'autres informations des requêtes associées au besoin.
Cache de requête
MyBatis fournit des caches de requête pour réduire la pression des données et améliorer les performances de la base de données.
Mybaits fournit un cache de premier niveau et un cache de second niveau.
Le cache de niveau 1 est un cache au niveau SQLSession. Lors de l'exploitation de la base de données, vous devez construire l'objet SQLSession et il existe une structure de données (hashmap) dans l'objet pour stocker des données mises en cache. Les zones de données mises en cache (hashmaps) entre les différentes SQLSIONS ne se affectent pas mutuellement.
Le cache secondaire est un cache au niveau du mappeur. Plusieurs SQLSESIONS fonctionnent les instructions SQL du même mappeur. Plusieurs SQLSESIONS peuvent partager le cache secondaire. Le cache secondaire est unesion croisée.
Pourquoi utiliser le cache?
S'il y a des données dans le cache, vous n'avez pas besoin de les obtenir de la base de données, ce qui améliore considérablement les performances du système.
Cache de niveau 1
Principe de travail de mise en cache de premier niveau
La première fois que j'ai lancé une requête sur les informations utilisateur avec l'ID utilisateur 1, recherchez d'abord s'il existe des informations utilisateur avec des informations utilisateur avec l'ID 1 dans le cache. Sinon, interrogez les informations utilisateur de la base de données.
Obtenez des informations utilisateur et stockez des informations utilisateur dans un cache de premier niveau.
Si SQLSession effectue des opérations de validation (exécute l'insertion, la mise à jour et la suppression), efface le cache de premier niveau dans SQLSession. Le but de cela est de faire du cache les dernières informations et d'éviter la lecture sale.
La deuxième fois que j'ai lancé une requête sur les informations utilisateur avec l'ID utilisateur 1, recherchez d'abord s'il existe des informations utilisateur avec des informations utilisateur avec l'ID 1 dans le cache. S'il y en a un dans le cache, j'obtiendrai directement des informations utilisateur à partir du cache.
Test de cache de niveau 1
MyBatis prend en charge la mise en cache de premier niveau par défaut et n'a pas besoin d'être configuré dans le fichier de configuration.
Suivez les étapes de principe de cache de niveau un ci-dessus pour tester.
//Ordersmappercusntomtest.java@testpublic void testCache1 () lève une exception {sqlSession sqlSession = SqlSessionFactory.OpenSession (); // Créer un objet proxy Userperper Userperper = sqlSession.getMapper (USerMapper.class); Avec ID 1 est une question user1 = userMapper.FinDuserById (1); System.out.println (user1); // Si SQLSession effectue des opérations de validation (exécute l'insertion, la mise à jour et la suppression), efface le cache de premier niveau dans SQLSession. Le but de cela est de faire du cache les dernières informations et d'éviter la lecture sale. // Mettre à jour les informations de l'utilisateur User1.SetUsername ("Test User22"); userMapper.UpDateUser (user1); // Exécuter l'opération de validation pour effacer le cache SqlSession.Commit (); // Démarrez la deuxième demande et interrogez l'utilisateur avec l'id 1 utilisateur User2 = userMapper.finDuserById (1); System.out.println (user2); sqlSession.close ();}Application de cache de niveau 1
Le développement formel consiste à intégrer MyBatis et Spring, et les transactions sont contrôlées en service.
Une méthode de service comprend de nombreux appels de méthode de mappeur.
Service {// Lors du démarrage de l'exécution, démarrez la transaction et créez l'objet SQLSession // Appelez la méthode du mappeur pour la première fois findUserById (1) // Cellule la méthode de mappeur pour la deuxième fois que FindUserById (1), récupérant les données à partir du cache de premier niveau // La méthode se termine, SQLSession est fermée}Si vous exécutez deux appels de service pour interroger les mêmes informations utilisateur, vous n'allez pas au cache de premier niveau, car la méthode de session se termine, la SQLSession sera fermée et le cache de premier niveau sera effacé.
Cache de niveau 2
principe
Tout d'abord, activez le cache de deuxième niveau de Mybatis.
SQLSession1 Querys Informations utilisateur avec l'ID utilisateur 1. Lors de l'interrogation des informations utilisateur, les données de requête seront stockées dans le cache secondaire.
Si SQLSession3 exécute SQL sous la même carte, exécute la soumission de validation et efface les données dans la zone de cache secondaire sous le mappeur.
SQLSession2 interroge les informations utilisateur avec l'ID utilisateur 1 et découvre s'il existe des données dans le cache. S'il existe, les données sont directement récupérées du cache.
La différence entre le cache secondaire et le cache primaire est plus grande. La plage du cache secondaire est plus grande. Plusieurs SQLSESIONS peuvent partager la zone de cache secondaire d'un Usermappeur.
UserMapper a une zone de cache secondaire (subdivisée par l'espace de noms), et d'autres mapppers ont également leur propre zone de cache secondaire (subdivisée par l'espace de noms).
Chaque mappeur d'espace de noms a une deuxième zone de cache. Si l'espace de noms des deux mappeurs est le même, les deux mappeurs auront la même zone de cache deuxième lorsque les données seront exécutées par SQL.
Allumez le cache de niveau 2
Le cache de deuxième niveau de Mybaits est le niveau de plage de mappeurs. En plus de définir le commutateur principal du cache de deuxième niveau dans SQLMAPConfig.xml, le cache de deuxième niveau doit également être activé dans le mappeur spécifique.xml.
Ajouté au fichier de configuration de base sqlmapconfig.xml
<setting name = "cacheenabled" value = "true" />
DESCRIPTION Valeur autorisée Valeur par défaut
Cacheenabled paramètres sur / désactivés globalement pour tous les caches dans ce fichier de configuration. Vrai ou faux
Allumez le cache secondaire dans userMapper.xml, et l'exécution SQL sous UserMapper.xml sera stockée dans sa zone de cache (Hashmap).
Appelez la classe Pojo pour implémenter l'interface de sérialisation
Afin d'extraire des données en cache, les opérations de désérialisation sont effectuées, car les supports de stockage de données en cache secondaires sont divers et différents en mémoire.
Test de cache de niveau 2
@TestPublic void TestCache2 () lève une exception {SqlSession SqlSession1 = SqlSessionFactory.OpenSession (); SqlSession SqlSession2 = SqlSessionFactory.OpenSession (); SqlSession SqlSession3 = SqlSessionFactory.OpenSession (); // Créer un objet proxy sqlSession1.getMapper (userMapper.class); // initier la première demande et interroge l'utilisateur avec l'identifiant 1 utilisateur User1 = userMapper1.finduserById (1); System.out.println (user1); // Exécuter le fonctionnement proche ici et écrire les données dans la SQLSession à la zone de cache secondaire SQLSESSION1.Close (); commit () opération userMapper UserMapper3 = sqlSession3.GetMapper (userMapper.class); utilisateur utilisateur = userMapper3.FindUserById (1); user.sesername ("Zhang Mingming"); userMapper3.UpDateUser (User); // Exécuter la soumission et effacer le cache secondaire sous Usermapperper (User); sqlSession3.Commit (); sqlSession3.close (); userMapper userMapper2 = sqlSession2.getMapper (userMapper.class); // Envoyez la deuxième demande pour interroger l'utilisateur avec id 1 user2 = userMapper2.FindUserById (1); System.out.println (user2); SqlSession.Configuration UseCache
La définition UseCache = false dans l'instruction peut désactiver le cache secondaire de l'instruction SELECT actuelle, c'est-à-dire que chaque requête émettra SQL à la requête. La valeur par défaut est vraie, c'est-à-dire que le SQL utilise un cache secondaire.
<select id = "findOrderListResultMap" resultMap = "orderssermap" usecache = "false">
Résumé: Pour chaque requête, les dernières données SQL sont requises. Réglez-le sur UseCache = false et désactivez le cache secondaire.
Cache de rafraîchissement
Effacer juste le cache
Dans le même espace de noms du mappeur, s'il y a d'autres données d'insertion, de mise à jour ou de supprimer des données d'opération, le cache doit être actualisé et si le cache n'est pas actualisé, une lecture sale se produira.
Définissez la propriété flushcache = "true" dans la configuration de l'instruction. Par défaut, il est vrai, ce qui signifie que le cache est rafraîchi. S'il est changé en faux, il ne se rafraîchira pas. Lorsque vous utilisez Cache, des lectures sales se produiront si vous modifiez manuellement les données de requête dans la table de la base de données.
<insert id = "insertuser" ParameterType = "cn.itcast.mybatis.po.user" flushcache = "true">
Résumé: Généralement, après l'exécution de l'opération de validation, le cache doit être rafraîchi. FlushCache = True signifie rafraîchir le cache, ce qui peut éviter la lecture sale de la base de données.
Intégration mybatis ehcache
Ehcache est un cadre de mise en cache distribué.
Cache distribué
我们系统为了提高系统并发，性能、一般对系统进行分布式部署（集群部署方式）
不使用分布缓存，缓存的数据在各各服务单独存储，不方便系统开发。所以要使用分布式缓存对缓存数据进行集中管理。
mybatis无法实现分布式缓存，需要和其它分布式缓存框架进行整合。
整合ehcache方法(掌握)
mybatis提供了一个cache接口，如果要实现自己的缓存逻辑，实现cache接口开发即可。
mybatis和ehcache整合，mybatis和ehcache整合包中提供了一个cache接口的实现类。
mybatis默认实现cache类是：
加入ehcache包
整合ehcache
配置mapper中cache中的type为ehcache对cache接口的实现类型。
加入ehcache的配置文件(在classpath下配置ehcache.xml)
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="../config/ehcache.xsd"><diskStore path="F:/develop/ehcache" /><defaultCache maxElementsInMemory="1000" maxElementsOnDisk="10000000"eternal="false" overflowToDisk="false" timeToIdleSeconds="120"timeToLiveSeconds="120" diskExpiryThreadIntervalSeconds="120"memoryStoreEvictionPolicy="LRU"></defaultCache></ehcache>
属性说明：
diskStore：指定数据在磁盘中的存储位置。
defaultCache：当借助CacheManager.add(“demoCache”)创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
maxElementsInMemory - 在内存中缓存的element的最大数目
maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
二级应用场景
对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，业务场景比如：耗时较高的统计分析sql、电话账单查询sql等。
实现方法如下：通过设置刷新间隔时间，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新间隔flushInterval，比如设置为30分钟、60分钟、24小时等，根据需求而定。
二级缓存局限性
mybatis二级缓存对细粒度的数据级别的缓存实现不好，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存。