项目一总结（上）

注意点

第一天

1.nginx必须放在没有中文的目录中才能正常运行（双击nginx.exe）。

2.在idea中创建git仓库vcs中Create Git Repository，找到该项目目录。在gitee中创建与项目同名的仓库，复制远程仓库的地址，在idea中push中Define remote 中粘贴该地址。

3.读取配置文件中的配置，该类要用到@ConfigurationProperties（prefix="*.*"）和@Component注解。

4.开启多个配置文件 （即application-dev.yml文件）。

spring：

    profiles：

        active：dev 

5.可采用@Builder注解加在该类上，在调用时XX.builder.属性（）....build();构建new对象。

XX.builder()

     .属性（..）

     ...  

     .build();

6.nginx反向代理，将前端请求动态请求nginx转发到后端服务器。

1. 提高访问速度
2. 进行负载均衡
3. 保证后端服务安全

7.nginx负载均衡配置

8.nginx负载均衡策略

 9.//todo 需要后期完善代码

10.md5加密

password = DigestUtils.md5DigestAsHex(password.getBytes());

11.Swagger测试

1.引入依赖

   com.github.xiaoymin
   knife4j-spring-boot-starter

2.在配置类中加入knife4j相关配置，WebMvcConfiguration.java 

/**
     * 通过knife4j生成接口文档
     * @return
*/
    @Bean
    public Docket docket() {
        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("苍穹外卖项目接口文档")
                .version("2.0")
                .description("苍穹外卖项目接口文档")
                .build();
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
                .paths(PathSelectors.any())
                .build();
        return docket;
    }

3.设置静态资源映射，WebMvcConfiguration.java

/**
     * 设置静态资源映射
     * @param registry
*/
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}

4.访问测试，接口文档访问路径为 http://ip:port/doc.html ---> http://localhost:8080/doc.html

12.Swagger常用注解

@Api	用在类上，例如Controller，表示对类的说明，eg：（tags = "员工相关接口"）
@ApiModel	用在类上，例如entity、DTO、VO，eg：（description = "员工登录时传递的数据类"）
@ApiModelProperty	用在属性上，描述属性信息，eg：（"用户名"）
@ApiOperation	用在方法上，例如Controller的方法，说明方法的用途、作用，eg：（value = "员工登录"）

第二天

1.在全局异常处理器中捕获sql唯一约束异常

/**
 * 全局异常处理器，处理项目中抛出的业务异常
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    /**
     * 捕获业务异常
     * @param ex
     * @return
     */
    @ExceptionHandler
    public Result exceptionHandler(BaseException ex){
        log.error("异常信息：{}", ex.getMessage());
        return Result.error(ex.getMessage());
    }

    /**
     * 捕获sql唯一约束异常
     * @param ex
     * @return
     */
    @ExceptionHandler
    public Result exceptionHandler(SQLIntegrityConstraintViolationException ex){
        //获取异常信息 Duplicate entry 'xiaoai' for key 'employee.idx_username'
        String message = ex.getMessage();
        //判断消息中是否包含Duplicate entry
        if (message.contains("Duplicate entry")){
            //以空格分隔信息
            String[] s = message.split(" ");
            String name= s[2];
            //返回该信息已存在
            return Result.error(name+ MessageConstant.ALREADY_EXISTS);
        }else{
            //返回未知错误
           return Result.error(MessageConstant.UNKNOWN_ERROR); 
        }
    }

}

注意：

1.一定要写@ExceptionHandler注解，否则无法生效。

2.要重写exceptionHandler（）方法。

3.尽量使用常量类，拼接msg。

2.采用ThreadLocal存储当前用户id

public class BaseContext {

    public static ThreadLocal threadLocal = new ThreadLocal<>();

    public static void setCurrentId(Long id) {
        threadLocal.set(id);
    }

    public static Long getCurrentId() {
        return threadLocal.get();
    }

    public static void removeCurrentId() {
        threadLocal.remove();
    }

}

注意：

1.若没有上面的类时获取当前线程id

        Thread.currentThread().getId()

2.在拦截器中解析出id后，放入ThreadLocal中

        BaseContext.getCurrentId()

3.安装Mybatisx插件，方便编写复杂sql

4.动态模糊匹配，降序

   
       and name like concat('%',#{name},'%')
   

order by create_time desc

4.员工分页插件

1.先引入依赖

    com.github.pagehelper
    pagehelper-spring-boot-starter

2.业务层

PageHelper.startPage(pageQueryDTO.getPage(), pageQueryDTO.getPageSize());
Page page=xxMapper.page(pageQueryDTO);
long total = page.getTotal();
List records = page.getResult();
return new PageResult(total,records);

5.日期格式问题

 注意：WebMvcConfiguration 必须继承WebMvcConfigurationSupport

extends WebMvcConfigurationSupport

重写extendMessageConverters方法

 /**
     * 扩展Spring mvc框架消息转换器
     * @param converters
     */
    @Override
    protected void extendMessageConverters(List> converters) {
        //创建一个消息转换器对象
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        //需要为消息转换器设置一个对象转换器，对象转换器可以将java对象序列话为json数据
        converter.setObjectMapper(new JacksonObjectMapper());
        //将自己的消息转化器加入容器中,设置成0可将我们自定义的转化器设置在第一位
        converters.add(0,converter);
    }

第三天

1.公共字段的填充（技术点：枚举、注解、AOP、反射 ）

实现步骤：

1). 自定义注解 AutoFill，用于标识需要进行公共字段自动填充的方法

2). 自定义切面类 AutoFillAspect，统一拦截加入了 AutoFill 注解的方法，通过反射为公共字段赋值

3). 在 Mapper 的方法上加入 AutoFill 注解

步骤1

1.1自定义注解 AutoFill

/**
 * 自定义注解，用于标识某个方法需要进行功能字段自动填充处理
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {
    //数据库操作类型：UPDATE INSERT
    OperationType value();
}

1.2定义枚举

/**
 * 数据库操作类型
 */
public enum OperationType {

    /**
     * 更新操作
     */
    UPDATE,

    /**
     * 插入操作
     */
    INSERT
}

步骤2

2.1自定义切面 AutoFillAspect

/**
 * 自定义切面，实现公共字段自动填充处理逻辑
 */
@Aspect
@Component
@Slf4j
public class AutoFillAspect {

    /**
     * 切入点
     */
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut(){}

    /**
     * 前置通知，在通知中进行公共字段的赋值
     */
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint){
        log.info("开始进行公共字段自动填充...");

        //获取到当前被拦截的方法上的数据库操作类型
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
        AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解对象
        OperationType operationType = autoFill.value();//获得数据库操作类型

        //获取到当前被拦截的方法的参数--实体对象
        Object[] args = joinPoint.getArgs();
        if(args == null || args.length == 0){
            return;
        }

        Object entity = args[0];

        //准备赋值的数据
        LocalDateTime now = LocalDateTime.now();
        Long currentId = BaseContext.getCurrentId();

        //根据当前不同的操作类型，为对应的属性通过反射来赋值
        if(operationType == OperationType.INSERT){
            //为4个公共字段赋值
            try {
                Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过反射为对象属性赋值
                setCreateTime.invoke(entity,now);
                setCreateUser.invoke(entity,currentId);
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else if(operationType == OperationType.UPDATE){
            //为2个公共字段赋值
            try {
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过反射为对象属性赋值
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

步骤3

3.1在Mapper接口的方法上加入 AutoFill 注解

/**
     * 插入数据
     * @param category
     */ 
@AutoFill(value = OperationType.INSERT)
  void insert(Category category);
    /**
     * 根据id修改分类
     * @param category
     */
@AutoFill(value = OperationType.UPDATE)
   void update(Category category);

2.文件上传

实现步骤：

1). 定义OSS相关配置

application-dev.yml

sky:
  alioss:
    endpoint: oss-cn-hangzhou.aliyuncs.com
    access-key-id: LTAI5tEaecZtGfJxSSUioDPu
    access-key-secret: PRxIxbZVQdvpfPQEEPfL2NFDAR6P4p
    bucket-name: hmleadnewswxx

application.yml

spring:
  profiles:
    active: dev    #设置环境
sky:
  alioss:
    endpoint: ${sky.alioss.endpoint}
    access-key-id: ${sky.alioss.access-key-id}
    access-key-secret: ${sky.alioss.access-key-secret}
    bucket-name: ${sky.alioss.bucket-name}

2). 读取OSS配置

@Component
@ConfigurationProperties(prefix = "sky.alioss")
@Data
public class AliOssProperties {
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;
}

3). 生成OSS工具类对象

/**
 * 配置类，用于创建AliOssUtil对象
 */
@Configuration
@Slf4j
public class OssConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public AliOssUtil aliOssUtil(AliOssProperties aliOssProperties){
        log.info("开始创建阿里云文件上传工具类对象：{}",aliOssProperties);
        return new AliOssUtil(aliOssProperties.getEndpoint(),
                aliOssProperties.getAccessKeyId(),
                aliOssProperties.getAccessKeySecret(),
                aliOssProperties.getBucketName());
    }
}

@Data
@AllArgsConstructor
@Slf4j
public class AliOssUtil {

    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;

    /**
     * 文件上传
     *
     * @param bytes
     * @param objectName
     * @return
     */
    public String upload(byte[] bytes, String objectName) {

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

        try {
            // 创建PutObject请求。
            ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes));
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }

        //文件访问路径规则 https://BucketName.Endpoint/ObjectName
        StringBuilder stringBuilder = new StringBuilder("https://");
        stringBuilder
                .append(bucketName)
                .append(".")
                .append(endpoint)
                .append("/")
                .append(objectName);

        log.info("文件上传到:{}", stringBuilder.toString());

        return stringBuilder.toString();
    }
}

4). 定义文件上传接口

/**
 * 通用接口
 */
@RestController
@RequestMapping("/admin/common")
@Api(tags = "通用接口")
@Slf4j
public class CommonController {

    @Autowired
    private AliOssUtil aliOssUtil;

    /**
     * 文件上传
     * @param file
     * @return
     */
    @PostMapping("/upload")
    @ApiOperation("文件上传")
    public Result upload(MultipartFile file){
        log.info("文件上传：{}",file);

        try {
            //原始文件名
            String originalFilename = file.getOriginalFilename();
            //截取原始文件名的后缀   dfdfdf.png
            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
            //构造新文件名称
            String objectName = UUID.randomUUID().toString() + extension;

            //文件的请求路径
            String filePath = aliOssUtil.upload(file.getBytes(), objectName);
            return Result.success(filePath);
        } catch (IOException e) {
            log.error("文件上传失败：{}", e);
        }

        return Result.error(MessageConstant.UPLOAD_FAILED);
    }
}

3.新增返回id

4.循环遍历新增

   insert into dish_flavor (dish_id, name, value) VALUES
   
        (#{df.dishId},#{df.name},#{df.value})
   

5.新增菜品以及口味

 /**
     * 新增菜品和对应的口味
     *
     * @param dishDTO
     */
    @Transactional
    public void saveWithFlavor(DishDTO dishDTO) {

        Dish dish = new Dish();

        BeanUtils.copyProperties(dishDTO, dish);

        //向菜品表插入1条数据
        dishMapper.insert(dish);//后绪步骤实现

        //获取insert语句生成的主键值
        Long dishId = dish.getId();

        List flavors = dishDTO.getFlavors();
        if (flavors != null && flavors.size() > 0) {
            flavors.forEach(dishFlavor -> {
                dishFlavor.setDishId(dishId);
            });
            //向口味表插入n条数据
            dishFlavorMapper.insertBatch(flavors);//后绪步骤实现
        }
    }

6.关于前端向后端传入参数的问题

第一种：用@RequestParam注解来接收。注意：当直接用List ids接收就会收不到

删除时向后端批量传入ids，以实现单个删除和多个删除方法公用时，参数在后端的接收问题

    @DeleteMapping
    @ApiOperation("批量删除")
    public Result delete(@RequestParam List ids) {
        log.info("批量删除：{}", ids);
        xxService.deleteBatch(ids);//后绪步骤实现
        return Result.success();
    }

第二种：用数组来接收，不带@RequestParam

    @DeleteMapping
    public R delete(Long[] ids){
        for (Long id : ids) {
            log.info("id = {}", id);
        }
        return null;
    }

7.遍历查找集合中的元素

select setmeal_id from setmeal_dish where dish_id in

#{dishId}

第四天

第五天

1.Redis是一个基于内存的key-value结构数据库（非关系型数据库 ）（中文网：Redis中文网 ）

• 基于内存存储，读写性能高

• 适合存储热点数据（热点商品、资讯、新闻）

• 企业应用广泛

2.Redis下载与安装

• Windows版下载地址：https://github.com/microsoftarchive/redis/releases

• Linux版下载地址： Index of /releases/

Redis安装

在Windows中安装Redis(项目中使用)直接解压即可使用

在Linux系统安装Redis步骤：

1. 将Redis安装包上传到Linux

2. 解压安装包，命令：tar -zxvf redis-4.0.0.tar.gz -C /usr/local

3. 安装Redis的依赖环境gcc，命令：yum install gcc-c++

4. 进入/usr/local/redis-4.0.0，进行编译，命令：make

5. 进入redis的src目录进行安装，命令：make install

注意：

• /usr/local/redis-4.0.0/src/redis-server：Redis服务启动脚本

• /usr/local/redis-4.0.0/src/redis-cli：Redis客户端脚本

• /usr/local/redis-4.0.0/redis.conf：Redis配置文件

3.Redis服务启动与停止

3.1服务启动命令

redis-server.exe redis.windows.conf

Redis服务默认端口号为 6379 ，通过快捷键Ctrl + C 即可停止

3.2客户端连接命令

通过redis-cli.exe命令默认连接的是本地的redis服务，并且使用默认6379端口

• -h ip地址

• -p 端口号

• -a 密码（如果需要）

3.3修改redis配置文件

设置Redis服务密码，修改redis.windows.conf

requirepass 123456

注意：

• 修改密码后需要重启Redis服务才能生效

• Redis配置文件中 # 表示注释

重启Redis后，再次连接Redis时，需加上密码，否则连接失败。

redis-cli.exe -h localhost -p 6379 -a 123456

3.4图形画工具

当天资料中已提供安装包，直接安装即可

新建连接

连接成功

4.redis中的数据类型

• 字符串 string

• 哈希 hash

• 列表 list

• 集合 set

• 有序集合 sorted set / zset

解释

• 字符串(string)：普通字符串，Redis中最简单的数据类型

• 哈希(hash)：也叫散列，类似于Java中的HashMap结构

• 列表(list)：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList

• 集合(set)：无序集合，没有重复元素，类似于Java中的HashSet

• 有序集合(sorted set/zset)：集合中每个元素关联一个分数(score)，根据分数升序排序，没有重复元素

5.redis常用命令（Redis中文网 ）

字符串操作命令

SET key value 设置指定key的值

GET key 获取指定key的值

SETEX key seconds value 设置指定key的值，并将 key 的过期时间设为 seconds 秒

SETNX key value 只有在 key 不存在时设置 key 的值

哈希操作命令

HSET key field value 将哈希表 key 中的字段 field 的值设为 value

HGET key field 获取存储在哈希表中指定字段的值

HDEL key field 删除存储在哈希表中的指定字段

HKEYS key 获取哈希表中所有字段

HVALS key 获取哈希表中所有值

列表操作命令

LPUSH key value1 [value2] 将一个或多个值插入到列表头部

LRANGE key start stop 获取列表指定范围内的元素

RPOP key 移除并获取列表最后一个元素

LLEN key 获取列表长度

BRPOP key1 [key2 ] timeout 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超 时或发现可弹出元素为止

集合操作命令

SADD key member1 [member2] 向集合添加一个或多个成员

SMEMBERS key 返回集合中的所有成员

SCARD key 获取集合的成员数

SINTER key1 [key2] 返回给定所有集合的交集

SUNION key1 [key2] 返回所有给定集合的并集

SREM key member1 [member2] 移除集合中一个或多个成员

有序集合操作命令

ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员

ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合中指定区间内的成员

ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment

ZREM key member [member ...] 移除有序集合中的一个或多个成员

通用命令（不分数据类型的，都可以使用的命令 ）

KEYS pattern 查找所有符合给定模式( pattern)的 key

EXISTS key 检查给定 key 是否存在

TYPE key 返回 key 所储存的值的类型

DEL key 该命令用于在 key 存在是删除 key

6.java中使用redis{Jedis，Lettuce，Spring Data Redis（常用Spring中整合的）}

spring Data Redis使用方式（Spring Data Redis ）Spring Data Redis中提供了一个高度封装的类：RedisTemplate 对相关api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下：

• ValueOperations：string数据操作

• SetOperations：set类型数据操作

• ZSetOperations：zset类型数据操作

• HashOperations：hash类型的数据操作

• ListOperations：list类型的数据操作

 6.1maven坐标

	org.springframework.boot
	spring-boot-starter-data-redis

6.2配置redis数据源

在application-dev.yml中添加

sky:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 10

解释说明：

database:指定使用Redis哪个数据库，Redis服务启动后默认有16个数据库，编号是从0到15。

可以通过修改Redis配置文件来指定数据库的数量。

在application.yml中添加读取application-dev.yml中的相关Redis配置

spring:
  profiles:
    active: dev
  redis:
    host: ${sky.redis.host}
    port: ${sky.redis.port}
    password: ${sky.redis.password}
    database: ${sky.redis.database}

6.3编写配置类，创建RedisTemplate对象

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

解释说明：

当前配置类不是必须的，因为 Spring Boot 框架会自动装配 RedisTemplate 对象，但是默认的key序列化器为

JdkSerializationRedisSerializer，导致我们存到Redis中后的数据和原始数据有差别，故设置为

StringRedisSerializer序列化器。

6.4通过RedisTemplate对象操作Redis

@Autowired
private RedisTemplate redisTemplate;

6.4.1操作字符串类型的数据（set get setex setnx）

redisTemplate.opsForValue().set("name","小明");
String city = (String) redisTemplate.opsForValue().get("name");
System.out.println(city);
redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);
redisTemplate.opsForValue().setIfAbsent("lock","1");
redisTemplate.opsForValue().setIfAbsent("lock","2");

6.4.2操作哈希类型数据（hset hget hdel hkeys hvals）

HashOperations hashOperations = redisTemplate.opsForHash();

hashOperations.put("100","name","tom");
hashOperations.put("100","age","20");

String name = (String) hashOperations.get("100", "name");
System.out.println(name);

Set keys = hashOperations.keys("100");
System.out.println(keys);

List values = hashOperations.values("100");
System.out.println(values);

hashOperations.delete("100","age");

6.4.3操作列表类型数据（lpush lrange rpop llen）

ListOperations listOperations = redisTemplate.opsForList();

listOperations.leftPushAll("mylist","a","b","c");
listOperations.leftPush("mylist","d");

List mylist = listOperations.range("mylist", 0, -1);
System.out.println(mylist);

listOperations.rightPop("mylist");

Long size = listOperations.size("mylist");
System.out.println(size);

6.4.4操作集合类型数据（sadd smembers scard sinter sunion srem）

SetOperations setOperations = redisTemplate.opsForSet();

setOperations.add("set1","a","b","c","d");
setOperations.add("set2","a","b","x","y");

Set members = setOperations.members("set1");
System.out.println(members);

Long size = setOperations.size("set1");
System.out.println(size);

Set intersect = setOperations.intersect("set1", "set2");
System.out.println(intersect);

Set union = setOperations.union("set1", "set2");
System.out.println(union);

setOperations.remove("set1","a","b");

6.4.5操作有序集合类型数据（zadd zrange zincrby zrem）

ZSetOperations zSetOperations = redisTemplate.opsForZSet();

zSetOperations.add("zset1","a",10);
zSetOperations.add("zset1","b",12);
zSetOperations.add("zset1","c",9);

Set zset1 = zSetOperations.range("zset1", 0, -1);
System.out.println(zset1);

zSetOperations.incrementScore("zset1","c",10);

zSetOperations.remove("zset1","a","b");

6.4.6通用命令操作（keys exists type del）

Set keys = redisTemplate.keys("*");
System.out.println(keys);

Boolean name = redisTemplate.hasKey("name");
Boolean set1 = redisTemplate.hasKey("set1");

for (Object key : keys) {
    DataType type = redisTemplate.type(key);
    System.out.println(type.name());
}

redisTemplate.delete("mylist");

7.营业状态存储方式：基于Redis的字符串来进行存储

@RestController("adminShopController")
@RequestMapping("/admin/shop")
@Api(tags = "店铺相关接口")
@Slf4j
public class ShopController {

    public static final String KEY = "SHOP_STATUS";

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 设置店铺的营业状态
     * @param status
     * @return
     */
    @PutMapping("/{status}")
    @ApiOperation("设置店铺的营业状态")
    public Result setStatus(@PathVariable Integer status){
        log.info("设置店铺的营业状态为：{}",status == 1 ? "营业中" : "打烊中");
        redisTemplate.opsForValue().set(KEY,status);
        return Result.success();
    }
}

查询营业状态

/**
     * 获取店铺的营业状态
     * @return
     */
    @GetMapping("/status")
    @ApiOperation("获取店铺的营业状态")
    public Result getStatus(){
        Integer status = (Integer) redisTemplate.opsForValue().get(KEY);
        log.info("获取到店铺的营业状态为：{}",status == 1 ? "营业中" : "打烊中");
        return Result.success(status);
    }

8.接口分组展示（管理端和用户端的接口放在一起，不方便区分）

我们要实现管理端和用户端接口进行区分 ，在WebMvcConfiguration.java中，分别扫描"com.sky.controller.admin"和"com.sky.controller.user"这两个包。

@Bean
    public Docket docket1(){
        log.info("准备生成接口文档...");
        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("苍穹外卖项目接口文档")
                .version("2.0")
                .description("苍穹外卖项目接口文档")
                .build();

        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .groupName("管理端接口")
                .apiInfo(apiInfo)
                .select()
                //指定生成接口需要扫描的包
                .apis(RequestHandlerSelectors.basePackage("com.sky.controller.admin"))
                .paths(PathSelectors.any())
                .build();

        return docket;
    }

    @Bean
    public Docket docket2(){
        log.info("准备生成接口文档...");
        ApiInfo apiInfo = new ApiInfoBuilder()
                .title("苍穹外卖项目接口文档")
                .version("2.0")
                .description("苍穹外卖项目接口文档")
                .build();

        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .groupName("用户端接口")
                .apiInfo(apiInfo)
                .select()
                //指定生成接口需要扫描的包
                .apis(RequestHandlerSelectors.basePackage("com.sky.controller.user"))
                .paths(PathSelectors.any())
                .build();

        return docket;
    }

重启服务器，再次访问接口文档，可进行选择用户端接口或者管理端接口

第六天

1.HttpClient(发送HTTP请求,接收响应数据)

1.1maven坐标(若项目中引入了aliyun-sdk-oss（底层包含了HttpClient依赖 ）坐标，则不用引入 )

	org.apache.httpcomponents
	httpclient
	4.5.13

核心Api

• HttpClient：Http客户端对象类型，使用该类型对象可发起Http请求。

• HttpClients：可认为是构建器，可创建HttpClient对象。

• CloseableHttpClient：实现类，实现了HttpClient接口。

• HttpGet：Get方式请求类型。

• HttpPost：Post方式请求类型。

发送请求步骤

• 创建HttpClient对象

• 创建Http请求对象

• 调用HttpClient的execute方法发送请求

1.2入门

1.2.1GET请求

/**
     * 测试通过httpclient发送GET方式的请求
     */
    @Test
    public void testGET() throws Exception{
        //1.创建httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //2.创建请求对象
        HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");

        //3.发送请求，接受响应结果
        CloseableHttpResponse response = httpClient.execute(httpGet);

        //4.获取服务端返回的状态码
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("服务端返回的状态码为：" + statusCode);

        HttpEntity entity = response.getEntity();
        String body = EntityUtils.toString(entity);
        System.out.println("服务端返回的数据为：" + body);

        //5.关闭资源
        response.close();
        httpClient.close();
    }

1.2.2POST请求

/**
     * 测试通过httpclient发送POST方式的请求
     */
    @Test
    public void testPOST() throws Exception{
        // 1.创建httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        //2.创建请求对象
        HttpPost httpPost = new HttpPost("http://localhost:8080/admin/employee/login");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("username","admin");
        jsonObject.put("password","123456");

        StringEntity entity = new StringEntity(jsonObject.toString());
        //指定请求编码方式
        entity.setContentEncoding("utf-8");
        //数据格式
        entity.setContentType("application/json");
        httpPost.setEntity(entity);

        //3.发送请求
        CloseableHttpResponse response = httpClient.execute(httpPost);

        //4.解析返回结果
        int statusCode = response.getStatusLine().getStatusCode();
        System.out.println("响应码为：" + statusCode);

        HttpEntity entity1 = response.getEntity();
        String body = EntityUtils.toString(entity1);
        System.out.println("响应数据为：" + body);

        //5.关闭资源
        response.close();
        httpClient.close();
    }

2微信小程序开发（微信小程序 ）

2.1准备工作

1.注册小程序（小程序 ）

2.完善小程序信息（微信公众平台 ）查看小程序的 AppID

3.下载开发者工具（微信开发者工具（稳定版 Stable Build）下载地址与更新日志 | 微信开放文档 ）

2.2小程序目录结构

会存放在pages目录

app.js：必须存在，主要存放小程序的逻辑代码

app.json：必须存在，小程序配置文件，主要存放小程序的公共配置

app.wxss: 非必须存在，主要存放小程序公共样式表，类似于前端的CSS样式

每个小程序页面主要由四个文件组成

js文件：必须存在，存放页面业务逻辑代码，编写的js代码。

wxml文件：必须存在，存放页面结构，主要是做页面布局，页面效果展示的，类似于HTML页面。

json文件：非必须，存放页面相关的配置。

wxss文件：非必须，存放页面样式表，相当于CSS文件。

2.3编写和编译小程序

2.4发布小程序

点击上传-指定版本号-进到微信公众平台，打开版本管理页面-需提交审核，变成审核版本，审核通过后，进行发布，变成线上版本。

3.微信登陆流程（小程序登录 | 微信开放文档 ）

步骤：

1. 小程序端，调用wx.login()获取code，就是授权码。

2. 小程序端，调用wx.request()发送请求并携带code，请求开发者服务器(自己编写的后端服务)。

3. 开发者服务端，通过HttpClient向微信接口服务发送请求，并携带appId+appsecret+code三个参数。

4. 开发者服务端，接收微信接口服务返回的数据，session_key+opendId等。opendId是微信用户的唯一标识。

5. 开发者服务端，自定义登录态，生成令牌(token)和openid等数据返回给小程序端，方便后绪请求身份校验。

6. 小程序端，收到自定义登录态，存储storage。

7. 小程序端，后绪通过wx.request()发起业务请求时，携带token。

8. 开发者服务端，收到请求后，通过携带的token，解析当前登录用户的id。

9. 开发者服务端，身份校验通过后，继续相关的业务逻辑处理，最终返回业务数据。

4.微信代码开发

application-dev.yml

sky:
  wechat:
    appid: wxffb3637a228223b8
    secret: 84311df9199ecacdf4f12d27b6b9522d

application.yml

sky:
  wechat:
    appid: ${sky.wechat.appid}
    secret: ${sky.wechat.secret}

为微信用户生成jwt令牌

application.yml

sky:
  jwt:
    # 设置jwt签名加密时使用的秘钥
    admin-secret-key: itcast
    # 设置jwt过期时间
    admin-ttl: 7200000
    # 设置前端传递过来的令牌名称
    admin-token-name: token
    user-secret-key: itheima
    user-ttl: 7200000
    user-token-name: authentication

传入参数DTO

/**
 * C端用户登录
 */
@Data
public class UserLoginDTO implements Serializable {

    private String code;

}

返回数据vo类

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UserLoginVO implements Serializable {

    private Long id;
    private String openid;
    private String token;

}

controllercenglogin方法

@RestController
@RequestMapping("/user/user")
@Api(tags = "C端用户相关接口")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    @PostMapping("/login")
    @ApiOperation("微信登录")
    public Result login(@RequestBody UserLoginDTO userLoginDTO){
        log.info("微信用户登录：{}",userLoginDTO.getCode());

        //微信登录
        User user = userService.wxLogin(userLoginDTO);//后绪步骤实现

        //为微信用户生成jwt令牌
        Map claims = new HashMap<>();
        claims.put(JwtClaimsConstant.USER_ID,user.getId());//JwtClaimsConstant.USER_ID常量已定义
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);

        UserLoginVO userLoginVO = UserLoginVO.builder()
                .id(user.getId())
                .openid(user.getOpenid())
                .token(token)
                .build();
        return Result.success(userLoginVO);
    }
}

service接口

public interface UserService {

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    User wxLogin(UserLoginDTO userLoginDTO);
}

service实现类

@Service
@Slf4j
public class UserServiceImpl implements UserService {

    //微信服务接口地址
    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";

    @Autowired
    private WeChatProperties weChatProperties;
    @Autowired
    private UserMapper userMapper;

    /**
     * 微信登录
     * @param userLoginDTO
     * @return
     */
    public User wxLogin(UserLoginDTO userLoginDTO) {
        String openid = getOpenid(userLoginDTO.getCode());

        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if(openid == null){
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }

        //判断当前用户是否为新用户
        User user = userMapper.getByOpenid(openid);

        //如果是新用户，自动完成注册
        if(user == null){
            user = User.builder()
                    .openid(openid)
                    .createTime(LocalDateTime.now())
                    .build();
            userMapper.insert(user);//后绪步骤实现
        }

        //返回这个用户对象
        return user;
    }

    /**
     * 调用微信接口服务，获取微信用户的openid
     * @param code
     * @return
     */
    private String getOpenid(String code){
        //调用微信接口服务，获得当前微信用户的openid
        Map map = new HashMap<>();
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",code);
        map.put("grant_type","authorization_code");
        String json = HttpClientUtil.doGet(WX_LOGIN, map);

        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        return openid;
    }
}

mapper层

@Mapper
public interface UserMapper {

    /**
     * 根据openid查询用户
     * @param openid
     * @return
     */
    @Select("select * from user where openid = #{openid}")
    User getByOpenid(String openid);

    /**
     * 插入数据
     * @param user
     */
    void insert(User user);
}

XXMapper.xml映射文件

    
        insert into user (openid, name, phone, sex, id_number, avatar, create_time)
        values (#{openid}, #{name}, #{phone}, #{sex}, #{idNumber}, #{avatar}, #{createTime})
    

编写拦截器

JwtTokenUserInterceptor：统一拦截用户端发送的请求并进行jwt校验

/**
 * jwt令牌校验的拦截器
 */
@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 校验jwt
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getUserTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            Claims claims = JwtUtil.parseJWT(jwtProperties.getUserSecretKey(), token);
            Long userId = Long.valueOf(claims.get(JwtClaimsConstant.USER_ID).toString());
            log.info("当前用户的id：", userId);
            BaseContext.setCurrentId(userId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

在WebMvcConfiguration配置类中注册拦截器

	@Autowired
    private JwtTokenUserInterceptor jwtTokenUserInterceptor;
	/**
     * 注册自定义拦截器
     * @param registry
     */
    protected void addInterceptors(InterceptorRegistry registry) {
        log.info("开始注册自定义拦截器...");
        //.........

        registry.addInterceptor(jwtTokenUserInterceptor)
                .addPathPatterns("/user/**")
                .excludePathPatterns("/user/user/login")
                .excludePathPatterns("/user/shop/status");
    }