Mongodb数据库与springmvc整合

1：搭建好springmvc框架这里我们用到的是spring-data中一个集成mongodb的项目，首先在maven中添加对它的依赖。

<!-- mongodb spring -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
            <version>1.0.0.M5</version>
        </dependency>

2：新建一个mongodb.properties文件；基本配置如下

mongo.hostport=172.16.10.247:27017//前面是部署的服务器IP地址，后面是端口号默认的27017
mongo.connectionsPerHost=8
mongo.threadsAllowedToBlockForConnectionMultiplier=4
#\u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4
mongo.connectTimeout=1000
#\u7B49\u5F85\u65F6\u95F4
mongo.maxWaitTime=1500
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true
#Socket\u8D85\u65F6\u65F6\u95F4
mongo.socketTimeout=1500
mongo.slaveOk=true

3：新建一个springmvc与mongo整合的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/context   
          http://www.springframework.org/schema/context/spring-context-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/beans   
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
          
    <!-- 加载mongodb的属性配置文件 -->
    <context:property-placeholder location="classpath:mongodb.properties" />
    
    <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->
    <mongo:mongo id="mongo" replica-set="${mongo.hostport}">
        <!-- 一些连接属性的设置 -->    
        <mongo:options
             connections-per-host="${mongo.connectionsPerHost}"
             threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
             connect-timeout="${mongo.connectTimeout}"
             max-wait-time="${mongo.maxWaitTime}"
             auto-connect-retry="${mongo.autoConnectRetry}"
             socket-keep-alive="${mongo.socketKeepAlive}"
             socket-timeout="${mongo.socketTimeout}"
             slave-ok="${mongo.slaveOk}"
             write-number="1"
             write-timeout="0"
             write-fsync="true"/>        
    </mongo:mongo>

  <!-- mongo的工厂，通过它来取得mongo实例,dbname为db_mongo的数据库名，没有的话会自动创建 -->

    <mongo:db-factory dbname="db_mongo" mongo-ref="mongo" />
    <bean id="mappingContext"
        class="org.springframework.data.mongodb.core.mapping.MongoMappingContext"></bean>

    <bean id="defaultMongoTypeMapper"
        class="org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper">
        <constructor-arg name="typeKey" >
            <null /><!-- 这里设置为空,可以把 spring data mongodb 多余保存的_class字段去掉 -->
        </constructor-arg>
    </bean>
      <!-- MongoMappingConverter类起到实体映射的作用，通过注释把java类转换为mongodb的文档。 -->
    <bean id="mappingMongoConverter"
        class="org.springframework.data.mongodb.core.convert.MappingMongoConverter">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
        <constructor-arg name="mappingContext" ref="mappingContext" />
        <property name="typeMapper" ref="defaultMongoTypeMapper" />
    </bean>

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

</beans>

4:写一个dao文件

@Repository
@Transactional(rollbackFor=Exception.class)
public class BaseMongoDAO<T>{  
      
    /**
     * spring mongodb　集成操作类　
     */  
    @Autowired private MongoTemplate mongoTemplate;  
    
    /*public List<T> find(Query query) {  
        return (List<T>) mongoTemplate.find(query, this.getEntityClass());  
    } */
    @SuppressWarnings("unchecked")
    public List<T> find(Query query, Class<T> clazz) {  
        return (List<T>) mongoTemplate.find(query, clazz);  
    }  
 
    /*public T findOne(Query query) {  
        return (T) mongoTemplate.findOne(query, this.getEntityClass());  
    }  */
    @SuppressWarnings("unchecked")
    public T findOne(Query query, Class<T> clazz) {  
        return (T) mongoTemplate.findOne(query, clazz);  
    }
 
  /*  public void update(Query query, Update update) {  
        mongoTemplate.findAndModify(query, update, this.getEntityClass());  
    }  */
    public void update(Query query, Update update, Class<T> clazz) {  
        mongoTemplate.findAndModify(query, update, clazz);  
    }
    
    //批量更新
    public void updatemulti(Query query, Update update, Class<T> clazz) {  
        mongoTemplate.updateMulti(query, update, clazz);  
    }
   
    public void save(T entity) {  
        mongoTemplate.insert(entity);  
    }  
 
    /*public T findById(String id) {  
        return (T) mongoTemplate.findById(id, this.getEntityClass());  
    }*/
    @SuppressWarnings("unchecked")
    public T findById(String id, Class<T> clazz) {  
        return (T) mongoTemplate.findById(id, clazz);  
    }  
 
    /*public T findById(String id, String collectionName) {  
        return (T) mongoTemplate.findById(id, this.getEntityClass(), collectionName);  
    }  */
       
    public Page<T> findPage(Page<T> page,Query query, Class<T> clazz){  
        long count = this.count(query, clazz);  
        page.setTotal(count);  
        int pageNumber = page.getPageNum();  
        int pageSize = page.getPageSize();  
        query.skip((pageNumber - 1) * pageSize).limit(pageSize);  
        List<T> rows = this.find(query, clazz);  
        page.setRows(rows);  
        return page;  
    }  
      
    public long count(Query query, Class<T> clazz){  
        return mongoTemplate.count(query, clazz);  
    }  
      
    
    public void remove(Query query, Class<T> clazz){  
         mongoTemplate.remove(query,  clazz);  
    }
    /**
     * 获取需要操作的实体类class
     *  
     * @return
     */  
    private Class<T> getEntityClass(){  
        return ReflectionUtils.getSuperClassGenricType(getClass());  
    }  

}