山东大学软件学院创新实训----后端开发10 MedicalService服务类实现

简介：

MedicineService 类是一个用于管理药品信息的服务类。它提供了增、删、改、查等基本操作以及根据药品名称或关键字模糊查询和分页功能。

实现内容：

1. 根据条件查询药品

query(Medicine o) 方法根据条件查询药品对象列表。使用 QueryWrapper 将查询条件封装为 SQL 语句，简化了复杂的查询逻辑。

    /**
     * 根据条件查询 Medicine 对象列表
     *
     * @param o 查询条件封装的 Medicine 对象
     * @return 符合条件的 Medicine 对象列表
     */
    @Override
    public List<Medicine> query(Medicine o) {
        QueryWrapper<Medicine> 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 medicineDao.selectList(wrapper);
    }

2. 查询所有药品

all() 方法调用 query(null) 来查询所有药品对象。此方法提供了简单的接口来获取全部药品数据。

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

3. 保存或更新药品

save(Medicine o) 方法根据药品对象的 ID 是否为空决定是插入新的药品还是更新已有药品。通过这种方式，我们可以统一处理保存和更新操作，简化了代码逻辑。

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

4. 获取药品

get(Serializable id) 方法根据药品的主键 ID 获取药品对象。这是一个简单的封装，提供了基于 ID 获取药品数据的接口。

@Override
public Medicine get(Serializable id) {
    return medicineDao.selectById(id);
}

5. 删除药品

delete(Serializable id) 方法根据药品的主键 ID 删除药品对象。此方法返回删除操作影响的行数，通常为 1 表示成功删除，0 表示未找到。

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

6. 查找药品列表并分页返回结果

getMedicineList(String nameValue, Integer page) 方法根据药品名称或关键字进行模糊查询，并分页返回结果。

public Map<String, Object> getMedicineList(String nameValue, Integer page) {
    List<Medicine> medicineList = null;
    Map<String, Object> map = new HashMap<>(4);

    if (Assert.notEmpty(nameValue)) {
        medicineList = medicineDao.selectList(new QueryWrapper<Medicine>()
                .like("medicine_name", nameValue)
                .or().like("keyword", nameValue)
                .or().like("medicine_effect", nameValue)
                .last("limit " + (page - 1) * 9 + "," + page * 9));
    } else {
        medicineList = medicineDao.selectList(new QueryWrapper<Medicine>()
                .last("limit " + (page - 1) * 9 + "," + page * 9));
    }

    map.put("medicineList", medicineList);
    map.put("size", medicineList.size() < 9 ? 1 : (medicineList.size() + 8) / 9);

    return map;
}

7. 查找单个药品的方法

findMedicineOne(Integer id) 方法根据药品 ID 查找药品，并返回包含药品信息和相关疾病信息的结果。

public Map<String, Object> findMedicineOne(Integer id) {
    // 查询 Medicine 表，根据 ID 查找药品
    Medicine medicine = medicineDao.selectOne(new QueryWrapper<Medicine>().eq("id", id));
    // 查询 IllnessMedicine 表，找到所有与该药品 ID 相关的疾病
    List<IllnessMedicine> illnessMedicines = illnessMedicineDao.selectList(new QueryWrapper<IllnessMedicine>().eq("medicine_id", id));
    // 初始化一个列表来存储疾病
    List<Illness> list = new ArrayList<>(4);
    // 初始化一个 Map 来存储返回结果
    Map<String, Object> map = new HashMap<>(4);
    // 查询 Pageview 表，根据药品 ID 查找页面浏览记录
    Pageview medicine_id = pageviewDao.selectOne(new QueryWrapper<Pageview>().eq("medicine_id", id));
    // 如果没有找到对应的页面浏览记录，创建一个新的记录并插入数据库
    if (Assert.isEmpty(medicine_id)) {
        medicine_id = new Pageview();
        medicine_id.setMedicineId(id);
        medicine_id.setPageviews(1);
        pageviewDao.insert(medicine_id);
    } else {
        // 如果找到了对应的页面浏览记录，更新浏览次数并保存
        medicine_id.setPageviews(medicine_id.getPageviews() + 1);
        pageviewDao.updateById(medicine_id);
    }
    // 将药品信息放入返回结果的 Map 中
    map.put("medicine", medicine);

    // 如果找到了相关的疾病，将每个疾病的信息放入列表中
    if (CollUtil.isNotEmpty(illnessMedicines)) {
        illnessMedicines.forEach(illnessMedicine -> {
            // 查询 Illness 表，根据疾病 ID 查找疾病
            Illness illness = illnessDao.selectOne(new QueryWrapper<Illness>().eq("id", illnessMedicine.getIllnessId()));
            // 如果疾病不为空，将其添加到列表中
            if (ObjectUtil.isNotNull(illness)) {
                list.add(illness);
            }
        });
        // 将疾病列表放入返回结果的 Map 中
        map.put("illness", list);
    }
    // 返回包含药品和疾病信息的 Map
    return map;
}

8. 获取单个药品的方法

getOne(QueryWrapper<Medicine> queryWrapper) 方法用于根据查询条件获取单个药品对象。

public Medicine getOne(QueryWrapper<Medicine> queryWrapper) {
    return medicineDao.selectOne(queryWrapper);
}

完整实现代码：

package com.SmartMed_Connect.service;

import com.SmartMed_Connect.dao.MedicineDao;
import com.SmartMed_Connect.entity.Medicine;
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.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class MedicineService extends BaseService<Medicine> {

    @Autowired
    protected MedicineDao medicineDao;

    /**
     * 根据条件查询 Medicine 对象列表
     *
     * @param o 查询条件封装的 Medicine 对象
     * @return 符合条件的 Medicine 对象列表
     */
    @Override
    public List<Medicine> query(Medicine o) {
        QueryWrapper<Medicine> 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 medicineDao.selectList(wrapper);
    }

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

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

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

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

    /**
     * 根据药品名称或关键字模糊查询药品列表，并分页返回结果
     *
     * @param nameValue 药品名称或关键字
     * @param page      分页页码
     * @return 包含药品列表和分页信息的 Map
     */
    public Map<String, Object> getMedicineList(String nameValue, Integer page) {

        List<Medicine> medicineList = null;
        Map<String, Object> map = new HashMap<>(4);
        // 根据传入的名称或关键字进行模糊查询，支持分页
        if (Assert.notEmpty(nameValue)) {
            medicineList = medicineDao.selectList(new QueryWrapper<Medicine>().
                    like("medicine_name", nameValue)
                    .or().like("keyword", nameValue)
                    .or().like("medicine_effect", nameValue)
                    .last("limit " + (page - 1) * 9 + "," + page * 9));
        } else {
            medicineList = medicineDao.selectList(new QueryWrapper<Medicine>()
                    .last("limit " + (page - 1) * 9 + "," + page * 9));
        }
        // 将查询结果放入返回的 Map 中
        map.put("medicineList", medicineList);
        // 计算分页总数，并放入返回的 Map 中
        map.put("size", medicineList.size() < 9 ? 1 : medicineList.size() / 9 + 1);
        return map;
    }
}