Spring Data MongoDB示例
欢迎使用Spring Data MongoDB示例。Spring Data MongoDB是将Spring Framework与最广泛使用的NoSQL数据库MongoDB集成的Spring项目之一。
目录[ 隐藏 ]
Spring Data MongoDB
使用Spring的一个主要好处是它提供了与企业应用程序中使用的大多数主要框架的集成。例如，Spring ORM Hibernate Integration。
我们将使用最新版本的Spring Framework和Spring Data MongoDB作为示例项目。我们最终的Spring Data MongoDB示例项目如下图所示。
Spring Data MongoDB也可以在一个简单的应用程序中使用，它不需要使用Spring框架。让我们看一下简单的Spring MongoDB示例。为此，您需要在pom.xml文件中包含以下依赖项，它将通过maven传递依赖项自动包含兼容的MongoDB java驱动程序。
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>1.5.2.RELEASE</version>
</dependency>
Spring Data MongoDB示例 - 模型Bean
我们将有一个简单的模型bean，其中一些变量存储在MongoDB数据库中。
Person.java
package com.journaldev.spring.mongodb.model;
import org.springframework.data.annotation.Id;
public class Person {
//id will be used for storing MongoDB _id
@Id
private String id;
private String name;
private String address;
public Person(){}
public Person(String i, String n, String a){
this.id=i;
this.name=n;
this.address=a;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString(){
return id+"::"+name+"::"+address;
}
}
这是一个简单的java bean，但是你应该知道的重点很少。
- 我们知道MongoDB中的每个文档都需要有一个名为_id的主键，我们可以提供它，或者MongoDB会为我们生成它。我们可以使用
org.springframework.data.annotation.Id模型bean变量的注释将它映射到_id字段。 - 如果字段名称是“id”，那么我们不需要使用@Id注释，但是最好使用它。在上面的课程中，我们可以跳过@Id注释。
- 您应该始终在bean中具有id字段，否则它将不会映射到对象的任何属性，并且您将丢失主键引用。
现在让我们看看如何轻松使用Spring Data MongoDB在MongoDB数据库上执行CRUD操作。
SpringDataMongoDBMain.java
package com.journaldev.spring.mongodb.main;
import java.net.UnknownHostException;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import com.journaldev.spring.mongodb.model.Person;
import com.mongodb.MongoClient;
public class SpringDataMongoDBMain {
public static final String DB_NAME = "journaldev";
public static final String PERSON_COLLECTION = "Person";
public static final String MONGO_HOST = "localhost";
public static final int MONGO_PORT = 27017;
public static void main(String[] args) {
try {
MongoClient mongo = new MongoClient(
MONGO_HOST, MONGO_PORT);
MongoOperations mongoOps = new MongoTemplate(mongo, DB_NAME);
Person p = new Person("113", "PankajKr", "Bangalore, India");
mongoOps.insert(p, PERSON_COLLECTION);
Person p1 = mongoOps.findOne(
new Query(Criteria.where("name").is("PankajKr")),
Person.class, PERSON_COLLECTION);
System.out.println(p1);
mongoOps.dropCollection(PERSON_COLLECTION);
mongo.close();
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
现在当我运行Spring Data MongoDB示例程序时，它会生成以下输出。
02:02:14.785 [main] DEBUG o.s.d.m.c.i.MongoPersistentEntityIndexCreator - Analyzing class class com.journaldev.spring.mongodb.model.Person for index information.
02:02:14.794 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - Inserting DBObject containing fields: [_class, _id, name, address] in collection: Person
02:02:14.798 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:02:14.824 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "name" : "PankajKr"} fields: null for class: class com.journaldev.spring.mongodb.model.Person in collection: Person
02:02:14.826 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:02:14.826 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "name" : "PankajKr"} in db.collection: journaldev.Person
113::PankajKr::Bangalore, India
02:02:14.833 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:02:14.835 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - Dropped collection [journaldev.Person]
从我们的学习到现在，我们可以总结Spring Data MongoDB的以下几点。
- Spring Data MongoDB提供了MongoDB java驱动程序的包装器，在内部使用MongoDB java驱动程序来执行数据库操作。
MongoOperations为不同的操作声明了很多方法，大多数时候，它们对我们来说足够了。MongoTemplate是实现类，它需要Mongo或MongoClient（对于较新的MongoDB java驱动程序版本）或MongoDbFactory初始化它。我们还需要提供将要使用的数据库名称。- 如果数据库受密码保护，我们可以使用
org.springframework.data.authentication.UserCredentials传递身份验证用户名和密码详细信息。 org.springframework.data.mongodb.core.query.Query和org.springframework.data.mongodb.core.query.Criteria类用于定义用于查找特定记录或记录的查询。- Spring Data MongoDB的主要好处是我们不需要担心java bean到Mongo DBObject的转换，反之亦然，正如我们在MongoDB Java Example中看到的那样。
现在让我们继续在Spring环境中使用Spring Data MongoDB。它非常简单，主要需要配置相关的代码，我们可以通过XML，注释或通过java配置来完成。但是，我将为Spring Data MongoDB示例使用基于XML的配置。
这是我最后一个带有Spring Framework和Spring Data MongoDB依赖项的pom.xml。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework.samples</groupId>
<artifactId>SpringMongo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<!-- Generic properties -->
<java.version>1.6</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- Spring -->
<spring-framework.version>4.0.3.RELEASE</spring-framework.version>
<spring-data-mongodb.version>1.5.2.RELEASE</spring-data-mongodb.version>
<!-- Logging -->
<logback.version>1.0.13</logback.version>
<slf4j.version>1.7.5</slf4j.version>
</properties>
<dependencies>
<!-- Spring and Transactions -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>${spring-data-mongodb.version}</version>
</dependency>
<!-- Logging with SLF4J & LogBack -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>${logback.version}</version>
<scope>runtime</scope>
</dependency>
</dependencies>
</project>
Spring Data MongoDB DAO类
我们将使用DAO模式公开可以在Person对象上执行的不同操作。
PersonDAO.java
package com.journaldev.spring.mongodb.dao;
import com.journaldev.spring.mongodb.model.Person;
public interface PersonDAO {
public void create(Person p);
public Person readById(String id);
public void update(Person p);
public int deleteById(String id);
}
下面是MongoDB特定的实现类。
PersonDAOImpl.java
package com.journaldev.spring.mongodb.dao;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import com.journaldev.spring.mongodb.model.Person;
import com.mongodb.WriteResult;
public class PersonDAOImpl implements PersonDAO {
private MongoOperations mongoOps;
private static final String PERSON_COLLECTION = "Person";
public PersonDAOImpl(MongoOperations mongoOps){
this.mongoOps=mongoOps;
}
@Override
public void create(Person p) {
this.mongoOps.insert(p, PERSON_COLLECTION);
}
@Override
public Person readById(String id) {
Query query = new Query(Criteria.where("_id").is(id));
return this.mongoOps.findOne(query, Person.class, PERSON_COLLECTION);
}
@Override
public void update(Person p) {
this.mongoOps.save(p, PERSON_COLLECTION);
}
@Override
public int deleteById(String id) {
Query query = new Query(Criteria.where("_id").is(id));
WriteResult result = this.mongoOps.remove(query, Person.class, PERSON_COLLECTION);
return result.getN();
}
}
代码很简单，所以我不会详细解释它们。
Spring Data MongoDB Bean配置文件
与往常一样，此应用程序最重要的部分是spring bean配置文件。我们将依赖注入不同的bean并定义它们。
这是我们的最终spring bean配置文件。
spring.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:context="http://www.springframework.org/schema/context"
xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.5.xsd">
<mongo:mongo host="localhost" port="27017" id="mongo" />
<mongo:db-factory dbname="journaldev" mongo-ref="mongo" id="mongoDbFactory" />
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
</bean>
<bean id="personDAO" class="com.journaldev.spring.mongodb.dao.PersonDAOImpl">
<constructor-arg name="mongoOps" ref="mongoTemplate"/>
</bean>
</beans>
应该存在的重要配置是 - Spring Data MongoDB架构和MongoDB连接的Mongo实例。为方便起见，我定义了MongoDbFactory实例，我们也可以像下面一样定义MongoTemplate bean，
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg name="mongo" ref="mongo" />
<constructor-arg name="databaseName" value="journaldev" />
</bean>
Spring Data MongoDB测试程序
最后，让我们编写一个简单的测试程序，并在MongoDB数据库上运行一些CRUD操作。
SpringMongoDBXMLMain.java
package com.journaldev.spring.mongodb.main;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.journaldev.spring.mongodb.dao.PersonDAO;
import com.journaldev.spring.mongodb.model.Person;
public class SpringMongoDBXMLMain {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
PersonDAO personDAO = ctx.getBean("personDAO", PersonDAO.class);
Person p = new Person(null, "PankajKr", "Bangalore, India");
//create
personDAO.create(p);
System.out.println("Generated ID="+p.getId());
//read
Person p1 = personDAO.readById(p.getId());
System.out.println("Retrieved Person="+p1);
//update
p1.setName("David");p1.setAddress("SFO, USA");
personDAO.update(p1);
Person temp = personDAO.readById(p1.getId());
System.out.println("Retrieved Person after update="+temp);
//delete
int count = personDAO.deleteById(p1.getId());
System.out.println("Number of records deleted="+count);
ctx.close();
}
}
现在当我运行上面的应用程序时，它会生成以下输出。
02:27:34.509 [main] DEBUG o.s.d.m.c.i.MongoPersistentEntityIndexCreator - Analyzing class class com.journaldev.spring.mongodb.model.Person for index information.
02:27:34.516 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - Inserting DBObject containing fields: [_class, _id, name, address] in collection: Person
02:27:34.520 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
Generated ID=53f50bbe0364b65dbc0c4753
02:27:34.532 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "_id" : "53f50bbe0364b65dbc0c4753"} fields: null for class: class com.journaldev.spring.mongodb.model.Person in collection: Person
02:27:34.533 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:27:34.535 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "_id" : { "$oid" : "53f50bbe0364b65dbc0c4753"}} in db.collection: journaldev.Person
Retrieved Person=53f50bbe0364b65dbc0c4753::PankajKr::Bangalore, India
02:27:34.543 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - Saving DBObject containing fields: [_class, _id, name, address]
02:27:34.543 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:27:34.545 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "_id" : "53f50bbe0364b65dbc0c4753"} fields: null for class: class com.journaldev.spring.mongodb.model.Person in collection: Person
02:27:34.545 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:27:34.546 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - findOne using query: { "_id" : { "$oid" : "53f50bbe0364b65dbc0c4753"}} in db.collection: journaldev.Person
Retrieved Person after update=53f50bbe0364b65dbc0c4753::David::SFO, USA
02:27:34.549 [main] DEBUG o.s.data.mongodb.core.MongoDbUtils - Getting Mongo Database name=[journaldev]
02:27:34.550 [main] DEBUG o.s.data.mongodb.core.MongoTemplate - Remove using query: { "_id" : { "$oid" : "53f50bbe0364b65dbc0c4753"}} in collection: Person.
Number of records deleted=1
02:27:34.553 [main] INFO o.s.c.s.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@7a187814: startup date [Thu Aug 21 02:27:33 GMT+05:30 2014]; root of context hierarchy
02:27:34.553 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'lifecycleProcessor'
02:27:34.553 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@3f64b09c: defining beans [mongo,org.springframework.beans.factory.config.CustomEditorConfigurer#0,org.springframework.beans.factory.config.CustomEditorConfigurer#1,org.springframework.beans.factory.config.CustomEditorConfigurer#2,mongoDbFactory,mongoTemplate,personDAO]; root of factory hierarchy
02:27:34.554 [main] DEBUG o.s.b.f.s.DisposableBeanAdapter - Invoking destroy() on bean with name 'mongoDbFactory'
02:27:34.554 [main] DEBUG o.s.b.f.s.DisposableBeanAdapter - Invoking destroy() on bean with name 'mongo'
请注意，当Spring上下文关闭时，它也会关闭MongoDB连接，所以我们不需要担心。
另外，我在每个查询中提供MongoDB Collection名称，如果集合名称确认为java命名约定，我们可以跳过它。例如，对于“Person”和“PersonAddress”对象，Spring MongoDB使用的默认集合名称分别是“person”和“personAddress”。
我们还可以使用org.springframework.data.mongodb.core.mapping.DocumentModel类的注释来定义用于保存文档的集合名称。
基于Spring Data MongoDB注释的配置
如果要使用基于注释的配置，可以使用下面的Configuration类进行参考。
SpringMongoDBConfiguration.java
package com.journaldev.spring.mongodb.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import com.mongodb.MongoClient;
@Configuration
public class SpringMongoDBConfiguration {
public @Bean MongoDbFactory getMongoDbFactory() throws Exception {
return new SimpleMongoDbFactory(new MongoClient("localhost",27017), "journaldev");
}
public @Bean MongoTemplate getMongoTemplate() throws Exception {
MongoTemplate mongoTemplate = new MongoTemplate(getMongoDbFactory());
return mongoTemplate;
}
}
我们还需要其他配置来将MongoTemplate bean注入到我们的DAO实现类中，我将这部分留给您。
使用MongoOptions进行MongoDB连接选项
我们可以用来MongoOptions在spring bean配置文件中定义MongoDB选项，如下所示。还有一些其他配置选项，您可以检查优化连接。
<mongo:mongo host="localhost" port="27017">
<mongo:options connections-per-host="4"
connect-timeout="1000"
max-wait-time="1500"
auto-connect-retry="true"
socket-keep-alive="true"
socket-timeout="1500"
write-fsync="true" />
</mongo:mongo>
Spring Data MongoDB示例摘要
我希望这个教程足以让你开始使用Spring Data MongoDB，覆盖所有内容是不可行的。您应该更多地了解Query，Criteria和MongoTemplate方法以了解更多信息。您可以从下面的链接下载最终项目。
274
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
