医院项目-预约挂号-第四部分MongoDB使用

1、NoSQL简介

NoSQL(NoSQL = Not Only SQL)，意即反SQL运动，指的是非关系型的数据库，是一项全新的数据库革命性运动，早期就有人提出，发展至2009年趋势越发高涨。NoSQL的拥护者们提倡运用非关系型的数据存储，相对于目前铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。

为什幺使用NoSQL :

1、对数据库高并发读写。
2、对海量数据的高效率存储和访问。
3、对数据库的高可扩展性和高可用性。

弱点：
1、数据库事务一致性需求
2、数据库的写实时性和读实时性需求
3、对复杂的SQL查询，特别是多表关联查询的需求

2、什么是MongoDB ?

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。
在高负载的情况下，添加更多的节点，可以保证服务器性能。
MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

3、MongoDB 特点：

1、MongoDB 是一个面向文档存储的数据库，操作起来比较简单和容易。
2、你可以在MongoDB记录中设置任何属性的索引 (如：FirstName=“Sameer”,Address=“8 Gandhi Road”)来实现更快的排序。
3、你可以通过本地或者网络创建数据镜像，这使得MongoDB有更强的扩展性。
4、如果负载的增加（需要更多的存储空间和更强的处理能力） ，它可以分布在计算机网络中的其他节点上这就是所谓的分片。
5、Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。
6、MongoDb 使用update()命令可以实现替换完成的文档（数据）或者一些指定的数据字段 。
7、Mongodb中的Map/reduce主要是用来对数据进行批量处理和聚合操作。
8、Map和Reduce。Map函数调用emit(key,value)遍历集合中所有的记录，将key与value传给Reduce函数进行处理。
9、Map函数和Reduce函数是使用Javascript编写的，并可以通过db.runCommand或mapreduce命令来执行MapReduce操作。
10、GridFS是MongoDB中的一个内置功能，可以用于存放大量小文件。
11、MongoDB允许在服务端执行脚本，可以用Javascript编写某个函数，直接在服务端执行，也可以把函数的定义存储在服务端，下次直接调用即可。
12、MongoDB支持各种编程语言:RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
13、MongoDB安装简单。

linux中安装docker自行百度：

安装好了后：
#拉取镜像
docker pull mongo:latest

#创建和启动容器
docker run -d --restart=always -p 27017:27017 --name mymongo -v /data/db:/data/db -d mongo

启动并加入开机启动

systemctl start docker
systemctl enable docker

查看docker进程：docker ps

#进入容器

docker exec -it mymongo /bin/bash

#使用MongoDB客户端进行操作

mongo

然后：

show dbs #查询所有的数据库
admin 0.000GB
config 0.000GB
local 0.000GB

4、Spring boot集成mongodb

1、集成简介
spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb，MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。

2.1 初始化工程
使用 Spring Initializr 快速初始化一个 Spring Boot 工程
Group：com.fan
Artifact：mongodb

2.2 引入依赖
修改pom.xml

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

springBoot对一些依赖有版本仲裁，可以不声明version

2.3 添加配置
在application.properties文件添加配置

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

执行以下操作：

use test
db.getName()
db.User.save({name:‘zhangsan’,age:21,sex:true})
db.User.find()
结果：
{“_id”: Objectld(“4f69e680c9106ee2ec95da66”), “name”: “zhangsan”, “age”: 21,
“sex”: true}

test为数据库名字；

4.1、基于MongoTemplate 开发CRUD

3.1 添加实体
添加com.fan.mongodb.entity.User类
实体类：

package com.fan.mongodb.entity;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@Document("User")  //数据库中的表名，类似于@tableName标签
public class User {
    @Id
    private String id;
    private String name;
    private Integer age;
    private String email;
    private String createDate;

}

3.2 实现

常用方法：
mongoTemplate.findAll(User.class): 查询User文档的全部数据
mongoTemplate.findById(, 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”)))

测试：在springboot测试类中测试：
3.3 添加测试类
在/test/java下面添加测试类：

在docker中的db中使用查询命令查询数据是否插入进去：

db.User.find()

成功：

测试其他方法操作数据库：

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

导入的包：

import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

总的测试类：

package com.fan.mongodb;

import com.fan.mongodb.entity.User;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

@SpringBootTest
class MongodbApplicationTests {

    @Test
    void contextLoads() {
    }
    @Autowired
    private MongoTemplate mongoTemplate;

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

    //查询所有
    @Test
    public void findUser() {
        List<User> userList = mongoTemplate.findAll(User.class);
        System.out.println(userList);
    }
    //条件查询
    @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("62e92274cead1a2c3a769048", User.class);
        user.setName("test_1");
        user.setAge(25);
        user.setEmail("493220990@qq.com");
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        update.set("email", user.getEmail());
        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("62e9230aaa3ffa78dfec912c"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }

}

4.2、基于MongoRepository开发CRUD

实现
Spring Data提供了对mongodb数据访问的支持，我们只需要继承MongoRepository类，按照Spring Data规范就可以了；

1、不是随便声明的，而需要符合一定的规范
2、 查询方法以find | read | get开头
3、 涉及条件查询时，条件的属性用条件关键字连接
4、 要注意的是：条件属性首字母需要大写
5、 支持属性的级联查询，但若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接

添加com.fan.mongodb.repository.UserRepository接口：

@Repository  //1.注意加上持久层注解
public interface UserRepository extends MongoRepository<User, String> {
 //2.注意此处的MongoRepository的第二个泛型是实体类id的包装类
}

总的测试类：

package com.fan.mongodb;

import com.fan.mongodb.entity.User;
import com.fan.mongodb.repository.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.*;

import java.util.List;


@SpringBootTest
class MongodbApplicationTest2 {


    @Autowired //导入刚才的接口
    private UserRepository userRepository;

    //添加
    @Test
    public void createUser() {
        User user = new User();
        user.setAge(20);
        user.setName("张三");
        user.setEmail("3332200@qq.com");
        User user1 = userRepository.save(user);
    }
    //查询所有
    @Test
    public void findUser() {
        List<User> userList = userRepository.findAll();
        System.out.println(userList);
    }
    //id查询
    @Test
    public void getById() {
        User user = userRepository.findById("62e92274cead1a2c3a769048").get();
        System.out.println(user);
    }
    //条件查询
    @Test
    public void findUserList() {
        User user = new User();
        user.setName("张三");
        user.setAge(20);
        Example<User> userExample = Example.of(user);
        List<User> userList = userRepository.findAll(userExample);
        System.out.println(userList);
    }
    //模糊查询
    @Test
    public void findUsersLikeName() {
        //创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setName("三");
        Example<User> userExample = Example.of(user, matcher);
        List<User> userList = userRepository.findAll(userExample);
        System.out.println(userList);
    }
    //条件分页查询
    @Test
    public void findUsersPage() {
        Sort sort = Sort.by(Sort.Direction.DESC, "age");
//0为第一页
        Pageable pageable = PageRequest.of(0, 10, sort);
//创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setName("三");
        Example<User> userExample = Example.of(user, matcher);
//创建实例
        Example<User> example = Example.of(user, matcher);
        Page<User> pages = userRepository.findAll(example, pageable);
        System.out.println(pages);
    }
    //修改
    @Test
    public void updateUser() {
        User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
        user.setName("张三_1");
        user.setAge(25);
        user.setEmail("883220990@qq.com");
        User save = userRepository.save(user);
        System.out.println(save);
    }

    //删除
    @Test
    public void delete() {
        userRepository.deleteById("5ffbfe8197f24a07007bd6ce");
    }
/*end*/
}

整合医院系统：

将需要的文件复制过去：

复制pom: 把redis注释打开：

修改yml:dev文件

生成这个数据库和表：

医院管理系统自己的实体数据库：

一、上传医院接口（使用MongonDB数据库）：

1.添加帮助类：

在service_util的pom中增加fastjson

1.jsonString 转 jsonObject
/*
 * 字符串 转为 json对象
 * 源码：public static final JSONObject parseObject(String text)
 */
String str = "{\"age\":\"18\",\"name\":\"jack\"}";
JSONObject jsonObject = JSONObject.parseObject(str);

2.jsonObject 转 jsonString
/*
 * 源码：public static final JSONObject parseObject(String text)
 */
String str = "{\"age\":\"18\",\"name\":\"jack\"}";
JSONObject jsonObject = JSONObject.parseObject(str);
String jsonStr = jsonObject.toJSONString();

3.jsonString 转 map
String str = "{\"age\":\"18\",\"name\":\"jack\"}";
JSONObject jsonObject = JSONObject.parseObject(str);
//json对象转Map
Map<String,Object> map = jsonObject;
System.out.println(map.get("name"));
System.out.println(map.get("age"));

4.map 转 jsonString

 Map<String,Object> map = new HashMap<>();
 map.put("age", 18);
 map.put("name", "jack");
 System.out.println(map);
 String jsonString = JSON.toJSONString(map);
 System.out.println("json字符串是："+jsonString);

请参考：
https://www.jianshu.com/p/1249aabdbe4c

1、集成mongodb

1.1添加依赖
service-hosp模块pom.xml添加依赖

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

1.2添加配置

在application.properties文件添加配置

spring.data.mongodb.uri=mongodb://192.168.44.165:27017/yygh_hosp
说明：改为自己安装mongodb的ip地址

2、添加医院基础类(repository接口，service接口，controller接口)：

2.1 添加model
说明：由于实体对象没有逻辑，我们已经统一导入
com.atguigu.yygh.model.hosp.Hospital

使用mongodb开始增删改查：

2.2 添加Repository

2.3 添加service接口及实现类
1，添加com.atguigu.yygh.hosp.service.HospitalService接口

service:

public interface HospitalService {
 
}

2，添加com.atguigu.yygh.hosp.service.impl.HospitalServiceImpl接口实现

package com.atguigu.yygh.hosp.service.impl;

@Service
public class HospitalServiceImpl implements HospitalService {

@Autowired
private HospitalRepository hospitalRepository;

}

2.4 添加controller:

添加com.fan.yygh.hosp.api.ApiController

package com.atguigu.yygh.hosp.api;

@Api(tags = "医院管理API接口")
@RestController
@RequestMapping("/api/hosp")
public class ApiController {

@Autowired
private HospitalService hospitalService;

}

controller:添加com.atguigu.yygh.hosp.api.ApiController,说明：平台对外开发的接口都写在该Controller类

3、上传医院：

医院编号是平台分配的，全局唯一，上传医院接口可以多次调用，如果存在相同编号的为更新操作

request.getParameterMap()说明：

此方法返回一个Map类型值（Map(key,value[])，即：key是String型，value是String型数组）。该返回值存储着着前端所提交请求中的所有请求参数和请求参数值的映射关系。
这个返回值有个特别之处——只能读;

3.1 接口数据分析

{
"hoscode": "1000_0",
"hosname": "北京协和医院",
"hostype": "1",
"provinceCode": "110000",
"cityCode": "110100",
"districtCode": "110102",
"address": "大望路",
"intro": "北京协和医院是集医疗、教学、科研于一体的大型三级甲等综合医院，是国家卫生计生委...目标而继续努力。",
"route": "东院区乘车路线：106、...更多乘车路线详见须知。",
"logoData": "iVBORw0KGgoAAAA...NSUhEUg==",
"bookingRule": {
"cycle": "1",
"releaseTime": "08:30",
"stopTime": "11:30",
"quitDay": "-1",
"quitTime": "15:30",
"rule": [
"西院区预约号取号地点：西院区门诊楼一层大厅挂号窗口取号",
"东院区预约号取号地点：东院区老门诊楼一层大厅挂号窗口或新门诊楼各楼层挂号/收费窗口取号"
]
  }
}

说明：

1. 数据分为医院基本信息与预约规则信息
2. 医院logo转换为base64字符串
3. 预约规则信息属于医院基本信息的一个属性
4. 预约规则rule，以数组形式传递
5. 数据传递过来我们还要验证签名，只允许平台开通的医院可以上传数据，保证数据安全性

3.2 添加controller接口
在ApiController类添加接口:

@ApiOperation(value = "上传医院")
@PostMapping("saveHospital")
public Result saveHospital(HttpServletRequest request) {
      Map<String, Object> paramMap = 
      HttpRequestHelper.switchMap(request.getParameterMap());

		hospitalService.save(paramMap);
		return Result.ok();
   }

3.3 添加service接口

1、在HospitalService 类添加接口

/**
 * 上传医院信息
 * @param paramMap
*/
void save(Map<String, Object> paramMap);

说明：参数使用Map，减少对象封装，有利于签名校验，后续会体验到

说明：
map转javaBean:

Map<String,Object> map = new HashMap<>();
map.put("age", 24);
map.put("name", "jack");
//map转为javabean对象
Student student = JSONObject.parseObject(JSONObject.toJSONString(map), Student.class);

jsonString 转 javabean:

/*
 * 将 json 文本 解析为 JavaBean
 * 源码 ：public static final <T> T parseObject(String text, Class<T> clazz);
 */
String str = "{\"age\":\"18\",\"name\":\"jack\"}";
Student student = JSONObject.parseObject(str, Student.class);
System.out.println(student.getName());
System.out.println(student.getAge());

3.4、在HospitalServiceImpl类添加实现

因为医院那边发过来的是json ，我们无法操作所以只能转map转json转对象;

1、开始用户提交字符串给controller；2、然后转为map接收；3、然后把map转为二进制流，通过OutputStream把流放到request请求中传给我们；

中把map转为String；5、在把String转为Hospital对象给我们使用;

说明：
Hospital hospital = JSONObject.parseObject(JSONObject.toJSONString(paramMap),Hospital.class);
Map转换为Hospital对象时，预约规则bookingRule为一个对象属性，rule为一个数组属性，因此在转换时我们要重新对应的set方法，不然转换不会成功

最终的实现类：

@Override
public void save(Map<String, Object> paramMap) {
log.info(JSONObject.toJSONString(paramMap));
   Hospital hospital = JSONObject.parseObject(JSONObject.toJSONString(paramMap),Hospital.class);
   //判断是否存在
Hospital targetHospital = hospitalRepository.getHospitalByHoscode(hospital.getHoscode());
if(null != targetHospital) {
      hospital.setStatus(targetHospital.getStatus());
      hospital.setCreateTime(targetHospital.getCreateTime());
      hospital.setUpdateTime(new Date());
      hospital.setIsDeleted(0);
hospitalRepository.save(hospital);
   } else {
//0：未上线 1：已上线
hospital.setStatus(0);
      hospital.setCreateTime(new Date());
      hospital.setUpdateTime(new Date());
      hospital.setIsDeleted(0);
hospitalRepository.save(hospital);
   }
}

3.6 测试上传接口:

复制数据库中的set值：

这里的业务逻辑是预约平台和医院合作后，给医院提供hoscode,api_url,sign_key，医院端首先在数据库把该条记录添加上，才可以进行操作，完成科室排班等信息上传；

action="/hospitalSet/save:

医院设置：本质就是更新方法，将医院设置保存到yygh_manage的hospital_set表：

医院管理漏由下的–>添加按钮：参数是一个json数据

找到课件数据：

保存数据：

调用的是这个方法：

医院管理的 到此先结束：医院管理的添加，本质就是给其他微服务传递了一个一个医院的json数据，那边微服务进行接受处理；

---

---

百度一个这个软件：
nosqlbooster4mongo

4、参数签名

4.2 上传医院添加签名校验:

我们在医院设置的时候，为每个医院生成了医院编码与签名key，因此我在验证签名时要根据医院编码去动态获取签名key，然后再做签名校验

在医院管理服务中修改：

最后的总的ApiController :

package com.fan.yygh.hosp.controller.api;

//import com.fan.yygh.common.helper.HttpRequestHelper;
import com.fan.yygh.common.exception.YyghException;
import com.fan.yygh.common.helper.HttpRequestHelper;
import com.fan.yygh.common.result.Result;
import com.fan.yygh.common.result.ResultCodeEnum;
import com.fan.yygh.common.utils.MD5;
import com.fan.yygh.hosp.service.HospitalService;
import com.fan.yygh.hosp.service.HospitalSetService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;

@RestController
@RequestMapping("/api/hosp")
public class ApiController {
    @Resource //注入service接口
    private HospitalService hospitalService;
    @Resource //注入service接口
    private HospitalSetService hospitalSetService;

    //上传医院接口
    @PostMapping("saveHospital")
    public Result saveHosp(HttpServletRequest request){
        //获取传递过来医院信息,医院那边传过来的是json对象{xx：xx}，我们json转成map
        Map<String, String[]> requestMap = request.getParameterMap();
        Map<String, Object> paramMap = HttpRequestHelper.switchMap(requestMap);
        //签名验证
        //1.获取医院管理系统传递过来的签名，签名进行md5加密,hospSign已经进行了加密
        String hospSign = (String)paramMap.get("sign");//获取前端签名参数
        //2.根据传递过来的前端医院编码，查询数据库，查询数据库那边的签名
        String hoscode = (String)paramMap.get("hoscode");//先从参数map获取前端医院编码
        //此方法返回了医院设置的数据库签名
        String signKey = hospitalSetService.getSignKey(hoscode);
        //3.把数据库查询出来的签名进行md5加密
        String signKeyMd5 = MD5.encrypt(signKey);
        //4.判断签名是否一致
        if(!hospSign.equals(signKeyMd5)){
            throw new YyghException(ResultCodeEnum.SIGN_ERROR);
        }
        //调用service的方法
        hospitalService.save(paramMap);//传递一个map,为何
        return Result.ok();
    }

}

是医院自己那里传过来它们具体的一些信息，然后统一把医院的这些信息放到平台上展示

传输过程中要加密，然后我们这里要用相同的加密技术，比对加密结果，不需要解密

测试：先删除原先的集合：

测试能否增加成功：

存在的问题：当第二次保存json的时候会报失败，没有进行修改：

package com.fan.yygh.hosp.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.fan.yygh.hosp.repository.HospitalRepository;
import com.fan.yygh.hosp.service.HospitalService;
import com.fan.yygh.model.hosp.Hospital;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.Map;
@Service
public class HospitalServiceImpl implements HospitalService {
    //注入Repository层
    @Resource
    private HospitalRepository hospitalRepository;

    @Override
    public void save(Map<String, Object> paramMap) {
        //将map--》对象
        //把参数map集合转换成 Hospital对象
        String mapString = JSONObject.toJSONString(paramMap);
        //前端转成的hospital对象
        Hospital hospital = JSONObject.parseObject(mapString, Hospital.class);
        //判断mongodb中是否存在数据
        String hoscode = hospital.getHoscode();
        //从mongodb数据库查出来的hospital对象
        Hospital hospitalExist = hospitalRepository.getHospitalByHoscode(hoscode);

        //如果存在，进行修改
        if(hospitalExist != null){
            hospital.setStatus(hospitalExist.getStatus());
            hospital.setCreateTime(hospitalExist.getCreateTime());
            hospital.setUpdateTime(new Date());
            hospital.setIsDeleted(0);
            hospitalRepository.save(hospital);
        }else{//如果不存在，进行添加
            //0：未上线 1：已上线
            hospital.setStatus(0);
            hospital.setCreateTime(new Date());
            hospital.setUpdateTime(new Date());
            hospital.setIsDeleted(0);
            hospitalRepository.save(hospital);
        }

    }
}

5、图片的base64处理：

图片的base64编码就是可以将一张图片数据编码成一串字符串，使用该字符串代替图像地址url
在前端页面中常见的base64图片的引入方式：

<img src="data:image/png;base64,iVBORw0…>

1.优点
（1）base64格式的图片是文本格式，占用内存小，转换后的大小比例大概为1/3，降低了资源服务器的消耗；
（2）网页中使用base64格式的图片时，不用再请求服务器调用图片资源，减少了服务器访问次数。

修改ApiController类上传接口：

//传输过程中“+”转换为了“ ”，因此我们要转换回来
String logoDataString = (String)paramMap.get("logoData");
if(!StringUtils.isEmpty(logoDataString)) {
      String logoData = logoDataString.replaceAll("", "+");
      paramMap.put("logoData", logoData);
   }

存放位置：

用浏览器打开图片测试：

查询医院接口：

controller:

service:

impl:

修改医院管理：

启动测试：

本人bug:医院logo未显示

上传科室接口：

MongoDB类似于mysql，但是它可以存储大量的数据，高并发。一般是mysql和mongodb结合使用

service:

impl:

添加和修改的区别就在于是否存在id，如果你连其中的逻辑都没搞清楚，那你真的要下更多的功夫了，真的很容易理解

测试：

查询科室接口：

查询部门的接口路径;

注意：Page导包是用的org.springframework.data.domain.Page;

实现类;

VO是和前端交互的bean，和DTO不一样

删除科室的接口：

测试：

排班接口：

排版的额查询接口：