学习MongoDB,在java中使用MongoTemplate操作MongoDB

1. MongoDB简介

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

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

    2.在spring中集成

pom.xml

        <!--  mongodb支持库 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
            <version>1.8.0.RELEASE</version>
        </dependency>

applicationContext-mongodb.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <!-- spring连接mongodb数据库的配置 -->
    <mongo:mongo-client id="mongo" credentials="${mongo.credentials}" replica-set="${mongo.replica-set}">
        <mongo:client-options write-concern="SAFE"/>
    </mongo:mongo-client>

    <mongo:db-factory id="mongoDbFactory" dbname="${mongo.database}" mongo-ref="mongo"/>

    <!-- 只要使用这个调用相应的方法操作 -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
    </bean>

</beans>

    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<Person> findAll();

    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @return
     */
    List<Person> findList(Person person, int skip, int limit);

    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @param order         asc-升序  desc-降序
     * @param sortBy        排序字段
     * @return
     */
    List<Person> 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<Person> listAllByCondition(Person person);


    /**
     * 根据条件模糊查询
     *
     * @param key     键值key
     * @param content 模糊匹配content
     * @return
     */
    List<Person> 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<BookData> listAllByCondition(Person person) {
        Query query = getQuery(person);
        List<Person> listdata = this.mongoTemplate.find(query, Person.class);
        return listdata;
    }

    /**
     * 根据条件模糊查询
     *
     * @param key     键值key
     * @param content 模糊匹配content
     * @return
     */
    @Override
    public List<Person> listAllByLikeCondition(String key, String content) {

        //模糊匹配
        Pattern pattern = Pattern.compile("^.*" + content + ".*$", Pattern.CASE_INSENSITIVE);
        Query query = Query.query(Criteria.where(key).regex(pattern));
        List<Person> listdata = mongoTemplate.find(query, Person.class);
        return listdata;
    }


    /**
     * 查询所有
     *
     * @return
     */
    @Override
    public List<Person> findAll() {
        return this.mongoTemplate.find(new Query(), Person.class);
    }


    /**
     * 用于分页查询
     *
     * @param skip(第一个坐标为0)
     * @param limit
     * @return
     */
    @Override
    public List<BookData> 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<BookData> 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;
    }

    /**
     * 条件查询需要的参数
     * <br>------------------------------<br>
     *
     * @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);
        }
    }

}

下一篇:MongoTemplate聚合操作