MongoDB和Java（4）：Spring Data整合MongoDB（XML配置）

最近花了一些时间学习了下MongoDB数据库，感觉还是比较全面系统的，涉及了软件安装、客户端操作、安全认证、副本集和分布式集群搭建，以及使用Spring Data连接MongoDB进行数据操作，收获很大。特此记录，以备查看。

文章目录：

MongoDB和Java（1）：Linux下的MongoDB安装

MongoDB和Java（2）：普通用户启动mongod进程

MongoDB和Java（3）：Java操作MongoB

MongoDB和Java（4）：Spring Data整合MongoDB（XML配置）

MongoDB和Java（5）：Spring Data整合MongoDB（注解配置）

MongoDB和Java（6）：Spring Data整合MongoDB副本集、分片集群

MongoDB和Java（7）：MongoDB用户管理

本文记录如何使用XML配置方式整合Spring data和MongoDB

源代码下载
MongoDB和Java学习代码.zip

1、环境准备

JDK　　　　　1.8
Spring　　　　4.2.5.RELEASE
Junit　　　　   4.10
Spring-data-mongodb　　1.9.0.RELEASE
Logback　　　1.1.7

Maven　　　　3.2.1

依赖

 <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
     <spring.version>4.2.5.RELEASE</spring.version>
 </properties>

 <dependencies>

     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.10</version>
         <scope>test</scope>
     </dependency>

     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context-support</artifactId>
         <version>${spring.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>${spring.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-test</artifactId>
         <version>${spring.version}</version>
         <scope>test</scope>
     </dependency>

     <dependency>
         <groupId>org.springframework.data</groupId>
         <artifactId>spring-data-mongodb</artifactId>
         <version>1.9.0.RELEASE</version>
     </dependency>

     <!-- logback日志 -->
     <dependency>
         <groupId>ch.qos.logback</groupId>
         <artifactId>logback-core</artifactId>
         <version>1.1.7</version>
     </dependency>
     <dependency>
         <groupId>ch.qos.logback</groupId>
         <artifactId>logback-classic</artifactId>
         <version>1.1.7</version>
     </dependency>
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.6.1</version>
     </dependency>

 </dependencies>

 <build>
     <finalName>security-demo</finalName>
     <plugins>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <version>3.3</version>
             <configuration>
                 <source>${maven.compiler.source}</source>
                 <target>${maven.compiler.target}</target>
                 <encoding>${project.build.sourceEncoding}</encoding>
             </configuration>
         </plugin>
     </plugins>
 </build>

2、mongodb配置文件

这个是spring的子配置文件，通过从.properties文件读取连接属性创建mongoClient对象，再创建DBFactory对象，通过DBFactory创建MongoTemplate，我们的数据层实现类就是使用MongoTemplate操作MongoDB的。

 <?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-4.2.xsd
             http://www.springframework.org/schema/context
                   http://www.springframework.org/schema/context/spring-context-4.2.xsd
                   http://www.springframework.org/schema/data/mongo
                   http://www.springframework.org/schema/data/mongo/spring-mongo-1.8.xsd">

     <!-- 连接属性文件，配置服务器IP端口、数据库和连接参数 -->
     <context:property-placeholder location="classpath:mongodb.properties"
                             ignore-unresolvable="true" />

     <!-- 创建MongoClient -->
     <mongo:mongo-client id="mongo" replica-set="${mongo.hostport}">
         <mongo:client-options connections-per-host="${mongo.connectionsPerHost}"
             threads-allowed-to-block-for-connection-multiplier=
                     "${mongo.threadsAllowedToBlockForConnectionMultiplier}"
             connect-timeout="${mongo.connectTimeout}" max-wait-time="${mongo.maxWaitTime}"
             socket-keep-alive="${mongo.socketKeepAlive}"
             socket-timeout="${mongo.socketTimeout}" />
     </mongo:mongo-client>

     <!-- MongoDbFactory -->
     <mongo:db-factory id="mgFactory" dbname="${mongo.dbname}"
             mongo-ref="mongo" />

     <!-- MongoTemplate -->
     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
         <constructor-arg name="mongoDbFactory" ref="mgFactory" />
     </bean>

 </beans>

mongodb.properties

 mongo.hostport=10.10.12.195:27017
 mongo.dbname=test
 mongo.connectionsPerHost=8
 mongo.threadsAllowedToBlockForConnectionMultiplier=4
 mongo.connectTimeout=1000
 mongo.maxWaitTime=1500
 mongo.socketKeepAlive=true
 mongo.socketTimeout=1500

3、spring主配置文件

application.xml是spring的主配置文件，配置组件扫描，另外还要引入mongo的配置

 <?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:tx="http://www.springframework.org/schema/tx"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
             http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-4.2.xsd">

     <!-- 组件扫描 -->
     <context:component-scan base-package="org.net5ijy.mongo.dao" />
     <!--使用注解管理bean -->
     <context:annotation-config />

     <import resource="application-mongo.xml" />

 </beans>

4、实体类和数据层

Employee

 @Document(collection = "employee")
 public class Employee implements Serializable {

     @Id
     @Field(value = "_id")
     private String id;

     @Field(value = "name")
     private String name;

     @Field
     private Integer age;

     @Field
     private Date createTime = new Date();

     public Employee() {
         super();
     }
     public Employee(String name, Integer age) {
         super();
         this.name = name;
         this.age = age;
     }

     // getter & setter
 }

数据层实现

 @Repository
 public class EmployeeDaoImpl implements EmployeeDao {

     @Autowired
     private MongoTemplate mongoTemplate;

     @Override
     public List<Employee> findAll() {
         return mongoTemplate.findAll(Employee.class);
     }

     @Override
     public void insertOneEmployee(Employee employee) {
         mongoTemplate.insert(employee);
     }

     @Override
     public void deleteOneEmployeeByName(String name) {
         Criteria c = new Criteria();
         c.and("name").is(name);
         Query query = new Query(c);
         mongoTemplate.remove(query, Employee.class);
     }

     @Override
     public void deleteOneEmployee(String id) {
         Criteria c = new Criteria();
         c.and("_id").is(id);
         Query query = new Query(c);
         mongoTemplate.remove(query, Employee.class);
     }

     @Override
     public Employee findByName(String name) {
         Criteria c = new Criteria();
         c.and("name").is(name);
         Query query = new Query(c);
         return mongoTemplate.findOne(query, Employee.class);
     }

     @Override
     public Employee find(String id) {
         return mongoTemplate.findById(id, Employee.class);
     }
 }

代码中把MongoTemplate注入到了实现类，然后使用它的API进行数据库操作。

5、Junit测试类

 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(locations = { "classpath:application.xml" })
 public class EmployeeDaoImplTest {

     @Autowired
     private EmployeeDao employeeDao;

     @Autowired
     private ApplicationContext context;

     @Test
     public void testFindAll() {
         List<Employee> list = employeeDao.findAll();
         for (Employee employee : list) {
             System.out.println(employee);
         }
     }

     @Test
     public void testInsertOneEmployee() {
         Employee e = new Employee("admin", 28);
         employeeDao.insertOneEmployee(e);
     }

     @Test
     public void testDeleteOneEmployeeByName() {
         employeeDao.deleteOneEmployeeByName("admin");
     }

     @Test
     public void testDeleteOneEmployee() {
         Employee e = employeeDao.findByName("admin");
         employeeDao.deleteOneEmployee(e.getId());
     }

     @Test
     public void testFindByName() {
         Employee e = employeeDao.findByName("admin");
         System.out.println(e);
     }

     @Test
     public void testFind() {
         Employee e = employeeDao.findByName("admin");
         Employee e2 = employeeDao.find(e.getId());
         System.out.println(e2);
     }
 }

6、参考资料

Spring Data MongoDB - Reference Documentation

https://docs.spring.io/spring-data/mongodb/docs/1.10.15.RELEASE/reference/html/