Utilisez Mybatis seul pour gérer les choses
J'ai écrit du contenu connexe dans l'article de Mybatis. Ici, je continuerai à écrire la démo la plus simple. Passons auparavant le contenu de MyBatis. Tout d'abord, créez une table et créez une table étudiante simple:
Créer une table Student (Student_id int Auto_increment, Student_name Varchar (20) pas null, clé primaire (Student_id))
Créer une classe Entity Student.java:
classe publique étudiant {private int StudentId; private String étudiantname; public int getStudentid () {return StudentId;} public void SetStudentid (int studentId) {this.studentid = studentId;} public String getStudentName () {return StudentName;} public void SetStudentName (String StudentName) {this. toString () {return "Student {[StudentId:" + StudentId + "], [StudentName:" + StudentName + "]}";}} Pour le dire plus, la remplacement de la méthode toString () pour les classes d'entités et l'impression de chacun (ou un attribut clé) est une approche recommandée. Ensuite, Config.xml, qui contient la configuration JDBC de base:
<? xml version = "1.0" Encoding = "utf-8"?> <! Doctype Configuration public "- // mybatis.org//dtd config 3.0 // en" "http://mybatis.org/dtd/mybatis-3config.dtd"> <configuration> type = "org.xrq.domain.student" /> </ typealiases> <environnements default = "Development"> <environnement id = "Development"> <transactionManager type = "jdbc" /> <dataSource type = "pooled"> <propriété name = "Driver" value = "com.mysql.jdbc.driver" /> <propriété name = "url" value = "jdbc: mysql: // localhost: 3306 / test" /> <propriété name = "username" value = "root" /> <propriété name = "mot de passe" value = "root" /> </ dataSource> </ environnement>
Ensuite, il y a student_mapper.xml, principalement l'instruction SQL spécifique:
<mapper namespace = "studentMapper"> <resultmap type = "student" id = "étudiantMap"> <id chronn = "student_id" propriété = "StudentId" JDBCTYPE = "Integer" /> <Result Column = "Student_name" Property = "StudentName" JDBCTYPE = "Varchar" /> </ resultMap> ResultMap = "StudentMap"> Sélectionnez Student_id, Student_name From Student; </lect> <insert id = "insertstudent" useGeneratedKeys = "true" keyproperty = "StudentId" ParameterType = "Student"> INSERT INTER (Student_id, Student_name) Valeurs (# {StudentId, JdbcType = Integer}, # # # # # # # # # # # # # # # # # #, JDBCTYPE = INGER JDBCTYPE = VARCHAR}); </sert> </naupper> Créez un mybatisutil.java, qui est utilisé pour créer des éléments de base MyBatis. Les classes suivantes héritent de cette classe:
classe publique MyBatisUtil {protégé statique SQLSessionFactory SSF; Reader statique protégé; Static {try {Reader = news.getResourceSreader ("config.xml"); SQLSESSION SQLSESSIQUE protégé () {return ssf.opencession ();}} Exigences de développement au niveau de l'entreprise:
1. Définition et implémentation distinctes
2. Développement en couches, généralement DAO -> Service -> Contrôleur, il n'est pas exclu qu'une couche de plus / plusieurs couche ou une couche de moins est ajoutée en fonction de la situation spécifique.
Alors, écrivez d'abord une interface étudiantdao.java:
Interface publique StudentDao {public List <Student> selectAlStudents (); public int InsertStudent (étudiant étudiant);} Enfin, écrivez un étudiantdaoimpl.java pour implémenter cette interface. Notez que vous devez hériter de la classe mybatisutil.java:
classe publique StudentDaoimpl étend MyBatisUtil implémente StudentDao {private static final String namespace = "StudentMapper."; public list <Student> selectAllStudents () {SQLSession ss = getSQLSession (); List <Student> List = SS.SelectList (Namespace + "SelectLstudS"); Student) {sqlSession ss = getSQlSession (); int i = ss.insert (namespace + "insertstudent", étudiant); // ss.commit (); ss.close (); return i;}} Écrivez une classe de test:
classe publique StudentTest {public static void Main (String [] args) {StudentDao StudentDao = new StudentDaoimpl (); étudiant étudiant = new Student (); Student.setStudentName ("Jack"); StudentDao.InsertStudent (Student); System.out.println ("La clé principale inscrite:" + Student.getStudentid ()); System.out.println ("---- Afficher les étudiants ------"); List <Student> StudentList = StudentDao.SelectalStudents (); pour (int i = 0, longueur = studentList.Size (); i <longueur; i ++) System.out.println (StudentList.get (i));}} Le résultat doit être vide.
J'ai dit que cet exemple est à la fois une revue et une introduction à notre contenu aujourd'hui. La raison en est vide est que l'opération d'insertion a été effectuée, mais MyBatis ne nous aidera pas à soumettre les choses automatiquement, donc ce qui est affiché est naturellement vide. Dans ce cas, vous devez soumettre manuellement la transaction via la méthode commit () de SQLSession, c'est-à-dire ouvrir le commentaire sur la ligne 17 de la classe StudentDaoimpl.java.
Pour le dire plus, en plus de l'opération d'insertion de base MyBatis, cet exemple a également la fonction de renvoyer l'ID de clé primaire inséré sur la base de l'insertion.
Ensuite, utilisez Spring pour gérer les choses MyBatis, qui est également la pratique de gestion des choses la plus couramment utilisée dans le développement au niveau de l'entreprise.
Gérer les choses mybatis avec le printemps
Il existe de nombreux articles sur Internet pour expliquer cela, et j'ai beaucoup fouillé, mais soit copier et coller les uns les autres ou non expliquer l'intégralité de l'exemple. Grâce à cette partie, j'essaie d'expliquer comment utiliser le printemps pour gérer les choses mybatis.
En utilisant le printemps pour gérer les choses MyBatis, en plus des haricots du module nécessaire de Spring, du contexte, du noyau, de l'expression et de la collecte de biens communs, le contenu suivant est également requis:
(1) MyBatis-Spring-1.x.0.jar, il s'agit d'un package de pot nécessaire pour l'intégration de printemps Mybatis.
(2) Le pool de connexion de la base de données, DBCP et C3P0 peuvent être utilisés. J'utilise le druide d'alibaba ici
(3) JDBC, TX, AOP, JDBC est essentiellement sans parler. TX et AOP sont utilisés parce que le soutien de Spring pour la gestion des choses MyBatis est réalisé via AOP
(4) aopalliance.jar, il s'agit d'un package de pot nécessaire pour utiliser Spring AOP
Le package JAR ci-dessus sera téléchargé à l'aide de Maven. Ceux qui n'ont pas utilisé Maven peuvent le télécharger sur CSDN. Vous pouvez le rechercher.
Dans le fichier de configuration config.xml de MyBatis, la connexion JDBC peut être supprimée, et seule la pièce Typealiases peut être conservée:
<? xml version = "1.0" Encoding = "utf-8"?> <! Doctype Configuration public "- // mybatis.org//dtd config 3.0 // en" "http://mybatis.org/dtd/mybatis-3config.dtd"> <configuration> type = "org.xrq.domain.student" /> </pactaliases> </ configuration>
Permettez-moi de mentionner que MyBatis un autre fichier de configuration Student_Mapper.xml n'a pas besoin d'être modifié. Ensuite, écrivez le fichier de configuration de Spring et je l'appelle Spring.xml:
<? xml version = "1.0" Encoding = "UTF-8"?> <Beans xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://www.springframework.org/schema/beans" Mlns: tx = "http://www.springframework.org/schema/tx" xmlns: aop = "http://www.springframework.org/schema/aop" xsi: schemalation = "http://www.springframeworkwork.org/schema/bans http://www.springframework.org/schema/beans/spring-beans-4.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsdd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.2.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd"><!-- Configuration de l'annotation -> <tx: annotation-transaction-manager = "TransactionManager" /> <context: annotation-config /> <context: component-scan basage-package = "org.xrq" Pool, utilisez le druid d'alibaba -> <bean id = "dataSource" init-méthod = "init" destrie-métod = "close"> <propriété name = "url" value = "jdbc: mysql: // localhost: 3306 / test" /> <propriété name = "username" value = "root" /> <propriété name = "mot de passe" value = "root" /> <fEARD> id = "sqlSessionFactory"> <propriété name = "configLocation" value = "classpath: config.xml" /> <propriété name = "mapperlocations" value = "classpath: * _ MAPPER.XML" /> <! - Transaction Manager -> <ean id = "transactionmaner"> </ bean> <! - Transaction Manager -> <eAND name = "dataSource" ref = "dataSource" /> </ank> </bans>
Cela comprend principalement le gestionnaire de transactions et le pool de connexions de la base de données.
De plus, nous voyons qu'il y a un SQLSessionFactory. Les amis qui ont utilisé Mybatis doivent être familiers avec cette classe. Il est utilisé pour configurer l'environnement MyBatis. Il existe deux attributs de configlocation et de mappeurs dans le SQLSessionFactory. Comme son nom l'indique, il représente l'emplacement du fichier de configuration et l'emplacement du fichier de mappage. Ici, tant que le chemin est configuré correctement, Spring chargera automatiquement ces deux fichiers de configuration.
Ensuite, ce que vous voulez modifier est la classe d'implémentation de DAO. À l'heure actuelle, vous n'héritez plus de la classe MyBatisutil précédente, mais héritez de la SqlSessionDaosupport.java de Mybatis-Spring-1.x.0.jar. Le code spécifique est le suivant:
@RepositoryPublic Class StudentDaoimpl étend SqlSessionDaosupport implémente StudentDao {private static final String namespace = "StudentMapper."; @ ResourcePublic Void SetSQLSessionFactory (SqlSessionFactory SQLSessionFactory) {Super.SetsqLSessionfactory (SQLSessionfactory); selectAllStudents () {return getSQLSession (). selectList (namespace + "selectAlStudents");} public int insertStudent (étudiant étudiant) {return getSQLSession (). insert (namespace + "insertstudent", étudiant);}}Deux annotations sont utilisées ici, parlons-en séparément.
(1) @Repository, cette annotation est la même que @Component, @Controller et nos annotations @Service les plus courantes, qui peuvent toutes déclarer une classe comme un haricot de printemps. Leurs différences ne sont pas dans une sémantique spécifique, mais plus dans le positionnement de l'annotation. Comme mentionné précédemment, les applications au niveau de l'entreprise se concentrent sur le concept de développement hiérarchique, de sorte que ces quatre annotations similaires devraient être comprises comme suit:
• L'annotation du référentiel correspond à la couche de persistance, à savoir la couche DAO, qui est utilisée pour interagir directement avec la base de données. D'une manière générale, une méthode correspond à une instruction SQL spécifique
• @ Service Annotation, qui correspond à la couche de service, à savoir la couche de service, est la fonction de combiner des instructions SQL uniques / multiples. Bien sûr, s'il est simple, vous appellerez directement une méthode de la couche DAO.
• @ annotation du contrôleur, qui correspond à la couche de contrôle, c'est-à-dire la couche de contrôle dans le mode de conception MVC. Sa fonction est de recevoir des demandes d'utilisateurs, d'appeler différents services pour obtenir des données en fonction des demandes, et de combiner des données en fonction des exigences et de les envelopper à l'avant.
• @ Annotation des composants, qui correspond davantage au concept d'un composant. Si un haricot ne sait pas qu'il appartient à une couche, vous pouvez utiliser @Component Annotation pour annoter.
Cela reflète également l'un des avantages des annotations: voir le nom et connaître le sens, c'est-à-dire en voyant cette annotation, vous connaissez grossièrement la fonction de cette classe, c'est-à-dire son positionnement dans tout le projet.
(2) @Resource, cette annotation et l'annotation @Autowired ont le même sens, et les deux peuvent être automatiquement injectés avec des attributs d'attribut. Étant donné que SQLSessionFactory est le cœur de MyBatis, il a été déclaré dans Spring.xml. Par conséquent, le bean avec l'ID "SQLSessionFactory" est injecté ici par l'annotation @Resource. Après cela, la SQLSession peut être obtenue via la méthode getSQLSession () et les données sont ajoutées, supprimées, modifiées et vérifiées.
Enfin, ce n'est rien de plus que d'écrire une classe de test à tester:
public class StudentTest {public static void main (String [] args) {applicationContext ac = new ClassPathxmlapplicationContext ("printemps.xml"); StudentDao StudentDao = (StudentDao) ac.getBean ("StudentDaoiMpl"); étudiant = new Student (); Student.setStudentName ("Lucy"); int J = StudentDao.InsertStudent (étudiant); System.out.println ("J =" + J + "/n");system.out.println("-- - - Display Students ------"); List <Student> StudentList = StudentDao.SelectAllStudents (); pour (int i = 0, longueur = studentList.Size (); i <longueur; i ++) System.out.println (StudentList.get (i));}} Étant donné que la classe StudentDaoimpl.java utilise l'annotation @Repository et ne spécifie pas d'alias, le nom de StudentDaoimpl.java dans le conteneur de printemps est "First Letter Lines + Lettres restantes", c'est-à-dire "StudentDaoimpl".
Après avoir exécuté le programme, vous pouvez voir que le nouvel étudiant a été traversé sur la console, c'est-à-dire que l'étudiant a été directement inséré dans la base de données. Il n'y avait pas de validation ni de retour dans l'ensemble du processus. Tous ont été mis en œuvre par le printemps. Il s'agit d'utiliser le printemps pour gérer les choses sur mybatis.
post-scriptum
Cet article passe en revue l'utilisation de base de MyBatis et utilise Spring pour gérer les choses sur MyBatis, et donne des exemples de code plus détaillés. Les amis dans le besoin peuvent l'étudier selon le code. Sur la base de cet article, j'écrirai un article plus tard pour expliquer la mise en œuvre de la gestion des trucs de plusieurs données entre les tables uniques et plusieurs tables. Cette exigence est également une exigence commune dans les entreprises et les applications.