java
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {

        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        //默认的Key序列化器为：JdkSerializationRedisSerializer
        // 设置键的序列化器统一
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 设置值的序列化器统一
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;
    }
}

diff
@PostMapping("/sendMsg")
public Result<String> sendMsg(@RequestBody User user, HttpSession session) throws MessagingException {
    String phone = user.getPhone();
    if (!phone.isEmpty()) {
        //随机生成一个验证码
        String code = MailUtils.achieveCode();
        log.info(code);
        //这里的phone其实就是邮箱，code是我们生成的验证码
        MailUtils.sendTestMail(phone, code);
-       //验证码存session，方便后面拿出来比对phone
-       session.setAttribute(phone, code);
+		// 验证码缓存到Redis中，设置存活时间5分钟
+		redisTemplate.opsForValue().set("code",code,5, TimeUnit.MINUTES);
        return Result.success("验证码发送成功");
    }
    return Result.error("验证码发送失败");
}

java
@PostMapping("/sendMsg")
    public Result<String> sendMsg(@RequestBody User user, HttpSession session) throws MessagingException {
        String phone = user.getPhone();
        if (!phone.isEmpty()) {
            //随机生成一个验证码
            String code = MailUtils.achieveCode();
            log.info(code);
            //这里的phone其实就是邮箱，code是我们生成的验证码
            MailUtils.sendTestMail(phone, code);
            // 存储到Redis中并设置5分钟的存活时间
            redisTemplate.opsForValue().set("code",code,5, TimeUnit.MINUTES);
            return Result.success("验证码发送成功");
        }
        return Result.error("验证码发送失败");
    }

diff
@PostMapping("/login")
public Result<User> login(@RequestBody Map map, HttpSession session) {
    // 获取邮箱
    String phone = map.get("phone").toString();
    // 获得验证码，需要和系统内部的验证码进行比对
    String code = map.get("code").toString();
-   // 从session中获得验证码，session中的验证码之前在发送时，已经让服务器获得了
-   String codeInSession = session.getAttribute(phone).toString();
+	// 把刚刚存入Redis的code拿出来
+   Object codeInRedis = redisTemplate.opsForValue().get("code");
-   if (code != null && code.equals(codeInSession)) {
	// 用redis中的code进行比较
+	if (code != null && code.equals(codeInRedis)) {
        // 如果输入正确，验证用户是否存在
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getPhone, phone);
        User user = userService.getOne(queryWrapper);
        if (user == null) {
            // 如果user为空，就创建一个新的user对象
            user = new User();
            user.setPhone(phone);
            userService.save(user);
-           user.setName("用户" + codeInSession);
+			user.setName("用户" + codeInRedis);
        }
        // 存个session，表示登录状态
        session.setAttribute("user", user.getId());
        // 并作为结果返回
+       // 如果登录成功，则删除Redis中的验证码
+       redisTemplate.delete("code");
        return Result.success(user);
    }
    return Result.error("登录失败");
}

java
@PostMapping("/login")
public Result<User> login(@RequestBody Map map, HttpSession session) {
    // 获取邮箱
    String phone = map.get("phone").toString();
    // 获得验证码，需要和系统内部的验证码进行比对
    String code = map.get("code").toString();
    // 把刚刚存入Redis的code拿出来
    Object codeInRedis = redisTemplate.opsForValue().get("code");
    // 判断从Redis中获取的code是否相同
    if (code != null && code.equals(codeInRedis)) {
        // 如果输入正确，验证用户是否存在
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getPhone, phone);
        User user = userService.getOne(queryWrapper);
        if (user == null) {
            // 如果user为空，就创建一个新的user对象
            user = new User();
            user.setPhone(phone);
            userService.save(user);
            user.setName("用户" + codeInRedis);
        }
        // 存个session，表示登录状态
        session.setAttribute("user", user.getId());
        // 并作为结果返回
        // 如果登录成功，则删除Redis中的验证码
        redisTemplate.delete("code");
        return Result.success(user);
    }
    return Result.error("登录失败");
}

java
@GetMapping("/list")
    // 先将返回值类型改为List<DishDto>
    public Result<List<DishDto>> list(Dish dish){
        // 将dishDtoList作为内容缓存到Redis中
        List<DishDto> dishDtoList = null;

        // key是用于区分不同的缓存内容
        String key = "dish_" + dish.getCategoryId() + "_" + dish.getStatus();

        // 先从redis中获取缓存数据(获取的缓存数据应该是应该为dishDtoList)
        dishDtoList = (List<DishDto>) redisTemplate.opsForValue().get(key);

        // 如果存在，返回数据，无需查询
        if (dishDtoList != null){
            // 直接将查询到的缓存数据返回
            return Result.success(dishDtoList);
        }
        // 如果不存在，就需要进行查询，并使用redis加以缓存
        // 以下代码都是进行数据查询

        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        // 得到该菜品项对应的菜品
        queryWrapper.eq(dish.getCategoryId() != null,Dish::getCategoryId,dish.getCategoryId());

        // 添加条件，查询状态为1（起售状态）的菜品
        queryWrapper.eq(Dish::getStatus,1);

        //添加排序条件(先按照sort来排序，如果sort相同，再按照更新时间来排序)
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

        List<Dish> list = dishService.list(queryWrapper);

        dishDtoList = list.stream().map((item) -> {
            DishDto dishDto = new DishDto();
            BeanUtils.copyProperties(item,dishDto);
            // 分类id
            Long categoryId = item.getCategoryId();
            // 根据Id查询分类对象
            Category category = categoryService.getById(categoryId);

            if (category != null){
                // 如果分类对象查询到了，说明该菜品有分类
                String categoryName = category.getName();
                // 就让菜品设置一下这个分类对象名字
                dishDto.setCategoryName(categoryName);
            }

            // 得到菜品的id
            Long itemId = item.getId();

            LambdaQueryWrapper<DishFlavor> wrapper = new LambdaQueryWrapper<>();
            // 查找与当前菜品id相同的口味信息
            wrapper.eq(DishFlavor::getDishId,itemId);
            List<DishFlavor> flavors = dishFlavorService.list(wrapper);
            // 设置菜品口味
            dishDto.setFlavors(flavors);
            return dishDto;
        }).collect(Collectors.toList());

        // 将数据缓存到redis中，避免二次查询(并设置缓存时间为60分钟)
        redisTemplate.opsForValue().set(key,dishDtoList,60, TimeUnit.MINUTES);
        return Result.success(dishDtoList);
    }

java
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {

        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        //默认的Key序列化器为：JdkSerializationRedisSerializer
        // 设置键的序列化器统一
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 设置值的序列化器统一
//        redisTemplate.setValueSerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;
    }
}

java
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Slf4j
@SpringBootApplication
@ServletComponentScan
@EnableTransactionManagement
@EnableCaching
public class TakeOutApplication {

    public static void main(String[] args) {
        SpringApplication.run(TakeOutApplication.class, args);
        log.info("项目启动成功...");
    }

}

java
@GetMapping("/list")
@Cacheable(value="DishCache",key = "#dish.getCategoryId() + '_' + #dish.getStatus()",unless = "#result == null")
// 先将返回值类型改为List<DishDto>
public Result<List<DishDto>> list(Dish dish){
    // 将dishDtoList作为内容缓存到Redis中
    List<DishDto> dishDtoList = null;

    // 如果不存在，就需要进行查询，并使用redis加以缓存
    // 以下代码都是进行数据查询

    LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
    // 得到该菜品项对应的菜品
    queryWrapper.eq(dish.getCategoryId() != null,Dish::getCategoryId,dish.getCategoryId());

    // 添加条件，查询状态为1（起售状态）的菜品
    queryWrapper.eq(Dish::getStatus,1);

    //添加排序条件(先按照sort来排序，如果sort相同，再按照更新时间来排序)
    queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

    List<Dish> list = dishService.list(queryWrapper);

    dishDtoList = list.stream().map((item) -> {
        DishDto dishDto = new DishDto();
        BeanUtils.copyProperties(item,dishDto);
        // 分类id
        Long categoryId = item.getCategoryId();
        // 根据Id查询分类对象
        Category category = categoryService.getById(categoryId);

        if (category != null){
            // 如果分类对象查询到了，说明该菜品有分类
            String categoryName = category.getName();
            // 就让菜品设置一下这个分类对象名字
            dishDto.setCategoryName(categoryName);
        }

        // 得到菜品的id
        Long itemId = item.getId();

        LambdaQueryWrapper<DishFlavor> wrapper = new LambdaQueryWrapper<>();
        // 查找与当前菜品id相同的口味信息
        wrapper.eq(DishFlavor::getDishId,itemId);
        List<DishFlavor> flavors = dishFlavorService.list(wrapper);
        // 设置菜品口味
        dishDto.setFlavors(flavors);
        return dishDto;
    }).collect(Collectors.toList());

    return Result.success(dishDtoList);
}

java
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> implements Serializable {
    private Integer code;  // 编码：1成功。0和其他数字失败
    private String msg;  // 错误信息
    private T data; // 数据
    private Map map = new HashMap();  // 动态数据

    public static <T> Result<T> success(T data) {
        Result<T> r = new Result<>();
        r.code = 1;  //成功状态码
        r.data = data;
        return r;
    }

    public static <T> Result<T> error(String errMsg) {
        Result<T> r = new Result<>();
        r.msg = errMsg; //设置错误信息
        r.code = 0;  //默认失败状态码，后期我们可以根据自己的需求来设置其他状态码
        return r;
    }

    public Result<T> add(String msg, String value) {
        this.map.put(msg, value);
        return this;
    }
}

java
@GetMapping("/list")
@Cacheable(value = "SetmealCache",key = "#setmeal.categoryId + '_' + #setmeal.status",unless = "#result == null ")
public Result<List<SetmealDto>> list(Setmeal setmeal){
    LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
    // 得到该套餐项对应的菜品
    queryWrapper.eq(setmeal.getCategoryId() != null,Setmeal::getCategoryId,setmeal.getCategoryId());

    // 添加条件，查询状态为1（起售状态）的菜品
    queryWrapper.eq(Setmeal::getStatus,1);

    //添加排序条件(按照更新时间来排序)
    queryWrapper.orderByDesc(Setmeal::getUpdateTime);

    List<Setmeal> list = setMealService.list(queryWrapper);

    List<SetmealDto> setmealDtoList = list.stream().map((item) -> {
        SetmealDto setmealDto = new SetmealDto();
        BeanUtils.copyProperties(item,setmealDto);
        // 分类id
        Long categoryId = item.getCategoryId();
        // 根据Id查询分类对象
        Category category = categoryService.getById(categoryId);

        if (category != null){
            // 如果分类对象查询到了，说明该套餐有分类
            String categoryName = category.getName();
            // 就让套餐设置一下这个分类对象名字
            setmealDto.setCategoryName(categoryName);
        }

        // 得到套餐的id
        Long itemId = item.getId();

        LambdaQueryWrapper<SetmealDish> wrapper = new LambdaQueryWrapper<>();
        // 查找与当前套餐id相同的口味信息
        wrapper.eq(SetmealDish::getDishId,itemId);
        List<SetmealDish> flavors = setmealDishService.list(wrapper);
        // 设置菜品口味
        setmealDto.setSetmealDishes(flavors);
        return setmealDto;
    }).collect(Collectors.toList());
    return Result.success(setmealDtoList);
}

yaml
		spring:
		  shardingsphere:
		    datasource:
		      names:
		        # 这里的master和slave并不是写死的，但是需要跟下面的master和slave对应
		        # 定义了两个数据源，名叫master和slave
		        master,slave
		      # 主数据源
		      master:
		        type: com.alibaba.druid.pool.DruidDataSource
		        driver-class-name: com.mysql.cj.jdbc.Driver
		        # 主库ip及连接的数据库名
		        url: jdbc:mysql://192.168.10.135:3306/reggie?serverTimezone=UTC&useSSL=false
		        username: root
		        # 我的数据库没有密码，所以这里注释了，有需要可以自己调整
		        # password: root
		      # 从数据源
		      slave:
		        type: com.alibaba.druid.pool.DruidDataSource
		        driver-class-name: com.mysql.cj.jdbc.Driver
		        # 从库ip及连接的数据库名
		        url: jdbc:mysql://192.168.10.134:3306/reggie?serverTimezone=UTC&useSSL=false
		        username: root
		        # password: root
		    masterslave:
		      # 读写分离配置
		      # 负载均衡：配置的是从库的负载均衡策略(轮询策略)
		      # 轮询：从库可以有多个，假设有3个从库，第一次走sql查询就是走1号库，第二次走2号，这样以此类		   推，直到走完之后再次重复一遍，说白了就是按顺序来
		      load-balance-algorithm-type: round_robin
		      # 最终的数据源名称
		      name: dataSource
		      # 指定主库数据源名称
		      master-data-source-name: master
		      # 指定从库数据源名称列表，多个从库用逗号分隔
		      slave-data-source-names: slave
		    props:
		      sql:
		        show: true #开启SQL显示，默认false，就是在控制台可以输出sql
		    # 配置允许bean定义覆盖配置项
		  main:
		    allow-bean-definition-overriding: true

yaml
spring:
  shardingsphere:
    datasource:
      names:
        # 这里的master和slave并不是写死的，但是需要跟下面的master和slave对应
        # 定义了两个数据源，名叫master和slave
        master,slave
      # 主数据源
      master:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        # 主库ip及连接的数据库名
        url: jdbc:mysql://192.168.10.135:3306/reggie?serverTimezone=UTC&useSSL=false
        username: root
        # 我的数据库没有密码，所以这里注释了，有需要可以自己调整
        # password: root
      # 从数据源
      slave:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        # 从库ip及连接的数据库名
        url: jdbc:mysql://192.168.10.134:3306/reggie?serverTimezone=UTC&useSSL=false
        username: root
        # password: root
    masterslave:
      # 读写分离配置
      # 负载均衡：配置的是从库的负载均衡策略(轮询策略)
      # 轮询：从库可以有多个，假设有3个从库，第一次走sql查询就是走1号库，第二次走2号，这样以此类		   推，直到走完之后再次重复一遍，说白了就是按顺序来
      load-balance-algorithm-type: round_robin
      # 最终的数据源名称
      name: dataSource
      # 指定主库数据源名称
      master-data-source-name: master
      # 指定从库数据源名称列表，多个从库用逗号分隔
      slave-data-source-names: slave
    props:
      sql:
        show: true #开启SQL显示，默认false，就是在控制台可以输出sql
    # 配置允许bean定义覆盖配置项
  main:
    allow-bean-definition-overriding: true

bash
worker_processes  1;                             <-- 全局块
  
events {                                          <-- events块
    worker_connections  1024;  
}  
  
http {                                            <-- http块
    include       mime.types;                     <-- http全局块
    default_type  application/octet-stream;  
    sendfile        on;  
    keepalive_timeout  65;  
  
    server {                                      <-- Server块
        listen       80;                          <-- Server全局块
        server_name  localhost;  
        location / {                              <-- location块
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

java
@Configuration
@Slf4j
@EnableSwagger2
@EnableKnife4j
public class WebMvcConfig extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        log.info("开始进行静态资源映射...");
        registry.addResourceHandler("/backend/**").addResourceLocations("classpath:/backend/");
        registry.addResourceHandler("/front/**").addResourceLocations("classpath:/front/");
        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }

    @Override
    protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        //设置对象转化器，底层使用jackson将java对象转为json
        messageConverter.setObjectMapper(new JacksonObjectMapper());
        //将上面的消息转换器对象追加到mvc框架的转换器集合当中(index设置为0，表示设置在第一个位置，避免被其它转换器接收，从而达不到想要的功能)
        converters.add(0, messageConverter);
    }

    @Bean
    public Docket createRestApi() {
        //文档类型
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.eastwind.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("瑞吉外卖")
                .version("1.0")
                .description("瑞吉外卖接口文档")
                .build();
    }
}

java
//定义不需要处理的请求
String[] urls = new String[]{
        "/employee/login",
        "/employee/logout",
        "/backend/**",
        "/front/**",
        "/common/**",
        //对用户登陆操作放行
        "/user/login",
        "/user/sendMsg",

        "/doc.html",
        "/webjars/**",
        "/swagger-resources",
        "/v2/api-docs"
};