Il existe un article dans l'enregistrement précédent que sans utiliser Spring, il se connecte et exploite directement la base de données MongoDB dans Java Code. Ici, nous enregistrerons que lorsque vous utilisez le printemps, le fonctionnement simple de MongoDB en Java.
Configuration du package Maven:
Parce qu'il implique Spring et SpringMVC, il est également nécessaire d'importer leurs forfaits connexes:
<project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd "> <ModelVersion> 4.0.0 </ ModelVersion> <ProupId> Spring_mongo </rom groupeid> <ArtifActid> Spring_Mongo </napshot> <packaging> War </macking> <version> 0.0.1-snapshot </packaging> war </ packaging> <version> 0.0.1-SNAPS Webapp </name> <url> http://maven.apache.org </url> <Detendances> <Dedency> <proupId> org.springframework.data </proupId> <ArtifActid> Spring-data-MongoDB </ ArtifActid> <version> 1.8.0.release </DERNIFRIMENT <GroupId> org.mongoDB </proupId> <Ertifactid> mongo-java-driver </ ArtiFactId> <Dersion> 3.0.3 </DERNIFRIENT> </DENDENCENCE> <Dendency> <ProupId> Commons-Logging </proupId> <Artifactid> Commons-Logging </tatifactid> <version> 1.2 </DERNIERDS> </Dedency> <Dedency> <GroupId> org.SpringFramework </proupheId> <ArtifActid> Spring-Test </ ArtifactId> <DersonD> 4.1.6.release </ version> </ Dependency> <Dedency> <ProupId> Junit </proupId> <petefactid> JUnit </ Artifactid> <Derson> 4.11 </DERNIERDMENT> <GroupId> org.SpringFramework </rom grouped> <ArtifActid> Spring-Context </ ArtifactId> <DersonD> 4.1.7.release </ Version> </ Dependency> <Dependance> <ProupID> org.SpringFramework </proupId> <Artifactid> Spring-Context-Support </Retifactid> <version> 4.0.9. </Dependency> <Duild> <Glugins> <Glugin> <ArtefactId> Maven-Compiler-Plugin </Retifactid> <DERNÉRATEUR> 2.3.2 </ Version> <FIFIGIFICATION> <Source> 1.7 </ Source> <Parget> 1.7 </ Target> <Encoding> UTF-8 </ Encoding> <compileRarguments> <Everbose />> <OutClassPath> $ {java.home} /lib/rt.jar; $ {java.home} /lib/jce.jar </ bootclasspath> </ compilerarguments> </ configuration> </ plugin> </ plugins> <inalName> spring_mongo </inalname> </nubuil> </plugins> Configuration de base de Spring:
Principalement, c'est pour permettre la numérisation d'annotation, etc .::
<? xml version = "1.0" Encoding = "UTF-8"?> <Beans xmlns: task = "http://www.springframework.org/schema/task" xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/contex http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsddd http://www.springframework.org/schema/task http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd "> <! - Base-Package = "Spring_mogo.dao.daoimp" /> <! - Importez le fichier de configuration de MongoDB -> <importation ressource = "Spring-MongoDB305.xml" /> <! - Activez l'annotation -> <contexte: annotation-config /> </ beans>
Spring connecte MongoDB et établit des configurations pour les usines connexes:
<? 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: p = "http://www.springframework.org/schema/p" xmlns: mongo = "http://www.springframework.org/schema/data/mongo" xsi: schemalocation = "http://www.springframe http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd "> <! - Configuration de printemps pour se connecter à la base de données MongoDB -> <Mongo: Mongo-Client host =" 192.168.0.201 "port =" 27017 " CIDENTIELS = "Tuzongxun: 123456 @ Mongotest" id = "Mongo"> <Mongo: Client-Options Write-Concern = "Safe" /> </ Mongo: Mongo-Client> <Mongo: Db-Factory Id = "MongodbFactory" DBNAME = "Mongotest" Mongo-Ref = "Mongo" Méthode correspondante -> <bean id = "mongotemplate"> <constructor-arg name = "MongoDBFactory" ref = "MongoDBFactory" /> </bEAN> </EANS>
La classe d'entité correspondant à la base de données:
Il convient de noter que l'interface sérialisée doit être implémentée et que l'attribut UID est défini, sinon le résultat de retour de la base de données ne peut pas être converti directement en attributs d'objet pendant l'opération:
Package Spring_Mongo.Models; import java.io.serializable; classe publique UserModel implémente Serializable {private static final long SerialVersionUID = 1l; Nom d'utilisateur de chaîne privée; mot de passe de chaîne privé; public userModel (String Username, String Motword) {super (); this.userName = nom d'utilisateur; this.password = mot de passe; } public String getUserName () {return username; } public void setUsername (String username) {this.userName = username; } public String getPassword () {return mot de passe; } public void setPassword (String Motword) {this.password = mot de passe; }} Obtenez Mongotemplete qui fonctionne MongoDB en fonction de la configuration de Spring, et vous devez implémenter l'interface ApplicationContextAware:
package spring_mogo.dao.daoimp; import org.springframework.beans.beanSexception; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.data.mongodb.core.mongotemplate; classe abstraite publique AbstractBasEmongotemplete implémente ApplicationContextAware {Mongotemplate protégé mongotemplate; / ** * @description set mongotemplate selon le fichier de configuration * @param mongotemplate * / public void setMongotemplate (mongotemplate mongotemplate) {this.mongotemplate = mongotemplate; } @Override public void setApplicationContext (ApplicationContext ApplicationContext) lève BeanSexception {mongotemplate mongotemplate = applicationContext.getBean ("mongotemplate", mongotemplate.class); setMongotemplate (mongotemplate); }} L'interface pour faire fonctionner la base de données et la classe d'implémentation correspondante:
L'ajout, la suppression, la modification et la recherche les plus élémentaires sont démontrés. Ce à quoi il faut faire attention, c'est la déclaration de paramètres et la conversion de la classe d'entité lors de la réception des données retournées:
(1) Interface:
package spring_mogo.dao; Importer java.util.list; Importer Spring_Mongo.Models.UserModel; Interface publique UserDao {/ ** * Données de requête * * @Author: Tuzongxun * @Title: Findall * @param @return * @return List <SerModel> * @Date 13 mai 2016 3:07:39 PM * @throws * / public list <SerModel> findall (); / ** * Nouvelles données * * @author: tuzongxun * @title: insertuser * @param @param utilisateur * @return void * @Date 13 mai 2016 3:09:45 PM * @throws * / public void insertuser (userodel user); / ** * Supprimer les données * * @author: tuzongxun * @title: disposiuser * @param @param nom d'utilisateur * @return void * @Date 13 mai 2016 3:09:55 PM * @throws * / public void remoUser (String userName); / ** * Modifier les données * * @Author: Tuzongxun * @Title: UpdateUser * @param @param utilisateur * @return void * @Date 13 mai 2016 3:10:06 PM * @throws * / public void UpdateSer (UserModel User); / ** * Query par condition * * @Author: Tuzongxun * @Title: FindForRequery * @param * @return void * @Date 13 mai 2016 3:23:37 PM * @throws * / public list <UserModel> findForRequery (String Username); } (2) Classe de mise en œuvre, ici, nous devons hériter de la classe AbstractBasemongotemplete, afin d'obtenir le mongotemplete pour diverses opérations:
package spring_mogo.dao.daoimp; Importer java.util.list; import org.springframework.data.mongodb.core.query.criteria; import org.springframework.data.mongodb.core.query.query; import org.springframework.data.mongodb.core.query.update; import org.springframework.sterereotype.Component; import printemps_mogo.dao.userdao; Importer Spring_Mongo.Models.UserModel; import com.mongodb.basicdbObject; import com.mongodb.dbObject; @Component ("UserDaoimp") Classe publique UserDaoimp étend AbstractBasEmongotemplete implémente UserDao {/ ** * Recherchez toutes les données * * @Author: Tuzongxun * @Title: Findall * @description: todo * @param @return * @Date 13 May. findall () {// La classe Corpse correspondante et le nom de collection correspondant de la collection doivent être définis, de sorte que le résultat de la requête est directement mappé la liste <aserModel> userList = Mongotemplate.findall (userModel.class, "user"); return userList; } / ** * Nouvelles données * * @author: tuzongxun * @title: insertuser * @description: todo * @param @param user * @date 13 mai 2016 3:10:45 pm * @throws * / @Override public Insserser (UseraDel User) {// définir l'objet de document qui doit être inséré dans le dabase DBOBase DBOBSE = neuf = objet de document qui doit être inséré dans le DataBase DBOBOBS BasicDBObject (); object.put ("username", user.getUserName ()); object.put ("mot de passe", user.getPassword ()); mongotemplate.insert (objet, "utilisateur"); } / ** * Supprimer les données en fonction des conditions * * @Author: Tuzongxun * @Title: DoPoSeuser * @Description: TODO * @param @param username * @Date 13 mai 2016 3:11:01 PM * @throws * / @Override public Void SupporUser (String Username) {// Définir la condition de déteste, Delete All Query Query Query Query);); Critères critères = nouveaux critères ("nom d'utilisateur"); critères.is (nom d'utilisateur); query.addcriteria (critères); mongotemplate.remove (requête, "utilisateur"); } / ** * Modifier les données * * @Author: Tuzongxun * @Title: UpdateUser * @Description: TODO * @param @param user * @Date 13 mai 2016 3:11:12 PM * @throws * / @override public updateUser (UserModel User) {// set Modification Conditions Query Query = New Query (); Critères critères = nouveaux critères ("nom d'utilisateur"); critères.is (user.getUserName ()); query.addcriteria (critères); // Définir le contenu de modification Update Update = update.update ("mot de passe", user.getPassword ()); // Paramètres: conditions de requête, modifiez le résultat, nom de collection mongotemplate.updatefirst (requête, mise à jour, "utilisateur"); } / ** * Query basé sur la condition * * @Author: Tuzongxun * @Title: FindForReQuery * @Description: Todo * @param @param username * @Date 13 mai 2016 4:08:15 PM * @Throws * / @Override Public List <UserModel> FindForRery (String UserName) {Query Query Query = New Query (); Critères critères = nouveaux critères ("nom d'utilisateur"); critères.is (nom d'utilisateur); query.addcriteria (critères); // Condition de requête, classe d'entité correspondant à l'ensemble, la liste des noms de set <SerModel> userList = Mongotemplate.find (query, userModel.class, "user"); return userList; }} Classe de test:
Afin de vérifier l'exactitude du code et de la configuration ci-dessus, le code de classe de test est le suivant:
package spring_mongo.test; Importer java.util.list; import org.junit.test; import org.junit.runner.runwith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.contextConfiguration; import org.springframework.test.context.junit4.springjunit4classrunner; import printemps_mogo.dao.userdao; Importer Spring_Mongo.Models.UserModel; @Runwith (springjunit4classrunner.class) @contextconfiguration (locations = {"classpath: spring.xml"}) public class monGotest {@autowired private userdao userdao; / ** * Test de requête * * @Author: Tuzongxun * @Title: MonFindtest * @param * @return void * @Date 13 mai 2016 3:27:51 PM * @throws * / @test public void monFindTest () {list <Usermodel> userModels = userdao.Findall (); if (userModels! = null && userModels.size ()> 0) {for (userModel User: UserModels) {System.out.println (user.getUserName () + ":" + user.getPassword ()); }}} / ** * Insérer le test de données * * @Author: Tuzongxun * @Title: MoninsertTest * @param * @return void * @Date 13 mai 2016 3:27:38 PM * @throws * / @test public Void MoninsertTest () {UserModel; userdao.inserser (utilisateur); this.monFindTest (); } / ** * Delete Test * * @author: tuzongxun * @title: monremovetest * @param * @return void * @Date 13 mai 2016 3:28:06 pm * @throws * / @test public void monRemoveTest () {story username = "test111"; UserDao.Removeuser (nom d'utilisateur); this.monFindTest (); } / ** * Modification de test * * @author: tuzongxun * @title: monupdateTest * @param * @return void * @Date 13 mai 2016 3:50:08 PM * @throws * / @test public void monupDateTest () {UserModel User = new UserModel ("test111", "test"); userdao.updateUser (utilisateur); this.monFindTest (); } / ** * Query by condition * * @author: tuzongxun * @title: monfindforruq * @param * @return void * @Date 13 mai 2016 4:10:53 pm * @throws * / @test public void monFindforRuq () {String username = "test111"; List <userModel> userModels = userdao.findForRequery (nom d'utilisateur); if (userModels! = null && userModels.size ()> 0) {for (userModel User: UserModels) {System.out.println (user.getUserName () + ":" + user.getPassword ()); }}}} Téléchargez la démo dans la dernière étape: démo
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.