MongoDB
1、NoSQL
NoSQL(NoSQL = Not Only SQL)，指的是非关系型的数据库
为什么使用NoSQL :
1、对数据库高并发读写。请求量大
2、对海量数据的高效率存储和访问。 数据量大
3、对数据库的高可扩展性和高可用性。
noSQL缺点：
1、数据库事务一致性需求,形同虚设
2、对复杂的SQL查询，特别是多表关联查询的需求
2、MongoDB
MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。集群、分片、加节点的方式实现扩容
MongoDB 将数据存储为一个文档，存储格式是BSON，数据结构由键值对(key=>value)组成。
BSON是一种类json的一种二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型。
--------------------------------
MongoDB特点
1、MongoDB 是一个面向文档存储的数据库。
2、你可以在MongoDB记录中设置任何属性的索引来实现更快的排序 。
3、如果负载的增加（需要更多的存储空间和更强的处理能力），它可以分布在计算机网络中的其他节点上这就是所谓的分片。
4、Mongo支持丰富的查询表达式。
5、MongoDB支持各种编程语言:RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
一个mongodb中可以建立多个数据库，文档是一组键值(key-value)对(即BSON)。
MongoDB 的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型。
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。
-------------------------------
MongoDB适用场景
1、网站数据：Mongo非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
2、缓存：由于性能很高，Mongo也适合作为信息基础设施的缓存层。在系统重启之后，由Mongo搭建的持久化缓存层可以避免下层的数据源过载。
3、大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
3、使用Docker安装MongoDB
1.拉取镜像
docker pull mongo:4.4.8
2.data目录赋予777权限-目录挂载
chmod 777 /data/
3.创建和启动容器
docker run -id --restart=always -p 27017:27017 --name mymongo -v /data/db:/data/db mongo:4.4.8
4.进入容器
docker exec -it mymongo /bin/bash
5.使用MongoDB客户端操作
mongo
4、MongoDB常见数据类型
5、MongoDB基本命令
下表列出了 RDBMS 与 MongoDB 对应的术语
常用操作如下：
1.show dbs
还有一个默认的test库
2.use yygh，创建或切换数据库
3.show tables
查询当前数据库所有的集合
4.创建集合、插入文档
5.无条件查询所有
多了一个_id,是mongodb自动生成的
类型：ObjectId类型（bson中特有的一种类型）
12位，每位2个数字（16进制数据），一共24个字符
1. 时间戳：时间不断变化的
2. 机器：主机的唯一标识码。通常是机器主机名的散列值，这样可以确保不同主机生成不同的Objectld ，不产生冲突。
3. PID:为了确保在同一台机器上并发的多个进程产生的Objectld是唯一的，所以加上进程标识符(PID).
4. 计数器：后3个字节就是一个自动增加的计数器，确保相同进程同一秒产生的Objectld也是不一样。
6.无条件删除
7.根据指定条件删除
8.根据条件查询
9.多条件查询
6、常用操作第一组命令
field：指定返回的域（字段）
不要id
sort排序
在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。
升序1
降序-1
分页
在 MongoDB 中使用 skip()方法来跳过指定数量的数据，limit()方法来读取指定数量的数据
IN
COUNT
OR
AND
7、常用操作第二组命令
UPDATE
满足条件的都要修改
只改第一个
Remove
remove()用于删除单个或全部文档，删除后的文档无法恢复
根据条件删除
根据id删除
索引
索引通常能够极大的提高查询的效率，索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。
语法中 age值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。
创建索引
聚合
MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。
统计各个年龄的人数
MongoTemplate
spring-data-mongodb提供了两种方式访问mongodb：
（1）MongoTemplate
（2）MongoRepository
MongoRepository操作简单，MongoTemplate操作灵活;
1、添加依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
</dependencies>2、配置文件配置
spring.data.mongodb.uri=mongodb://192.168.188.129:27017/test3、准备一个实体类User
//@Document映射到哪一个集合
@Data
@Document("User")
public class User {
@Id
private String id;
private String name;
private Integer age;
private String email;
private String createDate;
}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对象
1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
2、 精准条件：criteria.and(“key”).is(“条件”)
模糊条件：criteria.and(“key”).regex(“条件”)
3、封装条件：query.addCriteria(criteria)
4、大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）
小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）
5、Query.addCriteria(new Criteria().andOperator(gt,lt));
6、一个query中只能有一个andOperator()。其参数也可以是Criteria数组。
7、排序 ：query.with（new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))
测试类前提：
import org.junit.jupiter.api.Test;
@SpringBootTest
public class MDTest {
@Autowired
private MongoTemplate mongoTemplate;
}1、insert 添加
//添加
@Test
public void test1() {
User user = new User();
user.setAge(19);
user.setName("阿肥");
user.setEmail("422eeeee@qq.com");
user.setCreateDate("2022-08-09");
//主键id会自动回填
mongoTemplate.insert(user);
System.out.println(user);
}2、updateMulti 修改
//修改
@Test
public void test8(){
Query query = new Query(Criteria.where("name").is("阿广"));
Update update = new Update();
update.set("name","test3");
update.set("age",18);
//修改符合条件的多列
UpdateResult updateResult = mongoTemplate.updateMulti(query, update, User.class);
}3、save修改
//修改
@Test
public void test9(){
User user = mongoTemplate.findById("62f0b33218603727b569c41a", User.class);
user.setName("test4");
//user有id save（）执行修改指定文档 无id 执行新增操作
mongoTemplate.save(user);
}4、remove带条件删除
//带条件删除
@Test
public void test10(){
Query query = new Query(Criteria.where("_id").is("62f0b33218603727b569c41a"));
mongoTemplate.remove(query, User.class);
}5、查询所有
//查询所有
@Test
public void test2() {
List<User> userList = mongoTemplate.findAll(User.class);
userList.forEach(u -> {
System.out.println(u);
});
}6、根据id查询
//根据id查询
@Test
public void test3() {
User user = mongoTemplate.findById("62f0b33218603727b569c41a", User.class);
System.out.println(user);
}7、根据条件查询
//根据条件查询
@Test
public void test4() {
Query query = new Query();
//is方法的参数类型object,但是实际传入的值一定和字段本身的类型要一致
query.addCriteria(Criteria.where("name").is("南哥"));
// Query query = new Query(
// Criteria.where("name").is("test").and("age").is(20) //注意：age是整型，不要加“”
// );
List<User> userList = mongoTemplate.find(query, User.class);
userList.forEach(u -> {
System.out.println(u);
});
}8、模糊查询
//模糊查询
@Test
public void test5() {
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);
userList.forEach(u -> {
System.out.println(u);
});
}9、分页查询
//分页查询
@Test
public void test6(){
Query query = new Query().skip(0).limit(3);
List<User> userList = mongoTemplate.find(query, User.class);
userList.forEach(u -> {
System.out.println(u);
});
}10、带条件的分页查询
//分页条件查询
@Test
public void test7(){
Query query = new Query(Criteria.where("age").is(28))
.skip(0).limit(3);
List<User> userList = mongoTemplate.find(query, User.class);
userList.forEach(u -> {
System.out.println(u);
});
}11、mongoTemplate做聚合查询
要做到页面效果：
代码先上，真是吓死个人啊
@Override
public Map<String, Object> getRuleSchedule(long page, long limit, String hoscode, String depcode) {
//1.定义查询条件
Criteria criteria = Criteria.where("hoscode").is(hoscode).and("depcode").is(depcode);
//2.定义聚合
Aggregation aggre = Aggregation.newAggregation(
Aggregation.match(criteria),
Aggregation.group("workDate")
.first("workDate").as("workDate")
.sum("reservedNumber").as("reservedNumber")
.sum("availableNumber").as("availableNumber")
.count().as("docCount"),
Aggregation.sort(Sort.Direction.ASC, "workDate"),
Aggregation.skip((page - 1) * limit),
Aggregation.limit(limit)
);
//执行查询
AggregationResults<BookingScheduleRuleVo> aggregate1 = mongoTemplate.aggregate(aggre, Schedule.class, BookingScheduleRuleVo.class);
List<BookingScheduleRuleVo> bookingScheduleRuleVoList = aggregate1.getMappedResults();
//3.获取总记录数
Aggregation aggregation = Aggregation.newAggregation(
Aggregation.match(criteria),
Aggregation.group("workDate")
);
AggregationResults<BookingScheduleRuleVo> aggregate = mongoTemplate.aggregate(aggregation, Schedule.class, BookingScheduleRuleVo.class);
int total = aggregate.getMappedResults().size();
//4. 获取日期对应的星期
for (BookingScheduleRuleVo bookingScheduleRuleVo : bookingScheduleRuleVoList) {
Date workDate = bookingScheduleRuleVo.getWorkDate();
String dayOfWeek = this.getDayOfWeek(new DateTime(workDate));
bookingScheduleRuleVo.setDayOfWeek(dayOfWeek);
}
//5.获取医院名称
String hosname = hospitalService.getByHoscode(hoscode).getHosname();
Map<String, String> baseMap = new HashMap<>();
baseMap.put("hosname", hosname);
//6. 封装返回值
Map<String, Object> result = new HashMap<>();
result.put("bookingScheduleRuleList", bookingScheduleRuleVoList);
result.put("total", total);
result.put("baseMap", baseMap);
return result;
}
/**
* 根据日期获取星期数据
*
* @param dateTime
* @return
*/
private String getDayOfWeek(DateTime dateTime) {
int dayOfWeek = dateTime.getDayOfWeek();
List<String> strings = Arrays.asList("周一", "周二", "周三", "周四", "周五", "周六", "周日");
return strings.get(dayOfWeek - 1);
}最主要的点：
断点：执行查询的效果
MongoRepository
SpringData提供了MongoRepository接口，非常方便的实现了增删改查。我们只需要继承MongoRepository接口，按照Spring Data规范就可以了。
添加一个接口：
@Repository
public interface UserRepository extends MongoRepository<User,String> {
}测试前提：
@SpringBootTest
public class RepositoryMDTest {
@Autowired
private UserRepository userRepository;
}1、添加
//添加
@Test
public void test1() {
User user = new User();
user.setAge(28);
user.setName("阿广");
user.setEmail("3322228@qq.com");
user.setCreateDate("22-08-07");
//save方法既可以添加也可以修改，取决于user中有没有id
User user1 = userRepository.save(user);
}2、修改
//修改
@Test
public void test2() {
User user = userRepository.findById("62f075ef7843a4005c1c4abe").get();
user.setName("通仔");
user.setAge(26);
User save = userRepository.save(user);
System.out.println(save);
}3、查询所有
//查询所有
@Test
public void test3() {
List<User> userList = userRepository.findAll();
System.out.println(userList);
}4、根据id查询
//根据id查询
@Test
public void test4() {
User user = userRepository.findById("62f075ef7843a4005c1c4abe").get();
System.out.println(user);
}5、根据id删除
//根据id删除
@Test
public void test5() {
userRepository.deleteById("62f075ef7843a4005c1c4abe");
}6、查询所有并排序
//查询所有并排序
@Test
public void test6(){
Sort sort = Sort.by(Sort.Direction.DESC, "age");
List<User> userList = userRepository.findAll(sort);
userList.forEach(user -> {
System.out.println(user);
});
}7、条件查询
//条件查询
@Test
public void test7(){
User user = new User();
user.setName("阿广");
Example<User> userExample = Example.of(user);
List<User> userList = userRepository.findAll(userExample);
userList.forEach(u -> {
System.out.println(u);
});
}8、分页查询
//分页查询
@Test
public void test8(){
//page=0表示第一页
PageRequest pageable = PageRequest.of(0, 2);
Page<User> all = userRepository.findAll(pageable);
List<User> userList = all.getContent();
userList.forEach(u -> {
System.out.println(u);
});
long totalElements = all.getTotalElements();//总记录数
int totalPages = all.getTotalPages();//总页数
System.out.println("总记录数："+ totalElements);
System.out.println("总页数："+ totalPages);
}9、分页查询并排序
//分页排序写在一块
@Test
public void test9(){
Sort sort = Sort.by(Sort.Direction.DESC, "age");
//page=0表示第一页
PageRequest pageable = PageRequest.of(0, 2,sort);
Page<User> all = userRepository.findAll(pageable);
List<User> userList = all.getContent();
userList.forEach(u -> {
System.out.println(u);
});
long totalElements = all.getTotalElements();//总记录数
int totalPages = all.getTotalPages();//总页数
System.out.println("总记录数："+ totalElements);
System.out.println("总页数："+ totalPages);
}10、模糊查询
//模糊查询
@Test
public void test10(){
User user = new User();
user.setName("test");
//模糊查询固定格式
ExampleMatcher matcher =
ExampleMatcher
.matching()
.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)//模糊查询
.withIgnoreCase(true); //忽略大小写
Example<User> example = Example.of(user,matcher);
List<User> userList = userRepository.findAll(example);
userList.forEach(u -> {
System.out.println(u);
});
}11、分页排序加模糊查询
//分页排序加模糊查询
@Test
public void test11(){
Sort sort = Sort.by(Sort.Direction.DESC, "age");
//page=0表示第一页
PageRequest pageable = PageRequest.of(0, 4,sort);
//模糊查询
ExampleMatcher matcher = ExampleMatcher.matching()
.withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)
.withIgnoreCase(true);
User user = new User();
user.setName("est");
Example<User> example = Example.of(user, matcher);
Page<User> pages = userRepository.findAll(example, pageable);
List<User> userList = pages.getContent();
userList.forEach(u -> {
System.out.println(u);
});
}SpringData方法规范
接口中，你可以自定义方法，但是需要满足一定的规则
查询方法以 find 、read 、get 开头， 涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。
如：根据name模糊删除
根据name或age等值删除
