Spring Boot集成MongoDB

1.引入依赖

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

Spring-Data-Mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb。

MongoRepository操作简单，MongoTemplate操作灵活

2.配置application.yml

server:
  port: 8888
spring:
  application:
    name: dmeo-app
  data:
    mongodb:
      #host: localhost
      #port: 27017
      uri:  mongodb://root:123456@localhost:27017 # mongodb的连接地址与端口
      database: dmeo # mongodb的连接的数据库      

3.创建User文档对象

@Document:标识映射到Mongodb文档上的领域对象, 即表明这是一个文档对象，名称为user，对应Mongo DB里的user表

@Id:标示某个域为ID域, 即标注主键字段, String类型的主键值在插入的时候Mongo DB会自动生成

@Indexed:标示某个字段为Mongodb的索引字段

@Transient: 如果对象中的某个属性为非表字段 ,使用注解@Transient进行排除

@Data
@Document(collection = "user")
public class User {

    @Id
    private String uid;

	@Indexed
    private String name;

    private Integer age;

    private String address;
}

4.基于MongoRepository的使用

创建UserRepository接口，继承MongoRepository并指定泛型分别为实体类型和主键类型。

在MongoRepository中定义了很多现成的方法，可以更方便的使用。

5.多条件查询

UserRepository通过继承MongoRepository已经具有了JPA的特性，可以通过方法名来构建多查询条件的SQL。

Spring Data mongodb也提供了自定义方法的规则，按照findByXXX，findByXXXAndYYY、countByXXXAndYYY等规则定义方法，实现查询操作。

/**
 * @Author: CJ
 * @Description:
 **/
public interface UserRepository extends MongoRepository<User,String> {

    /**
     * 根据名字查询
     * @param name
     * @return
     */
    User findByName(String name);

    /**
     * 根据姓名和年龄查询
     * @param name
     * @param age
     * @return
     */
    User findByNameAndAge(String name,Integer age);

    /**
     * 根据姓名和年龄查询记录数
     * @param name
     * @param age
     * @return
     */
    int countByNameAndAge(String name,Integer age);

    /**
     * 根据名字和地址分页查询
     * @param name
     * @param address
     * @param pageable
     * @return
     */
    Page<User> findByNameAndAddress(String name, String address, Pageable pageable);
}

6.编写测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;


    @Test
    public void testFindAll() {
        //分页从0开始
        int page = 0;
        int size = 10;
        Pageable pageable = PageRequest.of(page, size);
        Page<User> all = userRepository.findAll(pageable);
        System.out.println(all);
    }

    @Test
    public void testSave() {
        User user = new User();
        user.setName("lisi");
        user.setAddress("China");
        user.setAge(12);
        userRepository.save(user);
        System.out.println(user);
    }


    @Test
    public void testDelete() {
        userRepository.deleteById("5fce3a0728df2033145874fc");
    }

    @Test
    public void testUpdate() {
        Optional<User> optional = userRepository.findById("5fce3a0728df2033145874fc");
        if (optional.isPresent()) {
            User user = optional.get();
            user.setAge(22);
            userRepository.save(user);
        }
    }

    @Test
    public void testFindByName() {
        User user = userRepository.findByName("lisi");
        System.out.println(user);
    }

    @Test
    public void testCountByNameAndAge() {
        int count = userRepository.countByNameAndAge("lisi", 12);
        System.out.println(count);
    }

	
	@Test
    public void testExample() {
        //设置条件值
        User user= new User ();
        user.setAge(22);
        user.setAddress("China");

        //条件匹配器
        ExampleMatcher exampleMatcher = ExampleMatcher.matching();
        //ExampleMatcher.GenericPropertyMatchers.contains() 包含关键字,即模糊查询
        exampleMatcher = exampleMatcher.withMatcher("address",
                ExampleMatcher.GenericPropertyMatchers.contains());
        
        //创建条件实例
        Example<User> example = Example.of(user, exampleMatcher);
        //分页对象
        Pageable pageable = new PageRequest(0, 10);
        //分页查询
        Page<User> UserList = UserRepository.findAll(example, pageable);
        System.out.println(UserList);
    }
    
    @Autowired
	private MongoTemplate template;
	
		@Test
	    public void test() {
        Query query = new Query();
        Criteria criteria = new Criteria();
        criteria.and("name").is("小白");
        //模糊查询
        criteria.and("address").regex("四川");
        query.addCriteria(criteria);
        // 使用age字段降序排序
        Sort sort = Sort.by(Sort.Direction.DESC, "age");
        // size表示每页显示的条数，page表示当前页码数，0表示第一页
        Pageable pageable = PageRequest.of(1, 2, sort);

        List<User> users = template.find(query.with(pageable), User.class);
        Page<User> page = PageableExecutionUtils.getPage(users, pageable, () -> template.count(query, User.class));
        List<User> content = page.getContent();
        System.out.println(content);
    }
}

7.配置启动类

@SpringBootApplication
@EntityScan("cn.ybzy.model")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application .class, args);
    }
}

基于MongoTemplate的使用

注入MongoTemplate对象

@SpringBootTest
class ApplicationTests {

	@Autowired
	private MongoTemplate mongoTemplate;
}

常用方法

mongoTemplate.findAll(User.class): 查询User文档的全部数据

mongoTemplate.findById(<id>, User.class): 查询User文档id为id的数据

mongoTemplate.find(query, User.class);: 根据query内的查询条件查询

mongoTemplate.upsert(query, update, User.class): 修改

mongoTemplate.remove(query, User.class): 删除

mongoTemplate.insert(User): 新增

Query对象

创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）

精准条件：criteria.and(“key”).is(“条件”)

模糊条件：criteria.and(“key”).regex(“条件”)

封装条件：query.addCriteria(criteria)

大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）

小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）

Query.addCriteria(new Criteria().andOperator(gt,lt));

一个query中只能有一个andOperator()。其参数也可以是Criteria数组。

排序 ：query.with（new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))

使用示例

@SpringBootTest
class DemomogoApplicationTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 添加
     */
    @Test
    public void createUser() {
        User user = new User();
        user.setAge(20);
        user.setName("test");
        User user1 = mongoTemplate.insert(user);
        System.out.println(user1);
    }

    /**
     * 查询所有
     */
    @Test
    public void findUser() {
        List<User> userList = mongoTemplate.findAll(User.class);
        System.out.println(userList);
    }

    /**
     * 根据id查询
     */
    @Test
    public void getById() {
        User user =
                mongoTemplate.findById("5fce3a0728df2033145874fc", User.class);
        System.out.println(user);
    }

    /**
     * 条件查询
     */
    @Test
    public void findUserList() {
        Query query = new Query(Criteria
                .where("name").is("test")
                .and("age").is(20));
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

    /**
     * 模糊查询
     */
    @Test
    public void findUsersLikeName() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Query query = new Query(Criteria.where("name").regex(pattern));
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

    /**
     * 分页查询
     */
    @Test
    public void findUsersPage() {
        String name = "est";
        int pageNo = 1;
        int pageSize = 10;

        Query query = new Query();
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        query.addCriteria(Criteria.where("name").regex(pattern));
        int totalCount = (int) mongoTemplate.count(query, User.class);
        List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);

        Map<String, Object> pageMap = new HashMap<>();
        pageMap.put("list", userList);
        pageMap.put("totalCount", totalCount);
        System.out.println(pageMap);
    }

    /**
     * 修改
     */
    @Test
    public void updateUser() {
        User user = mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
        user.setName("test_1");
        user.setAge(25);
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        long count = result.getModifiedCount();
        System.out.println(count);
    }

    /**
     * 删除操作
     */
    @Test
    public void delete() {
        Query query =
                new Query(Criteria.where("_id").is("5fce3a0728df2033145874fc"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }
}