欧美日韩亚洲系列,成人福利电影,国产精品污www一区二区三区

基于java疫情防控管理系統

項目介紹：通過對依社區為單位進行人群的管理，以及疫苗的情況，包括小區狀況，通過RBAC進行角色與用戶之間的權限管理。

項目：環境-IDEA、Mysql數據庫，Tomcat服務器，SpringMVC，SpringBoot，AOP，攔截器，過濾器，全局異常，RBAC權限控制等。

1、登錄模塊(注冊）

Java 實戰項目之疫情防控管理系統詳解

核心代碼：service層

@Service
public class UserService extends BaseService<User,Integer> {
    @Resource
    //引入dao層
    private UserMapper userMapper;

    @Resource
    private UserRoleMapper userRoleMapper;

    @Resource
    private CommunityMapper communityMapper;


    //用戶登錄
    public UserModel userLogin(String userName,String userPwd){
        //對輸入的賬號密碼進行判斷，是否符合格式
        checkUserLoginParam(userName,userPwd);

        //通過對數據庫的查詢，查看用戶是否存在
        User temp =  userMapper.queryUserByUserName(userName);
        AssertUtil.isTrue(temp == null,"用戶不存在");

        //判斷用戶的密碼是否正確，拿數據庫查詢到的用戶密碼和用戶輸入的用戶密碼進行equest比較
        checkUserPwd(userPwd,temp.getUserPwd());

        //返回目標對象  對密碼進行加密
        return builderUserInfo(temp);
    }


    /**
     * //對輸入的賬號密碼進行判斷  是否符合格式
     * @param userName   賬號
     * @param userPwd    密碼
     */
    //對輸入的賬號密碼進行判斷，是否符合格式
    private void checkUserLoginParam(String userName, String userPwd) {
        //用戶非空
        AssertUtil.isTrue(StringUtils.isBlank(userName),"用戶名不能為空");

        //密碼非空
        AssertUtil.isTrue(StringUtils.isBlank(userPwd),"密碼不能為空");
    }



    /**
     * //判斷密碼是否正確
     * @param userPwd   用戶輸入的密碼
     * @param userPwd1  數據庫查出來的密碼
     */
    //判斷用戶的密碼是否正確，拿數據庫查詢到的用戶密碼和用戶輸入的用戶密碼進行equest比較
    private void checkUserPwd(String userPwd, String userPwd1) {
        //對用戶輸入的密碼進行加密
        userPwd = Md5Util.encode(userPwd);

        AssertUtil.isTrue(!(userPwd.equals(userPwd1)),"密碼不正確");



    }

    /**
     *
     * @param temp 當前登錄對象
     * @return
     */
    //對密碼進行加密  返回目標對象
    private UserModel builderUserInfo(User temp) {
        UserModel userModel = new UserModel();
        //為用戶密碼進行加密
        userModel.setUserIdStr(UserIDBase64.encoderUserID(temp.getId()));
        userModel.setUserName(temp.getUserName());
        userModel.setTrueName(temp.getTrueName());
        return userModel;

    }


    /**
     *
     * @param userId                 當前Cookie存儲的用戶dId
     * @param oldPassword           舊密碼
     * @param newPassword           新密碼
     * @param confirmPassword            確認密碼
     */
    //修改密碼
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateUserPassword(Integer userId, String oldPassword, String newPassword, String confirmPassword) {
        //通過Id獲取user對象
        User user = userMapper.selectByPrimaryKey(userId);
        //參數校驗 (用戶，舊密碼，新密碼，確認密碼)
        checkPasswordParams(user,oldPassword,newPassword,confirmPassword);

        //默認參數設置，把用戶輸入的新密碼  加密 添加進去
        user.setUserPwd(Md5Util.encode(newPassword));

        //執行更新操作
        AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"修改密碼失敗");
    }


    //修改密碼的參數校驗
    private void checkPasswordParams(User user, String oldPassword, String newPassword, String confirmPwd) {
        //用戶不能為空  （不存在）
        AssertUtil.isTrue(null == user,"用戶不存在");
        //原始密碼  非空
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        AssertUtil.isTrue(StringUtils.isBlank(oldPassword),"原始密碼不能為空");
        //原始密碼是否和數據庫查詢到的密碼一致
        AssertUtil.isTrue(!(Md5Util.encode(oldPassword).equals(user.getUserPwd())),"原始密碼不正確");
        //新密碼不能為空
        AssertUtil.isTrue(StringUtils.isBlank(newPassword),"新密碼不能為空");
        //新密碼和原始密碼不能相同
        AssertUtil.isTrue(oldPassword.equals(newPassword),"新密碼不能和原始密碼相同");
        //確認密碼非空
        AssertUtil.isTrue(StringUtils.isBlank(confirmPwd),"確認密碼不能為空");
        //確認密碼需要和新密碼一致
        AssertUtil.isTrue(!(newPassword.equals(confirmPwd)),"新密碼和確認密碼不一致");
    }

    /**
     * 多條件分頁查詢用戶數據
     * @param query
     * @return
     */
    public Map<String, Object> queryUserByParams (UserQuery query) {
        Map<String, Object> map = new HashMap<>();
        PageHelper.startPage(query.getPage(), query.getLimit());
        PageInfo<User> pageInfo = new PageInfo<>(userMapper.selectByParams(query));
        map.put("code",0);
        map.put("msg", "");
        map.put("count", pageInfo.getTotal());
        map.put("data", pageInfo.getList());
        System.out.println("執行完畢");
        return map;
    }

    /**
     * 添加用戶
     * @param user
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void saveUser(User user){
        //參數校驗
        checkParams(user.getUserName(),user.getComId(),user.getVc());
        //設置默認參數
        user.setCreateDate(new Date());
        user.setUpdateDate(new Date());
        user.setUserPwd(Md5Util.encode("123456"));
        //執行添加，判斷結果
        AssertUtil.isTrue(userMapper.insertSelective(user)==null,"用戶添加失敗！");
        relaionUserRole(user.getId(),user.getRoleIds());
        AssertUtil.isTrue(communityMapper.addNumByComId(user.getComId())<1, "社區用戶添加失敗");
    }

    /**
     * 用戶更新，修改
     * @param user
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateUser(User user){
        //1.參數校驗
        //通過用戶id獲取用戶對象
        User temp=userMapper.selectByPrimaryKey(user.getId());
        //判斷對象是否存在
        AssertUtil.isTrue(temp==null,"待更新記錄不存在");
        //驗證參數
        checkParams1(user.getUserName(),user.getComId(),user.getVc());
        //2.設置默認參數
        user.setUpdateDate(new Date());
        //3.執行更新，返回結果
        AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user)<1,"用戶更新失敗！");
        relaionUserRole(user.getId(),user.getRoleIds());
    }

    private void checkParams(String userName, Integer comId, Integer vc) {
        AssertUtil.isTrue(StringUtils.isBlank(userName),"用戶名不能為空");
        //驗證用戶是否存在
        User temp=userMapper.queryUserByUserName(userName);
        AssertUtil.isTrue(temp!=null,"用戶名已存在");
        AssertUtil.isTrue(comId==null,"請輸入所在社區");
        AssertUtil.isTrue(vc==null,"請選擇疫苗接種狀況");
    }

    private void checkParams1(String userName, Integer comId, Integer vc) {
        AssertUtil.isTrue(StringUtils.isBlank(userName),"用戶名不能為空");
        //驗證用戶是否存在
        AssertUtil.isTrue(comId==null,"請輸入所在社區");
        AssertUtil.isTrue(vc==null,"請選擇疫苗接種狀況");
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void deleteUser(Integer[] ids){
        AssertUtil.isTrue(ids==null||ids.length==0,"請選擇您要刪除的記錄");
        for (int id:ids){
            User user=userMapper.selectByPrimaryKey(id);
            AssertUtil.isTrue(communityMapper.subNumByComId(user.getComId())!=ids.length, "社區用戶刪除失敗");
        }
        AssertUtil.isTrue(deleteBatch(ids) != ids.length,"用戶角色刪除失敗");
    }


    /*SZC*/
    /**
     * 用戶注冊
     * @param userName
     * @param password1
     * @param password2
     * @param icon
     */
    public void registerUser(String userName, String password1, String password2, String icon) {
        // 參數校驗
        checkRegister(userName, password1, password2, icon);
        // 實例化user
        User user = new User();
        //設置默認參數
        user.setUserName(userName);
        user.setUserPwd(Md5Util.encode(password1));
        user.setUserPhone(icon);
        user.setCreateDate(new Date());
        user.setUpdateDate(new Date());
        // 執行方法
        AssertUtil.isTrue(userMapper.insertSelective(user)<1, "用戶添加失敗");
    }

    /**
     * 用戶注冊的參數校驗
     * @param userName
     * @param password1
     * @param password2
     * @param icon
     */
    private void checkRegister(String userName, String password1, String password2, String icon) {
        // 用戶名不為空
        AssertUtil.isTrue(StringUtils.isBlank(userName), "請輸入用戶名");
        // 判斷用戶名是否存在
        User user1 = userMapper.selectByName(userName);
        AssertUtil.isTrue(user1!=null, "該用戶已存在");
        // 判斷手機號是否存在
        User user2 = userMapper.selectByPhone(icon);
        AssertUtil.isTrue(user2!=null, "該手機號已注冊過賬號");
        // 密碼不為空
        AssertUtil.isTrue(StringUtils.isBlank(password1), "請輸入密碼");
        // 確認密碼不為空
        AssertUtil.isTrue(StringUtils.isBlank(password2), "請輸入確認密碼");
        // 密碼長度校驗
        AssertUtil.isTrue(password1.length()<6 || password1.length()>12, "密碼長度為6-12位");
        // 密碼和確認密碼相等
        AssertUtil.isTrue(!password1.equals(password2), "確認密碼與密碼不一致");
        // 手機號合法
        AssertUtil.isTrue(!PhoneUtil.isMobile(icon), "請輸入正確的手機號");
    }

    /**
     * 刪除用戶原先的角色，并重新賦予新的角色
     * @param userId
     * @param roleIds
     */
    private void relaionUserRole(int userId, String roleIds) {
        // 通過id獲取用戶的角色數量
        int count = userRoleMapper.countUserRoleByUserId(userId);
        // count>0  說明用戶原先有角色  先刪除所有的角色
        if (count>0) {
            AssertUtil.isTrue(userRoleMapper.deleteUserRoleByUserId(userId)!=count, "用戶角色刪除失敗");
        }
        // 傳入的角色信息不為空 添加新的角色
        if (StringUtils.isNoneBlank(roleIds)) {
            // 將傳入的roleIds轉成字符串數組
            String[] roleStrIds = roleIds.split(",");
            // 用來存放用戶的角色信息
            List<UserRole> roleList = new ArrayList<>();
            // 遍歷roleIds
            for (String rid : roleStrIds) {
                // 準備對象
                UserRole userRole = new UserRole();
                userRole.setUserId(userId);
                userRole.setRoleId(Integer.parseInt(rid));
                userRole.setCreateDate(new Date());
                userRole.setUpdateDate(new Date());
                roleList.add(userRole);
            }
            AssertUtil.isTrue(userRoleMapper.insertBatch(roleList) != roleList.size(), "用戶角色分配失敗");
        }

    }

}

Java 實戰項目之疫情防控管理系統詳解

2、今日疫情模塊

Java 實戰項目之疫情防控管理系統詳解

核心代碼Service

@Service
public class ConfirmedService extends BaseService<Confirmed,Integer> {

    @Resource
    //引入ConfirmedMapper
    private ConfirmedMapper confirmedMapper;

    @Resource
    //引入user表
    private UserMapper userMapper;

    @Resource
    //引入user表
    private CommunityMapper  communityMapper;

    //角色的條件查詢以及 分頁
    public Map<String,Object> findRoleByParam(ConfirmedQuery confirmedQuery){
        //實例化對象
        Map<String,Object> map = new HashMap<>();
        //實例化分頁單位
        PageHelper.startPage(confirmedQuery.getPage(), confirmedQuery.getLimit());
        //開始分頁
        PageInfo<Confirmed> rlist = new PageInfo<>(selectByParams(confirmedQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("count",rlist.getTotal());
        map.put("data",rlist.getList());
        //返回Map
        return map;
    }


    @Transactional(propagation = Propagation.REQUIRED)           //涉及到事務   就需要此注解
    //用戶模塊的添加
    public void addUser(Confirmed user) {
        //1、參數校驗
        checkConfirmed(user.getTrueName(),user.getState());

        if (user.getComId().equals("浦東區")){
            user.setComId(1);
        }
        if (user.getComId().equals("黃浦區")){
            user.setComId(2);
        }
        if (user.getComId().equals("松江區")){
            user.setComId(3);
        }
        if (user.getComId().equals("徐匯區")){
            user.setComId(4);
        }
        if (user.getComId().equals("虹口區")){
            user.setComId(5);
        }

        //查詢user表中是否存在此人  不存在   添加上去  設置默認值
        User temp =  userMapper.selectByPhone(user.getTcPhone());
       //   手機號查詢用戶
        if (temp != null){
            //健康狀態改成2    如果user表里面已經有了的情況下
            userMapper.updateUserHealthById(temp.getUserPhone());
            //默認值  確診表中的userId字段
            user.setUserId(temp.getId());

        }else {          //表里沒有這個人的時候  添加 這個用戶  新建一個user對象
            User u = new User();
            //真實姓名
            u.setTrueName(user.getTrueName());
            //名字
            u.setUserName(user.getTrueName());
            //設置密碼  默認值  ：123456
            u.setUserPwd(Md5Util.encode("123456"));

            //設置社區ID
            u.setComId(user.getComId());

            //手機號  唯一
            u.setUserPhone(user.getTcPhone());
            u.setEcPhone(user.getTcPhone());
            u.setHealth("2");
            //創建時間
            u.setCreateDate(new Date());
            //修改時間
            u.setUpdateDate(new Date());

            //添加用戶是否成功
            AssertUtil.isTrue(userMapper.insertSelective(u)<1,"插入用戶失敗");

            //給確診人員添加其  userId
            Integer userId =  userMapper.selectById(user.getTcPhone());
            user.setUserId(userId);
        }

        //2、默認值設置
        //確診日期
        user.setCreateDate(new Date());

        //添加是否成功
        AssertUtil.isTrue(insertSelective(user)<1,"添加失敗");

        //relaionUserRole(user.getId(),user.getComId());


    }


    @Transactional(propagation = Propagation.REQUIRED)           //涉及到事務   就需要此注解
    //用戶模塊的修改
    public void changeUser(Confirmed user) {
        //通過id獲取用戶信息
        Confirmed temp = confirmedMapper.selectByPrimaryKey(user.getId());
        //判斷用戶信息是否存在
        AssertUtil.isTrue(temp == null,"當前用戶不存在");

        //校驗參數
        changeConfirmed(user.getTrueName(),user.getTcPhone(),user.getState());

        //修改是否成功  完整版
        //AssertUtil.isTrue(updateByPrimaryKeySelective(user)<1,"修改失敗了");


        //修改是否成功  完整版
        AssertUtil.isTrue(confirmedMapper.uBPKS(user)<1,"修改失敗了");

    }

    //修改的參數校驗
    private void changeConfirmed(String trueName, String tcPhone, Integer state) {
        //1、用戶名不能為空
        AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能為空");
        //2、當前狀態不能為空
        AssertUtil.isTrue(StringUtils.isBlank(tcPhone),"請輸入手機號");
        //3、當前狀態不能為空
        AssertUtil.isTrue(state<1 || state>4,"請選擇正確的狀態碼");
    }

    //用戶模塊的添加的參數校驗
    private void checkConfirmed(String trueName, Integer state) {
        //1、用戶名不能為空
        AssertUtil.isTrue(StringUtils.isBlank(trueName),"姓名不能為空");
        //2、當前狀態不能為空
        AssertUtil.isTrue(state<1 || state>3,"請選擇正確的狀態碼");
    }

    //添加社區時的校驗
    private void relaionUserRole(Integer id, Integer comId) {
        //準備集合  存儲對象
        List<Community> urlist = new ArrayList<>();

        //userId,roleId
        //判斷是否選擇了角色信息

        //只能選擇一個社區
        AssertUtil.isTrue(comId>1 || comId<1,"只能選擇一個社區");

        //通過社區表的 com_id    查詢到社區表的對應社區名
        communityMapper.selectaddresComId(comId);
        //添加

    }

    @Transactional(propagation = Propagation.REQUIRED)           //涉及到事務   就需要此注解
    //確診人員的批量刪除
    public void deleteUserByIds(Integer[] ids) {
        //要刪除記錄不能為空
        AssertUtil.isTrue(ids == null || ids.length==0,"請選擇要刪除的記錄");

        //修改user表的狀態碼
        for(Integer id: ids){
            Confirmed confirmed = confirmedMapper.selectId(id);
            System.out.println(id+ " -----------------" );
            System.out.println(confirmed.getTrueName());
            AssertUtil.isTrue(userMapper.updateById(confirmed.getUserId())<1,"修改失敗");
        }

        //刪除確診表的個人信息記錄
        AssertUtil.isTrue(deleteBatch(ids)!=ids.length,"刪除失敗");
    }

    //查詢所有社區
    public List<Map<String, Object>> queryComs() {
        return confirmedMapper.selectComs();
    }
   
}

3、防疫管理模塊

Java 實戰項目之疫情防控管理系統詳解

核心代碼Service:

@Service
public class CommunityService extends BaseService<Community,Integer> {
    @Resource
    private CommunityMapper communityMapper;

    /**
     * 多條件分頁查詢
     * @param query
     * @return
     */
    public Map<String,Object> queryComByParams(CommunityQuery query){
        Map<String,Object> map=new HashMap<>();
        //初始化分頁
        PageHelper.startPage(query.getPage(), query.getLimit());
        //開始分頁
        PageInfo<Community> pageInfo=new PageInfo<>(communityMapper.selectByParams(query));
        //準備數據
        map.put("code",0);
        map.put("msg","");
        map.put("count",pageInfo.getTotal());
        map.put("data",pageInfo.getList());
        return map;
    }

    //查詢所有角色信息
    public List<Map<String, Object>> findRoles(Integer userId) {
        return communityMapper.selectRoles(userId);
    }

}

//============================================================
@Service
public class VaccinationService {

    @Resource
    VaccinationMapper vaccinationMapper;

    /*多條件查詢*/
    public Map<String,Object> selectAll(VaccinationQuery vaccinationQuery) {
        //創建map
        Map<String,Object> map =new HashMap<String,Object>();
        //查數據并分頁
        PageHelper.startPage(vaccinationQuery.getPage(),vaccinationQuery.getLimit());
        PageInfo<Vaccination> pageInfo=new PageInfo<>(vaccinationMapper.selectByParams(vaccinationQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("data",pageInfo.getList());
        map.put("count",pageInfo.getTotal());

        return map;
    }
    /*通過ID獲取對象*/
    public Vaccination selectId(Integer id) {
        return vaccinationMapper.selectById(id);
    }

    /*添加*/
    @Transactional(propagation = Propagation.REQUIRED)
    public void insertVaccination(Vaccination vaccination) {
        //審核
        checkOK(vaccination);
        vaccination.setFirstDate(new Date());
        vaccination.setSecondDate(new Date());
        //插入
        AssertUtil.isTrue(vaccinationMapper.insertSelective(vaccination)<1,"插入失敗");
    }

    private void checkOK(Vaccination vaccinatio){
        AssertUtil.isTrue(vaccinatio==null,"請輸入添加的角色");
        AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getTrueName()),"用戶名不能為空");
        AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getFirst()),"請填寫(是/否)");
        AssertUtil.isTrue(StringUtils.isBlank(vaccinatio.getSecond()),"請填寫(是/否)");
    }

    /*刪除*/
    public void delete(Integer[] ids) {
        AssertUtil.isTrue(ids==null||ids.length==0,"請選擇要刪除的用戶");
        AssertUtil.isTrue(vaccinationMapper.deleteVa(ids)!=ids.length,"刪除失敗~~~");
    }

    /*編輯*/
    public void updateVa(Vaccination vaccination) {
        checkOK(vaccination);
        if(vaccination.getFirst()==null||"否".equals(vaccination.getFirst())){
            vaccination.setFirstDate(null);
        }
        if(vaccination.getSecond()==null||"否".equals(vaccination.getSecond())){
            vaccination.setSecondDate(null);
        }
        if("是".equals(vaccination.getFirst())){
            vaccination.setFirstDate(new Date());
        }
        if("是".equals(vaccination.getSecond())){
            vaccination.setSecondDate(new Date());
        }
        AssertUtil.isTrue(vaccinationMapper.updateByPrimaryKeySelective(vaccination)<1,"修改失敗~");

    }
}

4、系統管理模塊

Java 實戰項目之疫情防控管理系統詳解

核心代碼：Service：

@Service
public class RoleService extends BaseService<Role,Integer> {


    @Autowired(required = false)
    RoleMapper roleMapper;

    @Autowired(required = false)
    RoleQuery roleQuery;

    @Resource
    private ModuleMapper moduleMapper;

    @Resource
    private PermissionMapper permissionMapper;

    /*多條件查詢*/
    public Map<String,Object> selectRole(RoleQuery roleQuery){
        //創建map
        Map<String,Object> map =new HashMap<String,Object>();
        //查數據并分頁
        PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());
        PageInfo<Role> pageInfo=new PageInfo<>(roleMapper.selectByParams(roleQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("data",pageInfo.getList());
        map.put("count",pageInfo.getTotal());
        return map;
    }

    /*添加角色*/
    @Transactional(propagation = Propagation.REQUIRED)
    public void insertRole(Role role) {
        //審核
        checkRole(role);
        //添加
        role.setCreateDate(new Date());
        role.setUpdateDate(new Date());
        System.out.println("就差一點！！！！");
        AssertUtil.isTrue(insertSelective(role)<1,"添加失敗了呢~");
    }
    private void checkRole(Role role) {
        //是否為空
        AssertUtil.isTrue(role==null,"請輸入角色信息~");
        //判斷是否已經重復
        System.out.println("判斷");
        Role role1= roleMapper.selectByName(role.getRoleName());
        System.out.println("判斷結束");
        System.out.println(role1!=null);
        AssertUtil.isTrue(role1!=null,"已添加過啦~");
        System.out.println("退出@");
    }
    /*編輯角色*/
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateRole(Role role) {
        role.setUpdateDate(new Date());
        AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"編輯失敗啦~");
    }

    /**
     * 刪除角色信息
     * @param role
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void deleteRole(Role role) {
        // 驗證
        AssertUtil.isTrue(role.getId()==null || selectByPrimaryKey(role.getId())==null, "待刪除角色不存在");
        // 設定默認值
        role.setUpdateDate(new Date());
        // 刪除角色綁定的權限資源
        int count = roleMapper.countPermissionByRoleId(role.getId());
        if (count>0) {
            int i = roleMapper.deletePermissionsByRoleId(role.getId());
            AssertUtil.isTrue(i!=count, "角色綁定的權限資源刪除失敗");
        }
        // 判斷是否成功
        AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色刪除失敗");
    }

    /**
     * 查詢所有角色
     * @return
     */
    public List<Map<String, Object>> seleceAllRole(Integer userId) {
        return roleMapper.seleceAllRole(userId);
    }

    /**
     * 給角色添加權限
     * @param mids
     * @param roleId
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void addGrant(Integer[] mids, Integer roleId) {
        // 判斷roleId是否存在
        AssertUtil.isTrue(roleId==null || roleMapper.selectByPrimaryKey(roleId)==null, "待授權的角色不存在");
        // 統計當前角色的權限資源數量
        int count = roleMapper.countPermissionByRoleId(roleId);
        if (count>0) {
            // 如果角色存在權限資源，就全部刪除
            int num = roleMapper.deletePermissionsByRoleId(roleId);
            AssertUtil.isTrue(count!=num, "資源刪除失敗");
        }
        List<Permission> plist = new ArrayList<>();
        if (mids!=null && mids.length!=0) {
            // 遍歷mids
            for (Integer mid : mids) {
                // 實例化對象
                Permission permission = new Permission();
                // 設置數據
                permission.setRoleId(roleId);
                permission.setModuleId(mid);
                // 權限碼
                permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());
                permission.setCreateDate(new Date());
                permission.setUpdateDate(new Date());
                // 添加到list
                plist.add(permission);
            }
        }
        AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(), "角色權限更新失敗");
    }
}

5、用戶模塊

Java 實戰項目之疫情防控管理系統詳解

核心代碼Service:

@Service
public class RoleService extends BaseService<Role,Integer> {

    @Autowired(required = false)
    RoleMapper roleMapper;

    @Autowired(required = false)
    RoleQuery roleQuery;

    @Resource
    private ModuleMapper moduleMapper;

    @Resource
    private PermissionMapper permissionMapper;

    /*多條件查詢*/
    public Map<String,Object> selectRole(RoleQuery roleQuery){
        //創建map
        Map<String,Object> map =new HashMap<String,Object>();
        //查數據并分頁
        PageHelper.startPage(roleQuery.getPage(),roleQuery.getLimit());
        PageInfo<Role> pageInfo=new PageInfo<>(roleMapper.selectByParams(roleQuery));
        map.put("code",0);
        map.put("msg","success");
        map.put("data",pageInfo.getList());
        map.put("count",pageInfo.getTotal());
        return map;
    }

    /*添加角色*/
    @Transactional(propagation = Propagation.REQUIRED)
    public void insertRole(Role role) {
        //審核
        checkRole(role);
        //添加
        role.setCreateDate(new Date());
        role.setUpdateDate(new Date());
        System.out.println("就差一點！！！！");
        AssertUtil.isTrue(insertSelective(role)<1,"添加失敗了呢~");
    }
    private void checkRole(Role role) {
        //是否為空
        AssertUtil.isTrue(role==null,"請輸入角色信息~");
        //判斷是否已經重復
        System.out.println("判斷");
        Role role1= roleMapper.selectByName(role.getRoleName());
        System.out.println("判斷結束");
        System.out.println(role1!=null);
        AssertUtil.isTrue(role1!=null,"已添加過啦~");
        System.out.println("退出@");
    }
    /*編輯角色*/
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateRole(Role role) {
        role.setUpdateDate(new Date());
        AssertUtil.isTrue(updateByPrimaryKeySelective(role)<1,"編輯失敗啦~");
    }

    /**
     * 刪除角色信息
     * @param role
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void deleteRole(Role role) {
        // 驗證
        AssertUtil.isTrue(role.getId()==null || selectByPrimaryKey(role.getId())==null, "待刪除角色不存在");
        // 設定默認值
        role.setUpdateDate(new Date());
        // 刪除角色綁定的權限資源
        int count = roleMapper.countPermissionByRoleId(role.getId());
        if (count>0) {
            int i = roleMapper.deletePermissionsByRoleId(role.getId());
            AssertUtil.isTrue(i!=count, "角色綁定的權限資源刪除失敗");
        }
        // 判斷是否成功
        AssertUtil.isTrue(roleMapper.updateRoleById(role.getId())<1, "角色刪除失敗");
    }

    /**
     * 查詢所有角色
     * @return
     */
    public List<Map<String, Object>> seleceAllRole(Integer userId) {
        return roleMapper.seleceAllRole(userId);
    }

    /**
     * 給角色添加權限
     * @param mids
     * @param roleId
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void addGrant(Integer[] mids, Integer roleId) {
        // 判斷roleId是否存在
        AssertUtil.isTrue(roleId==null || roleMapper.selectByPrimaryKey(roleId)==null, "待授權的角色不存在");
        // 統計當前角色的權限資源數量
        int count = roleMapper.countPermissionByRoleId(roleId);
        if (count>0) {
            // 如果角色存在權限資源，就全部刪除
            int num = roleMapper.deletePermissionsByRoleId(roleId);
            AssertUtil.isTrue(count!=num, "資源刪除失敗");
        }
        List<Permission> plist = new ArrayList<>();
        if (mids!=null && mids.length!=0) {
            // 遍歷mids
            for (Integer mid : mids) {
                // 實例化對象
                Permission permission = new Permission();
                // 設置數據
                permission.setRoleId(roleId);
                permission.setModuleId(mid);
                // 權限碼
                permission.setAclValue(moduleMapper.selectByPrimaryKey(mid).getOptValue());
                permission.setCreateDate(new Date());
                permission.setUpdateDate(new Date());
                // 添加到list
                plist.add(permission);
            }
        }
        AssertUtil.isTrue(permissionMapper.insertBatch(plist)!=plist.size(), "角色權限更新失敗");
    }
}

大概就是這樣，管理系統，基本都差不多，比如圖書管理，CRM等，詳細源碼見文件上傳~

到此這篇關于Java 實戰項目之疫情防控管理系統詳解的文章就介紹到這了,更多相關Java 疫情防控管理系統內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！

原文鏈接：https://blog.csdn.net/llAl_lAll/article/details/121065156