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