J'ai résumé trois méthodes dans l'article précédent, mais il existe deux méthodes qui annotent SQL. Cette méthode est assez déroutante, donc tout le monde ne l'utilise pas beaucoup. Résumons les deux méthodes couramment utilisées:
1. Classe d'implémentation de proxy dynamique sans écrire DAO
Cette méthode est relativement simple. Vous n'avez pas besoin d'implémenter la couche DAO, il vous suffit de définir l'interface. Ici, c'est juste pour enregistrer le fichier de configuration, donc le programme est très simple:
1. Diagramme de structure globale:
2. Trois fichiers de configuration et un fichier de mappage
(1) l'entrée du programme et la configuration du contrôleur frontal web.xml
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" XSI: ScheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id = "webapp_id =" 3.0 " <Display-Name> Site Web1 </ Display-Name> <! - Configurez l'écoute et assemblez automatiquement les informations de configuration de ApplicationContext lorsque le conteneur Web démarre -> <ouciner> <écouteur-classe> org.springframework.web.context.contextloderListener </ auteur-classe> </ écouteur> <! <param-name> ContextConfiglocation </ param-name> <param-valeur> classpath: config / printempsmvc-servlet.xml, classpath: config / applicationContext.xml </ param-value> </ context-param> <! - Caractère Encoding Filter -> <filter> <fileter-name> EncodingFilter </filter-name> <filter-class> org.springframework.web.filter.characterencodingfilter </filter-class> <innit-Param> <param-name> Encoding </ param-name> <param-value> utf-8 </ param-value> <Ar param-Value> true </ param-Value> </ init-Param> </ Filter> <Imlter-Mapping> <Filter-Name> EncodingFilter </filter-Name> <Url-Pattern> *. Do </url-Pattern> </filter-Mapping> <! - Front-End Contrôleur -> <Serplet> <Serplet-Name> <Servlet-Class> org.springframework.web.servlet.dispatcherservlet </vrlett-class> <itrist-Param> <Am param-name> ContextConfiglocation </ Param-Name> <Am param-Value> classpath: config / springmvc-servlet.xml </ param-valeur> </Init-Param> <! - <Charot-on-startup> 1 </ Load-on-startup> </ servlet> <Serplet-mapping> <servlet-mapping> <servlet-name> springmvc </ servlet-name> <! - Intercept request -> <url-potern> *. do </url-potern> </ servlet-mapping> <lesen-file-list> <bienvenue> index.htMl </ bienvenue> <Deen welcome-File> index.htm </venke-file> <leen welcome-file> index.jsp </venke-file> <ven welcome-file> default.html </ bienvenue-file> <ven welcome-file> default.htm </ bienvenue-file> </loque> default.jsp </venke-file> </ven wellow-file-list> </low-app>
(2) Calque de commande de balayage, injection automatique et afficher la configuration de l'analyseur Springmvc-servlet.xml
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http://www.spring xmlns: util = "http://www.springframework.org/schema/util" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: jdbc = "http://www.springfrramework.orga/jdbc" xmlns:cache="http://www.springframework.org/schema/cache" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd "> <! - annotation pilote -> <mvc: annotation-driven /> <! - <context: annotation-config /> -> <! <
(3) Source de données, numérisation et injection automatique du service, Spring MyBatissQLSessionFactory, proxy dynamique de l'interface Dao Couche, et la configuration de la transaction ApplicationContext.xml
Il y aura plusieurs fichiers de configuration ici
1) Source de données unique, Dynamic Proxy ne définit pas les valeurs des deux propriétés de SQLSessionFactoryBeanName ou SQLSessionTemplateBeAnname lors de l'implémentation de l'interface Dao Layer.
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: context = "http://www.springframework.org/schema/contex http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <! - File de configuration JDBC -> <contexte: Property-Lacehat Location =" ClassPath: DB.Properties "/> <- Data Source) id = "dataSource"> <propriété name = "DriverClassName"> <value> $ {jdbc.DriverClassName} </ value> </ propriété> <propriété name = "url"> <value> $ {jdbc.url} </ value> </ propriété> <propriété name = "username"> <value> $ {jdbc.ususame} name = "mot de passe"> <value> $ {jdbc.password} </value> </prophed> </-bean> <! - Activez la configuration d'annotation, à savoir automatiquement -> <! - <Context: Annotation-Config /> -> <! - En fait, Component-Scan a la fonction d'annotation-config, c'est-à-dire, regardez les classes requises dans le contenu sprinc Base-Package = "com.website.service" /> <! - Lorsque vous utilisez MyBatis, Spring utilise SQLSessionFactoryBean pour gérer MyBatis SqlSessionFactory -> <Bean Id = "SqlSessionFactory"> <Property Name = "DataSource" Ref = "DataSource" /> <! /> <! - Chemin de fichier de carte de classe d'entité, un seul d'entre eux est écrit à la fin, et plusieurs peuvent être remplacés par Mybatis / *. Xml -> <propriété name = "Mappelocations" value = "ClassPath: Mybatis / UserMapper.xml" /> </ Bean bean = "SqlSessionFactory" /> </ Constructor-Arg> </ Bean> -> <! - La mise en œuvre du proxy dynamique n'a pas besoin d'écrire dao -> <bean id = "MapperscannerConfigurer"> <! - Ici, Basepackage, la puissance d'interface de la couche Dao est spécifiée, et l'interface DAO ici ne doit pas être mise en œuvre par elle-même -> <Propriété) "Basepack" Value = "com.website.dao" /> <! - S'il n'y a qu'une seule source de données, vous ne pouvez pas le spécifier, mais s'il existe plusieurs sources de données, vous devez le spécifier -> <! - <propriété name = sqlSessionFactoryBeAnname "Value =" SqlSessionFactory "/> -> <! name = "sqlSessionTemplateBeAnName" value = "SqlSession" /> -> </Ean> <! - Transaction Manager -> <Bean Id = "TransactionManager"> <propriété name = "DataSource" Ref = "DataSource" /> </ank2) Configurer la valeur de la propriété de SQLSessionFactoryBeanName pour une seule source de données
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: context = "http://www.springframework.org/schema/contex http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <! - File de configuration JDBC -> <contexte: Property-Lacehat Location =" ClassPath: DB.Properties "/> <- Data Source) id = "dataSource"> <propriété name = "DriverClassName"> <value> $ {jdbc.DriverClassName} </ value> </ propriété> <propriété name = "url"> <value> $ {jdbc.url} </ value> </ propriété> <propriété name = "username"> <value> $ {jdbc.ususame} name = "mot de passe"> <value> $ {jdbc.password} </value> </prophed> </-bean> <! - Activez la configuration d'annotation, à savoir automatiquement -> <! - <Context: Annotation-Config /> -> <! - En fait, Component-Scan a la fonction d'annotation-config, c'est-à-dire, regardez les classes requises dans le contenu sprinc Base-Package = "com.website.service" /> <! - Lorsque vous utilisez MyBatis, Spring utilise SQLSessionFactoryBean pour gérer MyBatis SqlSessionFactory -> <Bean Id = "SqlSessionFactory"> <Property Name = "DataSource" Ref = "DataSource" /> <! /> <! - Chemin de fichier de carte de classe d'entité, un seul d'entre eux est écrit à la fin, et plusieurs peuvent être remplacés par Mybatis / *. Xml -> <propriété name = "Mappelocations" value = "ClassPath: Mybatis / UserMapper.xml" /> </ Bean bean = "SqlSessionFactory" /> </ Constructor-Arg> </ Bean> -> <! - La mise en œuvre du proxy dynamique n'a pas besoin d'écrire dao -> <bean id = "MapperscannerConfigurer"> <! - Ici, Basepackage, la puissance d'interface de la couche Dao est spécifiée, et l'interface DAO ici ne doit pas être mise en œuvre par elle-même -> <Propriété) "Basepack" Value = "com.website.dao" /> <! - S'il n'y a qu'une seule source de données, vous ne pouvez pas les spécifier, mais s'il existe plusieurs sources de données, vous devez le spécifier -> <propriété name = "SQLSessionFactoryBeAnName" Value = "SqlSessionFactory" /> <! - Directement au nom de SqlSessionTemplate name = "sqlSessionTemplateBeAnName" value = "SqlSession" /> -> </Ean> <! - Transaction Manager -> <Bean Id = "TransactionManager"> <propriété name = "DataSource" Ref = "DataSource" /> </ank3) Configurer la valeur de propriété SQLSessionTemplateBameName pour une seule source de données
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: context = "http://www.springframework.org/schema/contex http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <! - File de configuration JDBC -> <contexte: Property-Lacehat Location =" ClassPath: DB.Properties "/> <- Data Source) id = "dataSource"> <propriété name = "DriverClassName"> <value> $ {jdbc.DriverClassName} </ value> </ propriété> <propriété name = "url"> <value> $ {jdbc.url} </ value> </ propriété> <propriété name = "username"> <value> $ {jdbc.ususame} name = "mot de passe"> <value> $ {jdbc.password} </value> </prophed> </-bean> <! - Activez la configuration d'annotation, à savoir automatiquement -> <! - <Context: Annotation-Config /> -> <! - En fait, Component-Scan a la fonction d'annotation-config, c'est-à-dire, regardez les classes requises dans le contenu sprinc Base-Package = "com.website.service" /> <! - Lorsque vous utilisez MyBatis, Spring utilise SQLSessionFactoryBean pour gérer MyBatis SqlSessionFactory -> <Bean Id = "SqlSessionFactory"> <Property Name = "DataSource" Ref = "DataSource" /> <! /> <! - Chemin de fichier de carte de classe d'entité, un seul d'entre eux est écrit jusqu'à la fin, et plusieurs peuvent être remplacés par MyBatis / *. Xml -> <propriété name = "Mappenlocations" value = "ClassPath: MyBatis / UserMapper.xml" /> </ Bean /> </ Constructor-arg> </-bean> <! - L'implémentation de proxy dynamique ne nécessite pas d'écriture dao -> <bean id = "MAPPERSCANNERCONFIGURER"> <! - BASEPACKAGE ICI, la puissance de l'interface de la couche Dao est spécifiée, et l'interface DAO ici n'a pas besoin d'être implémentée par elle-même -> <propriété nom = "basage" Une seule source de données, vous ne pouvez pas les spécifier, mais s'il existe plusieurs sources de données, vous devez les spécifier -> <! - <propriété name = "SqlSessionFactoryBeanName" Value = "SqlSessionFactory" /> -> <! - Formullez directement le nom SQLSessionTemplate, qui est en fait le même -> <propriété nom = "SQLSSessionTemplate. Value = "SqlSession" /> </ Bean> <! - Transaction Manager -> <Bean Id = "TransactionManager"> <propriété name = "DataSource" Ref = "DataSource" /> </Eban> <! - Utilisation de la transaction annotation complète -> </ Beans> Annotation-Drive Transaction-Manager = "TransactionManager" /> </EANTS>4) Sources de données multiples
Notez que s'il s'agit d'une source multi-données, vous devez utiliser SQLSessionFactoryBeanName ou SQLSessionTemplateBeAnname pour spécifier la source de données spécifique. Je ne sais pas si vous l'avez remarqué dans la configuration ci-dessus. Si vous utilisez SQLSessionTemplateBeanName, vous devez
<bean id = "sqlSession"> <constructor-arg index = "0"> <ref bean = "sqlSessionFactory" /> </ constructor-arg> </ank>
Pour créer une instance spécifique et attribuer à la propriété SQLSessionTemplateBeanName.
(4), MyBatis SQL Mapping Fichier UserMapper.xml:
<? xml version = "1.0" Encoding = "UTF-8"?> <! Doctype Mappeur public "- // mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <! Pour cette démo, l'espace de noms est le chemin complet de userdao.java -> <mapper namespace = "com.website.dao.userdao"> <! - L'ID est le nom de la méthode dans l'interface -> <insert id = "SaveSer" ParamètreType = "Java.util.map"> INSERT IN USER (ID,, nom) valeurs (# {id}, # {name}) </sert> </ mapper>Ok, allons au fichier de configuration et le faisons. Jetons un coup d'œil à la couche de contrôle, à la couche logique métier et au code de couche DAO.
3. Couche de contrôleur
package com.website.controller; import java.util.hashmap; importation java.util.map; Importer javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterreotype.Controller; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestMethod; import com.website.service.userservice; @Controller @RequestMapping (value = "/ user") classe publique UserController {// Inject UserService Object @Autowired Private UserService UserService; @RequestMapping (value = "/save.do", méthode = requestMethod.get) public String SaveUser (HttpServLetRequest Request, HttpServletResponse Response) {String id = request.getParAmter ("id"); String name = request.getParameter ("name"); Map <string, string> map = new hashmap <string, string> (); map.put ("id", id); map.put ("nom", nom); userService.saveuser (carte); return "index"; }}4. Couche de service
package com.website.service; importation java.util.map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterreotype.service; import org.springframework.transaction.annotation.transactional; import com.website.dao.userdao; @Service ("userService") @Transactional Public Class UseserService {// Injection d'interface DAO Implémentation Classe Classe // Les deux méthodes d'injection peuvent être @Autowired Private UserDao UserDao; public void SaveUser (map <string, string> map) {int end = userdao.saveuser (map); System.out.println ("end:" + end); }}5. Interface de couche Dao
package com.website.dao; importation java.util.map; //com.website.dao.userdao Interface publique UserDao {int wakeUser (map <string, string> map); } Le chemin complet de l'interface DAO est l'espace de noms du fichier de mappage correspondant à cette interface DAO, et le nom de la méthode est la valeur de l'ID
OK, cette méthode de configuration est terminée, et il y a aussi une petite démo complète. Résumons brièvement ci-dessous:
Comparé à la méthode de configuration précédente (qui sera écrite ci-dessous) est qu'il utilise la méthode proxy dynamique de l'interface de couche DAO. Avant, nous implémenterons manuellement la couche DAO dans la couche DAO, puis injecterons automatiquement l'instance SQLSessionTemplate pour appeler des méthodes spécifiques telles que INSERT ("", "") selectOne ("", "") et d'autres méthodes. Le premier paramètre est l'adresse du fichier de mappage: espace de noms + id, et le deuxième paramètre est les conditions passées. De cette façon, MyBatis trouvera le fichier de mappage spécifique en fonction des deux paramètres que nous avons passés pour l'analyse et l'interrogation. L'utilisation du proxy dynamique élimine ici l'étape d'implémentation de l'interface DAO, mais nous l'avons implémentée par printemps. Il y a un problème. Nous avons passé les paramètres de condition de requête, mais le chemin spécifique du fichier de mappage est: namespce + id. Que dois-je faire s'il n'est pas passé? Autrement dit, l'espace de noms de votre fichier de mappage doit être le nom complet de la classe et de l'ID d'interface doit être le nom de la méthode dans l'interface, afin que le proxy dynamique puisse trouver le chemin et a également des paramètres. Pensez-vous que c'est la même chose? Hahaha!
2. Implémentez manuellement l'interface de couche DAO
Jetons d'abord un coup d'œil à la configuration et au code pour implémenter manuellement la couche DAO:
1. Schéma de structure du sujet
2. Trois fichiers de configuration et fichiers de mappage
(1) Entrée du programme, configuration du contrôleur frontal web.xml
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" XSI: ScheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id = "webapp_id =" 3.0 " <splay-name> Site Web2 </ Display-Name> <! - Chargez la configuration du conteneur Spring -> <ouciner> <auditeur-class> org.springframework.web.context.contextLoaderListener </ écouteur-classe> </duner> <! - Définit le Path de configuration de la configuration de chargement Contator </ param-name du conteneur Spring </ param-Param> CLASSPATH: config / springmvc-servlet.xml, classpath: config / applicationContext.xml </ param-Value> </ Context-Param> <! - Filtre d'encodage de caractères -> <filter> <Filter-Name> EncodingFilter </filter-name> <filter-class> org.springframework.web.filter.characterencodingfilter </filter-class> <innit-Param> <param-name> Encoding </ param-name> <param-value> utf-8 </ param-value> <Ar param-Value> true </ param-Value> </ init-Param> </ Filter> <Imlter-Mapping> <Filter-Name> EncodingFilter </filter-Name> <Url-Pattern> *. Do </url-Pattern> </filter-Mapping> <! - Front-End Contrôleur -> <Serplet> <Serplet-Name> <Servlet-Class> org.springframework.web.servlet.dispatcherservlet </vrlett-class> <itrist-Param> <Am param-name> ContextConfiglocation </ Param-Name> <Am param-Value> classpath: config / springmvc-servlet.xml </ param-valeur> </Init-Param> <! - <Charot-on-startup> 1 </ Load-on-Startup> </ servlet> <servlet-mapping> <servlet-name> SpringMvc </vrlet-name> <! - Intercept request -> <url-potern> *. do </url-Pattern> </vreentlet-mapping> <leen weende-file-list> </vendule> index.html </vège <endemed-file> index.jsp </venke-file> <leen welcome-file> default.html </venke-file> <leen welcome-file> default.htm </venke-file> <leen welcome-file> default.jsp </ bienvenue-file> </venke-file-list> </ Web-App>
(2) Calque de commande de balayage, injection automatique et afficher la configuration de l'analyseur Springmvc-servlet.xml
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http://www.spring xmlns: util = "http://www.springframework.org/schema/util" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: jdbc = "http://www.springfrramework.orga/jdbc" xmlns:cache="http://www.springframework.org/schema/cache" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd "> <! - annotation pilote -> <mvc: annotation-driven /> <! - <context: annotation-config /> -> <! - scan -> <context: component-can-can-canal Base-Package = "com.website.controller"> </ context: Component-Scan> <! - Afficher l'analyseur -> <bean id = "ViewResolver"> <propriété name = "Prefix" value = "/ web-inf / voir / propriété> </EAND> </pEANS>
(3) Source de données, numérisation et injection automatique du service, Spring MyBatissQLSessionFactory et Configuration de transaction ApplicationContext.xml
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: context = "http://www.springframework.org/schema/contex http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd "> <! - File de configuration JDBC -> <contexte: Property-Lacehat Location =" ClassPath: DB.Properties "/> <- Data Source) id = "dataSource"> <propriété name = "DriverClassName"> <value> $ {jdbc.DriverClassName} </ value> </ propriété> <propriété name = "url"> <value> $ {jdbc.url} </ value> </ propriété> <propriété name = "username"> <value> $ {jdbc.ususame} name = "mot de passe"> <value> $ {jdbc.password} </value> </prophed> </-bean> <! - Activez la configuration d'annotation, à savoir automatiquement -> <! - Component-scan a la fonction de l'annotation-config Pour scanner le bean avant qu'il ne puisse être utilisé -> <Context: Component-Scan Base-Package = "com.website.service, com.website.dao" /> <! - Lors de l'utilisation de MyBatis, Spring utilise SQLSessionFactoryBean pour gérer la méthode d'utilisation de SQLSSessionTem -> <! Il fournit certaines méthodes -> <bean id = "sqlSessionFactory"> <propriété name = "dataSource" ref = "dataSource" /> <! - MyBatis Configuration Fichier Path -> <propriété name = "configLocation" value = "" /> <! - Entity Class Map File Path Value = "ClassPath: Mybatis / Userapping.xml" /> </Eban> <! - En fait, l'exemple de cette classe est SqlSession dans MyBatis -> <Ref Bean = "SqlSession"> <Constructor-Arg Index = "0"> <Ref Bean = "SqlSessionFactory" /> </18 name = "dataSource" ref = "dataSource" /> </ bean> <! - Utilisez la transaction annotation complète -> <tx: transaction-manager de transaction annotation = "TransactionManager" /> </ Beans>(4) Fichier de mappage Mybatis
<? xml version = "1.0" Encoding = "utf-8"?> <! Doctype Mappeur public "- // mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <! - Cetpace de noms + L'ID ci-dessous est A atel. Après avoir rédigé le chemin complet dans la couche Dao Mybatis est la mappage des instructions SQL pertinentes dans ce fichier -> <mapper namespace = "com.website.usermapper"> <! user (id, nom, mot de passe) valeurs (# {id}, # {name}, # {mot de passe}) </sert> </ mapper>Vous pouvez voir que l'ID de l'espace de noms + du fichier de mappage ici est personnalisé au lieu du nom complet de classe + ID de l'interface de couche Dao.
3. Contrôleur
package com.website.controller; import java.util.hashmap; importation java.util.map; Importer javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterreotype.Controller; import org.springframework.web.bind.annotation.requestmapping; import com.website.service.userservice; / ** * @author whd Data 5 juin 2016 * / @Controller @RequestMapping (value = "/ user") public class userController {@Autowired Private UserService Userservice; @RequestMapping (value = "/save.do") Public String SaveUser (HttpServLetRequest Request, HttpServletResponse Response) {String id = request.getParamètre ("id"); String name = request.getParameter ("name"); String mot de passe = request.getParameter ("mot de passe"); Map <string, string> map = new hashmap <string, string> (); map.put ("id", id); map.put ("nom", nom); map.put ("mot de passe", mot de passe); userService.saveuser (carte); return "index"; }}4. Service de couche logique commerciale
package com.website.service; importation java.util.map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterreotype.service; import org.springframework.transaction.annotation.transactional; import com.website.dao.userdao; / ** * @author whd data 5 juin 2016 * / @Service ("userService") @Transactional public class userService {@Autowired private userDao UserDao; public void SaveUser (map <string, string> map) {userdao.saveuser (map); }}5. Couche Dao
package com.website.dao; importation java.util.map; import org.mybatis.spring.sqlSessionTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.sterreotype.repository; / ** * @Author WHD DATA 5 juin 2016 * / @Repository ("UserDao") Classe publique UserDao {@Autowired Private SQLSessionTemplate SqlSession; public void SaveUser (map <string, string> map) {int end = sqlSession.insert ("com.website.usermapper.inserser", map); System.out.println ("end" + end); }}Nous regardons le sqlSessionTemplate de la couche DAO inversée. Il s'agit en fait de l'objet SQLSession dans Mybatis. Nous voyons qu'il est configuré dans ApplicationContext.xml, donc lorsque nous l'utilisons, Spring l'injectera automatiquement. Nous pouvons l'utiliser directement sans le créer nous-mêmes. C'est la soi-disant inversion de contrôle. Ok, les méthodes de configuration de ces deux fichiers sont terminées.
Résumer
Ce qui précède est une explication détaillée des méthodes de configuration de Spring et Mybatis qui vous ont été introduites (deux méthodes couramment utilisées). 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!