Spring data mongodb配置

配置文件mongoldb-context.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/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-2.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.web.mongo.*" />
    <context:property-placeholder location="classpath:/properties/mongodb.properties"/>
    <!--<bean id="propertyConfigurer"-->
          <!--class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">-->
        <!--<property name="locations" value="classpath:/properties/mongodb.properties" />-->
    <!--</bean>-->
    <!--credentials的配置形式是：用户名:密码@默认数据库-->
    <mongo:mongo-client id="mongoClient" host="${mongodb.host}" port="${mongodb.port}"    credentials="${mongodb.username}:${mongodb.password}@${mongodb.dbname}">
        <mongo:client-options  write-concern="SAFE"
                               connections-per-host="${mongodb.connectionsPerHost}"
                               threads-allowed-to-block-for-connection-multiplier="${mongodb.threadsAllowedToBlockForConnectionMultiplier}"
                               connect-timeout="${mongodb.connectTimeout}"
                               max-wait-time="${mongodb.maxWaitTime}"
                               socket-timeout="${mongodb.socketTimeout}"/>
    </mongo:mongo-client>

    <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->
    <mongo:db-factory id="mongoDbFactory" dbname="${mongodb.dbname}" mongo-ref="mongoClient" />
    <!-- mongodb的主要操作对象，所有对mongodb的增删改查的操作都是通过它完成 -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
    </bean>

    <!-- 映射转换器，扫描back-package目录下的文件，根据注释，把它们作为mongodb的一个collection的映射 -->

</beans>

2、maven的依赖：

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

3、mongodb.properties配置文件

mongodb.host=192.168.1.228
mongodb.port=27017
mongodb.username=bmwuser
mongodb.password=bmwpass
mongodb.dbname=bmw

#一个线程变为可用的最大阻塞数
mongodb.connectionsPerHost=8
#线程队列数,它以上面connectionsPerHost值相乘的结果就是线程队列最大值
mongodb.threadsAllowedToBlockForConnectionMultiplier=1000
#连接超时时间（毫秒）
mongodb.connectTimeout=30000
#最大等待时间
mongodb.maxWaitTime=5000
#自动重连
mongodb.autoConnectRetry=true
#scoket保持活动
mongodb.socketKeepAlive= true
#scoket超时时间
mongodb.socketTimeout=60000
#读写分离
mongodb.slaveOk=true
mongodb.writeNumber=1
mongodb.writeTimeout=0
mongodb.writeFsync=true

java dao层：

package com.web.mongo.dao;

import com.mongodb.WriteResult;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.List;

/**
 * Created by yd on 2018/3/26.
 */
public abstract class MongoGenDao<T> {
    @Autowired
    protected MongoTemplate mongoTemplate;

    /**
     * 保存一个对象
     *
     */
    public void save(T t)
    {
        this.mongoTemplate.save(t);
    }

    /**
     * 批量保存对象
     *
     */
    public void insertList(List<T> list)
    {
        this.mongoTemplate.insertAll(list);
    }

    public List<T>  queryAll(){
        return this.mongoTemplate.findAll(this.getEntityClass());
    }

    /**
     * 根据Id从Collection中查询对象
     *
     */
    public T queryById(String id)
    {
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").is(id);
        query.addCriteria(criteria);
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }

    /**
     * 根据条件查询集合
     *
     * @author http://www.chisalsoft.com
     */
    public List<T> queryList(Query query)
    {
        return this.mongoTemplate.find(query, this.getEntityClass());
    }

    /**
     * 通过条件查询单个实体
     *
     */
    public T queryOne(Query query)
    {
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }

    /**
     * 通过条件进行分页查询
     *
     */
    public List<T> getPage(Query query, int start, int size)
    {
        query.skip(start);
        query.limit(size);
        List<T> lists = this.mongoTemplate.find(query, this.getEntityClass());
        return lists;
    }

    /**
     * 根据条件查询库中符合记录的总数,为分页查询服务
     *
     */
    public Long getPageCount(Query query)
    {
        return this.mongoTemplate.count(query, this.getEntityClass());
    }

    /**
     * 根据Id删除用户
     *
     * @author http://www.chisalsoft.com
     */
    public void deleteById(String id)
    {
        Criteria criteria = Criteria.where("_id").in(id);
        if (null != criteria)
        {
            Query query = new Query(criteria);
            if (null != query && this.queryOne(query) != null)
            {
                this.mongoTemplate.remove(query);
            }
        }
    }

    /**
     * 更新满足条件的第一个记录
     *
     * @author http://www.chisalsoft.com
     */
    public void updateFirst(Query query, Update update)
    {
        this.mongoTemplate.updateFirst(query, update, this.getEntityClass());
    }

    /**
     * 更新满足条件的所有记录
     *
     * @author http://www.chisalsoft.com
     */
    public void updateMulti(Query query, Update update)
    {
        this.mongoTemplate.updateMulti(query, update, this.getEntityClass());
    }

    /**
     * 查找更新,如果没有找到符合的记录,则将更新的记录插入库中
     */
    public void updateInser(Query query, Update update)
    {
        this.mongoTemplate.upsert(query, update, this.getEntityClass());
    }

    /**
     * 删除对象
     *
     * @author http://www.chisalsoft.com
     */
    public Integer delete(T t)
    {
        WriteResult writeResult = this.mongoTemplate.remove(t);
        return (null == writeResult ? 0 : writeResult.getN());

    }

    /**
     * 删除对象
     *
     * @author http://www.chisalsoft.com
     */
    public Integer deleteByCondition(Query query)
    {
        WriteResult writeResult = this.mongoTemplate.remove(query,this.getEntityClass());
        return (null == writeResult ? 0 : writeResult.getN());

    }

    /**
     * 为属性自动注入bean服务
     *
     * @author http://www.chisalsoft.com
     */
    public void setMongoTemplate(MongoTemplate mongoTemplate)
    {
        this.mongoTemplate = mongoTemplate;
    }

    protected abstract Class<T> getEntityClass();


}

package com.web.mongo.dao;

import com.exception.CommonExcepiton;
import com.web.mongo.data.CarRequestData;
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;

/**
 * Created by qxr4383 on 2018/3/26.
 */
@Repository
public class CarRquestMongoDao extends MongoGenDao<CarRequestData> {

    /**
     * 根据条件查询集合
     *
     * @author http://www.chisalsoft.com
     */
    public List<CarRequestData> queryList(Query query)
    {
        return this.mongoTemplate.find(query, CarRequestData.class);
    }

    /**
     * 分页查询 对应mongodb操作中的 db.book.find().skip(10).limit(10);
     *
     */
    public List<CarRequestData> queryPage(CarRequestData CarRequestData, Integer start, Integer size)
    {
        Query query = new Query();
        // 此处可以增加分页查询条件Criteria.然后query.addCriteria(criteria);
        return this.getPage(query, (start - 1) * size, size);
    }

    /**
     * 查询满足分页的记录总数
     */
    public Long queryPageCount(CarRequestData CarRequestData)
    {
        Query query = new Query();
        // 此处可以增加分页查询条件Criteria.然后query.addCriteria(criteria);
        return this.getPageCount(query);
    }

    /**
     * 更新操作
     *
     * @author http://www.chisalsoft.com
     */
    public void updateFirst(CarRequestData CarRequestData) throws Exception
    {
        Update update = new Update();
        if (null == CarRequestData.getVin() || "".equals(CarRequestData.getVin().trim()))
        {
            // 如果主键为空,则不进行修改
            throw new Exception("Update data Id is Null");
        }
        if (CarRequestData.getVin() != null)
        {
            update.set("vin", CarRequestData.getVin());
        }
        this.updateFirst(Query.query(Criteria.where("vin").is(CarRequestData.getVin())), update);
    }

    /**
     * 更新库中所有数据
     *
     * @author http://www.chisalsoft.com
     */
    public void updateMulti(CarRequestData CarRequestData) throws Exception
    {
        Update update = new Update();
        if (null == CarRequestData.getVin() || "".equals(CarRequestData.getVin().trim()))
        {
            // 如果主键为空,则不进行修改
            throw new CommonExcepiton("Update data Id is Null");
        }
        if (CarRequestData.getVin() != null)
        {
            update.set("vin", CarRequestData.getVin());
        }
        this.updateMulti(Query.query(Criteria.where("vin").is(CarRequestData.getVin())), update);
    }

    /**
     * 实现钩子方法,返回反射的类型
     *
     */
    @Override
    protected Class<CarRequestData> getEntityClass()
    {
        return CarRequestData.class;
    }

}

entity类：

package com.web.mongo.data;

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

import java.io.Serializable;
import java.util.Date;

@Document(collection = "car_request")
public class CarRequestData implements Serializable{
    @Id
    private String id;

    private String vuser;

    private String appName;

    private String pu;

    private String system;

    private String page;

    private Date requestDate;

    private Date updateDate;

    private Date creatDate;

    public String getId() {
        return id;
    }

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

    public String getVuser() {
        return vuser;
    }

    public void setVuser(String vuser) {
        this.vuser = vuser == null ? null : vin.trim();
    }

    public String getAppName() {
        return appName;
    }

    public void setAppName(String appName) {
        this.appName = appName == null ? null : appName.trim();
    }

    public String getPu() {
        return pu;
    }

    public void setPu(String pu) {
        this.pu = pu == null ? null : pu.trim();
    }

    public String getSystem() {
        return system;
    }

    public void setSystem(String system) {
        this.system = system == null ? null : system.trim();
    }

    public String getPage() {
        return page;
    }

    public void setPage(String page) {
        this.page = page == null ? null : page.trim();
    }

    public Date getRequestDate() {
        return requestDate;
    }

    public void setRequestDate(Date requestDate) {
        this.requestDate = requestDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    public Date getCreatDate() {
        return creatDate;
    }

    public void setCreatDate(Date creatDate) {
        this.creatDate = creatDate;
    }
}

Spring data mongodb配置

猜你喜欢