MongoDB整合Spring

1、maven项目架构

2、Dependencies

<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>com.bestpay.learn</groupId>
  <artifactId>springmongo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springmongo</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
          <type>jar</type>
          <scope>provided</scope>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>1.6.1</version>
          <type>jar</type>
          <scope>compile</scope>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>1.7.5</version>
          <type>jar</type>
          <scope>runtime</scope>
      </dependency>
      <dependency>
          <groupId>org.mongodb</groupId>
          <artifactId>mongo-java-driver</artifactId>
          <version>2.10.1</version>
          <type>jar</type>
          <scope>compile</scope>
      </dependency>
      <dependency>
          <groupId>org.springframework.data</groupId>
          <artifactId>spring-data-mongodb</artifactId>
          <version>1.2.1.RELEASE</version>
          <type>jar</type>
          <scope>compile</scope>
      </dependency>
      <dependency>
          <groupId>org.springframework.data</groupId>
          <artifactId>spring-data-mongodb-cross-store</artifactId>
          <version>1.2.1.RELEASE</version>
          <type>jar</type>
          <scope>compile</scope>
      </dependency>
      <dependency>
          <groupId>org.springframework.data</groupId>
          <artifactId>spring-data-mongodb-log4j</artifactId>
          <version>1.2.1.RELEASE</version>
          <type>jar</type>
          <scope>compile</scope>
      </dependency>
  </dependencies>
</project>

3、配置文件

<?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-3.0.xsd
        http://www.springframework.org/schema/data/mongo
        http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <context:component-scan base-package="com.bestpay.learn"/>

    <mongo:mongo host="172.25.132.21" port="10001"/>

    <!-- mongo的工厂，通过它来取得mongo实例，dbname为mongod的数据库名，没有的话会自动创建 -->
    <mongo:db-factory dbname="imooc" mongo-ref="mongo"/>

    <!-- mongodb的主要操作对象，所有对mongodb的增删改查的操作都是通过它完成 -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
    </bean>

    <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->
    <mongo:mapping-converter base-package="com.bestpay.learn.model" />

    <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->
    <mongo:repositories base-package="com.bestpay.learn.dao.impl" />

    <context:annotation-config />

</beans>

4、增删改查

1）UserEntity.java

package com.bestpay.learn.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.Date;

/**
 * Created by Administrator on 15-3-27.
 */
@Document(collection = "user")
public class UserEntity {
    @Id
    private String id;
    private NameEntity name;
    private int age;
    private int works;
    private Date birth;
    private String password;
    private String regionName;
    private String[] special;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public NameEntity getName() {
        return name;
    }

    public void setName(NameEntity name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getWorks() {
        return works;
    }

    public void setWorks(int works) {
        this.works = works;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRegionName() {
        return regionName;
    }

    public void setRegionName(String regionName) {
        this.regionName = regionName;
    }

    public String[] getSpecial() {
        return special;
    }

    public void setSpecial(String[] special) {
        this.special = special;
    }
}

2）NameEntity.java

package com.bestpay.learn.model;

/**
 * Created by Administrator on 15-3-27.
 */
public class NameEntity {

    private String username;

    private String nickname;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

}

3）UserDao.java

package com.bestpay.learn.dao;

import com.bestpay.learn.model.UserEntity;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * Created by Administrator on 15-3-27.
 */
@Transactional
public interface UserDao {
    public abstract void _test();

    public abstract void createCollection();

    public abstract List<UserEntity> findList(int skip, int limit);

    public abstract List<UserEntity> findListByAge(int age);

    public abstract UserEntity findOne(String id);

    public abstract UserEntity findOneByUsername(String username);

    public abstract void insert(UserEntity entity);

    public abstract void update(UserEntity entity);
}

3）UserDaoImpl.java

package com.bestpay.learn.dao.impl;

import com.bestpay.learn.dao.UserDao;
import com.bestpay.learn.model.UserEntity;
import com.mongodb.DB;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
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.stereotype.Repository;

import java.util.List;
import java.util.Set;

/**
 * Created by Administrator on 15-3-27.
 */
@Repository
public class UserDaoImpl implements UserDao {

    public static final Logger logger = LoggerFactory.getLogger(UserDaoImpl.class);

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void _test() {
        Set<String> colls = this.mongoTemplate.getCollectionNames();
        for(String coll : colls){
            logger.info("CollectionName=" +coll );
        }
        DB db = this.mongoTemplate.getDb();
        logger.info("db:" + db.toString());
    }

    @Override
    public void createCollection() {
        if (!this.mongoTemplate.collectionExists(UserEntity.class)) {
            this.mongoTemplate.createCollection(UserEntity.class);
        }
    }

    @Override
    public List<UserEntity> findList(int skip, int limit) {
        Query query = new Query();
        query.with(new Sort(new Sort.Order(Sort.Direction.ASC, "_id")));
        query.skip(skip).limit(limit);
        return this.mongoTemplate.find(query, UserEntity.class);
    }

    @Override
    public List<UserEntity> findListByAge(int age) {
        Query query = new Query();
        query.addCriteria(new Criteria("age").is(age));
        return this.mongoTemplate.find(query, UserEntity.class);
    }

    @Override
    public UserEntity findOne(String id) {Query query = new Query();
        query.addCriteria(new Criteria("_id").is(id));
        return this.mongoTemplate.findOne(query, UserEntity.class);
    }

    @Override
    public UserEntity findOneByUsername(String username) {
        Query query = new Query();
        query.addCriteria(new Criteria("name.username").is(username));
        return this.mongoTemplate.findOne(query, UserEntity.class);
    }

    @Override
    public void insert(UserEntity entity) {
        this.mongoTemplate.insert(entity);
    }

    @Override
    public void update(UserEntity entity) {
        Query query = new Query();
        query.addCriteria(new Criteria("_id").is(entity.getId()));
        Update update = new Update();
        update.set("age", entity.getAge());
        update.set("password", entity.getPassword());
        update.set("regionName", entity.getRegionName());
        update.set("special", entity.getSpecial());
        update.set("works", entity.getWorks());
        update.set("name", entity.getName());
        this.mongoTemplate.updateFirst(query, update, UserEntity.class);
    }

}

App.java

package com.bestpay.learn;

import com.bestpay.learn.dao.UserDao;
import com.bestpay.learn.dao.impl.UserDaoImpl;
import com.bestpay.learn.model.UserEntity;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * Hello world!
 */
public class App {
    public static void main(String[] args) {
        System.out.println("Bootstrapping HelloMongo");

        ConfigurableApplicationContext context = null;
        context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = context.getBean(UserDaoImpl.class);
        userDao._test();
        UserEntity entity1 = new UserEntity();
        entity1.setId("5");
        entity1.setAge(1);
        entity1.setBirth(new Date());
        entity1.setPassword("asdfasdf");
        entity1.setRegionName("北京");
        entity1.setWorks(1);
        userDao.insert(entity1);
        userDao.update(entity1);
        userDao.createCollection();

        List<UserEntity> list = userDao.findList(0, 10);
        for (UserEntity e : list) {
            System.out.println("age:" + e.getAge());
        }

        list = userDao.findListByAge(1);
        for (UserEntity e : list) {
            System.out.println("age:" + e.getAge());
        }

        UserEntity e = userDao.findOne("1");
        if(e != null){
            System.out.println("age:" + e.getAge());
        }

        e = userDao.findOneByUsername("limingnihao");
        if(e!=null){
            System.out.println("age:" + e.getAge());
        }
        System.out.println("DONE");
    }
}