案例一：MongoClient最简单操作
1、优缺点
- 优点：简单，快速测试实现
- 缺点：不适合项目整合使用
2、添加依赖
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.12.10</version>
</dependency>
3、源码
package com.detail.util;
import java.util.ArrayList;
import java.util.List;
import org.bson.Document;
import org.bson.conversions.Bson;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
//mongodb 连接数据库工具类
public class MongoDBUtil {
//不通过认证获取连接数据库对象
public static MongoDatabase getConnect(){
//连接到 mongodb 服务
MongoClient mongoClient = new MongoClient("服务器ip", 27017);
//连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
//返回连接数据库对象
return mongoDatabase;
}
//需要密码认证方式连接
public static MongoDatabase getAuthConnect(){
List<ServerAddress> adds = new ArrayList<>();
//ServerAddress()两个参数分别为 服务器地址 和 端口
ServerAddress serverAddress = new ServerAddress("服务器ip", 27017);
adds.add(serverAddress);
List<MongoCredential> credentials = new ArrayList<>();
//MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
MongoCredential mongoCredential = MongoCredential.createScramSha1Credential("root", "test", "root".toCharArray());
credentials.add(mongoCredential);
//通过连接认证获取MongoDB连接
MongoClient mongoClient = new MongoClient(adds, credentials);
//连接到数据库
MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
//返回连接数据库对象
return mongoDatabase;
}
//插入一个文档
public void insertOneTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//要插入的数据
Document document = new Document("name","张三")
.append("sex", "男")
.append("age", 18);
//插入一个文档
collection.insertOne(document);
}
//插入多个文档
public void insertManyTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//要插入的数据
List<Document> list = new ArrayList<>();
for(int i = 1; i <= 3; i++) {
Document document = new Document("name", "张三")
.append("sex", "男")
.append("age", 18);
list.add(document);
}
//插入多个文档
collection.insertMany(list);
}
//删除与筛选器匹配的单个文档
public void deleteOneTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//申明删除条件
Bson filter = Filters.eq("age",18);
//删除与筛选器匹配的单个文档
collection.deleteOne(filter);
}
//删除与筛选器匹配的所有文档
public void deleteManyTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//申明删除条件
Bson filter = Filters.eq("age",18);
//删除与筛选器匹配的所有文档
collection.deleteMany(filter);
}
//修改单个文档
public void updateOneTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//修改过滤器
Bson filter = Filters.eq("name", "张三");
//指定修改的更新文档
Document document = new Document("$set", new Document("age", 100));
//修改单个文档
collection.updateOne(filter, document);
}
//修改多个文档
public void updateManyTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//修改过滤器
Bson filter = Filters.eq("name", "张三");
//指定修改的更新文档
Document document = new Document("$set", new Document("age", 100));
//修改多个文档
collection.updateMany(filter, document);
}
//查找集合中的所有文档
public void findTest(){
//获取数据库连接对象
// MongoDatabase mongoDatabase = MongoDBUtil.getAuthConnect();
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("customer");
//查找集合中的所有文档
FindIterable findIterable = collection.find();
MongoCursor cursor = findIterable.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
}
//指定查询过滤器查询
public void FilterfindTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//指定查询过滤器
Bson filter = Filters.eq("name", "张三");
//指定查询过滤器查询
FindIterable findIterable = collection.find(filter);
MongoCursor cursor = findIterable.iterator();
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
}
//取出查询到的第一个文档
public void findFirstTest(){
//获取数据库连接对象
MongoDatabase mongoDatabase = MongoDBUtil.getConnect();
//获取集合
MongoCollection<Document> collection = mongoDatabase.getCollection("user");
//查找集合中的所有文档
FindIterable findIterable = collection.find();
//取出查询到的第一个文档
Document document = (Document) findIterable.first();
//打印输出
System.out.println(document);
}
public static void main(String[] args) {
MongoDBUtil mongodb = new MongoDBUtil();
mongodb.findTest();
}
}
案例二：继承MongoRepository
懒得搭建，需要的话进扣扣裙索要，783092701
1、优缺点
- 优点：适合springboot项目整合，分层操作
- 缺点：不支持过滤条件分组。即不支持过滤条件用 or(或) 来连接，所有的过滤条件，都是简单一层的用 and(并且) 连接不支持两个值的范围查询，如时间范围的查询
2、接口类继承MongoRepository
package com.yhzq.dao.repository;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Component;
import com.yhzq.dao.entity.Customer;
import java.util.List;
/**
* <p>Title: 客户数据访问服务</p>
* <p>Description:抽象出接口层，目的是为了自定义规范;
* 并且未声明的，使用时，父类的也能直接使用 </p>
* @author wangmoumo
* @myblog www.681vip.com
* @date 2022年10月18日
*/
public interface BaseRepository extends MongoRepository<Customer, String> {
Customer findByFirstName(String firstName);
List<Customer> findByLastName(String lastName);
}
3、service类注入接口BaseRepository
package com.yhzq.service;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import com.yhzq.dao.entity.Customer;
import com.yhzq.dao.repository.BaseRepository;
import javax.annotation.Resource;
import java.util.List;
/**
* <p>Title: CustomerService.java</p>
* <p>Description: service操作mongodb</p>
* @author wangmoumo
* @myblog www.681vip.com
* @date 2022年10月18日
*/
@Service
public class CustomerService{
@Resource
private BaseRepository repository;
/**
* 保存客户
* @param customer 客户
* 第一种使用save的方式修改，一般这种只能修改单个。
* 这种修改的方式是通过id去修改，如果id不存在就新增一个，
* 存在就修改为新传入的数据
*/
public List<Customer> saveAll(Iterable<Customer> iterable) {
return repository.saveAll(iterable);
}
/**
* 保存客户
* @param customer 客户
*/
public Customer save(Customer customer) {
Customer save = repository.save(customer);
return save;
}
/**
* 删除所有的客户
*/
public void deleteAll() {
repository.deleteAll();
}
/**
* 删除所有的客户
*/
public void deleteAll(Customer customer) {
repository.delete(customer);
}
/**
* 删除所有的客户
*/
public void deleteAll(Iterable<? extends Customer> entities) {
repository.deleteAll(entities);
}
/**
* 删除所有的客户
*/
public void deleteById(String id) {
repository.deleteById(id);
}
/**
* 查询所有客户列表
* @return 客户列表
*/
public List<Customer> findAll() {
return repository.findAll();
}
/**
* 查询所有客户列表
* @return 客户列表
*/
public Iterable<Customer> findAll(Sort sort) {
return repository.findAll(sort);
}
/**
* 查询所有客户列表
* @return 客户列表
*/
public Iterable<Customer> findAll(Example<Customer> example) {
return repository.findAll(example);
}
/**
* 查询所有客户列表
* @return 客户列表
*/
public Iterable<Customer> findAllById(Iterable<String> ids) {
return repository.findAllById(ids);
}
/**
* 通过名查找某个客户
* @param firstName
* @return
*/
public Customer findByFirstName(String firstName) {
return repository.findByFirstName(firstName);
}
/**
* 通过姓查找客户列表
* @param lastName
* @return
*/
public List<Customer> findByLastName(String lastName) {
return repository.findByLastName(lastName);
}
}
4、controller类注入service类
package com.yhzq.controller;
import java.util.List;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.yhzq.dao.entity.Customer;
import com.yhzq.service.CustomerService;
@RestController
public class CustomerController{
private static final Logger log = LoggerFactory.getLogger(CustomerController.class);
@Resource
private CustomerService service;
@RequestMapping("/customer")
public Customer save(){
Customer customer = new Customer("wang","baoluo");
Customer save = service.save(customer);
log.info("save:"+save);
return save;
}
@RequestMapping("/list")
public List<Customer> findAll() {
List<Customer> findAll = service.findAll();
log.info("findAll:"+findAll);
return findAll;
}
}
案例三：使用MongoTemplate
懒得搭建，需要的话进扣扣裙索要，783092701
1、优缺点
- 优点：擅长复杂查询，条件查询，聚合查询
- 缺点：不支持返回固定字段
2、MongoTemplate结合Query
2.1 实现一：使用Criteria封装增删改查条件
2.1.1 Dao注入mongotemplate
package com.example.dao;
import com.example.entity.MongodbTest;
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 org.springframework.stereotype.Component;
/**
* create by wbl
* 2023/02/08
*/
@Component
public class MongodbTestDao {
@Autowired
private MongoTemplate mongoTemplate;
/**
* 创建对象
* @param test
*/
public void save(MongodbTest test) {
mongoTemplate.insert(test);
}
/**
* 根据名字去查询对象
* @param name
* @return
*/
public MongodbTest findOne(String name) {
Query query = new Query(Criteria.where("name").is(name));
MongodbTest mgt = mongoTemplate.findOne(query,MongodbTest.class);
return mgt;
}
/**
* 修改对象
* @param test
*/
public void updateMongoDb(MongodbTest test) {
Query query = new Query(Criteria.where("id").is(test.getId()));
Update update = new Update().set("age",test.getAge()).set("name",test.getName());
mongoTemplate.updateFirst(query,update,MongodbTest.class);
}
/**
* 删除对象
* @param id
*/
public void removeMongodb(String id) {
Query query = new Query(Criteria.where("id").is(id));
mongoTemplate.remove(query,MongodbTest.class);
}
}
2.1.2 Service注入Dao
package com.example.service;
import com.example.dao.MongodbTestDao;
import com.example.entity.MongodbTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* create by wbl
* 2023/02/08
*/
@Service
public class MongodbTestService {
@Autowired
private MongodbTestDao mongodbTestDao;
/**
* 增加的方法
*/
public void save(){
MongodbTest mongodbTest = new MongodbTest();
mongodbTest.setId(1);
mongodbTest.setAge(19);
mongodbTest.setName("招投标");
mongodbTestDao.save(mongodbTest);
}
/**
* 修改的方法
*/
public void update() {
MongodbTest mongodbTest = new MongodbTest();
mongodbTest.setId(1);
mongodbTest.setAge(20);
mongodbTest.setName("国网商城");
mongodbTestDao.updateMongoDb(mongodbTest);
}
}
2.1.3 Controller层注入service
package com.example.controller;
import com.example.service.MongodbTestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* create by wsh
* 2019/10/30
*/
@RestController
public class MongodbTestController {
@Autowired
private MongodbTestService mongodbTestService;
/**
* 增加对象
*/
@GetMapping("/save")
public void save() {
mongodbTestService.save();
}
@GetMapping("/update")
public void update() {
mongodbTestService.update();
}
@GetMapping("/delete")
public void update2() {
mongodbTestService.update();
}
}
2.2 实现二：使用Example和Criteria封装查询条件
/**
*Query query = new Query();
* query.addCriteria(Criteria.where("name").is(name));
* @param key
* @return
*/
//把多个条件组合在一起
public static Criteria where(String key) {
return new Criteria(key);
}
//封装查询条件
/**例如：
*
*创建匹配器，即如何使用查询条件
* ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
* .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
* .withIgnoreCase(true) //改变默认大小写忽略方式：忽略大小写
* .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains()) //标题采用“包含匹配”的方式查询
* .withIgnorePaths("pageNum", "pageSize"); //忽略属性，不参与查询
*创建实例
*Example<Student> example = Example.of(student, matcher);
*Query query = new Query(Criteria.byExample(example));
**/
public static Criteria byExample(Object example) {
return byExample(Example.of(example));
}
//封装查询条件
public static Criteria byExample(Example<?> example) {
return (new Criteria()).alike(example);
}
//匹配文档
public static Criteria matchingDocumentStructure(MongoJsonSchema schema) {
return (new Criteria()).andDocumentStructureMatches(schema);
}
//并且
public Criteria and(String key) {
return new Criteria(this.criteriaChain, key);
}
//是
public Criteria is(@Nullable Object o) {
if (!this.isValue.equals(NOT_SET)) {
throw new InvalidMongoDbApiUsageException("Multiple 'is' values declared. You need to use 'and' with multiple criteria");
} else if (this.lastOperatorWasNot()) {
throw new InvalidMongoDbApiUsageException("Invalid query: 'not' can't be used with 'is' - use 'ne' instead.");
} else {
this.isValue = o;
return this;
}
}
//用于匹配正则表达式
private boolean lastOperatorWasNot() {
return !this.criteria.isEmpty() && "$not".equals(this.criteria.keySet().toArray()[this.criteria.size() - 1]);
}
//不等于
public Criteria ne(@Nullable Object o) {
this.criteria.put("$ne", o);
return this;
}
//小于
public Criteria lt(Object o) {
this.criteria.put("$lt", o);
return this;
}
//小于等于
public Criteria lte(Object o) {
this.criteria.put("$lte", o);
return this;
}
//大于
public Criteria gt(Object o) {
this.criteria.put("$gt", o);
return this;
}
//大于等于
public Criteria gte(Object o) {
this.criteria.put("$gte", o);
return this;
}
//包含
public Criteria in(Object... o) {
if (o.length > 1 && o[1] instanceof Collection) {
throw new InvalidMongoDbApiUsageException("You can only pass in one argument of type " + o[1].getClass().getName());
} else {
this.criteria.put("$in", Arrays.asList(o));
return this;
}
}
//包含
public Criteria in(Collection<?> c) {
this.criteria.put("$in", c);
return this;
}
//与in相反
public Criteria nin(Object... o) {
return this.nin((Collection)Arrays.asList(o));
}
//与in相反
public Criteria nin(Collection<?> o) {
this.criteria.put("$nin", o);
return this;
}
//取模(求余)运算 ,即：key对应的值%value==remainder（求余是否等于remainder）
public Criteria mod(Number value, Number remainder) {
List<Object> l = new ArrayList();
l.add(value);
l.add(remainder);
this.criteria.put("$mod", l);
return this;
}
//key键对应的集合包含col(all是包含关系，in是被包含关系)
public Criteria all(Object... o) {
return this.all((Collection)Arrays.asList(o));
}
public Criteria all(Collection<?> o) {
this.criteria.put("$all", o);
return this;
}
//匹配key所对应的集合的元素的指定数量(!!!不能进行像<5之类的范围匹配)
public Criteria size(int s) {
this.criteria.put("$size", s);
return this;
}
//查询字段是否存在(true:存在，false:不存在)
public Criteria exists(boolean b) {
this.criteria.put("$exists", b);
return this;
}
//基于 bson type来匹配一个元素的类型，像是按照类型ID来匹配
public Criteria type(int t) {
this.criteria.put("$type", t);
return this;
}
public Criteria type(Type... types) {
Assert.notNull(types, "Types must not be null!");
Assert.noNullElements(types, "Types must not contain null.");
this.criteria.put("$type", Arrays.asList(types).stream().map(Type::value).collect(Collectors.toList()));
return this;
}
//取反
public Criteria not() {
return this.not((Object)null);
}
private Criteria not(@Nullable Object value) {
this.criteria.put("$not", value);
return this;
}
//模糊查询用
public Criteria regex(String re) {
return this.regex(re, (String)null);
}
public Criteria regex(String re, @Nullable String options) {
return this.regex(this.toPattern(re, options));
}
public Criteria regex(Pattern pattern) {
Assert.notNull(pattern, "Pattern must not be null!");
if (this.lastOperatorWasNot()) {
return this.not(pattern);
} else {
this.isValue = pattern;
return this;
}
}
public Criteria regex(BsonRegularExpression regex) {
if (this.lastOperatorWasNot()) {
return this.not(regex);
} else {
this.isValue = regex;
return this;
}
}
//
private Pattern toPattern(String regex, @Nullable String options) {
Assert.notNull(regex, "Regex string must not be null!");
return Pattern.compile(regex, options == null ? 0 : BSON.regexFlags(options));
}
public Criteria withinSphere(Circle circle) {
Assert.notNull(circle, "Circle must not be null!");
this.criteria.put("$geoWithin", new GeoCommand(new Sphere(circle)));
return this;
}
public Criteria within(Shape shape) {
Assert.notNull(shape, "Shape must not be null!");
this.criteria.put("$geoWithin", new GeoCommand(shape));
return this;
}
//输出接近某一地理位置的有序文档
public Criteria near(Point point) {
Assert.notNull(point, "Point must not be null!");
this.criteria.put("$near", point);
return this;
}
//指定地理空间查询从最近到最远返回文档的点。 MongoDB 使用球面几何计算$nearSphere的距离
public Criteria nearSphere(Point point) {
Assert.notNull(point, "Point must not be null!");
this.criteria.put("$nearSphere", point);
return this;
}
//
public Criteria intersects(GeoJson geoJson) {
Assert.notNull(geoJson, "GeoJson must not be null!");
this.criteria.put("$geoIntersects", geoJson);
return this;
}
//创建一个地理空间标准,与nearSphere一起使用
public Criteria maxDistance(double maxDistance) {
if (!this.createNearCriteriaForCommand("$near", "$maxDistance", maxDistance) && !this.createNearCriteriaForCommand("$nearSphere", "$maxDistance", maxDistance)) {
this.criteria.put("$maxDistance", maxDistance);
return this;
} else {
return this;
}
}
//mongodb地理空间计算逻辑
public Criteria minDistance(double minDistance) {
if (!this.createNearCriteriaForCommand("$near", "$minDistance", minDistance) && !this.createNearCriteriaForCommand("$nearSphere", "$minDistance", minDistance)) {
this.criteria.put("$minDistance", minDistance);
return this;
} else {
return this;
}
}
//匹配查询
public Criteria elemMatch(Criteria c) {
this.criteria.put("$elemMatch", c.getCriteriaObject());
return this;
}
//使用给定对象作为模式创建条件
public Criteria alike(Example<?> sample) {
this.criteria.put("$example", sample);
this.criteriaChain.add(this);
return this;
}
//创建一个criteria ($jsonSchema)，根据MongoJsonSchema定义的给定结构匹配文档
public Criteria andDocumentStructureMatches(MongoJsonSchema schema) {
Assert.notNull(schema, "Schema must not be null!");
Criteria schemaCriteria = new Criteria();
schemaCriteria.criteria.putAll(schema.toDocument());
return this.registerCriteriaChainElement(schemaCriteria);
}
public Criteria.BitwiseCriteriaOperators bits() {
return new Criteria.BitwiseCriteriaOperatorsImpl(this);
}
//或者
/**
* Aggregation agg = Aggregation.newAggregation(
* Aggregation.match(new Criteria()
* .andOperator(Criteria.where("onlineTime").gt(new Date()))
* .orOperator( Criteria.where("offlineTime").gt(new Date())
* ,Criteria.where("offlineTime").exists(false) ))
* @param criteria
* @return
*/
public Criteria orOperator(Criteria... criteria) {
BasicDBList bsonList = this.createCriteriaList(criteria);
return this.registerCriteriaChainElement((new Criteria("$or")).is(bsonList));
}
//非或者
public Criteria norOperator(Criteria... criteria) {
BasicDBList bsonList = this.createCriteriaList(criteria);
return this.registerCriteriaChainElement((new Criteria("$nor")).is(bsonList));
}
//并且
public Criteria andOperator(Criteria... criteria) {
BasicDBList bsonList = this.createCriteriaList(criteria);
return this.registerCriteriaChainElement((new Criteria("$and")).is(bsonList));
}
private Criteria registerCriteriaChainElement(Criteria criteria) {
if (this.lastOperatorWasNot()) {
throw new IllegalArgumentException("operator $not is not allowed around criteria chain element: " + criteria.getCriteriaObject());
} else {
this.criteriaChain.add(criteria);
return this;
}
}
@Nullable
public String getKey() {
return this.key;
}
public Document getCriteriaObject() {
if (this.criteriaChain.size() == 1) {
return ((Criteria)this.criteriaChain.get(0)).getSingleCriteriaObject();
} else if (CollectionUtils.isEmpty(this.criteriaChain) && !CollectionUtils.isEmpty(this.criteria)) {
return this.getSingleCriteriaObject();
} else {
Document criteriaObject = new Document();
Iterator var2 = this.criteriaChain.iterator();
while(var2.hasNext()) {
Criteria c = (Criteria)var2.next();
Document document = c.getSingleCriteriaObject();
Iterator var5 = document.keySet().iterator();
while(var5.hasNext()) {
String k = (String)var5.next();
this.setValue(criteriaObject, k, document.get(k));
}
}
return criteriaObject;
}
}
protected Document getSingleCriteriaObject() {
Document document = new Document();
boolean not = false;
Iterator var3 = this.criteria.entrySet().iterator();
while(true) {
while(var3.hasNext()) {
Entry<String, Object> entry = (Entry)var3.next();
String key = (String)entry.getKey();
Object value = entry.getValue();
if (requiresGeoJsonFormat(value)) {
value = new Document("$geometry", value);
}
if (not) {
Document notDocument = new Document();
notDocument.put(key, value);
document.put("$not", notDocument);
not = false;
} else if ("$not".equals(key) && value == null) {
not = true;
} else {
document.put(key, value);
}
}
if (!StringUtils.hasText(this.key)) {
if (not) {
return new Document("$not", document);
}
return document;
}
Document queryCriteria = new Document();
if (!NOT_SET.equals(this.isValue)) {
queryCriteria.put(this.key, this.isValue);
queryCriteria.putAll(document);
} else {
queryCriteria.put(this.key, document);
}
return queryCriteria;
}
}
private BasicDBList createCriteriaList(Criteria[] criteria) {
BasicDBList bsonList = new BasicDBList();
Criteria[] var3 = criteria;
int var4 = criteria.length;
for(int var5 = 0; var5 < var4; ++var5) {
Criteria c = var3[var5];
bsonList.add(c.getCriteriaObject());
}
return bsonList;
}
private void setValue(Document document, String key, Object value) {
Object existing = document.get(key);
if (existing == null) {
document.put(key, value);
} else {
throw new InvalidMongoDbApiUsageException("Due to limitations of the com.mongodb.BasicDocument, you can't add a second '" + key + "' expression specified as '" + key + " : " + value + "'. Criteria already contains '" + key + " : " + existing + "'.");
}
}
private boolean createNearCriteriaForCommand(String command, String operation, double maxDistance) {
if (!this.criteria.containsKey(command)) {
return false;
} else {
Object existingNearOperationValue = this.criteria.get(command);
if (existingNearOperationValue instanceof Document) {
((Document)existingNearOperationValue).put(operation, maxDistance);
return true;
} else if (existingNearOperationValue instanceof GeoJson) {
Document dbo = (new Document("$geometry", existingNearOperationValue)).append(operation, maxDistance);
this.criteria.put(command, dbo);
return true;
} else {
return false;
}
}
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else if (obj != null && this.getClass().equals(obj.getClass())) {
Criteria that = (Criteria)obj;
if (this.criteriaChain.size() != that.criteriaChain.size()) {
return false;
} else {
for(int i = 0; i < this.criteriaChain.size(); ++i) {
Criteria left = (Criteria)this.criteriaChain.get(i);
Criteria right = (Criteria)that.criteriaChain.get(i);
if (!this.simpleCriteriaEquals(left, right)) {
return false;
}
}
return true;
}
} else {
return false;
}
}
private boolean simpleCriteriaEquals(Criteria left, Criteria right) {
boolean keyEqual = left.key == null ? right.key == null : left.key.equals(right.key);
boolean criteriaEqual = left.criteria.equals(right.criteria);
boolean valueEqual = this.isEqual(left.isValue, right.isValue);
return keyEqual && criteriaEqual && valueEqual;
}
//判断是否相等
private boolean isEqual(Object left, Object right) {
if (left == null) {
return right == null;
} else if (Pattern.class.isInstance(left)) {
if (!Pattern.class.isInstance(right)) {
return false;
} else {
Pattern leftPattern = (Pattern)left;
Pattern rightPattern = (Pattern)right;
return leftPattern.pattern().equals(rightPattern.pattern()) && leftPattern.flags() == rightPattern.flags();
}
} else {
return ObjectUtils.nullSafeEquals(left, right);
}
}
public int hashCode() {
int result = 17;
int result = result + ObjectUtils.nullSafeHashCode(this.key);
result += this.criteria.hashCode();
result += ObjectUtils.nullSafeHashCode(this.isValue);
return result;
}
private static boolean requiresGeoJsonFormat(Object value) {
return value instanceof GeoJson || value instanceof GeoCommand && ((GeoCommand)value).getShape() instanceof GeoJson;
}
private static class BitwiseCriteriaOperatorsImpl implements Criteria.BitwiseCriteriaOperators {
private final Criteria target;
BitwiseCriteriaOperatorsImpl(Criteria target) {
this.target = target;
}
public Criteria allClear(int numericBitmask) {
return this.numericBitmask("$bitsAllClear", numericBitmask);
}
public Criteria allClear(String bitmask) {
return this.stringBitmask("$bitsAllClear", bitmask);
}
public Criteria allClear(List<Integer> positions) {
return this.positions("$bitsAllClear", positions);
}
public Criteria allSet(int numericBitmask) {
return this.numericBitmask("$bitsAllSet", numericBitmask);
}
public Criteria allSet(String bitmask) {
return this.stringBitmask("$bitsAllSet", bitmask);
}
public Criteria allSet(List<Integer> positions) {
return this.positions("$bitsAllSet", positions);
}
public Criteria anyClear(int numericBitmask) {
return this.numericBitmask("$bitsAnyClear", numericBitmask);
}
public Criteria anyClear(String bitmask) {
return this.stringBitmask("$bitsAnyClear", bitmask);
}
public Criteria anyClear(List<Integer> positions) {
return this.positions("$bitsAnyClear", positions);
}
public Criteria anySet(int numericBitmask) {
return this.numericBitmask("$bitsAnySet", numericBitmask);
}
public Criteria anySet(String bitmask) {
return this.stringBitmask("$bitsAnySet", bitmask);
}
public Criteria anySet(List<Integer> positions) {
return this.positions("$bitsAnySet", positions);
}
private Criteria positions(String operator, List<Integer> positions) {
Assert.notNull(positions, "Positions must not be null!");
Assert.noNullElements(positions.toArray(), "Positions must not contain null values.");
this.target.criteria.put(operator, positions);
return this.target;
}
private Criteria stringBitmask(String operator, String bitmask) {
Assert.hasText(bitmask, "Bitmask must not be null!");
this.target.criteria.put(operator, new Binary(Base64Utils.decodeFromString(bitmask)));
return this.target;
}
private Criteria numericBitmask(String operator, int bitmask) {
this.target.criteria.put(operator, bitmask);
return this.target;
}
}
public interface BitwiseCriteriaOperators {
Criteria allClear(int var1);
Criteria allClear(String var1);
Criteria allClear(List<Integer> var1);
Criteria allSet(int var1);
Criteria allSet(String var1);
Criteria allSet(List<Integer> var1);
Criteria anyClear(int var1);
Criteria anyClear(String var1);
Criteria anyClear(List<Integer> var1);
Criteria anySet(int var1);
Criteria anySet(String var1);
Criteria anySet(List<Integer> var1);
}
}
}