在Spring项目中集成使用MongoDB

 

 

在Spring项目中集成使用MongoDB

 

这里使用的是maven工程，所以依赖jar包都是pom.xml配置型式。

pom.xml引入依赖

<properties>
    <spring.version>4.3.5.RELEASE</spring.version>
</properties>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>1.9.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>2.14.2</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>5.2.4.Final</version>
</dependency>

applicationContext.xml配置spring托管

引入约束mongo

xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xsi:schemaLocation=" 
    http://www.springframework.org/schema/data/mongo
    http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd"

spring依赖配置

<!--连接池配置-->
<mongo:mongo host="${mongo.host}" port="${mongo.port}">
    <mongo:options connections-per-host="${mongo.options.connections-per-host}"
                   threads-allowed-to-block-for-connection-multiplier="${mongo.options.threads-allowed-to-block-for-connection-multiplier}"
                   connect-timeout="${mongo.options.connect-timeout}"
                   max-wait-time="${mongo.options.max-wait-time}"
                   auto-connect-retry="${mongo.options.auto-connect-retry}"
                   socket-keep-alive="${mongo.options.socket-keep-alive}"
                   socket-timeout="${mongo.options.socket-timeout}"
                   slave-ok="${mongo.options.slave-ok}"
                   write-number="${mongo.options.write-number}"
                   write-timeout="${mongo.options.write-timeout}"
                   write-fsync="${mongo.options.write-fsync}"/>
</mongo:mongo>
<!--连接池工厂配置-->
<mongo:db-factory dbname="${mongo.dbname}" username="${mongo.username}" password="${mongo.password}"  mongo-ref="mongo"/>
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
    <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
</bean>
<!--实体映射自动扫描注入的包-->
<mongo:mapping-converter>
    <mongo:custom-converters base-package="com.xyh.mongodb_model" />
</mongo:mapping-converter>

mongo.properties

mongo.host=127.0.0.1
mongo.port=27001
mongo.dbname=test
mongo.username=testuser
mongo.password=12345
mongo.options.connections-per-host=8
mongo.options.threads-allowed-to-block-for-connection-multiplier=4
mongo.options.connect-timeout=1000
mongo.options.max-wait-time=1500
mongo.options.auto-connect-retry=true
mongo.options.socket-keep-alive=true
mongo.options.socket-timeout=1500
mongo.options.slave-ok=false
mongo.options.write-number=1
mongo.options.write-timeout=0
mongo.options.write-fsync=true

• mongo.host：mongoDB数据库所在主机ip地址
• mongo.port：mongoDB数据库使用通讯端口
• mongo.dbname：连接使用的数据库名
• mongo.username：该数据库操作用户名
• mongo.password：该数据库操作用户密码

实体类

@Document
public class LoginHistory {
    @Id
    private String id;

    @Indexed
    private String uid;

    private String ip;

    private String imei;

    @Indexed(direction = IndexDirection.DESCENDING)
    private String timestamp;

    private String longitude;

    private String latitude;

    private String address;

    @PersistenceConstructor
    public LoginHistory( String id, String uid, String ip, String imei, String timestamp, String longitude, String latitude, String address) {
        this.id = id;
        this.uid = uid;
        this.ip = ip;
        this.imei = imei;
        this.timestamp = timestamp;
        this.longitude = longitude;
        this.latitude = latitude;
        this.address = address;
    }

    public String getId() {
        return id;
    }

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

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public String getImei() {
        return imei;
    }

    public void setImei(String imei) {
        this.imei = imei;
    }

    public String getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(String timestamp) {
        this.timestamp = timestamp;
    }

    public String getLongitude() {
        return longitude;
    }

    public void setLongitude(String longitude) {
        this.longitude = longitude;
    }

    public String getLatitude() {
        return latitude;
    }

    public void setLatitude(String latitude) {
        this.latitude = latitude;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

@Id - 文档的唯一标识，在mongodb中为ObjectId，它是唯一的，通过时间戳+机器标识+进程ID+自增计数器（确保同一秒内产生的Id不会冲突）构成。

@Document - 把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。@Document(collection=”mongodb”) mongodb对应表

@DBRef - 声明类似于关系数据库的关联关系。ps：暂不支持级联的保存功能，当你在本实例中修改了DERef对象里面的值时，单独保存本实例并不能保存DERef引用的对象，它要另外保存，如下面例子的Person和Account。

@Indexed - 声明该字段需要索引，建索引可以大大的提高查询效率。

@CompoundIndex - 复合索引的声明，建复合索引可以有效地提高多字段的查询效率。

@GeoSpatialIndexed - 声明该字段为地理信息的索引。

@Transient - 映射忽略的字段，该字段不会保存到mongodb。

@PersistenceConstructor - 声明构造函数，作用是把从数据库取出的数据实例化为对象。该构造函数传入的值为从DBObject中取出的数据

增删改查操作类

在dao中注入xml中配置的mongoTemplate 
MongoOperations是MongoTemplate的父类

@Autowired
private MongoOperations mongoOperations;

//save存在则更新，不存在则插入
public void save(LoginHistory loginHistory){
    mongoOperations.save(loginHistory);
}

//insert存在则不做处理，不存在则插入
public void insert(LoginHistory loginHistory){
    mongoOperations.insert(loginHistory);
}

//根据uid删除文档
public void remove(String uid){
    Query query = new Query();
    query.addCriteria(Criteria.where("uid").is(uid));
    mongoOperations.remove(query,LoginHistory.class);
}

//根据id更新文档
public int update(LoginHistory loginHistory){
    Query query = new Query();
    query.addCriteria(Criteria.where("_id").is(loginHistory.getId()));
    Update update = new Update();
    update.set("uid",loginHistory.getUid());
    update.set("ip",loginHistory.getIp());
    update.set("imei",loginHistory.getImei());
    update.set("timestamp",loginHistory.getTimestamp());
    update.set("longitude",loginHistory.getLongitude());
    update.set("latitude",loginHistory.getLatitude());
    update.set("address",loginHistory.getAddress());
    return mongoOperations.updateFirst(query,update,LoginHistory.class).getN();
}

//单条件查询，find查询所有
public List<LoginHistory> findByUid(String uid){
    Query query = new Query();
    query.addCriteria(Criteria.where("uid").is(uid));
    return mongoOperations.find(query,LoginHistory.class);
}

//多条件查询，find查询所有
public List<LoginHistory> findByUidAndTimestamp(String uid,String startTimestamp,String endTimestamp){
    Query query = new Query();
    query.addCriteria(Criteria.where("uid").is(uid).and("timestamp").gte(startTimestamp).lte(endTimestamp));
    return mongoOperations.find(query,LoginHistory.class);
}



//根据uid分页查询
public List<LoginHistory> page(int page,String uid){
    Query query = new Query();
    query.addCriteria(Criteria.where("uid").is(uid));
    query.with(new Sort(new Sort.Order(Sort.Direction.DESC,"timestamp")));
    query.limit(20);
    query.skip((page-1)*20);
    return mongoOperations.find(query,LoginHistory.class);
}

转载来源：https://blog.csdn.net/xuanyonghao/article/details/76976149