增删改查+redis+token+mybatisplus 完整代码+讲解适合大一大二以及新手小白 Service层讲解

最新推荐文章于 2024-04-02 21:56:07 发布

simplesin

最新推荐文章于 2024-04-02 21:56:07 发布

阅读量691

点赞数 24

分类专栏： JAVA增删改查文章标签： redis 数据库缓存后端 mysql

本文链接：https://blog.csdn.net/2301_80185446/article/details/135744870

版权

JAVA增删改查专栏收录该内容

3 篇文章 0 订阅

订阅专栏

来咯！

之前说了对于service层来说，先到接口，再到Impl，也就是实际编写代码的地方

这是管理层的

package com.simplesin.service;

import com.simplesin.result.Result;

import javax.servlet.http.HttpSession;

public interface EmployeeService {
    /**
     * 发送手机验证码
     * @param phone
     * @param session
     * @return
     */
    Result sendCode(String phone, HttpSession session);

    /**
     * 管理员登录
     * @param phone
     * @param Code
     * @return
     */
    Result login(String phone,String Code );
}

这是用来做统计的

package com.simplesin.service;

import com.simplesin.vo.EpidemicVO;

public interface InformationService {

    /**
     * 各地方的总情况
     * @return
     */

    EpidemicVO allCount();



}

这是患者的

package com.simplesin.service;

import com.simplesin.dto.PatientDTO;
import com.simplesin.dto.PatientPageQueryDTO;
import com.simplesin.entity.Patient;
import com.simplesin.result.PageResult;
import com.simplesin.result.Result;

import java.util.List;

public interface PatientService {
    /**
     * 新增病患
     * @param patientDTO
     */
    void save(PatientDTO patientDTO);

    /**
     * 分页查询
     * @param patientPageQueryDTO
     * @return
     */
    PageResult pageQuery(PatientPageQueryDTO patientPageQueryDTO);

    /**
     * 被感染情况
     * @param beInfected
     * @param id
     */
    void beInfected(Integer beInfected, Long id);

    /**
     * 康复情况
     * @param recover
     * @param id
     */
    void recover(Integer recover, Long id);

    /**
     * 死亡情况
     * @param die
     * @param id
     */
    void die(Integer die, Long id);

    /**
     * 根据id查询病患信息
     * @param id
     * @return
     */
//    Result<Patient> getById(Long id);

    /**
     * 编辑病患信息
     * @param patientDTO
     */
    void update(PatientDTO patientDTO);

    /**
     * 病患信息批量删除
     * @param ids
     */
    void deleteBatch(List<Long> ids);

    Result<Patient> getById1(Long id);
}

这个也是做统计的

package com.simplesin.service;

import javax.servlet.http.HttpServletResponse;

public interface ReportService {

    /**
     * 被感染情况
     * @param address
     */
    Integer be_Infectedcount(String address);

    /**
     * 康复情况
     * @param address
     * @return
     */
    Integer recovercount(String address);

    /**
     * 死亡情况
     * @param address
     * @return
     */
    Integer diecount(String address);

    /**
     * 导出疫情情况xlsx
     * @param response
     */
    void exportBusinessData(HttpServletResponse response);




}

以上

接下来

讲解最重要的那一层

Service

@Service
public class PatientServiceImpl implements PatientService  {
    @Autowired
    private PatientMapper patientMapper;
    @Autowired
    private CacheClient cacheClient;

这里分别注入了 Mapper层以及用来写redis的cacheClient

因为只有注入了，才可以使用

/**
     * 新增病患
     * @param patientDTO
     */
    @Override
    public void save(PatientDTO patientDTO) {
        Patient patient =new Patient();
        //对象属性拷贝
        BeanUtils.copyProperties(patientDTO,patient);
        //设置感染状态，默认正常状态 1表示感染 0表示未感染
        patient.setBeInfected(StatusConstant.infected);
        //设置康复状态，默认正常状态 1表示康复 0表示未康复
        patient.setRecover(StatusConstant.notRecover);
        //设置死亡状态，默认正常状态 1表示死亡 0表示未死亡
        patient.setDie(StatusConstant.notDie);
        patientMapper.insert(patient);
    }

这里，我们new了一个Patient，现在，Patient这里面是空空如也的。

我们使用一个对象属性拷贝，将patientDTO（Controller层接受到前端发来的消息）的信息拷贝到patient（我们新建的），但是因为DTO和实体类的信息不等，比如说DTO只有5个信息，可是我实体类需要7个信息。因此，我要补充前端没有传来的信息.

这里没有传来的消息就是患者的感染，康复，死亡以及创建时间，创建人，更新时间，更新人。

针对创建时间，创建人，更新时间，更新人我们有特定的方式进行处理（在Mapper层处理，这里先不管）。

因此，我们后端手动设置他们这三个状态。

为了使代码更好看，我们用了StatusConstant。用StatusConstant.infected，且在StatusConstant里面，我标注了StatusConstant.infected=1，就说明实际上就是patient.setBeInfected(1);

这里，展示所有需要用到的Constant

package com.simplesin.constant;

/**
 * 信息提示常量类
 */
public class MessageConstant {

    public static final String AlREADY_EXISTS = "已存在";
    public static final String UNKONWN_ERROR = "未知错误";
}

package com.simplesin.constant;

public class RedisConstants {
    public static final String LOGIN_CODE_KEY = "login:code:";
    public static final Long LOGIN_CODE_TTL = 2L;
    public static final String LOGIN_USER_KEY = "login:token:";
    public static final Long LOGIN_USER_TTL = 30L;
}

package com.simplesin.constant;

/**
 * 状态常量
 */
public class StatusConstant {

    //感染
    public static final Integer infected = 1;

    //未感染
    public static final Integer notInfected = 0;

    //康复
    public static final Integer recover = 1;

    //未康复
    public static final Integer notRecover = 0;

    //死亡
    public static final Integer die = 1;

    //未死亡
    public static final Integer notDie = 0;

    //正常
    public static final Integer ENABLE = 1;

    //不正常
    public static final Integer UNABLE = 0;
}

package com.simplesin.constant;

/**
 * 公共字段自动填充相关常量
 */
public class AutoFillConstant {
    /**
     * 实体类中的方法名称
     */
    public static final String SET_CREATE_TIME = "setCreateTime";
    public static final String SET_UPDATE_TIME = "setUpdateTime";
    public static final String SET_CREATE_USER = "setCreateUser";
    public static final String SET_UPDATE_USER = "setUpdateUser";
}

PatientMapper.insert，就是将数据传入Mapper层

patientMapper.insert(patient);

分页查询的代码很固定，这里不细说

 /**
     * 分页查询
     * @param patientPageQueryDTO
     * @return
     */
    @Override
    public PageResult pageQuery(PatientPageQueryDTO patientPageQueryDTO) {
        //开始分页查询
        PageHelper.startPage(patientPageQueryDTO.getPage(),patientPageQueryDTO.getPageSize());
        Page<Patient> page =  patientMapper.PageQuery(patientPageQueryDTO);

        long total = page.getTotal();
        List<Patient> records = page.getResult();
        return new PageResult(total,records);
    }

这里的其实也是新建一个patient，


        Patient patient = Patient.builder()
                .beInfected(beInfected)
                .id(id)
                .build();

因为redis是用来存储短暂的数据的，思前想后，在这个项目中，这里去尝试运用，比较合理。我设置了数据在redis只能存储2分钟

大概讲解一下，redis怎么运行

前端发起请求，要访问后端数据，先看看redis中有没有要的数据，若有，直接返回，若没有，再访问数据库，这样就不用次次都访问数据库了

我把这个封装成一个方法了

package com.simplesin.service;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.simplesin.utils.RedisConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

@Slf4j
@Component
public class CacheClient {
   @Resource
    private StringRedisTemplate stringRedisTemplate;

    public void set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }
    
    public <R,ID> R queryWithPAssThrough
            (String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        //1.从redis查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.判断是否存在
        if (StrUtil.isNotBlank(json)) {
            //3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }
        //判断命中的是否是空值
        if (json != null) {
            //返回一个错误信息
            return null;
        }
        //4.不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        //5.不存在，返回错误
        if(r == null){
            //将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"", RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            //返回错误信息
            return null;
        }
        //6.存在，写入redis
        this.set(key,r,time,unit);
        return r;
    }
}

RedisConstants.CACHE_PATIENT_KEY, 前缀，说明是患者的信息

id,患者的id

Patient.class,说明是Patient而不是Employee，

id2->getById(id2),若查数据库，用这个方法

RedisConstants.CACHE_PATIENT_TTL,在redis中这个信息可以储存多久

TimeUnit.MINUTES表示分钟，若RedisConstants.CACHE_PATIENT_TTL为2，那合起来的意思就是2分钟

/**
     * 根据id查询病患信息
     * @param id
     * @return
     */
    @Override
    public Result<Patient> getById1(Long id) {
        Patient patient = cacheClient.queryWithPAssThrough(RedisConstants.CACHE_PATIENT_KEY,id,Patient.class,id2->getById(id2),RedisConstants.CACHE_PATIENT_TTL, TimeUnit.MINUTES);

        return Result.success(patient);
    }

package com.simplesin.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.simplesin.constant.StatusConstant;
import com.simplesin.dto.PatientDTO;
import com.simplesin.dto.PatientPageQueryDTO;
import com.simplesin.entity.Patient;
import com.simplesin.mapper.PatientMapper;
import com.simplesin.result.PageResult;
import com.simplesin.result.Result;
import com.simplesin.service.CacheClient;
import com.simplesin.service.PatientService;
import com.simplesin.utils.RedisConstants;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Service
public class PatientServiceImpl implements PatientService  {
    @Autowired
    private PatientMapper patientMapper;
  
    @Autowired
    private CacheClient cacheClient;
    /**
     * 新增病患
     * @param patientDTO
     */
    @Override
    public void save(PatientDTO patientDTO) {
        Patient patient =new Patient();
        //对象属性拷贝
        BeanUtils.copyProperties(patientDTO,patient);
        //设置感染状态，默认正常状态 1表示感染 0表示未感染
        patient.setBeInfected(StatusConstant.infected);
        //设置康复状态，默认正常状态 1表示康复 0表示未康复
        patient.setRecover(StatusConstant.notRecover);
        //设置死亡状态，默认正常状态 1表示死亡 0表示未死亡
        patient.setDie(StatusConstant.notDie);
        patientMapper.insert(patient);
    }

    /**
     * 分页查询
     * @param patientPageQueryDTO
     * @return
     */
    @Override
    public PageResult pageQuery(PatientPageQueryDTO patientPageQueryDTO) {
        //开始分页查询
        PageHelper.startPage(patientPageQueryDTO.getPage(),patientPageQueryDTO.getPageSize());
        Page<Patient> page =  patientMapper.PageQuery(patientPageQueryDTO);

        long total = page.getTotal();
        List<Patient> records = page.getResult();
        return new PageResult(total,records);
    }

    /**
     * 被感染情况
     * @param beInfected
     * @param id
     */
    @Override
    public void beInfected(Integer beInfected, Long id) {
        Patient patient = Patient.builder()
                .beInfected(beInfected)
                .id(id)
                .build();

        patientMapper.update(patient);
    }

    /**
     * 康复情况
     * @param recover
     * @param id
     */
    @Override
    public void recover(Integer recover, Long id) {
        Patient patient = Patient.builder()
                .beInfected(recover)
                .id(id)
                .build();

        patientMapper.update(patient);

    }

    /**
     * 死亡情况
     * @param die
     * @param id
     */
    @Override
    public void die(Integer die, Long id) {
        Patient patient = Patient.builder()
                .beInfected(die)
                .id(id)
                .build();

        patientMapper.update(patient);
    }

    /**
     * 根据id查询病患信息
     * @param id
     * @return
     */
    @Override
    public Result<Patient> getById1(Long id) {
        Patient patient = cacheClient.queryWithPAssThrough(RedisConstants.CACHE_PATIENT_KEY,id,Patient.class,id2->getById(id2),RedisConstants.CACHE_PATIENT_TTL, TimeUnit.MINUTES);

        return Result.success(patient);
    }

    private Patient getById(Long id2) {
        Patient patient = patientMapper.getById(id2);
        return patient;
    }

    /**
     * 编辑病患信息
     * @param patientDTO
     */
    @Override
    public void update(PatientDTO patientDTO) {
        Patient patient = new Patient();
        BeanUtils.copyProperties(patientDTO,patient);

        patientMapper.update(patient);
    }

    /**
     * 病患信息批量删除
     * @param ids
     */
    @Override
    public void deleteBatch(List<Long> ids) {
        patientMapper.deleteBatch(ids);
    }
}

simplesin

关注

24
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
增删改查+redis+token+mybatisplus 完整代码+讲解适合大一大二以及新手小白 Service层讲解

【代码】增删改查+redis+token+mybatisplus 完整代码+讲解适合大一大二以及新手小白 Service层讲解。
复制链接

扫一扫

专栏目录