在java中使用MongoTemplate操作MongoDB

原文链接：https://blog.csdn.net/baidu_38990811/article/details/80095088

MongoDB简介
MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB  是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引

    2.在spring中集成

pom.xml

       
       
            org.springframework.data
            spring-data-mongodb
            1.8.0.RELEASE
       
applicationContext-mongodb.xml

       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xmlns="http://www.springframework.org/schema/beans"
       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.xsd">
 
   
   
       
   
 
   
 
   
   
       
   
 

    3.CRUD操作

实体:

@Document(collection = "Person")
public class Person {
 
    @Id
    private String id;//唯一标识id：时间戳+随机的6位字符串
 
    private String name;
}
service:

public interface IPersonService {
    /**
     * 根据参数查询
     *
     * @param person
     * @return
     */
    Person listAllByCondition(Person person);
    
     /**
     * 查询所有数据
     *
     * @return
     */
    List findAll();
 
    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @return
     */
    List findList(Person person, int skip, int limit);
 
    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @param order         asc-升序  desc-降序
     * @param sortBy        排序字段
     * @return
     */
    List findList(Person person, int skip, int limit, String order, String sortBy);
 
    /**
     * 保存用户
     *
     * @param person
     */
    void save(Person person);
 
 
    /**
     * 根据id查询
     *
     * @param id
     * @return
     */
    Person findOne(String id);
 
 
    /**
     * 根据参数查询
     *
     * @param person
     * @return
     */
    List listAllByCondition(Person person);
 
 
    /**
     * 根据条件模糊查询
     *
     * @param key     键值key
     * @param content 模糊匹配content
     * @return
     */
    List listAllByLikeCondition(String key, String content);
 
 
    /**
     * 删除
     *
     * @param ids
     */
    void delete(String... ids);
    
    /**
     * 修改
     * @param personSet
     * @param personWhere
     */
    void update(Person personSet, Person personWhere);
 
 
}
serviceImpl:

@Service
@Transactional
public class PersonServiceImpl implements IPersonService {
 
    //MongoTemplate是数据库和代码之间的接口，对数据库的操作都在它里面
    @Resource(name = "mongoTemplate")
    private MongoTemplate mongoTemplate;
    
    @Override
    public Person listAllByCondition(Person person) {
        Person person = this.mongoTemplate.findOne(new Query(Criteria.where("name").is("小明")),BookData.class);
 
        return bookData;
    }
/**
     * 保存用户
     *
     * @param person
     */
    @Override
    public void save(Person person) {
        this.mongoTemplate.insert(person);
    }
    
    /**
     * 修改
     */
    @Override
    public void update(Person personSet, Person personWhere) {
        Query query = getQuery(personWhere);  
        Update update = getUpdate(personSet); 
        
        this.mongoTemplate.upsert(query, update, Person.class);
    }
 
 
    /**
     * 根据条件查询
     *
     * @param data
     * @return
     */
    @Override
    public List listAllByCondition(Person person) {
        Query query = getQuery(person);
        List listdata = this.mongoTemplate.find(query, Person.class);
        return listdata;
    }
 
    /**
     * 根据条件模糊查询
     *
     * @param key     键值key
     * @param content 模糊匹配content
     * @return
     */
    @Override
    public List listAllByLikeCondition(String key, String content) {
 
        //模糊匹配
        Pattern pattern = Pattern.compile("^.*" + content + ".*$", Pattern.CASE_INSENSITIVE);
        Query query = Query.query(Criteria.where(key).regex(pattern));
        List listdata = mongoTemplate.find(query, Person.class);
        return listdata;
    }
 
 
    /**
     * 查询所有
     *
     * @return
     */
    @Override
    public List findAll() {
        return this.mongoTemplate.find(new Query(), Person.class);
    }
 
 
    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @return
     */
    @Override
    public List findList(Person person, int skip, int limit) {
        Query query = getQuery(person);
        query.skip(skip);
        query.limit(limit);
        return mongoTemplate.find(query, Person.class);
    }
 
    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @param order         asc-升序  desc-降序
     * @param sortBy        排序字段
     * @return
     */
    public List findList(Person person, int skip, int limit, String order, String sortBy) {
        try {
            Query query = getQuery(person);
            query.skip(skip);
            query.limit(limit);
            query.with(new Sort(new Sort.Order((order.equals("asc") ? Sort.Direction.ASC : Sort.Direction.DESC), sortBy)));
           
            return mongoTemplate.find(query, Person.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    /**
     * 条件查询需要的参数
     *
------------------------------

     *
     * @param criteriaUser
     * @return
     */
    private Query getQuery(Person criteriaUser) {
        if (criteriaUser == null) {
            criteriaUser = new Person();
        }
        Query query = new Query();
        if (criteriaUser.getName() != null) {
            Criteria criteria = Criteria.where("name").is(criteriaUser.getName());
            query.addCriteria(criteria);
        }
        
        return query;
    }
    private Update getUpdate(Person info) {
        if (info == null) {
            info = new Person();
        }
        Update update = new Update();
        if (info.getName() != null) {
            update.set("name", info.getName());
        }
        
        
        return update;
    }
 
    /**
     * 根据id查询
     *
     * @param id
     * @return
     */
    @Override
    public Person findOne(String id) {
        Query query = new Query();
        Criteria criteria = Criteria.where("_id").is(id);
        query.addCriteria(criteria);
        return this.mongoTemplate.findOne(query, Person.class);
    }
 
 
    /**
     * 删除
     *
     * @param ids
     */
    @Override
    public void delete(String... ids) {
        if (ids == null || ids.length == 0) {
            return;
        }
        for (String id : ids) {
            Query query = new Query(Criteria.where("_id").is(id));
            this.mongoTemplate.remove(query, Person.class);
        }
    }
 
}
————————————————