创新实训个人工作 —— 部分服务类

以下服务类提供了对对应实体的增删改查（CRUD）操作，并添加了若干逻辑，如查询方法、获取所有记录等等。

package com.SmartMed_Connect.service;

import com.SmartMed_Connect.dao.IllnessKindDao;
import com.SmartMed_Connect.entity.IllnessKind;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.SmartMed_Connect.utils.Assert;
import com.SmartMed_Connect.utils.BeanUtil;
import com.SmartMed_Connect.utils.VariableNameUtils;

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

@Service
public class IllnessKindService extends BaseService<IllnessKind> {

    // 自动注入 IllnessKindDao 对象
    @Autowired
    protected IllnessKindDao illnessKindDao;

    // 查询方法，根据传入的 IllnessKind 对象的非空字段生成查询条件
    @Override
    public List<IllnessKind> query(IllnessKind o) {
        QueryWrapper<IllnessKind> wrapper = new QueryWrapper();
        if (Assert.notEmpty(o)) {
            Map<String, Object> bean2Map = BeanUtil.bean2Map(o);// 将对象转换为 Map
            for (String key : bean2Map.keySet()) {
                if (Assert.isEmpty(bean2Map.get(key))) {
                    continue;// 跳过空值字段
                }
                wrapper.eq(VariableNameUtils.humpToLine(key), bean2Map.get(key));
            }
        }
        return illnessKindDao.selectList(wrapper);// 执行查询并返回结果列表
    }

    // 查询所有记录的方法
    @Override
    public List<IllnessKind> all() {
        return query(null);// 查询条件为 null，则返回所有记录
    }

    // 保存方法，根据是否有 ID 来判断是插入还是更新操作
    @Override
    public IllnessKind save(IllnessKind o) {
        if (Assert.isEmpty(o.getId())) {
            illnessKindDao.insert(o);// ID 为空则插入新记录
        } else {
            illnessKindDao.updateById(o); // ID 不为空则更新记录
        }
        return illnessKindDao.selectById(o.getId()); // 返回保存后的记录
    }

    // 根据 ID 获取单条记录的方法
    @Override
    public IllnessKind get(Serializable id) {
        return illnessKindDao.selectById(id);
    }

    // 根据 ID 删除记录的方法
    @Override
    public int delete(Serializable id) {
        return illnessKindDao.deleteById(id);// 根据 ID 删除记录并返回影响的行数
    }

    // 获取所有 IllnessKind 列表的方法
    public List<IllnessKind> findList() {
        return illnessKindDao.selectList(new QueryWrapper<IllnessKind>());// 执行查询并返回结果列表
    }
}

 

package com.SmartMed_Connect.service;

import com.SmartMed_Connect.dao.IllnessMedicineDao;
import com.SmartMed_Connect.entity.IllnessMedicine;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.SmartMed_Connect.utils.Assert;
import com.SmartMed_Connect.utils.BeanUtil;
import com.SmartMed_Connect.utils.VariableNameUtils;

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

@Service
public class IllnessMedicineService extends BaseService<IllnessMedicine> {

    @Autowired
    protected IllnessMedicineDao illnessMedicineDao;

    @Override
    public List<IllnessMedicine> query(IllnessMedicine o) {
        QueryWrapper<IllnessMedicine> wrapper = new QueryWrapper();
        if (Assert.notEmpty(o)) {
            Map<String, Object> bean2Map = BeanUtil.bean2Map(o);
            for (String key : bean2Map.keySet()) {
                if (Assert.isEmpty(bean2Map.get(key))) {
                    continue;
                }
                wrapper.eq(VariableNameUtils.humpToLine(key), bean2Map.get(key));
            }
        }
        return illnessMedicineDao.selectList(wrapper);
    }

    @Override
    public List<IllnessMedicine> all() {
        return query(null);
    }

    @Override
    public IllnessMedicine save(IllnessMedicine o) {
        if (Assert.isEmpty(o.getId())) {
            illnessMedicineDao.insert(o);
        } else {
            illnessMedicineDao.updateById(o);
        }
        return illnessMedicineDao.selectById(o.getId());
    }

    @Override
    public IllnessMedicine get(Serializable id) {
        return illnessMedicineDao.selectById(id);
    }

    @Override
    public int delete(Serializable id) {
        return illnessMedicineDao.deleteById(id);
    }
}

package com.SmartMed_Connect.service;

import com.SmartMed_Connect.dao.MedicalNewsDao;
import com.SmartMed_Connect.entity.MedicalNews;
import com.SmartMed_Connect.utils.Assert;
import com.SmartMed_Connect.utils.BeanUtil;
import com.SmartMed_Connect.utils.VariableNameUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class MedicalNewsService extends BaseService<MedicalNews> {

    @Autowired
    protected MedicalNewsDao medicalNewsDao;

    /**
     * 根据条件查询 MedicalNews 对象列表
     *
     * @param o 查询条件封装的 MedicalNews 对象
     * @return 符合条件的 MedicalNews 对象列表
     */
    @Override
    public List<MedicalNews> query(MedicalNews o) {
        QueryWrapper<MedicalNews> wrapper = new QueryWrapper();
        if (Assert.notEmpty(o)) {
            // 将对象转换为 Map 形式
            Map<String, Object> bean2Map = BeanUtil.bean2Map(o);
            for (String key : bean2Map.keySet()) {
                // 跳过空值字段
                if (Assert.isEmpty(bean2Map.get(key))) {
                    continue;
                }
                // 使用下划线形式的字段名查询
                wrapper.eq(VariableNameUtils.humpToLine(key), bean2Map.get(key));
            }
        }
        return medicalNewsDao.selectList(wrapper);
    }

    /**
     * 查询所有的 MedicalNews 对象
     *
     * @return 所有的 MedicalNews 对象列表
     */
    @Override
    public List<MedicalNews> all() {
        return query(null);
    }

    /**
     * 保存或更新一个 MedicalNews 对象
     *
     * @param o 要保存的 MedicalNews 对象
     * @return 保存后的 MedicalNews 对象
     */
    @Override
    public MedicalNews save(MedicalNews o) {
        // 如果 ID 为空，则插入新的对象
        if (Assert.isEmpty(o.getId())) {
            medicalNewsDao.insert(o);
        } else {
            // 如果 ID 不为空，则更新已有对象
            medicalNewsDao.updateById(o);
        }
        return medicalNewsDao.selectById(o.getId());
    }

    /**
     * 根据 ID 获取一个 MedicalNews 对象
     *
     * @param id 对象的主键 ID
     * @return 获取到的 MedicalNews 对象
     */
    @Override
    public MedicalNews get(Serializable id) {
        return medicalNewsDao.selectById(id);
    }

    /**
     * 根据 ID 删除一个 MedicalNews 对象
     *
     * @param id 要删除的对象的主键 ID
     * @return 删除操作影响的行数（一般为1表示成功删除，0表示未找到）
     */
    @Override
    public int delete(Serializable id) {
        return medicalNewsDao.deleteById(id);
    }
}

定义了一个通用的服务接口 IService，用于处理不同实体类型的基本CRUD操作（创建、读取、更新、删除）。借助这个接口，具体的服务类可以实现这些操作来管理各种实体对象。该接口的主要用途包括：

通用性：通过使用泛型 <T>，该接口可以适用于任何类型的实体，从而为不同的实体类型提供一致的操作方法。

规范化：接口定义了一组标准方法，使得不同的服务实现遵循相同的操作规范，如保存、获取、删除、查询单个和查询所有实体对象。

代码复用：通过定义通用接口和继承此接口的具体服务类，可以避免重复实现相同的CRUD逻辑，提升代码的复用性和可维护性。

package com.SmartMed_Connect.service;

import java.io.Serializable;
import java.util.List;


public interface IService<T> {

    /**
     * 保存一个实体对象
     *
     * @param t 要保存的实体对象
     * @return 保存后的实体对象
     */
    T save(T t);

    /**
     * 根据主键获取一个实体对象
     *
     * @param id 实体对象的主键
     * @return 获取到的实体对象
     */
    T get(Serializable id);

    /**
     * 根据主键删除一个实体对象
     *
     * @param id 实体对象的主键
     * @return 删除操作影响的行数（一般为1表示成功删除，0表示未找到）
     */
    int delete(Serializable id);

    /**
     * 根据条件查询实体对象列表
     *
     * @param o 查询条件
     * @return 符合条件的实体对象列表
     */
    List<T> query(T o);

    /**
     * 查询所有的实体对象
     *
     * @return 所有的实体对象列表
     */
    List<T> all();
}