文章目录
任务目标
-
业务目标
理解权限管理的实现逻辑 -
技能目标
代码实现角色管理和人员管理
涉及知识点
5、枚举类定义
6、Servlet处理请求（ Servlet工作原理、Servlet请求与响应）
7、JSTL标签库+EL表达式
9、AJAX学习
任务过程
- 熟悉权限模块的功能
- 理解权限模块涉及的数据表
- 实现用户列表展示
- 实现角色的增删改查
- 实现权限菜单的动态展示
思路及代码实现
本模块基于学生管理模块，因此部分代码（即文件中白色标题的代码）详见文章Javaweb教学系统项目实战之学生管理模块
接下来的代码基于上一文章
☆前端页面创建
菜单、角色及用户，每个对应列表、新增和修改
☆数据库创建
创建数据库，并创建菜单信息表menu、角色信息表role、登录用户信息表users和连接role和menu的中间表middle
menu
role
users
middle
☆后端
一、工具包utils
创建一个utils包，新建类DBUtils，新建配置文件db.properties
properties配置文件
使用ResourceBundle访问本地资源，从里面读取我们需要的值
DBUtils
JDBC工具类，封装了操作sql的方法，因此方法都推荐静态static
二、 实体类的定义，创建bean包
文件标题为白色的文件已存在
根据所创建的sql创建对应的类
类名=表名，属性名=列名
Menu
- 定义属性
private Integer menuId;
private String menuName;
private Integer upmenuId;
private Integer state;
private String desc;
private String url;
/**
* 和role多对多
*/
private List<Role> roleList;
/**
* 保存二级目录
*/
private List<Menu> secondMenuList;
- 用setter和getter设置和获取值
public Integer getMenuId() {
return menuId;
}
public void setMenuId(Integer menuId) {
this.menuId = menuId;
}
public String getMenuName() {
return menuName;
}
public void setMenuName(String menuName) {
this.menuName = menuName;
}
public Integer getUpmenuId() {
return upmenuId;
}
public void setUpmenuId(Integer upmenuId) {
this.upmenuId = upmenuId;
}
public Integer getState() {
return state;
}
public void setState(Integer state) {
this.state = state;
}
public String getDesc(String desc) {
return this.desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public List<Role> getRoleList() {
return roleList;
}
public void setRoleList(List<Role> roleList) {
this.roleList = roleList;
}
public List<Menu> getSecondMenuList() {
return secondMenuList;
}
public void setSecondMenuList(List<Menu> secondMenuList) {
this.secondMenuList = secondMenuList;
}
Role
- 定义属性
private Integer roleId;
private String roleName;
private Integer roleState;
/**
* 一个角色包含多个用户
*/
private List<Users> usersList;
private List<Menu> menuList;
- 用setter和getter设置和获取值
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Integer getRoleState() {
return roleState;
}
public void setRoleState(Integer roleState) {
this.roleState = roleState;
}
public List<Users> getUsersList() {
return usersList;
}
public void setUsersList(List<Users> usersList) {
this.usersList = usersList;
}
public List<Menu> getMenuList() {
return menuList;
}
public void setMenuList(List<Menu> menuList) {
this.menuList = menuList;
}
Users
- 定义属性
private Integer userId;
private String loginName;
private String password;
private String realName;
private Integer sex;
private String email;
private String address;
private String phone;
private String cardId;
private String desc;
private Integer roleId;
/**
* 一个用户包含一个角色
* @return
*/
private Role role;
- 用setter和getter设置和获取值
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
三、模块功能实现
文件标题为白色的文件已存在
service包中定义学生管理的各种操作
dao层定义service层操作的具体实现
web包中定义servlet
※ Users
实现用户登录退出、用户列表展示
UsersService(Impl)、UsersDao(Impl)、UsersServlet
① 用户登录
在登录时实现动态权限列表展示
service
UsersService
/**
* 登录方法
*/
public Users login(String username,String password);
UsersServiceImpl
/**
* 登录方法
* @param username
* @param password
* @return
*/
@Override
public Users login(String username, String password) {
Users users = usersDao.login(username, password);
if(users == null){
return null;
}
//如果非空，根据角色id查询角色菜单信息（角色名称、菜单名、请求地址。。。三表联查）
Integer roleId = users.getRoleId();
//定义一个方法，查询角色信息
Role role = roleDao.findById(roleId);
//当前角色没有进行菜单分类，即没有一二级，因此对菜单进行分级
List<Menu> menuList = role.getMenuList();
List<Menu> newMenuList = new ArrayList<>();
for (Menu menu:menuList) {
if(menu.getUpmenuId()==0){
//一级菜单
ArrayList<Menu> secondList = new ArrayList<>();//用于保存二级菜单
for (Menu second : menuList) {
//跑二级菜单
if(second.getUpmenuId()==menu.getMenuId()){
secondList.add(second);
}
}
menu.setSecondMenuList(secondList);
newMenuList.add(menu);
}
}
role.setMenuList(newMenuList);//把分级之后的菜单保存到role中
users.setRole(role);
return users;
}
dao
UsersDao
/**
* 登录方法
*/
public Users login(String username, String password);
UsersDaoImpl
/**
* 登录方法
* @param username
* @param password
* @return
*/
@Override
public Users login(String username, String password) {
Users users = null;
try {
String sql = "select * from users where loginname = ? and password = ?";
ArrayList arrayList = new ArrayList();
arrayList.add(username);
arrayList.add(password);
resultSet = query(sql, arrayList);//查询之后返回结果集
//包装结果集数据
users = null;
if(resultSet == null){
return null;
}
while (resultSet.next()){
users = new Users();
users.setLoginName(username);
users.setRealName(resultSet.getString("realname"));
users.setUserId(resultSet.getInt("userid"));
users.setRoleId(resultSet.getInt("roleid"));
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return users;
}
servlet
LoginServlet
login.jsp页面输入username、password后点击登录按钮提交表单， action=“login” method=“post”
@WebServlet(urlPatterns = "/login")
public class LoginServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.接收参数
String username = req.getParameter("username");
String password = req.getParameter("password");
//2.调取service
UsersService usersService = new UsersServiceImpl();
Users users = usersService.login(username, password);
//3.跳转页面
if(users == null){
//以弹窗方式提示用户，登录失败
resp.setContentType("text/html;charset=utf-8");//防止返回数据乱码
PrintWriter writer = resp.getWriter();
writer.println("<script>location.href='login.jsp';alert('用户名或密码不正确');</script>");
}else{
//保存用户信息，重定向跳转到主页面
//session，整个会话期间
req.getSession().setAttribute("u1",users);
resp.sendRedirect("index.jsp");
}
}
}
② 查询用户列表，总条数
service
UsersService
/**
* 查询总条数
*/
public int total();
UsersServiceImpl
@Override
public int total() {
return usersDao.total();
}
dao
UsersDao
/**
* 查询总条数
*/
public int total();
UsersDaoImpl
/**
* 统计条数
* @return
*/
@Override
public int total() {
int total = 0;
try {
String sql = "select count(1) from users u,role r where u.roleid = r.roleid ";
resultSet = query(sql, null);
while (resultSet.next()){
total = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return total;
}
servlet
UsersServlet
/**
* 查询列表
*/
protected void findlist(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.2分页数据（limit 开始位置，显示条数）
//页码值
String pageIndex = req.getParameter("pageIndex");//当前页码值
//如果页面没有传入pageIndex的值，则默认查询第一页
int index = pageIndex==null?1:Integer.parseInt(pageIndex);
//2调取service方法
PageUtil pageUtil = new PageUtil();
UsersService service = new UsersServiceImpl();
/**
* 获取总页数
* 总页数=总条数%每页显示的条数>0?总条数/每页显示的条数+1:总条数/每页显示的条数
*/
int total = service.total();//总条数
pageUtil.setTotal(total);
//3跳转页面
//如果后台想给前台传数据，一定要在后台存值
//req.setAttribute("stulist",students);
pageUtil.setPageIndex(index);
//存储页码值
req.setAttribute("p1",pageUtil);
//list前面如果加/表示从根目录下进行寻找
req.getRequestDispatcher("list.jsp").forward(req,resp);//转发的方式，跳转到list.jsp
}
③ 点击实现分页查询数据
service
UsersService
/**
* 查询用户列表
*/
public List<Users> getUsersList(int pageIndex,int pageSize);
UsersServiceImpl
@Override
public List<Users> getUsersList(int pageIndex, int pageSize) {
return usersDao.getUsersList(pageIndex, pageSize);
}
dao
UsersDao
/**
* 查询用户列表
*/
public List<Users> getUsersList(int pageIndex, int pageSize);
UsersDaoImpl
@Override
public List<Users> getUsersList(int pageIndex, int pageSize) {
List<Users> usersList = new ArrayList<Users>();
try {
String sql = "select userid,loginname,realname,rolename from users u,role r where u.roleid = r.roleid limit ?,?";
List params = new ArrayList();
params.add((pageIndex-1)*pageSize);
params.add(pageSize);
resultSet = query(sql, params);
while (resultSet.next()){
//1取出各表的数据
Users users = new Users();
users.setUserId(resultSet.getInt("userid"));
users.setLoginName(resultSet.getString("loginname"));
users.setRealName(resultSet.getString("realname"));
Role role = new Role();
role.setRoleName(resultSet.getString("rolename"));
//2建立关系
users.setRole(role);
usersList.add(users);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return usersList;
}
servlet
UsersServlet
/power/user/users?method=select
/**
* 查询数据
* （分页）
*/
protected void select(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1接收参数.分页参数、模糊查参数
String index = req.getParameter("index");
int pageIndex=(index==null || index.length()==0)?1:Integer.parseInt(index);
//2调取service方法
PageUtil pageUtil = new PageUtil();
List<Users> usersList = usersService.getUsersList(pageIndex, pageUtil.getPageSize());
int total = usersService.total();
pageUtil.setTotal(total);//总条数
pageUtil.setPageIndex(pageIndex);
pageUtil.setDataList(usersList);
//3存值跳页面
req.setAttribute("pi",pageUtil);
req.getRequestDispatcher("list.jsp").forward(req,resp);
}
④ 新增用户信息
service
UsersService
/**
* 新增用户
*/
public int insertUser(Users users);
UsersServiceImpl
@Override
public int insertUser(Users users) {
return usersDao.insertUser(users);
}
RoleService
/**
* 查询角色id对应关系
*/
public List<Role> getRoleMap();
RoleServiceImpl
@Override
public List<Role> getRoleMap() {
return roleDao.getRoleMap();
}
dao
UsersDao
/**
* 新增用户
*/
public int insertUser(Users users);
UsersDaoImpl
@Override
public int insertUser(Users users) {
int i = 0;
if(existLoginName(users.getLoginName(),users.getRealName()) == 1 || existLoginName(users.getLoginName(),users.getRealName()) == -1){
System.out.println("该用户名已经存在！");
return -1;
}
try {
String sql = "insert into users values(null,?,?,?,?,?,?,?,?,?,?)";
List params = new ArrayList();
params.add(users.getLoginName());
params.add(users.getPassword());
params.add(users.getRealName());
params.add(users.getSex());
params.add(users.getEmail());
params.add(users.getAddress());
params.add(users.getPhone());
params.add(users.getCardId());
params.add(users.getDesc());
params.add(users.getRoleId());
i = update(sql, params);//i表示受影响的行数
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return i;
}
/**
*根据用户名判断该用户是否存在
*/
public int existLoginName(String loginname,String realname){
int f = 0;
System.out.println("2判断用户名是否存在");
System.out.println("传入的loginname："+loginname+"-realname:"+realname);
Users users = findByName(realname);
System.out.println("2: 此时传入根据姓名查找用户名的user,"+"此时users：loginname:"+users.getLoginName()+"-realname:"+users.getRealName());
if(loginname.equals(users.getLoginName())){
System.out.println("此时该用户名存在");
return -1;
}
try {
String sql = "select * from users where loginname = ?";
List params = new ArrayList();
params.add(loginname);
resultSet = query(sql, params);
if(resultSet.next()) {
f = 1;
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return f;
}
/**
* 通过姓名查找用户名是否存在
* @return
*/
public Users findByName(String realname) {
System.out.println("3执行findByName");
Users users = new Users();
try {
String sql = "select * from users where realname = ?";
List params = new ArrayList();
params.add(realname);
resultSet = query(sql, params);
System.out.println("传进来的realname："+realname);
//System.out.println("finebyname resultSet:");
while(resultSet.next()){
//目前只需要获得登录名和姓名，因此其它省略
users.setLoginName(resultSet.getString("loginname"));
System.out.println("loginname:"+resultSet.getString("loginname"));
users.setRealName(resultSet.getString("realname"));
System.out.println("realname:"+resultSet.getString("realname"));
System.out.println("此时users：loginname:"+users.getLoginName()+"-realname:"+users.getRealName());
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return users;
}
RoleDao
/**
* 查询角色id对应关系
*/
public List<Role> getRoleMap();
RoleDaoImpl
@Override
public List<Role> getRoleMap() {
List rs = new ArrayList();
try {
String sql = "select * from role";
resultSet = query(sql, null);
while (resultSet.next()){
Role role = new Role();
role.setRoleId(resultSet.getInt("roleid"));
role.setRoleName(resultSet.getString("rolename"));
rs.add(role);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return rs;
}
servlet
RoleListServlet
获取角色列表，href="/power/user/getRoleList"
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
RoleService service = new RoleServiceImpl();
List<Role> list = service.getRoleMap();
req.setAttribute("rlist",list);
req.getRequestDispatcher("add.jsp").forward(req,resp);
}
UsersServlet
在add中输入用户信息后提交，action="/power/role/roles?method=insert" method=“post”，在UsersServlet中继续进行处理
/**
* 新增用户信息
* @param req
* @param resp
* @throws ServletException
* @throws IOException
*/
protected void insert(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理乱码
//req.setCharacterEncoding("utf-8");
//接收参数
String loginName = req.getParameter("loginName");
String password = req.getParameter("password");
String realName = req.getParameter("realName");
String sex = req.getParameter("sex");
String roleId = req.getParameter("roleId");
String email = req.getParameter("email");
String phone = req.getParameter("phone");
String address = req.getParameter("address");
String cardId = req.getParameter("cardId");
String desc = req.getParameter("desc");
//调取service方法
UsersService service = new UsersServiceImpl();
//将参数封装到学生对象中
Users users = new Users();
users.setLoginName(loginName);
users.setPassword(password);
users.setRealName(realName);
users.setSex(Integer.parseInt(sex));
users.setRoleId(Integer.parseInt(roleId));
users.setEmail(email);
users.setPhone(phone);
users.setAddress(address);
users.setCardId(cardId);
users.setDesc(desc);
int i = service.insertUser(users);//受影响的行数
System.out.println("insertUser受影响的行数"+i);
resp.setContentType("text/html;charset=utf-8");
PrintWriter writer = resp.getWriter();
if(i>0){
//新增成功
writer.println("<script>alert('新增成功');location.href='/power/user/users?method=select'</script>");
}else if(i == -1){
writer.println("<script>alert('该用户名已存在，新增失败');location.href='/power/user/getRoleList'</script>");
}else{
//新增失败
writer.println("<script>alert('新增失败,请检查输入信息');location.href='/power/user/getRoleList'</script>");
}
}
※ Role
角色的增删改查
RoleService(Impl)、RoleDao(Impl)、RoleServlet
① 查询列表
servlet
RoleServlet
/**
* 查询列表
*/
protected void findlist(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1获取参数（两部分，第一部分：模糊从查找的条件 第二部分：分页数据）
// //1.1模糊查找条件
// String stuname = req.getParameter("stuname");
// String stuno = req.getParameter("stuno");
// String sex = req.getParameter("sex");
//1.2分页数据（limit 开始位置，显示条数）
//页码值
String pageIndex = req.getParameter("pageIndex");//当前页码值
//如果页面没有传入pageIndex的值，则默认查询第一页
int index = pageIndex==null?1:Integer.parseInt(pageIndex);
//2调取service方法
PageUtil pageUtil = new PageUtil();
UsersService service = new UsersServiceImpl();
/**
* 获取总页数
* 总页数=总条数%每页显示的条数>0?总条数/每页显示的条数+1:总条数/每页显示的条数
*/
int total = service.total();//总条数
pageUtil.setTotal(total);
//3跳转页面
//如果后台想给前台传数据，一定要在后台存值
//req.setAttribute("stulist",students);
pageUtil.setPageIndex(index);
//存储页码值
req.setAttribute("p1",pageUtil);
//list前面如果加/表示从根目录下进行寻找
req.getRequestDispatcher("list.jsp").forward(req,resp);//转发的方式，跳转到list.jsp
}
② 查询所有角色（分页）
service
RoleService
/**
*查询所有角色
*/
public List<Role> getRoleList(int pageIndex,int pageSize);
/**
* 查询总条数
*/
public int total();
RoleServiceImpl
@Override
public List<Role> getRoleList(int pageIndex, int pageSize) {
return roleDao.getRoleList(pageIndex, pageSize);
}
@Override
public int total() {
return roleDao.total();
}
dao
RoleDao
/**
*查询所有角色
*/
public List<Role> getRoleList(int pageIndex,int pageSize);
/**
* 查询总条数
*/
public int total();
RoleDaoImpl
@Override
public List<Role> getRoleList(int pageIndex, int pageSize) {
List<Role> rolesList = new ArrayList<Role>();
try {
String sql = "select * from role limit ?,?";
List params = new ArrayList();
params.add((pageIndex-1)*pageSize);
params.add(pageSize);
resultSet = query(sql, params);
while (resultSet.next()){
//1取出各表的数据
Role role = new Role();
role.setRoleId(resultSet.getInt("roleid"));
role.setRoleName(resultSet.getString("rolename"));
role.setRoleState(resultSet.getInt("rolestate"));
rolesList.add(role);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return rolesList;
}
@Override
public int total() {
int total = 0;
try {
String sql = "select count(1) from role ";
resultSet = query(sql, null);
while (resultSet.next()){
total = resultSet.getInt(1);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return total;
}
servlet
RoleServlet
/**
* 查询数据
* （分页）
*/
protected void select(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1接收参数.分页参数、模糊查参数
String index = req.getParameter("index");
int pageIndex=(index==null || index.length()==0)?1:Integer.parseInt(index);
//2调取service方法
PageUtil pageUtil = new PageUtil();
List<Role> roleList = roleService.getRoleList(pageIndex, pageUtil.getPageSize());
int total = roleService.total();
pageUtil.setTotal(total);//总条数
pageUtil.setPageIndex(pageIndex);
pageUtil.setDataList(roleList);
//3存值跳页面
req.setAttribute("pi",pageUtil);
req.getRequestDispatcher("list.jsp").forward(req,resp);
}
③ 新增角色
service
RoleService
/**
* 新增角色
*/
public int insertRole(String rolename,String state,String[] ids);
RoleServiceImpl
@Override
public int insertRole(String rolename, String state, String[] ids) {
/**
* 1和2都执行成功，则新增成功
*/
int k1 = 0;//标记
try {
//1新增角色表
Role role = new Role();
role.setRoleName(rolename);
role.setRoleState(Integer.parseInt(state));
int k = roleDao.insertRole(role);
//2新增中间表
//（获得新增数据的id）
for (String id : ids) {
middleDao.insertMiddle(k,Integer.parseInt(id));
}
k1 = 1;
} catch (NumberFormatException e) {
e.printStackTrace();
}
return k1;
}
MenuService
/**
* 查询菜单列表，无参数，无分级
*/
public List<Menu> getMenuList();
MenuServiceImpl
@Override
public List<Menu> getMenuList() {
List<Menu> menuList = menuDao.getMenuList();//先调取方法返回菜单集合，此时没有分一二级
/**
* 进行分页
*/
//保存分级以后的菜单
List<Menu> newMenuList = new ArrayList<>();
for (Menu menu:menuList) {
if(menu.getUpmenuId()==0){
//一级菜单
ArrayList<Menu> secondList = new ArrayList<>();//用于保存二级菜单
for (Menu second : menuList) {
//跑二级菜单
if(second.getUpmenuId()==menu.getMenuId()){
secondList.add(second);
}
}
menu.setSecondMenuList(secondList);
newMenuList.add(menu);
}
}
return newMenuList;
}
dao
RoleDao
/**
* 新增角色
*/
public int insertRole(Role role);
RoleDaoImpl
@Override
public int insertRole(Role role) {
int key = 0;//新增数据的id
try {
String sql = "insert into role values(null,?,?)";
List params = new ArrayList();
params.add(role.getRoleName());
params.add(role.getRoleState());
int update = update(sql, params);//update保存的是受影响的行数
ResultSet generatedKeys = pps.getGeneratedKeys();
if(generatedKeys.next()){
key = generatedKeys.getInt(1);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return key;
}
MiddleDao
/**
* 新增角色
*/
public int insertMiddle(int roleId,int menuId);
MiddleDaoImpl
@Override
public int insertMiddle(int roleId, int menuId) {
int i = 0;
try {
String sql = "insert into middle values(null,?,?)";
List params = new ArrayList();
params.add(roleId);
params.add(menuId);
i = update(sql, params);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return i;
}
servlet
RoleServlet
首先获取菜单列表，即角色对应的功能列表 href="/power/role/roles?method=selectmenus"
/**
* 查询菜单列表
*/
protected void selectmenus(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1接收参数（无参数跳过）
//2调取service方法
List<Menu> menuList = menuService.getMenuList();
req.setAttribute("menulist",menuList);
req.getRequestDispatcher("add.jsp").forward(req,resp);
}
获取菜单列表后，在add.jsp界面输入角色信息，进行新增角色action="/power/role/roles?method=insert" method=“post”
/**
* 新增角色
* @param req
* @param resp
* @throws ServletException
* @throws IOException
*/
protected void insert(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理乱码
//req.setCharacterEncoding("utf-8");
//接收参数
String rolename = req.getParameter("rolename");
String state = req.getParameter("state");
String[] menuids = req.getParameterValues("menuid");
//调取service方法
int i = roleService.insertRole(rolename, state, menuids);
resp.setContentType("text/html;charset=utf-8");
PrintWriter writer = resp.getWriter();
if(i>0){
//新增成功
writer.println("<script>alert('新增成功');location.href='/power/role/roles?method=select'</script>");
}else{
//新增失败
writer.println("<script>alert('新增失败,请检查输入信息');location.href='/power/role/roles?method=selectmenus'</script>");
}
}
④ 主键查询
根据id查询到角色信息
service
RoleService
/**
* 根据id查找角色
*/
public Role findById(int roleid);
RoleServiceImpl
@Override
public Role findById(int roleid) {
Role role = roleDao.findById(roleid);
return role;
}
MenuService
/**
* 获取菜单列表(菜单对象里存有拥有该菜单的角色列表)
*/
public List<Menu> getMenuList(Role role);
MenuServiceImpl
@Override
public List<Menu> getMenuList(Role role) {
List<Menu> menuList = menuDao.getMenuList();//未分级
//1.遍历集合，将role赋值
for (Menu menu : menuList) {
for (Menu roleMenu : role.getMenuList()) {
if(menu.getMenuId() == roleMenu.getMenuId()){
List<Role> list = new ArrayList<>();
list.add(role);
menu.setRoleList(list);
}
}
}
//2.分级
List<Menu> newMenuList = new ArrayList<>();
for (Menu menu : menuList) {
if(menu.getUpmenuId() == 0){
List<Menu> secondList = new ArrayList<>();
for (Menu second : menuList) {
if(second.getUpmenuId() == menu.getMenuId()){
secondList.add(second);
}
}
menu.setSecondMenuList(secondList);
newMenuList.add(menu);
}
}
return newMenuList;
}
dao
RoleDao
/**
* 根据id查找角色
*/
public Role findById(int roleid);
RoleDaoImpl
@Override
public Role findById(int roleid) {
Role role = new Role();
ArrayList<Menu> ms = new ArrayList<>();
try {
String sql ="select * from role,middle,menu where role.roleid = middle.roleid and middle.menuid = menu.menuid and role.roleid = ?";
List params = new ArrayList();
params.add(roleid);
resultSet = query(sql,params);
while (resultSet.next()){
role.setRoleId(resultSet.getInt("roleid"));
role.setRoleName(resultSet.getString("rolename"));
role.setRoleState(resultSet.getInt("rolestate"));
Menu menu = new Menu();
menu.setMenuId(resultSet.getInt("menuid"));
menu.setMenuName(resultSet.getString("menuname"));
menu.setUrl(resultSet.getString("url"));
menu.setState(resultSet.getInt("state"));
menu.setUpmenuId(resultSet.getInt("upmenuid"));
ms.add(menu);
}
role.setMenuList(ms);
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return role;
}
MenuDao
/**
* 查询菜单列表
*/
public List<Menu> getMenuList();
MenuDaoImpl
@Override
public List<Menu> getMenuList() {
List<Menu> menuList = new ArrayList<>();
try {
String sql = "select * from menu";
resultSet = query(sql, null);
while (resultSet.next()){
Menu menu = new Menu();
menu.setMenuId(resultSet.getInt("menuid"));
menu.setMenuName(resultSet.getString("menuname"));
menu.setUpmenuId(resultSet.getInt("upmenuid"));
menu.setState(resultSet.getInt("state"));
menu.setDesc(resultSet.getString("desc"));
menu.setUrl(resultSet.getString("url"));
menuList.add(menu);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
} finally {
closeAll();
}
return menuList;
}
servlet
RoleServlet
href="/power/role/roles?method=findbyid&roleid=${r.roleId}"
/**
* 主键查询
*/
protected void findbyid(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1接收参数
String roleId = req.getParameter("roleid");
//2处理查询方法,根据主键查询学生信息
Role role = roleService.findById(Integer.parseInt(roleId));
List<Menu> menuList = menuService.getMenuList(role);
req.setAttribute("role",role);
req.setAttribute("menulist",menuList);
req.getRequestDispatcher("edit.jsp").forward(req,resp);
}
⑤ 修改角色
service
RoleService
/**
* 更新角色
*/
public int updateRole(String rolename, String state,String[] ids, String roleid);
RoleServiceImpl
@Override
public int updateRole(String rolename, String state,String[] ids, String roleid) {
Role role = new Role();
role.setRoleId(Integer.parseInt(roleid));
role.setRoleName(rolename);
role.setRoleState(Integer.parseInt(state));
int update = roleDao.updateRole(role);
System.out.println("RoleServiceIimpl-role-Id:"+role.getRoleId());
int delete = middleDao.deleteMiddle(Integer.parseInt(roleid));
//新增middle表
int count = 0;
for (String menu : ids) {
count += middleDao.insertMiddle(Integer.parseInt(roleid), Integer.parseInt(menu));
}
return count;
}
dao
RoleDao
/**
* 更新角色
*/
public int updateRole(Role role);
RoleDaoImpl
@Override
public int updateRole(Role role) {
int update = 0;
try {
String sql = "update role set rolename=?,rolestate=? where roleid=?";
List params = new ArrayList();
params.add(role.getRoleName());
params.add(role.getRoleState());
params.add(role.getRoleId());
update = update(sql,params);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return update;
}
MiddleDao
/**
* 更新时先将原来的id删掉
*/
public int deleteMiddle(int roleId);
MiddleDaoImpl
@Override
public int deleteMiddle(int roleId) {
int delete = 0;
try {
String sql = "delete from middle where roleid=? ";
List params = new ArrayList();
params.add(roleId);
delete = update(sql,params);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return delete;
}
servlet
RoleServlet
首先通过要修改角色的id进行主键查询查找到角色信息href="/power/role/roles?method=findbyid&roleid=${r.roleId}"，随后跳转到edit.jsp页面进行信息修改
信息修改完成后点击提交action="/power/role/roles?method=update" method=“post”
/**
* 修改角色信息
*/
protected void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理乱码
//req.setCharacterEncoding("utf-8");
//接收参数
String roleid = req.getParameter("roleid");
String rolename = req.getParameter("rolename");
String state = req.getParameter("state");
String[] menuids = req.getParameterValues("menuid");
//调取service方法
int i = roleService.updateRole(rolename,state,menuids,roleid);//成功count
resp.setContentType("text/html;charset=utf-8");
PrintWriter writer = resp.getWriter();
if(i == menuids.length){
//修改成功
writer.println("<script>alert('修改成功');location.href='/power/role/roles?method=select'</script>");
}else{
//修改失败
writer.println("<script>alert('修改失败,请检查输入信息');location.href='/power/role/roles?method=findbyid&roleid="+Integer.parseInt(roleid)+"'</script>");
}
}
⑥ 删除角色
service
RoleService
/**
* 删除角色
*/
public int deletebyid(String roleid);
RoleServiceImpl
@Override
public int deletebyid(String roleid) {
int deleteMiddle = middleDao.delete(Integer.parseInt(roleid));
int deleteRole = roleDao.deleteRole(Integer.parseInt(roleid));
if(deleteRole>0 && deleteMiddle>0){
return 1;
}
return 0;
}
dao
RoleDao
/**
* 删除角色
*/
public int deleteRole(int roleid);
RoleDaoImpl
@Override
public int deleteRole(int roleid) {
int i = 0;
try {
String sql = "delete from role where roleid=? ";
List params = new ArrayList();
params.add(roleid);
i = update(sql,params);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return i;
}
MiddleDao
/**
* 删除
*/
public int delete(int roleid);
MiddleDaoImpl
/**
* 删除
*/
@Override
public int delete(int roleid) {
int i = 0;
try {
String sql = "delete from middle where roleid=? ";
List params = new ArrayList();
params.add(roleid);
i = update(sql,params);
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return i;
}
servlet
RoleServlet
/**
* 删除角色
*/
protected void delete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理乱码
//req.setCharacterEncoding("utf-8");
//接收参数
String roleid = req.getParameter("roleid");
//调取service方法
int i = roleService.deletebyid(roleid);//成功返回1，失败返回0
resp.setContentType("text/html;charset=utf-8");
PrintWriter writer = resp.getWriter();
if(i>0){
//删除成功
writer.println("<script>alert('删除成功');location.href='/power/role/roles?method=select'</script>");
}else{
//删除失败
writer.println("<script>alert('删除失败');location.href='/power/role/roles?method=select'</script>");
}
}