SpringBoot中操作MongoDB数据库(使用MongoTemplate和Jpa方式)_jpa和mongotemplate

1.声明

当前的内容用于本人学习和操作当前的SpringBoot对MongoDB数据库的操作，该操作分为使用MongoTemplate和Jpa两种方式

当前内容借鉴：Spring Data MongoDB

2.pom依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.5.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>springboot-jpa-mongodb</groupId>
	<artifactId>springboot-jpa-mongodb</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot-jpa-mongodb</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
	</dependencies>
</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

主要使用spring-boot-starter-data-mongodb

3.使用MongoTemplate方式操作数据库

配置文件mongodb.properties中的内容：

mongodb.url=mongodb://localhost
mongodb.database=database

1.首先创建配置类MongoDBConfig

/**
 * @description 当前MongoDB的配置类
 * @author hy
 * @date 2020-04-05
 */
@PropertySource(value = { "mongodb.properties" })
@Configuration
public class MongoDBConfig {

	@Value("${mongodb.url}")
	private String mongoUrl;

	@Value("${mongodb.database}")
	private String mongoDateBase;

	public @Bean MongoTemplate mongoTemplate() {
		return new MongoTemplate(new SimpleMongoClientDbFactory(MongoClients.create(mongoUrl), mongoDateBase));
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.创建实体类Person

public class Person {

	private String id;
	private String name;
	private int age;
}
1
2
3
4
5
6

3.创建controller来实现各种操作

@RestController
public class PersonController {
	@Autowired
	MongoTemplate mongoTemplate;

	// 分页查询
	@RequestMapping("/findPersonPage")
	public Object findPersonPage(Integer currentPageNo, Integer pageSize) {
		Query limit = new Query().skip((currentPageNo - 1) * pageSize).limit(pageSize);
		List<Person> findPerson = mongoTemplate.find(limit, Person.class);
		return findPerson;
	}

	// 查询所有的数据
	@RequestMapping("/findAll")
	public Object findAll() {
		List<Person> findPerson = mongoTemplate.findAll(Person.class);
		return findPerson;
	}

	// 修改数据
	@RequestMapping("updatePersonByName")
	public ResponseEntity<?> updatePersonByName(String name, Integer age) {
		UpdateResult updateResult = mongoTemplate.updateFirst(Query.query(Criteria.where("name").is(name)),
				Update.update("age", age), Person.class);
		long modifiedCount = updateResult.getModifiedCount();
		/* mongoTemplate.updateMulti(query, update, entityClass) */
		return ResponseEntity.ok("修改成功,修改数量：" + modifiedCount);
	}

	// 增加数据
	@RequestMapping("/insertPerson")
	public ResponseEntity<?> insertPerson(Person person) {
		Person insert = mongoTemplate.insert(person);
		return ResponseEntity.ok("添加成功,添加后的用户id为：" + insert.getId());
	}

	// 删除数据
	@RequestMapping("/deletePersonById/{id}")
	public ResponseEntity<?> deletePersonById(@PathVariable("id") String id) {
		Person findAndRemove = mongoTemplate.findAndRemove(Query.query(Criteria.where("id").is(id)), Person.class);
		return ResponseEntity.ok("删除成功,删除的数据为：" + findAndRemove);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

4.创建入口类

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MongoDBApplication {
	public static void main(String[] args) {
		SpringApplication.run(MongoDBApplication.class, args);
	}
}
1
2
3
4
5
6

6.测试成功，这里就不显示结果了

4.使用Jpa方式(Spring data方式操作)

1.还是配置MongoDBConfig和前面3中保持一致

2.创建实体类

@Document
public class PersonJpa {

	@Id
	private String id;
	private String name;
	private Integer age;
}
1
2
3
4
5
6
7
8

这里需要使用@Document方式，这里默认创建的collection就是PersonJpa,可以指定，需要指定@Id

3.创建dao层

@Repository
public interface PersonJpaDao extends MongoRepository<PersonJpa, String> {
	PersonJpa findByName(String name);//自定义查询方法查询单个数据
}
1
2
3
4

4.创建controller层

@RestController
public class PersonJpaController {
	@Autowired
	PersonJpaDao personJpaDao;

	// 分页查询
	@RequestMapping("/findPersonPage")
	public Object findPersonPage(Integer currentPageNo, Integer pageSize) {
		/*
		 * Query limit = new Query().skip((currentPageNo - 1) *
		 * pageSize).limit(pageSize);
		 */
		/* ExampleMatcher matcher=new */
		Page<PersonJpa> findPerson = personJpaDao.findAll(PageRequest.of(currentPageNo, pageSize));
		// List<Person> findPerson = mongoTemplate.find(limit, Person.class);
		return findPerson;
	}

	// 查询所有的数据
	@RequestMapping("/findAll")
	public Object findAll() {
		List<PersonJpa> findPerson = personJpaDao.findAll();
		return findPerson;
	}

	// 修改数据
	@RequestMapping("updatePersonByName")
	public ResponseEntity<?> updatePersonByName(PersonJpa personJpa) {
		/*
		 * UpdateResult updateResult =
		 * mongoTemplate.updateFirst(Query.query(Criteria.where("name").is(name)),
		 * Update.update("age", age), Person.class);
		 */
		Example<PersonJpa> of = Example.of(personJpa,UntypedExampleMatcher.matchingAny());
		Optional<PersonJpa> findOne = personJpaDao.findOne(of);
		PersonJpa findByName = personJpaDao.findByName(personJpa.getName());// 使用这个方式也可以实现
		PersonJpa update = findOne.get();
		if (update != null) {
			update.setAge(personJpa.getAge());
			personJpaDao.save(update);
			return ResponseEntity.ok("修改成功,修改数量：1");
		}
		return ResponseEntity.ok("修改失败,当前的 【" + personJpa.getName() + "】 不存在！");

	}

	// 增加数据
	@RequestMapping("/insertPerson")
	public ResponseEntity<?> insertPerson(PersonJpa personJpa) {
		PersonJpa save = personJpaDao.save(personJpa);
		return ResponseEntity.ok("添加成功,添加后的用户id为：" + save.getId());
	}

	// 删除数据
	@RequestMapping("/deletePersonById/{id}")
	public ResponseEntity<?> deletePersonById(@PathVariable("id") String id) {
		Optional<PersonJpa> findById = personJpaDao.findById(id);
		PersonJpa personJpa = findById.get();
		if (personJpa != null) {
			personJpaDao.delete(personJpa);
			/* personJpaDao.deleteAll(entities); */
			return ResponseEntity.ok("删除成功,删除的数据为：" + personJpa);
		}

		return ResponseEntity.ok("删除成功,当前需要删除的id不存在：" + id);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

5.创建入口类

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableMongoRepositories(basePackageClasses = { PersonJpaDao.class }) // springdata的使用
public class MongoDBApplication {
	public static void main(String[] args) {
		SpringApplication.run(MongoDBApplication.class, args);
	}
}
1
2
3
4
5
6
7

6.测试，结果这里不显示(是成功的)

5.总结

1.使用MongoTemplate,其中的Query和Criteria以及Update这个对数据库操作粒度更加细致

2.使用当前的Jpa方式操作，需要让dao层继承MongoRepository或者其他的Reposity实现接口,还需要让实体类定义为@Document并且必须指定@Id,最后还要开启@EnableMongoRepositories，才能操作成功

以上纯属个人见解，如有问题请联系本人！