JAVA项目实战-shrio框架使用（二）

本节介绍利用shiro框架完成用户模块,角色模块接口

1.数据库实体对象

package com.sf.detectcore.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;

@TableName(value = "sys_menu")
public class SysMenu implements Serializable {

    @TableId(type = IdType.AUTO,value = "menu_id")
    private Long menuId;

    private String name;

    private String icon;

    private Long parentId;

    private Byte status;

    private String identity;

    private static final long serialVersionUID = 1L;

    public Long getMenuId() {
        return menuId;
    }

    public void setMenuId(Long menuId) {
        this.menuId = menuId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getIcon() {
        return icon;
    }

    public void setIcon(String icon) {
        this.icon = icon == null ? null : icon.trim();
    }

    public Long getParentId() {
        return parentId;
    }

    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }

    public Byte getStatus() {
        return status;
    }

    public void setStatus(Byte status) {
        this.status = status;
    }


    @Override
    public String toString() {
        return "SysMenu{" +
                "menuId=" + menuId +
                ", name='" + name + '\'' +
                ", icon='" + icon + '\'' +
                ", parentId=" + parentId +
                ", status=" + status +
                ", identity='" + identity + '\'' +
                '}';
    }
}

package com.sf.detectcore.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

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

@TableName(value = "sys_permission")
public class SysPermission implements Serializable {

    @TableId(type = IdType.AUTO,value = "permission_id")
    private Long permissionId;

    private String name;

    private String sn;

    private String resources;

    private Long parentId;

    private Long menuId;

    private Byte status;

    /**
     * 子权限
     */
    @TableField(exist = false)
    private List children;

    private static final long serialVersionUID = 1L;

    public Long getPermissionId() {
        return permissionId;
    }

    public void setPermissionId(Long permissionId) {
        this.permissionId = permissionId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getSn() {
        return sn;
    }

    public void setSn(String sn) {
        this.sn = sn == null ? null : sn.trim();
    }

    public String getResources() {
        return resources;
    }

    public void setResources(String resources) {
        this.resources = resources == null ? null : resources.trim();
    }

    public Long getParentId() {
        return parentId;
    }

    public void setParentId(Long parentId) {
        this.parentId = parentId;
    }

    public Long getMenuId() {
        return menuId;
    }

    public void setMenuId(Long menuId) {
        this.menuId = menuId;
    }

    public Byte getStatus() {
        return status;
    }

    public void setStatus(Byte status) {
        this.status = status;
    }

    public List getChildren() { return children; }

    public void setChildren(List children) { this.children = children; }
}

package com.sf.detectcore.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

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

@Data
@TableName(value = "sys_role")
public class SysRole implements Serializable {

    @TableId(type = IdType.AUTO,value = "role_id")
    private Long roleId;

    private String name;

    private String remarks;

    private Byte status;

    private Date createTime;

    private Long createId;

    private Date updateTime;

    private Long updateId;

    /**
     * 角色所拥有的权限id集合
     */
    @TableField(exist = false)
    private List permissionIds;

    /**
     * 角色所拥有的权限集合
     */
    @TableField(exist = false)
    private List permissions;

    private static final long serialVersionUID = 1L;

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getRemarks() {
        return remarks;
    }

    public void setRemarks(String remarks) {
        this.remarks = remarks == null ? null : remarks.trim();
    }

    public Byte getStatus() {
        return status;
    }

    public void setStatus(Byte status) {
        this.status = status;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Long getCreateId() {
        return createId;
    }

    public void setCreateId(Long createId) {
        this.createId = createId;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public Long getUpdateId() {
        return updateId;
    }

    public void setUpdateId(Long updateId) {
        this.updateId = updateId;
    }

    public List getPermissionIds() { return permissionIds; }

    public void setPermissionIds(List permissionIds) { this.permissionIds = permissionIds; }

    public List getPermissions() { return permissions; }

    public void setPermissions(List permissions) { this.permissions = permissions; }
}

package com.sf.detectcore.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.io.Serializable;

@TableName(value = "sys_role_permission")
public class SysRolePermission implements Serializable {

    @TableId(type = IdType.AUTO,value = "id")
    private Long id;

    private Long roleId;

    private Long permissionId;

    private static final long serialVersionUID = 1L;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }

    public Long getPermissionId() {
        return permissionId;
    }

    public void setPermissionId(Long permissionId) {
        this.permissionId = permissionId;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(getClass().getSimpleName());
        sb.append(" [");
        sb.append("Hash = ").append(hashCode());
        sb.append(", id=").append(id);
        sb.append(", roleId=").append(roleId);
        sb.append(", permissionId=").append(permissionId);
        sb.append(", serialVersionUID=").append(serialVersionUID);
        sb.append("]");
        return sb.toString();
    }
}

package com.sf.detectcore.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;

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

@TableName(value = "sys_user")
public class SysUser implements Serializable {

    @TableId(type = IdType.AUTO,value = "user_id")
    private Long userId;

    private String name;

    private String account;

    @JsonIgnore
    private String password;

    private Integer status;

    private Date createTime;

    private Long createId;

    private Date updateTime;

    private Long updateId;


    private Long labId;

    /**
     * 角色ID集合
     */
    @TableField(exist = false)
    private List roleIds;

    /**
     * 角色ID集合
     */
    @TableField(exist = false)
    private Long roleId;

    /**
     * 角色名字
     */
    @TableField(exist = false)
    private String roleName;


    /**
     * 实验室名字
     */
    @TableField(exist = false)
    private String labName;

    private static final long serialVersionUID = 1L;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account == null ? null : account.trim();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password == null ? null : password.trim();
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Long getCreateId() {
        return createId;
    }

    public void setCreateId(Long createId) {
        this.createId = createId;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public Long getUpdateId() {
        return updateId;
    }

    public void setUpdateId(Long updateId) {
        this.updateId = updateId;
    }

    public List getRoleIds() { return roleIds; }

    public void setRoleIds(List roleIds) { this.roleIds = roleIds; }


    public Long getLabId() {
        return labId;
    }

    public void setLabId(Long labId) {
        this.labId = labId;
    }

    public String getLabName() {
        return labName;
    }

    public void setLabName(String labName) {
        this.labName = labName;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public Long getRoleId() {
        return roleId;
    }

    public void setRoleId(Long roleId) {
        this.roleId = roleId;
    }
}

2.mapper.xml

  
    
    
    
    
    
    
  

  
  
    
      SELECT LAST_INSERT_ID()
    
    insert into m_menu (`name`, icon, parent_id,
    `status`)
    values (#{name,jdbcType=VARCHAR}, #{icon,jdbcType=VARCHAR}, #{parentId,jdbcType=BIGINT},
    #{status,jdbcType=TINYINT})
  

  
    
    
    
    
  

  
  
    SELECT  m1.menu_id menuId, m1.name name, m1.icon icon,m1.parent_id parentId ,m1.identity
    FROM sys_menu m1
    JOIN sys_permission t1  ON m1.menu_id = t1.menu_id
    JOIN sys_role_permission t2 ON t1.permission_id = t2.permission_id
    JOIN  sys_role t3 ON t2.role_id = t3.role_id
    JOIN  sys_user_role t4 ON t3.role_id = t4.role_id
    JOIN  sys_user t5 ON t4.user_id = t5.user_id
    WHERE t5.user_id = #{userId} AND m1.`status` = 0
    ORDER BY m1.menu_id ASC
  


  
  
    select m.menu_id menuId, m.name name, m.icon icon,m.parent_id parentId ,m.identity identity FROM sys_menu m
    where m.parent_id = #{parentId}
  

  
    
    
    
    
    
    
    
  

  
  
    SELECT DISTINCT * FROM(
    SELECT p.* FROM sys_permission p
    LEFT JOIN sys_role_permission rp ON p.permission_id = rp.permission_id
    WHERE rp.role_id in
    
      #{id}
    
    AND p.`status` = 0 AND p.sn IS NOT NULL
    ORDER BY p.permission_id
    ) a
  

  
  
    select permission_id, `name`, sn, resources, parent_id, menu_id, `status` from sys_permission
    WHERE `status` = 0 AND sn IS NOT NULL AND resources IS NOT NULL
  

  
  
    select permission_id, `name`, sn, resources, parent_id, menu_id, `status`
    from sys_permission
    where permission_id = #{permissionId,jdbcType=BIGINT}
  


  
  
    select role_id from sys_user_role WHERE user_id = #{userId}
  


  
  
    select permission_id from sys_role_permission WHERE role_id = #{roleId}
  


  
  
    select permission_id, `name`, sn, resources, parent_id, menu_id, `status` from sys_permission
    where permission_id = #{permId}
          and parent_id is not null
          and menu_id is not null
  


  
  
    select permission_id, `name`, sn, resources, parent_id, menu_id, `status` from sys_permission
    where parent_id = #{parentPermId}
    and permission_id in
    
      #{id}
    
  

  
    
    
    
    
    
    
    
    
  


  
  
    
      SELECT LAST_INSERT_ID()
    
    insert into sys_role (`name`, remarks, `status`,
    create_time, create_id, update_time,
    update_id)
    values (#{name,jdbcType=VARCHAR}, #{remarks,jdbcType=VARCHAR}, #{status,jdbcType=TINYINT},
    #{createTime,jdbcType=TIMESTAMP}, #{createId,jdbcType=BIGINT}, #{updateTime,jdbcType=TIMESTAMP},
    #{updateId,jdbcType=BIGINT})
  

  
  
    SELECT r.* FROM sys_role r
    LEFT JOIN sys_user_role ur ON r.role_id = ur.role_id
    WHERE ur.user_id = #{id} AND r.`status` = 0
  

  
  
    update sys_role
    set `name` = #{name,jdbcType=VARCHAR},
      remarks = #{remarks,jdbcType=VARCHAR},
      `status` = #{status,jdbcType=TINYINT},
      create_time = #{createTime,jdbcType=TIMESTAMP},
      create_id = #{createId,jdbcType=BIGINT},
      update_time = #{updateTime,jdbcType=TIMESTAMP},
      update_id = #{updateId,jdbcType=BIGINT}
    where role_id = #{roleId,jdbcType=BIGINT}
  

  
  
    select role_id, `name`, remarks, `status`, create_time, create_id, update_time, update_id
    from sys_role
    where role_id = #{roleId,jdbcType=BIGINT}
  

  
  
    delete from sys_role
    where role_id = #{roleId,jdbcType=BIGINT}
  

  
  
    select role_id, `name`, remarks, `status`, create_time, create_id, update_time, update_id
    from sys_role where role_id > 1
  

  
    
    
    
  


  
  
    select id, role_id, permission_id
    from sys_role_permission
    where id = #{id,jdbcType=BIGINT}
  

  
    
    
    
    
    
    
    
    
    
    
  

  
    select user_id, `name`, account, `password`,  `status`,
    create_time, create_id, update_time, update_id
    from sys_user
  

  
  
    select user_id, `name`, account, `password`, `status`, create_time, create_id,
    update_time, update_id,lab_id
    from sys_user where binary account = #{account}
  

  
  
    update sys_user
    set `name` = #{name,jdbcType=VARCHAR},
      account = #{account,jdbcType=VARCHAR},
      `password` = #{password,jdbcType=VARCHAR},
      `status` = #{status,jdbcType=TINYINT},
      create_time = #{createTime,jdbcType=TIMESTAMP},
      create_id = #{createId,jdbcType=BIGINT},
      update_time = #{updateTime,jdbcType=TIMESTAMP},
      update_id = #{updateId,jdbcType=BIGINT},
      lab_id = #{labId,jdbcType=BIGINT}
    where user_id = #{userId,jdbcType=BIGINT}
  

  
  
    delete from sys_user
    where user_id = #{userId,jdbcType=BIGINT}
  

  
  
    select user_id, `name`, account, `password`, `status`, create_time, create_id,
    update_time, update_id
    from sys_user
    where user_id = #{userId,jdbcType=BIGINT}
  

  
  
    SELECT role_id FROM sys_user_role WHERE user_id = #{userId}
  

  
  
    SELECT p.resources from sys_permission p
    LEFT JOIN sys_role_permission rp on p.permission_id = rp.permission_id
    WHERE rp.role_id = #{roleId} AND p.parent_id = #{menuId} AND p.resources IS NOT NULL
  

3.mapper层

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sf.detectcore.controller.user.model.MenuResponse;
import com.sf.detectcore.entity.SysMenu;
import java.util.List;

/**
 * @ClassName SysMenuMapper
 * @Description SysMenuMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysMenuMapper extends BaseMapper {

    /**
     * 插入一条数据
     * @param record
     * @return
     */
    @Override
    int insert(SysMenu record);


    /**
     * 根据用户id查询他拥有所有菜单
     * @param userId
     * @return List
     */
    List getMenusByUserId(Long userId);


    /**
     * 根据父Id(parentId) 查询二级菜单
     * @param parentId
     * @return
     */
    List getByParentId(Long parentId);

}

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sf.detectcore.controller.query.SysPermissionQuery;
import com.sf.detectcore.controller.role.model.RolePermissionParam;
import com.sf.detectcore.entity.SysPermission;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

/**
 * @ClassName SysPermissionMapper
 * @Description SysPermissionMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysPermissionMapper extends BaseMapper {

    /**
     * 根据用多个角色id查询拥有的权限
     * @param roleIds
     * @return List
     */
    List getPermissionsByRoles(@Param("roleIds")List roleIds);

    /**
     * 查询系统所有有效权限
     * @return List
     */
    List getAllPermissions();


    /**
     * 根据主键Id查询权限
     * @param permissionId
     * @return
     */
    SysPermission selectByPrimaryKey(Long permissionId);

    /**
     * 查询用户的角色id
     * @param userId
     * @return Long
     */
    Long getUserRoleId(Long userId);

    /**
     * 查询用户对应角色拥有的权限id
     * @param roleId
     * @return List
     */
    List getUserPermIds(Long roleId);

    /**
     * 根据权限id查询一条权限数据（二级菜单权限）
     * @param permId
     * @return SysPermission
     */
    SysPermission getTwoMenuPermById(Long permId);

    /**
     * 查询一条权限的所有子权限数据
     * @param param
     * @return List
     */
    List getChildrenPermission(RolePermissionParam param);

}

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sf.detectcore.entity.SysRole;
import java.util.List;

/**
 * @ClassName SysRoleMapper
 * @Description SysRoleMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysRoleMapper extends BaseMapper {

    /**
     * 插入一条数据
     * @param record
     * @return
     */
    @Override
    int insert(SysRole record);

    /**
     * 根据用户自增id查询他拥有的角色
     * @param id
     * @return List
     */
    List getRolesByUserId(Long id);

    /**
     * 根据主键修改角色信息
     * @param record
     * @return
     */
    int updateByPrimaryKey(SysRole record);

    /**
     * 根据主键Id查询角色信息
     * @param roleId
     * @return
     */
    SysRole selectByPrimaryKey(Long roleId);

    /**
     * 根据主键删除角色
     * @param roleId
     * @return
     */
    int deleteByPrimaryKey(Long roleId);


    /**
     * 获取所有系统角色
     * @return ResultData
     */
    List getAllSystemRole();
}

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sf.detectcore.entity.SysRolePermission;
import java.util.List;

/**
 * @ClassName SysRolePermissionMapper
 * @Description SysRolePermissionMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysRolePermissionMapper extends BaseMapper {

    /**
     * 根据主键Id查询角色权限关系
     * @param id
     * @return
     */
    SysRolePermission selectByPrimaryKey(Long id);




}

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.sf.detectcore.entity.SysUser;
import java.util.List;
import java.util.Map;

/**
 * @ClassName SysUserMapper
 * @Description UserMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysUserMapper extends BaseMapper {

    List selectAll();

    /**
     * 根据账号查询用户
     * @param account
     * @return User
     */
    SysUser getUserByAccount(String account);

    /**
     * 根据主键修改用户信息
     * @param record
     * @return
     */
    int updateByPrimaryKey(SysUser record);

    /**
     * 根据主键删除用户
     * @param userId
     * @return
     */
    int deleteByPrimaryKey(Long userId);

    /**
     * 根据主键查询用户信息
     * @param userId
     * @return
     */
    SysUser selectByPrimaryKey(Long userId);

    /**
     * 查询指定用户的角色id
     * @param userId
     * @return Long
     */
    Long getRoleId(Long userId);

    /**
     * 获取当前用户在指定页面的权限
     * @param map
     * @return List
     */
    List findUserPagePermission(Map map);


}

package com.sf.detectcore.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sf.detectcore.entity.SysUserRole;
import java.util.List;

/**
 * @ClassName SysUserRoleMapper
 * @Description SysUserRoleMapper
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysUserRoleMapper extends BaseMapper {


}

4.service层

 

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.controller.user.model.MenuResponse;
import com.sf.detectcore.entity.SysMenu;

import java.util.List;

/**
 * @ClassName SysMenuService
 * @Description 菜单相关服务
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysMenuService extends IService {

    /**
     * 根据用户id查询他拥有的菜单
     * @param userId
     * @returist
     */
    List findUserMenus(Long userId);
}

 

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.entity.SysPermission;
import com.sf.detectcore.entity.SysRole;

import java.util.List;

/**
 * @ClassName SysPermissionService
 * @Description 权限相关服务
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysPermissionService extends IService {

    /**
     * 根据用户的多个角色查询拥有的权限
     * @param roles
     * @return
     */
    List findPermissionsByRoles(List roles);

    /**
     * 查询系统所有有效权限
     * @return List
     */
    List loadAllPermissions();


}

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.entity.SysRolePermission;

/**
 * @ClassName SysRolePermissionService
 * @Description SysRolePermissionService
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysRolePermissionService extends IService {
}

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.controller.query.RoleQuery;
import com.sf.detectcore.entity.SysRole;
import com.sf.detectcore.entity.SysUser;
import com.sf.detectcore.util.R;

import java.util.List;

/**
 * @ClassName SysRoleService
 * @Description 角色相关服务
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysRoleService extends IService {


    /**
     * 根据roleId查询角色
     * @param roleId
     * @return
     */
    SysRole getByRoleId(Long roleId);

    /**
     * 添加系统角色数据
     * @param sysRole
     * @return R
     */
    R addRole(SysRole sysRole);


    /**
     * 编辑系统角色数据
     * @param sysRole
     * @return R
     */
    R editRole(SysRole sysRole);

    /**
     * 查询一个角色的详情
     * @param id
     * @return R
     */
    R getRoleById(Long id);


    /**
     * 删除角色
     * @param ids
     * @return R
     */
    R deleteRole(String ids);


    /**
     * 查询角色列表数据
     * @param roleQuery
     * @param user
     * @return R
     */
    R getRolePagingData(RoleQuery roleQuery , SysUser user);


    /**
     * 查询系统所有权限
     * @return R
     */
    R getSystemPermission();


    /**
     * 获取所有系统角色,添加用户时使用，排除超级管理员
     * @param user
     * @return R
     */
    R getSystemRole(SysUser user);

}

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.entity.SysUserRole;

/**
 * @ClassName SysUserRoleService
 * @Description SysUserRoleService
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysUserRoleService extends IService {
}

package com.sf.detectcore.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.sf.detectcore.controller.query.UserQuery;
import com.sf.detectcore.entity.SysRole;
import com.sf.detectcore.entity.SysUser;
import com.sf.detectcore.util.R;

import java.util.List;

/**
 * @ClassName SysUserService
 * @Description 管理员相关服务
 * @Author huyong
 * @Date 2019/10/14 18:23
 * @Version 1.0
 */
public interface SysUserService extends IService {


    /**
     * 根据账号查询用户
     * @param account
     * @return SysUser
     */
    SysUser findUserByAccount(String account);

    /**
     * 根据用户自增id查询他拥有的角色
     * @param
     * @return List
     */
    List findRolesByUserId(Long id);


    /**
     * 新增系统用户
     * @param user
     */
    void addUser(SysUser user);

    /**
     * 编辑系统用户
     * @param user
     */
    void editUser(SysUser user);


    /**
     * 删除系统用户
     * @param userIds
     */
    void deleteUser(String userIds);


    /**
     * 查询系统用户数据
     * @param userQuery
     * @param user
     * @return R
     */
    R getUserPagingData(UserQuery userQuery , SysUser user);


    /**
     * 查询系统用户数据
     * @param id
     * @return R
     */
    R getUserById(Long id);

    /**
     * 获取当前用户在指定页面的权限
     * @param userId
     * @param menuId
     * @return R
     */
    R findUserPagePermission(Long userId, Long menuId);


    /**
     * 通过实验室Id查询用户信息
     * @param id
     * @return
     */
    List listQueryByLabId(Long id);


}

5.serviceImpl

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.controller.user.model.MenuResponse;
import com.sf.detectcore.entity.SysMenu;
import com.sf.detectcore.mapper.SysMenuMapper;
import com.sf.detectcore.service.SysMenuService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;


@Service
public class SysMenuServiceImpl extends ServiceImpl implements SysMenuService {

   private final Logger logger = LoggerFactory.getLogger(SysMenuServiceImpl.class);

    @Autowired
    private SysMenuMapper sysMenuMapper;

    @Override
    public List findUserMenus(Long userId) {
        List list  = new ArrayList<>();
        //所有菜单
        List sysMenus = sysMenuMapper.getMenusByUserId(userId);
        if(sysMenus != null && sysMenus.size() != 0) {
            for(MenuResponse menuResponse: sysMenus) {
                List list1  = new ArrayList<>();
                if (Objects.equals(0L,menuResponse.getParentId())){
                    list.add(menuResponse);
                    //添加二级菜单
                    for (MenuResponse menuResponse1: sysMenus){
                        if (Objects.equals(menuResponse.getMenuId(),menuResponse1.getParentId())){
                            list1.add(menuResponse1);
                        }
                    }
                    menuResponse.setChildren(list1);
                }
            }
        }
        return list;
    }
}

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.entity.SysPermission;
import com.sf.detectcore.entity.SysRole;
import com.sf.detectcore.mapper.SysPermissionMapper;
import com.sf.detectcore.service.SysPermissionService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class SysPermissionServiceImpl extends ServiceImpl implements SysPermissionService {

    private final Logger logger = LoggerFactory.getLogger(SysPermissionServiceImpl.class);

    @Autowired
    SysPermissionMapper sysPermissionMapper;

    @Override
    public List findPermissionsByRoles(List roles) {
        List roleIds = new ArrayList<>();
        for (SysRole role : roles) {
            if(role != null){
                roleIds.add(role.getRoleId());
            }
        }
        if(roleIds.size() <= 0){
            return null;
        }
        try{
            return sysPermissionMapper.getPermissionsByRoles(roleIds);
        }catch (Exception e){
            logger.error("根据用户角色查询拥有权限时异常:{}" , e);
            return null;
        }
    }

    @Override
    public List loadAllPermissions() {
        return sysPermissionMapper.getAllPermissions();
    }



}

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.entity.SysRolePermission;
import com.sf.detectcore.mapper.SysRolePermissionMapper;
import com.sf.detectcore.service.SysRolePermissionService;
import org.springframework.stereotype.Service;

@Service
public class SysRolePermissionServiceImpl extends ServiceImpl implements SysRolePermissionService {
}

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.config.constant.SystemConstants;
import com.sf.detectcore.controller.query.RoleQuery;
import com.sf.detectcore.controller.role.model.RolePermissionParam;
import com.sf.detectcore.entity.*;
import com.sf.detectcore.mapper.SysPermissionMapper;
import com.sf.detectcore.mapper.SysRoleMapper;
import com.sf.detectcore.mapper.SysRolePermissionMapper;
import com.sf.detectcore.mapper.SysUserRoleMapper;
import com.sf.detectcore.service.SysRoleService;
import com.sf.detectcore.util.R;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

@Service
public class SysRoleServiceImpl extends ServiceImpl implements SysRoleService {
    private final Logger logger = LoggerFactory.getLogger(SysRoleServiceImpl.class);

    @Autowired
    private SysRoleMapper sysRoleMapper;

    @Autowired
    private SysRolePermissionMapper sysRolePermissionMapper;

    @Autowired
    private SysPermissionMapper sysPermissionMapper;

    @Autowired
    private SysUserRoleMapper sysUserRoleMapper;

    @Override
    public SysRole getByRoleId(Long roleId) {
        return sysRoleMapper.selectByPrimaryKey(roleId);
    }

    @Transactional(propagation = Propagation.REQUIRED , rollbackFor = Exception.class)
    @Override
    public R addRole(SysRole sysRole) {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("name" , sysRole.getName());
        SysRole existRole = sysRoleMapper.selectOne(wrapper);
        if(existRole != null){
            return new R(SystemConstants.PARAM_INCORRECT_CODE , Boolean.FALSE,"当前角色名称已经存在,添加失败!");
        }
        // 1添加基本信息
        sysRoleMapper.insert(sysRole);
        return R.ok();
    }

    @Transactional(propagation = Propagation.REQUIRED , rollbackFor = Exception.class)
    @Override
    public R editRole(SysRole sysRole) {
        // 1修改角色基本信息
        sysRoleMapper.updateByPrimaryKey(sysRole);
        if (Objects.nonNull(sysRole.getPermissionIds())){
            // 2修改角色权限关系数据 删除角色之前的权限数据
            QueryWrapper wrapper = new QueryWrapper<>();
            wrapper.eq("role_id" ,sysRole.getRoleId());
            sysRolePermissionMapper.delete(wrapper);
            List permissionIds = sysRole.getPermissionIds();
            for (Long id : permissionIds) {
                SysRolePermission relation = new SysRolePermission();
                relation.setRoleId(sysRole.getRoleId());
                relation.setPermissionId(id);
                sysRolePermissionMapper.insert(relation);
            }
        }
        return R.ok();
    }

    @Override
    public R getRoleById(Long id) {
        SysRole role = sysRoleMapper.selectByPrimaryKey(id);

        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("role_id" , id);
        List relations = sysRolePermissionMapper.selectList(wrapper);
        logger.info("relations:{}",relations);
        List result = new ArrayList<>();
        int i=0;
        for (SysRolePermission relation : relations) {
            Long permissionId = relation.getPermissionId();
            SysPermission permission = sysPermissionMapper.selectByPrimaryKey(permissionId);
            if(!StringUtils.isEmpty(permission.getResources())){
                result.add(relation.getPermissionId());
            }
        }
        role.setPermissionIds(result);
        return R.ok(result);
    }

    @Override
    public R deleteRole(String ids) {
        try{
            QueryWrapper urWrapper = new QueryWrapper<>();
            urWrapper.in("role_id" , ids.split(","));
            List relations = sysUserRoleMapper.selectList(urWrapper);
            if(relations != null && relations.size() >= 1){
                return R.error(SystemConstants.PARAM_INCORRECT_CODE,"所选角色有系统用户使用,不能删除!");
            }
            for (String id : ids.split(",")) {
                //删除角色-权限数据
                QueryWrapper wrapper = new QueryWrapper<>();
                wrapper.eq("role_id",Long.valueOf(id));
                sysRolePermissionMapper.delete(wrapper);
                // 删除基本数据
                sysRoleMapper.deleteByPrimaryKey(Long.valueOf(id));
            }
            return R.ok();
        }catch (Exception e){
            log.error("删除角色异常,异常信息:{}" , e);
            return R.error(SystemConstants.SERVER_ERROR_CODE,"失败");
        }
    }

    @Override
    public R getRolePagingData(RoleQuery roleQuery, SysUser user) {
        try{
            QueryWrapper wrapper = new QueryWrapper<>();
            if(roleQuery.getName() != null && !roleQuery.getName().isEmpty()){
                wrapper.like("name" , roleQuery.getName());
            }
            //角色列表,不展示超级管理员,数据库表统一配置为自增id为1
            wrapper.notIn("role_id",1);
            IPage pageData = sysRoleMapper.selectPage(new Page<>(roleQuery.getPageNum(), roleQuery.getPageSize()), wrapper);
            return R.ok(pageData);
        }catch (Exception e){
            log.error("查询角色列表数据异常,异常信息:{}" , e);
            return R.error(SystemConstants.SERVER_ERROR_CODE , "查询失败");
        }
    }

    @Override
    public R getSystemPermission() {
        List permission = new ArrayList<>();
        try{
            //查询出所有父权限Id
            QueryWrapper queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id",0);
            List sysPermissions1 = sysPermissionMapper.selectList(queryWrapper);
            permission.addAll(sysPermissions1);
            for (SysPermission sysPermission1:sysPermissions1){
                QueryWrapper queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("parent_id",sysPermission1.getPermissionId());
                List sysPermissions2 = sysPermissionMapper.selectList(queryWrapper1);
                sysPermission1.setChildren(sysPermissions2);
                for (SysPermission sysPermission2:sysPermissions2){
                    QueryWrapper queryWrapper2 = new QueryWrapper<>();
                    queryWrapper2.eq("parent_id",sysPermission2.getPermissionId());
                    List sysPermissions3 = sysPermissionMapper.selectList(queryWrapper2);
                    sysPermission2.setChildren(sysPermissions3);
                }
            }

            return R.ok(permission);

        }catch (Exception e){
            log.error("getSystemPermission查询系统权限异常,异常信息:{}" , e);
            return R.error(SystemConstants.SERVER_ERROR_CODE , "查询失败");
        }
    }

    @Override
    public R getSystemRole(SysUser user) {
        List systemRole;
//        if(user.getStationId() != null){
//            Long userId = user.getUserId();
//            systemRole = sysRoleMapper.getSystemRole(userId);
//        }else{
            systemRole = sysRoleMapper.getAllSystemRole();
//        }
        return R.ok(systemRole);
    }
}

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.entity.SysUserRole;
import com.sf.detectcore.mapper.SysUserRoleMapper;
import com.sf.detectcore.service.SysUserRoleService;
import org.springframework.stereotype.Service;

@Service
public class SysUserRoleServiceImpl extends ServiceImpl implements SysUserRoleService {
}

package com.sf.detectcore.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sf.detectcore.config.constant.SystemConstants;
import com.sf.detectcore.controller.query.UserQuery;
import com.sf.detectcore.entity.Lab;
import com.sf.detectcore.entity.SysRole;
import com.sf.detectcore.entity.SysUser;
import com.sf.detectcore.entity.SysUserRole;
import com.sf.detectcore.mapper.LabMapper;
import com.sf.detectcore.mapper.SysRoleMapper;
import com.sf.detectcore.mapper.SysUserMapper;
import com.sf.detectcore.mapper.SysUserRoleMapper;
import com.sf.detectcore.service.SysUserService;
import com.sf.detectcore.util.R;
import org.apache.http.impl.client.CloseableHttpClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class SysUserServiceImpl extends ServiceImpl implements SysUserService {

    @Autowired
    SysUserMapper sysUserMapper;

    @Autowired
    SysRoleMapper sysRoleMapper;

    @Autowired
    SysUserRoleMapper sysUserRoleMapper;

    @Autowired
    private LabMapper labMapper;


    @Override
    public SysUser findUserByAccount(String account){
        return sysUserMapper.getUserByAccount(account);
    }

    @Override
    public List findRolesByUserId(Long id) {
        return sysRoleMapper.getRolesByUserId(id);
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    @Override
    public void addUser(SysUser user) {
        // 1添加用户信息
        sysUserMapper.insert(user);

        // 2添加用户角色信息
        List roleIds = user.getRoleIds();
        for (Long roleId : roleIds) {
            SysUserRole relation = new SysUserRole();
            relation.setUserId(user.getUserId());
            relation.setRoleId(roleId);
            sysUserRoleMapper.insert(relation);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    @Override
    public void editUser(SysUser user) {
        // 1编辑用户基本信息
        sysUserMapper.updateByPrimaryKey(user);

        // 2编辑用户角色信息(先删除以往的角色,再添加角色)
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("user_id" , user.getUserId());
        sysUserRoleMapper.delete(wrapper);
        List roleIds = user.getRoleIds();
        for (Long roleId : roleIds) {
            SysUserRole relation = new SysUserRole();
            relation.setUserId(user.getUserId());
            relation.setRoleId(roleId);
            sysUserRoleMapper.insert(relation);
        }
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    @Override
    public void deleteUser(String userIds) {
        for (String userId : userIds.split(",")) {
            // 1删除用户基本信息
            sysUserMapper.deleteByPrimaryKey(Long.valueOf(userId));
            // 2删除用户角色信息
            QueryWrapper wrapper = new QueryWrapper<>();
            wrapper.eq("user_id" , userId);
            sysUserRoleMapper.delete(wrapper);
        }
    }

    @Override
    public R getUserPagingData(UserQuery userQuery, SysUser user) {
        QueryWrapper wrapper = new QueryWrapper<>();
        if(userQuery.getName() != null && !userQuery.getName().isEmpty()){
            wrapper.like("name" , userQuery.getName());
        }
        if(userQuery.getAccount() != null && !userQuery.getAccount().isEmpty()){
            wrapper.eq("account" , userQuery.getAccount());
        }
        //用户列表,不展示超级管理员,数据库表统一配置为自增id为1
        wrapper.notIn("user_id",1);
        IPage pageData = sysUserMapper.selectPage(new Page<>(userQuery.getPageNum(), userQuery.getPageSize()), wrapper);
        List users = pageData.getRecords();
        for (SysUser userd : users) {
            if(userd.getLabId() != null){
                Lab lab = labMapper.selectById(userd.getLabId());
                userd.setLabName(lab.getName());
            }
            //默认一个 用户仅存在一个角色
            List rolesByUserId = sysRoleMapper.getRolesByUserId(userd.getUserId());
            userd.setRoleId(rolesByUserId.get(0).getRoleId());
            userd.setRoleName(rolesByUserId.get(0).getName());
        }
        return R.ok(pageData);
    }

    @Override
    public R getUserById(Long id) {
        // 基本信息
        SysUser user = sysUserMapper.selectByPrimaryKey(id);
        // 角色自增ID
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("user_id" , id);
        List relationList = sysUserRoleMapper.selectList(wrapper);
        List roleIds = new ArrayList<>();
        for (SysUserRole relation : relationList) {
            if(relation != null){
                roleIds.add(relation.getRoleId());
            }
        }
        user.setRoleIds(roleIds);
        user.setRoleId(roleIds.get(0));
        return R.ok(user);
    }

//    @Override
//    public List getUsersByStationId(Long stationId) {
//        QueryWrapper wrapper = new QueryWrapper<>();
//        if(user.getStationId() != null && user.getStationId() > 0){
//            wrapper.eq("station_id" , user.getStationId());
//        }
//        wrapper.eq("s_df" , 0);
//        return stationMapper.selectList(wrapper);
//    }

    @Override
    public R findUserPagePermission(Long userId, Long menuId) {
        try {
            Long roleId = sysUserMapper.getRoleId(userId);
            Map map = new HashMap<>();
            map.put("roleId" , roleId);
            map.put("menuId" , menuId);
            List datas = sysUserMapper.findUserPagePermission(map);
            return R.ok(datas);
        }catch (Exception e){
            log.error("findUserPagePermission查询用户拥有的权限异常:{}" , e);
            return R.error(SystemConstants.SERVER_ERROR_CODE , "查询失败");
        }
    }

    @Override
    public List listQueryByLabId(Long id) {
        QueryWrapper q1 = new QueryWrapper<>();
        q1.eq("lab_id",id);
        return sysUserMapper.selectList(q1);
    }
}

6.登录控制器

 

package com.sf.detectcore.controller.login;

import com.alibaba.fastjson.JSON;
import com.sf.detectcore.config.constant.Constant;
import com.sf.detectcore.config.constant.SystemConstants;
import com.sf.detectcore.controller.login.model.LoginModel;
import com.sf.detectcore.entity.SysRole;
import com.sf.detectcore.entity.SysUser;
import com.sf.detectcore.service.SysUserService;
import com.sf.detectcore.util.R;
import com.sf.detectcore.util.VerifyCodeUtil;
import com.sf.detectcore.util.redis.RedisUtil;
import com.sf.detectcore.util.rsa.RSAUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.validation.Valid;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.*;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Description 登录相关接口
 * @Author huyong
 * @Date 2019/10/14 14:52
 * @Version 1.0
 */
@Api(value="LoginController", description = "登录相关接口")
@RestController
@RequestMapping(value="login")
public class LoginController {
    private final Logger logger = LoggerFactory.getLogger(LoginController.class);

    /** 登录有效时间 */
    @Value("${shiro.timeout}")
    private int timeOut;

    /** RSA私钥 */
    @Value("${RSA.privateKey}")
    private String privateKey;

    /** RSA公钥 */
    @Value("${RSA.publicKey}")
    private String publicKey;

    @Autowired
    SysUserService sysUserService;

    @Autowired
    StringRedisTemplate redis;

    @Autowired
    RedisUtil redisUtil;

    @ApiOperation(value = "用户登录", notes = "用户登录" , httpMethod = "POST")
    @PostMapping(value = "login")
    @ResponseBody
    public R login(@Valid @RequestBody LoginModel loginModel, HttpServletRequest request){
        String sessionVerifyCode = (String)request.getSession().getAttribute(SystemConstants.VERIFYCODE);
        System.out.println(sessionVerifyCode+": "+loginModel.getVerifyCode());
        if(sessionVerifyCode == null || !sessionVerifyCode.equals(loginModel.getVerifyCode())){
            return new R(SystemConstants.PARAM_INCORRECT_CODE,false , "验证码错误或已过期,请刷新页面重试");
        }
        request.getSession().removeAttribute(SystemConstants.VERIFYCODE);

        SysUser user = sysUserService.findUserByAccount(loginModel.getAccount());
        if(user == null){
            return new R(SystemConstants.PARAM_INCORRECT_CODE,false , "系统无此用户!");
        }
        String userPwd = getRsaDecryStr(user.getPassword());
        String loginPwd = getRsaDecryStr(loginModel.getPassword());
        if(!userPwd.equals(loginPwd)){
            return new R(SystemConstants.AUTH_FAIL_CODE,false  , "密码错误!");
        }

        List roles = sysUserService.findRolesByUserId(user.getUserId());
        if (Objects.equals(Constant.INT_1,user.getStatus())){
            return R.error(SystemConstants.PARAM_INCORRECT_CODE,"账号不可用,请联系管理员");
        }
        try{
            Subject subject = SecurityUtils.getSubject();
            subject.logout();
            Session oldSession = subject.getSession();
            // 重置session
            final LinkedHashMap attributes = new LinkedHashMap<>();
            Collection