SpringData集成Mongodb封装简单的CRUD

• maven配置：

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

• 配置文件：

  <?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/context    
           http://www.springframework.org/schema/context/spring-context.xsd    
           http://www.springframework.org/schema/data/mongo    
           http://www.springframework.org/schema/data/mongo/spring-mongo.xsd    
           http://www.springframework.org/schema/beans    
           http://www.springframework.org/schema/beans/spring-beans.xsd">
  
     <mongo:db-factory id="mongoDbFactory" host="${mongo.host}"
         port="${mongo.port}" dbname="${mongo.dbname}" />
  
     <mongo:mapping-converter id="mongoConverter">
     </mongo:mapping-converter>
  
     <bean id="noClassMongoConverter"
         class="com.le.jr.trade.usercenter.common.util.MongoConverterEnhanceFactoryBean">
         <property name="converter" ref="mongoConverter" />
     </bean>
  
     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
         <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
         <constructor-arg name="mongoConverter" ref="noClassMongoConverter" />
     </bean>
  </beans>    

  其中：host为mongodb服务器地址，port为端口号，dbname为数据库名，username为mongodb用户名，password为mongodb密码

• 特别的（去掉_class属性）：

  调用mongoTemplate的save方法时, spring-data-mongodb的TypeConverter会自动给document添加一个_class属性, 值是你保存的类名.
这种设计并没有什么坏处. spring-data-mongodb是为了在把document转换成Java对象时能够转换到具体的子类. 但有时候我们并不希望
出现这个字段, 主要是看上去会比较"烦". 可以通过设置MappingMongoConverter的MongoTypeMapper来解决这个问题.

  public class MongoConverterEnhanceFactoryBean implements FactoryBean<MappingMongoConverter> {
  
      private MappingMongoConverter converter;
  
      public void setConverter(MappingMongoConverter converter) {
          this.converter = converter;
      }
  
      public MappingMongoConverter getObject() throws Exception {
          MongoTypeMapper typeMapper = new DefaultMongoTypeMapper(null);
          converter.setTypeMapper(typeMapper);
          return converter;
      }
  
      public Class<?> getObjectType() {
          return MappingMongoConverter.class;
      }
  
      public boolean isSingleton() {
          return true;
      }
  }

  DefaultMongoTypeMapper类的构造函数的第一个参数是Type在MongoDB中名字. 设置为null的话就不会在保存时自动添加_class属性.

• PO类：

  public class JrTradeUser implements Serializable {
  
      private static final long serialVersionUID = 5401255707141549736L;
  
      // 主键
      @Id
      private Long id;
  
      // 状态
      private Byte state;
  
      // 姓名
      private String realName;
  
      // 生日
      private Date birthday;
  
      // 用户风险测评问卷等级
      private RiskLevelEnum userRisk;
  
      /**
       * getters && setters
       */
  }

• DAO接口：

  public interface BaseMongoDao<T, ID extends Serializable> extends Repository<T, ID> {
  
      /**
       * 通过条件查询实体(集合)
       * 
       * @param query
       */
      public List<T> find(Query query);
  
      /**
       * 通过一定的条件查询一个实体
       * 
       * @param query
       * @return
       */
      public T findOne(Query query);
  
      /**
       * 通过条件查询更新数据
       * 
       * @param query
       * @param update
       * @return
       */
      public void update(Query query, Update update);
  
      /**
       * 保存一个对象到mongodb
       * 
       * @param entity
       * @return
       */
      public T save(T entity);
  
      /**
       * 通过ID获取记录
       * 
       * @param id
       * @return
       */
      public T findById(String id);
  
      /**
       * 通过ID获取记录,并且指定了集合名(表的意思)
       * 
       * @param id
       * @param collectionName
       *            集合名
       * @return
       */
      public T findById(String id, String collectionName);
  
      /**
       * 分页查询
       * 
       * @param page
       * @param query
       * @return
       */
      public Page<T> findPage(Page<T> page, Query query);
  
      /**
       * 求数据总和
       * 
       * @param query
       * @return
       */
      public long count(Query query);
  
      /**
       * 求数据总和
       * 
       * @param query
       * @return
       */
      public void delete(Query query);
  }

• DAO实现类：

  @Service
  public class UserMongoDaoImpl implements BaseMongoDao<JrTradeUser, Long> {
  
      /**
       * spring mongodb　集成操作类　
       */
      @Resource
      MongoTemplate mongoTemplate;
  
      @Override
      public List<JrTradeUser> find(Query query) {
          return mongoTemplate.find(query, JrTradeUser.class);
      }
  
      @Override
      public JrTradeUser findOne(Query query) {
          return mongoTemplate.findOne(query, JrTradeUser.class);
      }
  
      @Override
      public void update(Query query, Update update) {
          mongoTemplate.findAndModify(query, update, JrTradeUser.class);
      }
  
      @Override
      public JrTradeUser save(JrTradeUser entity) {
          mongoTemplate.insert(entity);
          return entity;
      }
  
      @Override
      public JrTradeUser findById(String id) {
          return mongoTemplate.findById(id, JrTradeUser.class);
      }
  
      @Override
      public JrTradeUser findById(String id, String collectionName) {
          return mongoTemplate.findById(id, JrTradeUser.class, collectionName);
      }
  
      @Override
      public Page<JrTradeUser> findPage(Page<JrTradeUser> page, Query query) {
          long count = this.count(query);
          page.setTotalCount((int) count);
          int pageNumber = page.getCurrentPageNo();
          int pageSize = page.getPageSize();
          query.skip((pageNumber - 1) * pageSize).limit(pageSize);
          List<JrTradeUser> rows = this.find(query);
          page.setDataList(rows);
          return page;
      }
  
      @Override
      public long count(Query query) {
          return mongoTemplate.count(query, JrTradeUser.class);
      }
  
      @Override
      public void delete(Query query) {
          mongoTemplate.remove(query, JrTradeUser.class);
      }
  }

• 测试类：

  @RunWith(SpringJUnit4ClassRunner.class)
  @ContextConfiguration(locations = "classpath:spring-config*.xml")
  @ActiveProfiles("test")
  public class UserMongoTest {
  
      @Resource
      private BaseMongoDao<JrTradeUser, Long> userMongoDaoImpl;
  
      /**
       * 测试方法：baseMongoDAOImpl.save 参数输入格式正确
       */
      @Test
      public void testSave() {
          JrTradeUser user = new JrTradeUser();
          user.setId(100001L);
          user.setRealName("xxx");
          user.setBirthday(new Date());
          JrTradeUser test = (JrTradeUser) userMongoDaoImpl.save(user);
          assertNotNull(test);
      }
  
      /**
       * 测试方法：baseMongoDAOImpl.find 参数输入格式正确
       */
      @Test
      public void testFind() {
          Query query = new Query(Criteria.where("realName").is("xxx"));
          List<JrTradeUser> test = userMongoDaoImpl.find(query);
          assertNotNull(test);
      }
  
      /**
       * 测试方法：baseMongoDAOImpl.findOne 参数输入格式正确
       */
      @Test
      public void testFindOne() {
          Query query = new Query(Criteria.where("id").is(100001L));
          JrTradeUser test = userMongoDaoImpl.findOne(query);
          assertNotNull(test);
      }
  
      /**
       * 测试方法：baseMongoDAOImpl.findPage 参数输入格式正确
       */
      @Test
      public void testFindPage() {
          Page<JrTradeUser> page = new Page<JrTradeUser>();
          Query query = new Query(Criteria.where("id").is(100001L));
          Page<JrTradeUser> test = userMongoDaoImpl.findPage(page, query);
          assertNotNull(test);
      }
  
      /**
       * 测试方法：baseMongoDAOImpl.update 参数输入格式正确
       */
      @Test
      public void testUpdate() {
          Update update = new Update();
          update.set("realName", "xxx");
          Query query = new Query(Criteria.where("id").is(100001L));
          userMongoDaoImpl.update(query, update);
          this.testFindOne();
      }
  
      /**
       * 测试方法：baseMongoDAOImpl.count 参数输入格式正确
       */
      @Test
      public void testCount() {
          Query query = new Query(Criteria.where("realName").is("xxx"));
          long count = userMongoDaoImpl.count(query);
          assertTrue(count > 0);
      }
  }