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/