在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);
}