实习日记5：过滤器+批量删除+角色管理-CSDN博客

本文链接：https://blog.csdn.net/qq_45070054/article/details/107562880

本文记录了实习期间增加批量删除用户功能的实现，从dao、service到controller层的详细步骤。同时，介绍了过滤器的使用，以防止未登录用户直接访问管理界面。此外，还实现了角色管理功能，包括数据库表的设计和前后端交互，有助于用户分类管理。

摘要由CSDN通过智能技术生成

日记目录

项目分析
增加批量删除功能
过滤器的实现
角色管理
成果展示
总结

项目分析

在上一次迭代中，我们完成了功能的增删查改，但是目前的删除只能单个的删除用户，并且在只要上网时输入正确的url跳过用户登录界面就能对用户进行管理。在这个项目中也需要添加角色管理功能，对用户进行分类。

增加批量删除功能

dao层的实现
在UserDao接口中增加deletAll()方法

void deleteAll(@Param("ids")List<Integer> ids);

到UserMapper.xml文件中增加对应的sql代码

<delete id="deleteAll" parameterType="list">
        delete from user where id in
        <foreach collection="ids" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </delete>

service层的实现

接口功能
在userservice下编写deleteAll()接口

void deleteAll(List<Integer> ids);

具体实现
到UserServiceImpl类下实现deleteAll()方法：
这里边直接使用了userDao里的deleteAll()来实现功能

@Override
    public void deleteAll(List<Integer> ids) {
        userDao.deleteAll(ids);
    }

controller层的实现
在UserController类下实现逻辑功能增加public String deleteAll(String userList) 这里以前端返回来的字符串作为参数返回一个String作为重新申请findAll.do的请求

 @RequestMapping("deleteAll.do")
    public String deleteAll(String userList){
        System.out.println("userList"+userList);
        String[] str=userList.split(",");
        List<Integer> ids=new ArrayList<>();
        for(String s:str){
            ids.add(Integer.parseInt(s));
        }
        userService.deleteAll(ids);
        return "redirect:findAll.do";
    }

过滤器的实现

创建filter包并在包下创建LoginFilter类继承自servlet的Filter接口，重写接口的函数

package com.whut.filter;

import com.whut.bean.User;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class LoginFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request=(HttpServletRequest)servletRequest;
        HttpServletResponse response=(HttpServletResponse) servletResponse;
        HttpSession session=request.getSession();
        User user=(User)session.getAttribute("user");
        String uri=request.getRequestURI();
//        System.out.println("uri-----------"+uri);
//        System.out.println("uri.indexof----------=="+uri.indexOf("login.do"));
        if(user==null&&uri.indexOf("login.do")==-1){
            response.sendRedirect(request.getContextPath()+"../login.jsp");
        }else {
            filterChain.doFilter(request,response);
        }
    }

    @Override
    public void destroy() {

    }
}

写好LoginFilter后到web.xml中注册该过滤器

<filter>
  <filter-name>loginFilter</filter-name>
  <filter-class>com.whut.filter.LoginFilter</filter-class>
</filter>
  <filter-mapping>
    <filter-name>loginFilter</filter-name>
    <url-pattern>*.do</url-pattern>
  </filter-mapping>

角色管理

在数据库创建表
在数据库下创建两个tb_role和uer_role两个新表，分别用于存储管理员类型和用户对应的角色定位。
在这里插入图片描述

tb_role表
user_role表

在bean下创建新的对应该表的Role和UserRole类
Role类

public class Role {
    private int id;
    private String rolename;
    private String roledesc;

    public int getId() {
        return id;
    }

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

    public String getRolename() {
        return rolename;
    }

    public void setRolename(String rolename) {
        this.rolename = rolename;
    }

    public String getRoledesc() {
        return roledesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "id=" + id +
                ", rolename='" + rolename + '\'' +
                ", roledesc='" + roledesc + '\'' +
                '}';
    }

    public void setRoledesc(String roledesc) {
        this.roledesc = roledesc;
    }
}

UserRole类

public class UserRole {
    private int id;
    private int userId;
    private int roleId;

    public UserRole() {
    }

    public UserRole(int id, int userId, int roleId) {
        this.id = id;
        this.userId = userId;
        this.roleId = roleId;
    }

    public int getId() {
        return id;
    }

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

    public int getUserId() {
        return userId;
    }

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

    public int getRoleId() {
        return roleId;
    }

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

    @Override
    public String toString() {
        return "UserRole{" +
                "id=" + id +
                ", userId=" + userId +
                ", roleId=" + roleId +
                '}';
    }
}

在类这里上比较简单，对标的是数据库的数据类型这里不过多赘述。UserRole类主要用于连接用户和用户角色。
dao层的实现
新建一个RoleDao接口

package com.whut.dao;

import com.whut.bean.Role;
import com.whut.bean.UserRole;

import java.util.List;

public interface RoleDao {
    List<Integer> findRoleIdByUserId(int userId);
    List<Role> findRoleByUserId(int id);
    void addRole(UserRole userRole);
}

在mapper包下创建新的RoleMapper.xml用来对应数据库的功能查询。
编写RoleMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.whut.dao.RoleDao" >
    <select id="findRoleIdByUserId" parameterType="int" resultType="int">
        select  roleId from user_role where userId=#{userId}
    </select>

    <select id="findRoleByUserId" parameterType="int" resultType="role">
        select * from tb_role where id not in(select roleId from user_role where userId=#{id})
    </select>

    <insert id="addRole" parameterType="userRole">
        insert into user_role (userId,roleId) values (#{userId},#{roleId})
    </insert>
</mapper>

service层的实现
创建RoleService接口

package com.whut.service;

import com.whut.bean.Role;

import java.util.List;

public interface RoleService {
    List<Integer> findRoleId(int userId);
    List<Role> findRoleByUserId(int id);
    void add(List<Integer> ids,String userId);
}

在impl包下创建继承自该接口的RoleServiceImpl类

package com.whut.service.impl;

import com.whut.bean.Role;
import com.whut.bean.UserRole;
import com.whut.dao.RoleDao;
import com.whut.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class RoleServiceImpl implements RoleService {
    @Autowired
    private RoleDao roleDao;

    @Override
    public List<Integer> findRoleId(int userId) {
        return roleDao.findRoleIdByUserId(userId);
    }

    @Override
    public List<Role> findRoleByUserId(int id) {
        return roleDao.findRoleByUserId(id);
    }

    @Override
    public void add(List<Integer> ids, String userId) {
        for (int roleId:ids){
            UserRole userRole=new UserRole();
            userRole.setUserId(Integer.parseInt(userId));
            userRole.setRoleId(roleId);
            roleDao.addRole(userRole);
        }
    }
}

controller层的实现
在UserController下新增角色的功能

 @RequestMapping("toAddRole.do")
    public ModelAndView toAddRole(int id){
        List<Role> roleList=roleService.findRoleByUserId(id);
        ModelAndView mv=new ModelAndView();
        mv.addObject("roles",roleList);
        mv.addObject("id",id);
        mv.setViewName("user-role-add");
        return mv;
    }

    @RequestMapping("addRole.do")
    @ResponseBody
    public String add(String roleList,String userId){
        String [] strs=roleList.split(",");
        List<Integer>ids=new ArrayList<>();
        for (String s:strs){
            ids.add(Integer.parseInt(s));
        }
        roleService.add(ids,userId);
        return "";
    }

前端
在更新和删除按钮后新增一个增加角色

<% List<Integer> roleIds=(List<Integer>) session.getAttribute("roleIds");%>
												<% if(roleIds.contains(1)){ %>
												<a href="/user/toAddRole.do?id=${user.id}">添加角色</a>
												<% } %>