Spring Boot + MongoDB 增删改查的简单使用

MongoDB简介

mongodb是一个介于nosql数据库和mysql数据库之间的一个数据存储系统，它没有严格的数据格式，但同时支持复杂查询，而且自带sharding模式和Replica Set模式，支持分片模式，复制模式，自动故障处理，自动故障转移，自动扩容，全内容索引，动态查询等功能。扩展性和功能都比较强大。

    mongodb在数据查询方面，支持类sql查询，可以一个key多value内容，可以组合多个value内容来查询，支持索引，支持联合索引，支持复杂查询 ，支持排序，基本上除了join和事务类型的操作外，mongodb支持所有mysql支持的查询，甚至某个客户端api支持直接使用sql语句查询mongodb。

MongoDB的优缺点

优点

1. 文档结构的存储方式，能够更便捷的获取数据
2. 内置GridFS，支持大容量的存储
3. 内置Sharding，分片简单
4. 海量数据下，性能优越
5. 支持自动故障恢复（复制集）

缺点

1. 不支持事务操作
2. 占用空间过大
3. MongoDB没有如MySQL那样成熟的维护工具
4. 无法进行关联表查询，不适用于关系多的数据
5. 复杂聚合操作通过mapreduce创建，速度慢
6. 模式自由，  自由灵活的文件存储格式带来的数据错误

MongoDB的增删改查

1、pom包配置

首先安装MongoDB，然后创建一个spring boot 的web项目，然后在pom.xml上增加MongoDB的导包。

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2、在application.properties中添加配置

spring.data.mongodb.uri=mongodb://localhost:27017/test

我的MongoDB安装在本地，端口默认都是27017，用的库是test。

3、创建数据实体

public class UserEntity implements Serializable {

    private static final long serialVersionUID = -7084823252504701248L;

    private Long userId;

    private String userName;

    private String passsWord;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPasssWord() {
        return passsWord;
    }

    public void setPasssWord(String passsWord) {
        this.passsWord = passsWord;
    }
}

如果没有设置id字段，mongodb会默认生成一个唯一的_id。

3、使用MongoTemple创建实体dao的增删改查操作

dao层的实现方法

@Repository
public class UserDaoImpl implements UserDao {


    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 创建对象
     * @param user
     */
    public void saveUser(UserEntity user) {
        mongoTemplate.save(user);
    }

    /**
     * 根据用户名查询对象
     * @param userName
     * @return
     */
    public UserEntity findUserByUserName(String userName){
        Query query = new Query(Criteria.where("userName").regex(userName));//模糊查询
        return mongoTemplate.findOne(query,UserEntity.class);
    }

    /**
     * 更新对象
     * @param user
     */
    public void updateUser(UserEntity user){
        Query query = new Query(Criteria.where("id").is(user.getUserId()));
        Update update = new Update().set("userName",user.getUserName()).set("passWord",user.getPasssWord());
        //更新查询返回结果集的第一条
        mongoTemplate.updateFirst(query,update,UserEntity.class);
    }

    /**
     * 删除对象
     * @param id
     */
    public void deleteUserById(Long id){
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query,UserEntity.class);
    }

    /**
     * 根据Id查询对象
     * @param Id
     * @return
     */
    public UserEntity findUserById(Long Id){
        Query query = new Query(Criteria.where("user").is(Id));
        return mongoTemplate.findOne(query,UserEntity.class);
    }


    /**
     * 根据用户名查询数量
     * @param userName
     * @return
     */
    public Long findCountByUserName(String userName){
        Query query = new Query(Criteria.where("userName").regex(userName));
        Long num = mongoTemplate.count(query,UserEntity.class);
        return num;
    }

/**
 * 分页查询
 * @param pageNo
 * @param pageSize
 * @return
 */
public List<UserEntity> findAll(int pageNo,int pageSize){
    Query query = new Query();
    query.skip((pageNo - 1) * pageSize);
    query.limit(pageSize);
    query.with(new Sort(new Sort.Order(Sort.Direction.ASC, "userId")));//按照userId排序
    List<UserEntity> users = mongoTemplate.find(query,UserEntity.class);
    return users;
}

service层实现方法

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    /**
     * 创建对象
     * @param user
     */

    public void saveUser(UserEntity user) {
        userDao.saveUser(user);
    }

    /**
     * 根据用户名查询对象
     * @param userName
     * @return
     */

    public UserEntity findUserByUserName(String userName){
        return userDao.findUserByUserName(userName);
    }

    /**
     * 根据Id查询对象
     * @param Id
     * @return
     */

    public UserEntity findUserById(Long Id){
        return userDao.findUserById(Id);
    }


    /**
     * 根据用户名查询数量
     * @param userName
     * @return
     */

    public Long findCountByUserName(String userName){
        return userDao.findCountByUserName(userName);
    }

    /**
     * 更新对象
     * @param user
     */

    public void updateUser(UserEntity user){
        userDao.updateUser(user);
    }

    /**
     * 删除对象
     * @param id
     */

    public void deleteUserById(Long id){
        userDao.deleteUserById(id);
    }


    public List<UserEntity> findAll(int pageNo, int pageSize){
        return userDao.findAll(pageNo,pageSize);
    }
}

接口层controller实现方法

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    /**
     *  新增
     * @return
     */
    @RequestMapping(value = "/add")
    public void addUser(@RequestParam(value = "id",required = false)Long id,@RequestParam(value = "name",required = false)String name,@RequestParam(value = "pwd",required = false)String pwd){
        UserEntity userEntity = new UserEntity();
        userEntity.setUserId(id);
        userEntity.setUserName(name);
        userEntity.setPasssWord(pwd);
        userService.saveUser(userEntity);
    }

    /**
     * 改
     * @return
     */
    @RequestMapping("/update")
    public void updateUser(@RequestParam("id")Long id,@RequestParam("name")String name,@RequestParam("pwd")String pwd){
        UserEntity userEntity = new UserEntity();
        userEntity.setUserName(name);
        userEntity.setPasssWord(pwd);
        userService.updateUser(userEntity);
    }

    /**
     * 查 名字
     * @return
     */
    @RequestMapping("/name/query/{userName}")
    public UserEntity finUserByName(@PathVariable("userName")String userName){
        return userService.findUserByUserName(userName);
    }


    /**
     * 查 名字 数量
     * @return
     */
    @RequestMapping("/name/query/count/{userName}")
    public Long finCountByName(@PathVariable("userName")String userName){
        return userService.findCountByUserName(userName);
    }

    /**
     * 查 id
     * @return
     */
    @RequestMapping("/id/query/{id}")
    public UserEntity finUserById(@PathVariable("id")Long id){
        return userService.findUserById(id);
    }

    /**
     * 删除
     * @return
     */
    @RequestMapping("/delete")
    public void findOneUser(@RequestParam("id")Long id){
        userService.deleteUserById(id);
    }

    /**
     * 分页
     * @return
     */
    @RequestMapping("/query/{pageInde}/{pageSize}")
    public List<UserEntity> findOneUser(@PathVariable("pageInde")int pageInde,@PathVariable("pageSize")int pageSize){
        return userService.findAll(pageInde,pageSize);
    }


}