Skip to content

X
xzxt-shiro
Commit 84cc080c by zhaoshaonan
Options

Merge remote-tracking branch 'origin/dev' into dev

parents 43e62eae 3778144c
Showing with 23 additions and 4622 deletions
src/main/java/com/shiro/demo/controller/LoginController.java deleted 100644 → 0
package com.shiro.demo.controller;
import com.shiro.demo.pojo.User;
import com.shiro.demo.service.UserService;
import com.shiro.demo.util.TokenUtil;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
/**
* Created by changchao on 2018/6/22.
*/
//@RequestMapping(value = "/")
//@Controller
//public class LoginController {
// private static final Logger logger = LoggerFactory.getLogger(LoginController.class);
// @Autowired
// private UserService userService;
//
// @RequestMapping(value = "/login", method = RequestMethod.GET)
// public String login() {
//
// return "login";
// }
//
// @RequestMapping(value = "/login", method = RequestMethod.POST)
// public String login(User user, boolean rememberMe, Model model) {
// String msg = null;
// try {
// //用户登录
// user = TokenUtil.login(user, rememberMe);
//
// } catch (Exception e) {
// /*User login = userService.login(user.getUsername(), user.getPassword());
// if (login.getStatus() == 0) {
// msg = "用户已经被禁用，请联系管理员启用该账号";
// } else {
// msg = "用户名或密码不正确";
// }*/
// msg = "用户名或密码不正确";
// } finally {
// if (msg == null) {
// return "redirect:/admin/pagejump/index";
// }
//
// model.addAttribute("msg", msg);
// return "login";
// }
// }
//
// @RequestMapping(value = "/logout", method = RequestMethod.GET)
// public String logout(Model model) {
// Subject subject = SecurityUtils.getSubject();
// /*System.out.println("session信息已经成功清除!" + session.getAttribute("user"));
// session.removeAttribute("user");*/
// subject.logout();
// model.addAttribute("msg", "您已经退出登录,请重新登录");
// return "login";
// }
//
// @RequestMapping(value = "/unAuthorization")
// public String unAuthorization() {
// return "unAuthorization";
// }
//}
src/main/java/com/shiro/demo/controller/PageJunpController.java deleted 100644 → 0
package com.shiro.demo.controller;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.User;
import com.shiro.demo.service.UserService;
import com.shiro.demo.util.TokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import java.util.List;
/**
* 页面跳转controller
*
* @author changchao
* @date 2017年8月10日 上午11:15:56
*/
//@RequestMapping("/admin/pagejump")
//@Controller
//public class PageJunpController {
// @Autowired
// private UserService userService;
//
// /**
// * 跳转到index主页
// *
// * @param model
// * @return
// */
// @RequestMapping(value = "/index", method = RequestMethod.GET)
// public String index(Model model) {
// //获取用户信息
// User user = TokenUtil.getUser();
// Integer userId = user.getId();
// List<List<Permission>> list= userService.selectMenusByUserId(userId);
// //System.out.println(list);
// model.addAttribute("list", list);
// return "index";
// }
//
// /**
// * 跳转到welcome页面
// *
// * @param model
// * @return
// */
// @RequestMapping(value = "/welcome", method = RequestMethod.GET)
// public String welcome(Model model) throws Exception {
// return "welcome";
// }
//}
src/main/java/com/shiro/demo/controller/admin/MemberController.java deleted 100644 → 0
package com.shiro.demo.controller.admin;
import com.shiro.demo.pojo.User;
import com.shiro.demo.service.RoleService;
import com.shiro.demo.service.UserService;
import com.shiro.demo.util.ShiroKit;
import com.shiro.demo.util.TokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* @author changchao
* @desc
* @date 2017/10/31 12:52
*/
@Controller
@RequestMapping("/admin/member")
public class MemberController {
@Autowired
private UserService userService;
@Autowired
private RoleService roleService;
/**
* 跳转到修改密码页面
* @param msg
* @param model
* @return
*/
// @RequestMapping(value = "/updatepwd", method = RequestMethod.GET)
// public String updatepwd(String msg, Model model) {
// User user= TokenUtil.getUser();
// model.addAttribute("user",user);
// return "admin/member/updatepwd";
// }
//
// /**
// * 修改密码
// * @param user
// * @param pwd
// * @param model
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/updatepwd", method = RequestMethod.POST)
// public Integer update(User user, String pwd, Model model) {
// String pwdKit = ShiroKit.md5(pwd, user.getUsername());
// String password = userService.loadByUsername(user.getUsername()).getPassword();
// if (pwdKit.equals(password)) {
// //密码校验成功，执行修改密码操作
// Integer i = userService.updatePwd(user);
// if (i == 1) {
// return 1;
// } else {
// return 2;
// }
//
// } else {
// return 0;
// }
// }
/**
* 跳转到我的权限页面
* @param
* @param model
* @return
*/
/*@RequestMapping(value = "/mypermission", method = RequestMethod.GET)
public String mypermission(String msg, Model model) {
User user= TokenUtil.getUser();
List<Integer> roleIds=userService.selectRoleIdByUserId(user.getId());
String[] permissions ={};
if (roleIds!=null&&roleIds.size()==1){
Integer roleId=roleIds.get(0);
Role role = roleService.selectRoleById(roleId);
permissions = role.getPermission().split(" ");
}
model.addAttribute("permissions",permissions);
model.addAttribute("user",user);
return "admin/member/mypermission";
}*/
// @RequestMapping(value = "/index",method = RequestMethod.GET)
// public String index(Model model){
// User user= TokenUtil.getUser();
// model.addAttribute("user",user);
// return "admin/member/detail";
// }
}
src/main/java/com/shiro/demo/controller/admin/MenuController.java deleted 100644 → 0
package com.shiro.demo.controller.admin;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.PermissionPage;
import com.shiro.demo.service.PermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.ArrayList;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/30 9:59
*/
@Controller
@RequestMapping(value = "/admin/menu")
public class MenuController {
@Autowired
private PermissionService permissionService;
/**
* 跳转到菜单列表
*
* @return
*/
@RequestMapping(value = "/index", method = RequestMethod.GET)
public String index(String msg, Model model) {
if (msg != null) {
/*if ("success".equals(msg)){
model.addAttribute("msg", "菜单添加成功!");
}*/
if ("error1".equals(msg)){
model.addAttribute("msg", "当前菜单不可禁用!");
}
}
return "admin/menu/list";
}
/**
* 根据条件获取菜单列表
*
* @param
* @return
*/
@ResponseBody
@RequestMapping(value = "/list", method = RequestMethod.GET)
public PermissionPage list(Permission permission) {
return permissionService.selectMenuPage(permission);
}
/**
* 跳转到菜单添加页面
*
* @param model
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.GET)
public String addIndex(Model model) {
List<Permission> menus = permissionService.selectNoSetMenus();
List<Permission> parantMenus = permissionService.selectAllPermissions();
model.addAttribute("menus", menus);
model.addAttribute("parantMenus", parantMenus);
return "admin/menu/add";
}
/**
* 菜单添加
*
* @param permission
* @param model
* @return
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String add(Permission permission, Model model) {
Integer update = permissionService.updatePermissionById(permission);
if (update == 0) {
//添加失败,重新添加
model.addAttribute("permission", permission);
model.addAttribute("msg", "菜单添加失败,请重新添加!");
return "/admin/menu/add";
} else {
return "redirect:/admin/menu/index?msg=success";
}
}
/**
* 跳转到角色修改页面
*
* @param
* @param model
* @return
*/
@RequestMapping(value = "/update/{permissionId}", method = RequestMethod.GET)
public String updateInex(@PathVariable("permissionId") Integer permissionId, Model model) {
Permission permission = permissionService.selectPermissionById(permissionId);
List<Permission> menus = permissionService.selectNoSetMenus();
List<Permission> parantMenus = permissionService.selectAllPermissions();
model.addAttribute("menus", menus);
model.addAttribute("parantMenus", parantMenus);
model.addAttribute("permission", permission);
return "admin/menu/update";
}
/**
* 删除菜单
*
* @param
* @return
*/
@ResponseBody
@RequestMapping(value = "/deleteMenuById", method = RequestMethod.POST)
public String deleteMenuById(Permission permission) {
Integer i = permissionService.deleteMenuById(permission);
if (i == 1) {
return "success";
} else {
return "error";
}
}
/**
* 设置菜单启用状态
*
* @param permission
* @return
*/
@ResponseBody
@RequestMapping(value = "/updateFlag", method = RequestMethod.POST)
public String updateFlag(Permission permission) {
List permissionIds = new ArrayList();
permissionIds.add(5000);
permissionIds.add(5100);
permissionIds.add(5110);
permissionIds.add(5120);
permissionIds.add(5130);
permissionIds.add(5200);
permissionIds.add(5210);
permissionIds.add(5300);
permissionIds.add(5310);
permissionIds.add(5320);
permissionIds.add(5330);
Integer i = 0;
if (!permissionIds.contains(permission.getId())) {
i = permissionService.updateFlagById(permission);
}
if (i == 1) {
return "success";
} else if(i==0) {
return "error1";
}else {
return "error";
}
}
}
src/main/java/com/shiro/demo/controller/admin/PermissionController.java deleted 100644 → 0
package com.shiro.demo.controller.admin;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.PermissionPage;
import com.shiro.demo.service.PermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 11:54
*/
//@Controller
//@RequestMapping(value = "/admin/permission")
public class PermissionController {
// @Autowired
// private PermissionService permissionService;
//
// /**
// * 跳转到权限列表
// *
// * @return
// */
//// @RequestMapping(value = "/index", method = RequestMethod.GET)
//// public String index(String msg, Model model) {
//// /*if (msg != null && msg != "") {
//// model.addAttribute("msg", "权限添加成功!");
//// }*/
//// return "admin/permission/list";
//// }
////
//// /**
//// * 根据条件获取权限列表
//// *
//// * @param
//// * @return
//// */
//// @ResponseBody
//// @RequestMapping(value = "/list", method = RequestMethod.GET)
//// public PermissionPage list(Permission permission) {
//// return permissionService.selectPermissionPage(permission);
//// }
//
//// /**
//// * 跳转到权限添加页面
//// *
//// * @param model
//// * @return
//// */
//// @RequestMapping(value = "/add", method = RequestMethod.GET)
//// public String addIndex(Model model) {
//// List<Permission> parantMenus=permissionService.selectAllPermissions();
//// model.addAttribute("parantMenus",parantMenus);
//// return "admin/permission/add";
//// }
////
//// /**
//// * 添加权限---提交
//// *
//// * @param
//// * @param model
//// * @return
//// */
//// @RequestMapping(value = "/add", method = RequestMethod.POST)
//// public String add(Permission permission, Model model) {
//// //如果父级菜单为null,说明是顶级菜单,设置为0
//// if (permission.getParantid()==null){
//// permission.setParantid(0);
//// }
//// Integer add = permissionService.add(permission);
//// if (add == 0) {
//// //添加失败,重新添加
//// model.addAttribute("permission", permission);
//// model.addAttribute("msg", "权限ID已存在,请重新输入!");
//// return "/admin/permission/add";
//// } else {
//// return "redirect:/admin/permission/index?msg=success";
//// }
//// }
// /**
// * 跳转到角色修改页面
// *
// * @param
// * @param model
// * @return
// */
// @RequestMapping(value = "/update/{permissionId}", method = RequestMethod.GET)
// public String updateIndex(@PathVariable("permissionId") Integer permissionId, Model model) {
// Permission permission = permissionService.selectPermissionById(permissionId);
// List<Permission> parantMenus=permissionService.selectAllPermissions();
// model.addAttribute("permission",permission);
// model.addAttribute("parantMenus",parantMenus);
// return "admin/permission/update";
// }
//
// /**
// * 更新角色,删除授权并重新进行授权
// * @param
// * @param model
// * @return
// */
// @RequestMapping(value = "/update", method = RequestMethod.POST)
// public String update(Permission permission, Model model) {
// Integer update = permissionService.update(permission);
// return "redirect:/admin/permission/index?msg=success";
// }
// /**
// * 根据id删除权限
// * @param permission
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/deletePermissionById",method = RequestMethod.POST)
// public String deletePermissionById(Permission permission){
// Integer i=permissionService.deletePermissionById(permission);
// if (i==1) {
// return "success";
// }else {
// return "error";
// }
// }
}
src/main/java/com/shiro/demo/controller/admin/RoleController.java deleted 100644 → 0
package com.shiro.demo.controller.admin;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.RolePage;
import com.shiro.demo.service.PermissionService;
import com.shiro.demo.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.ArrayList;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/27 12:54
*/
@Controller
@RequestMapping(value = "/admin/role")
public class RoleController {
@Autowired
private RoleService roleService;
@Autowired
private PermissionService permissionService;
/**
* 跳转到角色列表
*
* @return
*/
// @RequestMapping(value = "/index", method = RequestMethod.GET)
// public String index(String msg, Model model) {
// /*if (msg != null && msg != "") {
// model.addAttribute("msg", "角色添加成功!");
// }*/
// return "admin/role/list";
// }
//
// /**
// * 根据条件获取角色列表
// *
// * @param
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/list", method = RequestMethod.GET)
// public RolePage list(Role role) {
// return roleService.selectRolePage(role);
// }
/**
* 跳转到角色添加页面
*
* @param model
* @return
*/
// @RequestMapping(value = "/add", method = RequestMethod.GET)
// public String addIndex(Model model) {
// Permission permission = permissionService.selectPermission();
// model.addAttribute("permission",permission);
// return "admin/role/add";
// }
/**
* 添加角色---提交
*
* @param
* @param model
* @return
*/
// @RequestMapping(value = "/add", method = RequestMethod.POST)
// public String add(Role role, Model model) {
// Role add = roleService.add(role);
// return "redirect:/admin/role/index?msg=success";
// }
/**
* 跳转到角色修改页面
*
* @param
* @param model
* @return
*/
// @RequestMapping(value = "/update/{roleId}", method = RequestMethod.GET)
// public String updateIndex(@PathVariable("roleId") Integer roleId, Model model) {
// Role role = roleService.selectRoleById(roleId);
// String[] permissions = role.getPermission().split(" ");
// List list=new ArrayList<>();
// for (int i = 0; i < permissions.length; i++) {
// String permission = permissions[i];
// list.add(permission);
// }
// Permission permission = permissionService.selectPermission();
// model.addAttribute("permission",permission);
// model.addAttribute("permissions",list);
// model.addAttribute("role", role);
// return "admin/role/update";
// }
//
// /**
// * 更新角色,删除授权并重新进行授权
// * @param role
// * @param model
// * @return
// */
// @RequestMapping(value = "/update", method = RequestMethod.POST)
// public String update(Role role, Model model) {
// Role update = roleService.update(role);
// return "redirect:/admin/role/index?msg=success";
// }
//
// /**
// * 删除角色,并删除授权
// * @param role
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/deleteRoleById",method = RequestMethod.POST)
// public String deleteRoleById(Role role){
// Integer i=roleService.deleteRoleById(role);
// if (i==1) {
// return "success";
// }else {
// return "error";
// }
// }
}
src/main/java/com/shiro/demo/controller/admin/UserController.java deleted 100644 → 0
package com.shiro.demo.controller.admin;
import com.shiro.demo.pojo.Dept;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.User;
import com.shiro.demo.pojo.UserPage;
import com.shiro.demo.service.DeptService;
import com.shiro.demo.service.RoleService;
import com.shiro.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 11:54
*/
@Controller
@RequestMapping(value = "/admin/user")
public class UserController {
@Autowired
private UserService userService;
@Autowired
private DeptService deptService;
@Autowired
private RoleService roleService;
/**
* 跳转到用户列表
*
* @return
*/
// @RequestMapping(value = "/index", method = RequestMethod.GET)
// public String index(String msg,Model model) {
// /*if (msg!=null&&msg!=""){
// model.addAttribute("msg","用户添加成功!");
// }*/
// return "admin/user/list";
// }
//
// /**
// * 根据条件获取用户列表
// *
// * @param user
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/list", method = RequestMethod.GET)
// public UserPage list(User user) {
// return userService.selectUserPage(user);
// }
// /**
// * 跳转到用户添加页面
// *
// * @param model
// * @return
// */
// @RequestMapping(value = "/add", method = RequestMethod.GET)
// public String addIndex(Model model) {
// List<Dept> depts = deptService.selectDepts();
// List<Role> roles = roleService.selectRoles();
//
// model.addAttribute("depts", depts);
// model.addAttribute("roles", roles);
// return "admin/user/add";
// }
/**
* 添加用户---提交
*
* @param user
* @param model
* @return
*/
//
// @RequestMapping(value = "/add", method = RequestMethod.POST)
// public String add(User user, Model model) {
// User add = userService.add(user);
// if (add.getUsername() == null) {
// List<Dept> depts = deptService.selectDepts();
// List<Role> roles = roleService.selectRoles();
// model.addAttribute("depts", depts);
// model.addAttribute("roles", roles);
// model.addAttribute("user", user);
// model.addAttribute("msg", "登录已存在,请修改登录名!");
// return "admin/user/add";
// } else {
// return "redirect:/admin/user/index?msg=success";
// }
// }
// /**
// * 跳转到用户修改页面
// *
// * @param userId
// * @param model
// * @return
// */
// @RequestMapping(value = "/update/{userId}", method = RequestMethod.GET)
// public String updateInex(@PathVariable("userId") Integer userId, Model model) {
// User user = userService.selectUserById(userId);
// List<Dept> depts = deptService.selectDepts();
// List<Role> roles = roleService.selectRoles();
// model.addAttribute("depts", depts);
// model.addAttribute("roles", roles);
// model.addAttribute("user", user);
// return "admin/user/update";
// }
//
// /**
// * 提交用户修改数据
// *
// * @param user
// * @return
// */
// @RequestMapping(value = "/update", method = RequestMethod.POST)
// public String update(User user,Model model) {
// User update = userService.update(user);
// if(update!=null){
// model.addAttribute("msg", "用户修改成功!");
// return "redirect:/admin/user/index?msg=success";
// }else{
// List<Dept> depts = deptService.selectDepts();
// List<Role> roles = roleService.selectRoles();
// model.addAttribute("depts", depts);
// model.addAttribute("roles", roles);
// model.addAttribute("user", user);
// model.addAttribute("msg", "用户失败成功!");
// return "admin/user/update";
// }
// }
// /**
// * 修改用户当前状态
// * @param user
// * @return
// */
// @ResponseBody
// @RequestMapping(value = "/updateState",method = RequestMethod.POST)
// public String updateState(User user) {
// Integer i=userService.updateStatusById(user);
// if (i==1) {
// return "success";
// }else {
// return "error";
// }
// }
/**
* 删除选择用户
* @param user
* @return
*/
// @ResponseBody
// @RequestMapping(value="/deleteUserById",method = RequestMethod.POST)
// public String deleteUserById(User user){
// Integer i=userService.deleteUserById(user);
// if (i==1) {
// return "success";
// }else {
// return "error";
// }
// }
}
src/main/java/com/shiro/demo/dao/DeptDao.java deleted 100644 → 0
package com.shiro.demo.dao;
import com.shiro.demo.pojo.Dept;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:19
*/
public interface DeptDao {
/**
* 获取部门列表
* @return
*/
List<Dept> selectDepts();
}
src/main/java/com/shiro/demo/dao/PermissionDao.java deleted 100644 → 0
package com.shiro.demo.dao;
import com.shiro.demo.pojo.Permission;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/27 15:49
*/
public interface PermissionDao {
/**
* 获取所有权限
*
* @return
*/
List<Permission> selectPermission();
/**
* 根据条件获取权限列表
*
* @param permission
* @return
*/
List<Permission> selectPermissionsByCondition(@Param("permission") Permission permission);
/**
* 根据条件获取权限总数
*
* @param permission
* @return
*/
Integer selectPermissionsCountByCondition(@Param("permission") Permission permission);
/**
* 添加权限&菜单
*
* @param permission
* @return
*/
Integer add(@Param("permission") Permission permission);
/**
* 获取菜单列表
*
* @param permission
* @return
*/
List<Permission> selectMenusByCondition(@Param("permission") Permission permission);
/**
* 获取菜单总数
*
* @param permission
* @return
*/
Integer selectMenusCountByCondition(@Param("permission") Permission permission);
/**
* 获取未生成菜单的选项,排除'系统管理'和'系统资源'
*
* @return
*/
List<Permission> selectNoSetMenus();
/**
* 获取所有父级菜单
*
* @return
*/
List<Permission> selectAllPermissions();
/**
* 菜单添加(权限数据修改)
*
* @param permission
* @return
*/
Integer updatePermissionById(@Param("permission") Permission permission);
/**
* 获取最大排序
*
* @param permission
* @return
*/
Integer selectMaxZindexByParantid(@Param("permission") Permission permission);
/**
* 根据id获取权限数据
*
* @param permissionId
* @return
*/
Permission selectPermissionById(@Param("permissionId") Integer permissionId);
/**
* 根据id修改菜单启用状态
*
* @param permission
* @return
*/
Integer updateFlagById(@Param("permission") Permission permission);
/**
* 根据id删除权限
*
* @param permission
* @return
*/
Integer deletePermissionById(@Param("permission") Permission permission);
/**
* 更新角色,删除授权并重新进行授权
*
* @param role
* @param model
* @return
*/
Integer update(@Param("permission") Permission permission);
/**
* 删除菜单
*
* @param permission
* @return
*/
Integer updateMenuById(@Param("permission") Permission permission);
}
src/main/java/com/shiro/demo/dao/RoleDao.java deleted 100644 → 0
package com.shiro.demo.dao;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.RoleAndPermission;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:23
*/
public interface RoleDao {
/**
* 获取角色列表
*
* @return
*/
List<Role> selectRoles();
/**
* 根据条件获取角色列表
*
* @param role
* @return
*/
List<Role> selectRoleByCondition(@Param("role") Role role);
/**
* 根据条件获取角色总数
*
* @param role
* @return
*/
Integer selectRoleCountByCondition(@Param("role") Role role);
/**
* 添加角色
*
* @param role
* @return
*/
int add(@Param("role") Role role);
/**
* 批量添加角色权限关联
*
* @param roleAndPermissions
* @return
*/
int batchAddRoleAndPermission(@Param("roleAndPermissions") List<RoleAndPermission> roleAndPermissions);
/**
* 根据角色id获取权限字符串
*
* @param roleId
* @return
*/
List<Role> selectPermissionByRoleId(@Param("roleId") Integer roleId);
/**
* 根据ID修改角色信息
*
* @param roleId
* @return
*/
Role selectRoleById(@Param("roleId") Integer roleId);
/**
* 修改角色
*
* @param role
* @return
*/
int update(@Param("role") Role role);
/**
* 删除授权
*
* @param roleId
* @return
*/
int delectPermissionByRoleId(@Param("roleId") Integer roleId);
/**
* 删除角色
*
* @param roleId
* @return
*/
int deleteRoleById(Integer roleId);
/**
* 根据用户id获取角色id
* @param userId
* @return
*/
Role selectRoleByUserId(Integer userId);
}
src/main/java/com/shiro/demo/dao/UserDao.java deleted 100644 → 0
package com.shiro.demo.dao;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.User;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface UserDao {
/**
* 根据用户名获取用户
*
* @param username
* @return
*/
User findByUserName(@Param("username") String username);
/**
* 根据用户id查询权限
*
* @param userId
* @return
*/
List<Permission> selectPermissionsByUserId(@Param("userId") Integer userId);
/**
* 根据用户id查询角色昵称
*
* @param userId
* @return
*/
List<String> selectRoleSnsByUserId(@Param("userId") Integer userId);
/**
* 根据用户id获取角色id
*
* @param userId
* @return
*/
List<Integer> selectRoleIdByUserId(@Param("userId") Integer userId);
/**
* 获取所有菜单列表
*
* @return
*/
List<Permission> selectAllMenus();
/**
* 根据用户ID获取菜单列表
*
* @param userId
* @return
*/
List<Permission> selectMenusByUserId(@Param("userId") Integer userId);
/**
* 根据条件获取用户列表
*
* @param user
* @return
*/
List<User> selectUserByCondition(@Param("user") User user);
/**
* 根据条件获取用户总数
*
* @return
*/
Integer selectUserCountByCondition();
/**
* 添加用户
*
* @param user
* @return
*/
int insert(@Param("user") User user);
/**
* 添加用户角色关联
*
* @param user
* @return
*/
int insertUserRole(@Param("user") User user);
/**
* 根据id获取用户信息
*
* @param userId
* @return
*/
User selectUserById(@Param("userId") Integer userId);
/**
* 提交用户修改数据
*
* @param user
* @return
*/
int update(@Param("user") User user);
/**
* 删除用户角色关联
*
* @param user
* @return
*/
int delectUserRole(@Param("user") User user);
/**
* 重新添加用户角色关联
*
* @param user
* @return
*/
int addUserRole(@Param("user") User user);
/**
* 修改用户当前状态
*
* @param status
* @return
*/
int updateStatusById(@Param("user") User user);
/**
* 删除选择用户
*
* @param user
* @return
*/
Integer deleteUserById(@Param("user") User user);
/**
* 根据用户名加载用户对象（用于登录使用）
* @param username
* @return
*/
User loadByUserName(@Param("username") String username);
/**
* 修改密码
* @param user
* @return
*/
Integer updatePwd(@Param("user") User user);
/**
* 根据用户id获取用户
* @param userId
* @return
*/
User findByUserId(@Param("userId") Integer userId);
}
src/main/java/com/shiro/demo/mapper/DeptDao.xml deleted 100644 → 0
<?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.shiro.demo.dao.DeptDao">
<select id="selectDepts" resultType="dept">
<!---->
SELECT
t_dept.id,
t_dept.`code`,
t_dept.`name`,
t_dept.parantid
FROM
t_dept
</select>
</mapper>
src/main/java/com/shiro/demo/mapper/PermissionDao.xml deleted 100644 → 0
<?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.shiro.demo.dao.PermissionDao">
<select id="selectPermission" resultType="permission">
<!---->
SELECT
t_permission.id,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission
</select>
<select id="selectPermissionsByCondition" resultType="permission">
<!---->
SELECT
(@r :=@r + 1) AS id,
t_permission.id permissionId,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission,
(SELECT @r := ${(permission.page-1)*permission.limit}) r
LIMIT ${(permission.page-1)*permission.limit},
${permission.limit}
</select>
<select id="selectPermissionsCountByCondition" resultType="int">
SELECT
count(1)
FROM
t_permission
</select>
<insert id="add">
<!---->
INSERT INTO `t_permission` (
`id`,
`name`,
`menuname`,
`permission`,
`url`,
`flag`,
`zindex`,
`parantid`
)
VALUES
(
#{permission.permissionId},
#{permission.name},
#{permission.menuname},
#{permission.permission},
#{permission.url},
#{permission.flag},
#{permission.zindex},
#{permission.parantid}
);
</insert>
<select id="selectMenusByCondition" resultType="permission">
<!---->
SELECT
(@r :=@r + 1) AS id,
t_permission.id permissionId,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission,
(SELECT @r := ${(permission.page-1)*permission.limit}) r
where menuname!=null or menuname!=''
LIMIT ${(permission.page-1)*permission.limit},
${permission.limit}
</select>
<select id="selectMenusCountByCondition" resultType="int">
SELECT
count(1)
FROM
t_permission
where menuname!=null or menuname!=''
</select>
<select id="selectNoSetMenus" resultType="permission">
<!---->
SELECT
t_permission.id,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission
WHERE
t_permission.id != 1
AND t_permission.id != 2
and (t_permission.menuname is NULL or t_permission.menuname = '')
</select>
<select id="selectAllPermissions" resultType="permission">
<!---->
SELECT
(@r :=@r + 1) AS id,
t_permission.id permissionId,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission,
(SELECT @r := 0) r
WHERE
t_permission.id != 1
AND t_permission.id != 2
and t_permission.parantid%1000=0 /*只保留顶级菜单和一级菜单*/
</select>
<update id="updatePermissionById">
<!---->
UPDATE `t_permission`
SET
`menuname` = #{permission.menuname},
`flag` = #{permission.flag},
`zindex` = #{permission.zindex}
WHERE
`id` = #{permission.id};
</update>
<select id="selectMaxZindexByParantid" resultType="int">
<!---->
SELECT
MAX(zindex)
from t_permission
where t_permission.parantid=#{permission.parantid}
</select>
<select id="selectPermissionById" resultType="permission">
<!---->
SELECT
t_permission.id,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission
where t_permission.id=#{permissionId}
</select>
<update id="updateFlagById">
<!---->
UPDATE `t_permission`
SET
`flag` = #{permission.flag}
WHERE
`id` = #{permission.id};
</update>
<delete id="deletePermissionById">
<!---->
DELETE
FROM
t_permission
WHERE
id = #{permission.id}
</delete>
<update id="update">
<!---->
UPDATE `t_permission`
SET
`name` = #{permission.name},
`permission` = #{permission.permission},
`url` = #{permission.url},
`flag` =#{permission.flag},
`parantid` = #{permission.parantid}
WHERE
`id` = #{permission.id};
</update>
<update id="updateMenuById">
<!---->
UPDATE `t_permission`
SET
`flag` = 0,
`menuname`=NULL ,
`zindex`=NULL
WHERE
`id` = #{permission.id};
</update>
</mapper>
src/main/java/com/shiro/demo/mapper/RoleDao.xml deleted 100644 → 0
<?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.shiro.demo.dao.RoleDao">
<select id="selectRoles" resultType="role">
<!---->
SELECT
t_role.id,
t_role.`name`,
t_role.sn,
t_role.remark
FROM
t_role
</select>
<select id="selectRoleByCondition" resultType="role">
<!---->
SELECT
(@r :=@r + 1) AS id,
t_role.id roleId,
t_role.`name`,
t_role.sn,
t_role.remark
FROM
t_role,
(SELECT @r := ${(role.page-1)*role.limit}) r
LIMIT ${(role.page-1)*role.limit},
${role.limit}
</select>
<select id="selectRoleCountByCondition" resultType="integer">
<!---->
SELECT
count(1)
FROM
t_role
</select>
<insert id="add">
<!---->
<selectKey resultType="integer" order="AFTER" keyProperty="role.roleId">
SELECT LAST_INSERT_ID();
</selectKey>
INSERT INTO `t_role` ( `name`, `sn`, `remark`)
VALUES
(
#{role.name},
#{role.sn},
#{role.remark}
);
</insert>
<insert id="batchAddRoleAndPermission">
<!---->
INSERT INTO `t_role_permission` (`role_id`, `permission_id`) VALUES
<foreach collection="roleAndPermissions" item="roleAndPermission" separator=",">
(#{roleAndPermission.roleId}, #{roleAndPermission.permissionId})
</foreach>
</insert>
<select id="selectPermissionByRoleId" resultType="role">
<!---->
SELECT
view_role_permission.permissionname permission
FROM
view_role_permission
where view_role_permission.id=${roleId}
</select>
<select id="selectRoleById" resultType="role">
<!---->
SELECT
t_role.id roleId,
t_role.`name`,
t_role.sn,
t_role.remark
FROM
t_role
where t_role.id=#{roleId}
</select>
<update id="update">
<!---->
UPDATE `t_role`
SET `name` = #{role.name},
`sn` = #{role.sn},
`remark` = #{role.remark}
WHERE
`id` = #{role.roleId};
</update>
<delete id="delectPermissionByRoleId">
<!---->
DELETE
FROM
t_role_permission
WHERE
t_role_permission.role_id =#{roleId}
</delete>
<delete id="deleteRoleById">
<!---->
DELETE
FROM
t_role where t_role.id=#{roleId}
</delete>
<select id="selectRoleByUserId" resultType="role">
<!---->
SELECT
view_role_user.id,
view_role_user.`name`,
view_role_user.sn,
view_role_user.user_id
FROM
view_role_user
where view_role_user.user_id=#{user.userId}
</select>
</mapper>
src/main/java/com/shiro/demo/mapper/UserDao.xml deleted 100644 → 0
<?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.shiro.demo.dao.UserDao">
<select id="findByUserName" resultType="user">
<!---->
SELECT
view_user_dept_role.id,
view_user_dept_role.id userId,
view_user_dept_role.staffname,
view_user_dept_role.username,
view_user_dept_role.`password`,
view_user_dept_role.`status`,
view_user_dept_role.deptname,
view_user_dept_role.rolename,
view_user_dept_role.roleId,
view_user_dept_role.deptId
FROM
view_user_dept_role
where username = #{username,jdbcType=VARCHAR}
</select>
<select id="selectPermissionsByUserId" parameterType="integer" resultType="permission">
<!---->
SELECT
view_permission_user.id,
view_permission_user.`name`,
view_permission_user.menuname,
view_permission_user.permission,
view_permission_user.url,
view_permission_user.flag,
view_permission_user.zindex,
view_permission_user.parantid,
view_permission_user.userid
FROM
view_permission_user
where view_permission_user.userid=#{userId}
</select>
<select id="selectRoleSnsByUserId" parameterType="integer" resultType="string">
<!---->
SELECT
view_role_user.sn
FROM
view_role_user
where view_role_user.user_id=#{userId}
</select>
<select id="selectRoleIdByUserId" parameterType="integer" resultType="integer">
<!---->
SELECT
t_user_role.role_id
FROM
t_user_role
where t_user_role.user_id=#{userId}
</select>
<select id="selectAllMenus" resultType="permission">
<!---->
SELECT
t_permission.id,
t_permission.`name`,
t_permission.menuname,
t_permission.permission,
t_permission.url,
t_permission.flag,
t_permission.zindex,
t_permission.parantid
FROM
t_permission
where t_permission.flag=1/*生成菜单*/
</select>
<select id="selectMenusByUserId" resultType="permission">
<!---->
SELECT
view_permission_user.id,
view_permission_user.`name`,
view_permission_user.menuname,
view_permission_user.permission,
view_permission_user.url,
view_permission_user.flag,
view_permission_user.zindex,
view_permission_user.parantid,
view_permission_user.userid
FROM
view_permission_user
where view_permission_user.flag=1/*生成菜单*/
<if test="userId!=null">and view_permission_user.userid=#{userId}</if>
</select>
<select id="selectUserByCondition" resultType="user">
<!---->
SELECT
(@r :=@r + 1) AS id,
view_user_dept_role.id userId,
view_user_dept_role.staffname,
view_user_dept_role.username,
view_user_dept_role.deptId,
view_user_dept_role.deptname,
view_user_dept_role.roleId,
view_user_dept_role.rolename,
view_user_dept_role.`password`,
view_user_dept_role.`status`
FROM
view_user_dept_role,
(SELECT @r := ${(user.page-1)*user.limit}) r
LIMIT ${(user.page-1)*user.limit},
${user.limit}
</select>
<select id="selectUserCountByCondition" resultType="integer">
<!---->
SELECT
count(1)
FROM
view_user_dept_role
</select>
<insert id="insert">
<!---->
<selectKey resultType="integer" order="AFTER" keyProperty="user.userId">
SELECT LAST_INSERT_ID();
</selectKey>
INSERT INTO `t_user` (
`dept_id`,
`staffname`,
`username`,
`password`,
`status`
)
VALUES
(
#{user.deptId},
#{user.staffname},
#{user.username},
#{user.password},
#{user.status});
</insert>
<insert id="insertUserRole">
<!---->
INSERT INTO `t_user_role` (`user_id`, `role_id`)
VALUES
(#{user.userId}, #{user.roleId});
</insert>
<select id="selectUserById" resultType="user">
<!---->
SELECT
view_user_dept_role.id,
view_user_dept_role.id userId,
view_user_dept_role.staffname,
view_user_dept_role.username,
view_user_dept_role.`password`,
view_user_dept_role.`status`,
view_user_dept_role.deptname,
view_user_dept_role.rolename,
view_user_dept_role.roleId,
view_user_dept_role.deptId
FROM
view_user_dept_role
where view_user_dept_role.id=#{userId}
</select>
<update id="update">
<!---->
UPDATE `t_user`
SET `dept_id` = #{user.deptId},
`staffname` = #{user.staffname},
`username` = #{user.username},
`password` = #{user.password},
`status` = #{user.status}
WHERE
(`id` =${user.userId});
</update>
<delete id="delectUserRole">
<!---->
DELETE
FROM
t_user_role
WHERE
t_user_role.user_id = #{user.userId}
</delete>
<insert id="addUserRole">
<!---->
INSERT INTO
`t_user_role` (`user_id`, `role_id`)
VALUES
(#{user.userId}, #{user.roleId});
</insert>
<update id="updateStatusById">
<!---->
UPDATE `t_user`
SET `status` = #{user.status}
WHERE
`id` = #{user.userId};
</update>
<delete id="deleteUserById">
<!---->
delete from t_user where id=#{user.userId}
</delete>
<select id="loadByUserName" resultType="user">
<!---->
SELECT
t_user.id,
t_user.dept_id,
t_user.staffname,
t_user.username,
t_user.`password`,
t_user.`status`
FROM
t_user
WHERE
username = #{username}
</select>
<update id="updatePwd">
UPDATE `t_user`
SET `password` = #{user.password}
WHERE
`id` = #{user.id};
</update>
<select id="findByUserId" resultType="user">
<!---->
SELECT
t_user.id,
t_user.dept_id,
t_user.staffname,
t_user.username,
t_user.`password`,
t_user.`status`
FROM
t_user
where t_user.id=#{userId}
</select>
</mapper>
src/main/java/com/shiro/demo/pojo/Dept.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.io.Serializable;
/**
* @author changchao
* @desc shiro权限控制之部门实体类
* @date 2017/10/25 15:56
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class Dept extends PageBean implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 部门ID
*/
protected Integer id;
/**
* 部门代码
*/
protected String code;
/**
* 部门名称
*/
protected String name;
/**
* 部门父级ID
*/
protected Integer parantid;
}
src/main/java/com/shiro/demo/pojo/PageBean.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
/**
* Created by changchao on 2017/9/1
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class PageBean {
protected Integer page;//页码
protected Integer limit;//当页总条数
protected Integer rn; //条数序列
}
src/main/java/com/shiro/demo/pojo/Permission.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.io.Serializable;
import java.util.List;
/**
* @author changchao
* @desc shiro权限控制之权限实体类
* @date 2017/10/25 15:56
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class Permission extends PageBean implements Serializable {
private static final long serialVersionUID = 1L;
protected Integer id;
/**
* 权限ID
*/
protected Integer permissionId;
/**
* 权限名
*/
protected String name;
/**
* 权限生成的菜单名
*/
protected String menuname;
/**
* 资源权限字符串
*/
protected String permission;
/**
* 资源访问路径
*/
protected String url;
/**
* 是否生成菜单,0:默认不生成菜单,1:生成菜单
*/
protected Integer flag;
/**
* 菜单排序
*/
protected Integer zindex;
/**
* 父级菜单id
*/
protected Integer parantid;
/**
* 子菜单list
*/
protected List childMenu;
}
src/main/java/com/shiro/demo/pojo/PermissionPage.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.util.List;
/**
* @author changchao
* @desc shiro权限控制之权限实体类(分页)
* @date 2017/10/25 16:35
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class PermissionPage {
protected Integer code = 0;
protected String msg;
protected Integer count = 0;
protected List<Permission> data;
}
src/main/java/com/shiro/demo/pojo/Role.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.io.Serializable;
/**
* @author changchao
* @desc shiro权限控制之角色实体类
* @date 2017/10/25 15:56
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class Role extends PageBean implements Serializable{
private static final long serialVersionUID = 1L;
/**
* ID
*/
protected Integer id;
/**
* 角色ID
*/
protected Integer roleId;
/**
* 角色名
*/
protected String name;
/**
* 角色字符串
*/
protected String sn;
/**
* 备注
*/
protected String remark;
/**
* 角色拥有的权限
*/
protected String permission;
}
src/main/java/com/shiro/demo/pojo/RoleAndPermission.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
/**
* @author changchao
* @desc shiro权限控制之角色权限关联实体类
* @date 2017/10/25 15:56
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class RoleAndPermission {
/**
* 角色ID
*/
protected Integer roleId;
/**
* 权限ID
*/
protected Integer permissionId;
}
src/main/java/com/shiro/demo/pojo/RolePage.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.util.List;
/**
* @author changchao
* @desc shiro权限控制之角色实体类(分页)
* @date 2017/10/25 16:35
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class RolePage {
protected Integer code = 0;
protected String msg;
protected Integer count = 0;
protected List<Role> data;
}
src/main/java/com/shiro/demo/pojo/User.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import java.io.Serializable;
/**
* @author changchao
* @desc shiro权限控制之用户实体类
* @date 2017/10/25 15:56
*/
@Data
@Slf4j
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User extends PageBean implements Serializable{
private static final long serialVersionUID = 1L;
/**
* ID
*/
private Integer id;
/**
* 用户ID
*/
private Integer userId;
/**
* 部门id
*/
private Integer deptId;
/**
* 部门名称
*/
private String deptname;
/**
* 角色id
*/
private Integer roleId;
/**
* 角色名
*/
private String rolename;
/**
* 员工姓名
*/
private String staffname;
/**
* 员工工号
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 状态:1 启用,2 禁用
*/
private Integer status;
}
\ No newline at end of file
src/main/java/com/shiro/demo/pojo/UserAndRole.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
/**
* @author changchao
* @desc shiro权限控制之用户角色关联实体类
* @date 2017/10/25 15:56
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class UserAndRole {
/**
* 角色ID
*/
protected Integer userId;
/**
* 权限ID
*/
protected Integer roleId;
}
src/main/java/com/shiro/demo/pojo/UserPage.java deleted 100644 → 0
package com.shiro.demo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.util.List;
/**
* @author changchao
* @desc shiro权限控制之用户实体类(分页)
* @date 2017/10/25 16:35
*/
@Data
@Log4j
@NoArgsConstructor
@AllArgsConstructor
public class UserPage {
protected Integer code = 0;
protected String msg;
protected Integer count = 0;
protected List<User> data;
}
src/main/java/com/shiro/demo/service/DeptService.java deleted 100644 → 0
package com.shiro.demo.service;
import com.shiro.demo.pojo.Dept;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:14
*/
public interface DeptService {
/**
* 获取部门列表
* @return
*/
List<Dept> selectDepts();
}
src/main/java/com/shiro/demo/service/PermissionService.java deleted 100644 → 0
package com.shiro.demo.service;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.PermissionPage;
import java.util.List;
/**
* @author changchao
* @desc 权限&菜单业务层
* @date 2017/10/26 10:54
*/
public interface PermissionService {
/**
* 获取所有权限
*
* @return
*/
Permission selectPermission();
/**
* 根据条件获取权限列表
*
* @param permission
* @return
*/
PermissionPage selectPermissionPage(Permission permission);
/**
* 添加权限&菜单
*
* @param permission
* @return
*/
Integer add(Permission permission);
/**
* 根据条件获取权限列表
*
* @param permission
* @return
*/
PermissionPage selectMenuPage(Permission permission);
/**
* 获取未生成菜单的选项,排除'系统管理'和'系统资源'
*
* @return
*/
List<Permission> selectNoSetMenus();
/**
* 获取所有父级菜单
*
* @return
*/
List<Permission> selectAllPermissions();
/**
* 菜单的添加,修改
*
* @param permission
* @return
*/
Integer updatePermissionById(Permission permission);
/**
* 根据id获取权限数据
*
* @param permissionId
* @return
*/
Permission selectPermissionById(Integer permissionId);
/**
* 根据id修改菜单启用状态
*
* @param permission
* @return
*/
Integer updateFlagById(Permission permission);
/**
* 根据id删除权限
*
* @param permission
* @return
*/
Integer deletePermissionById(Permission permission);
/**
* 更新角色,删除授权并重新进行授权
*
* @param
* @param
* @return
*/
Integer update(Permission permission);
/**
* 删除菜单
* @param permission
* @return
*/
Integer deleteMenuById(Permission permission);
}
src/main/java/com/shiro/demo/service/RoleService.java deleted 100644 → 0
package com.shiro.demo.service;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.RolePage;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:17
*/
public interface RoleService {
/**
* 获取角色列表
* @return
*/
List<Role> selectRoles();
/**
* 获取角色列表(分页)
* @param role
* @return
*/
RolePage selectRolePage(Role role);
/**
* 添加角色信息,并进行授权
* @param role
* @return
*/
Role add(Role role);
/**
* 根据ID修改角色信息
* @param roleId
* @return
*/
Role selectRoleById(Integer roleId);
/**
* 修改角色,删除授权并重新授权
* @param role
* @return
*/
Role update(Role role);
/**
* 删除角色,并删除授权
* @param role
* @return
*/
Integer deleteRoleById(Role role);
}
src/main/java/com/shiro/demo/service/UserService.java deleted 100644 → 0
package com.shiro.demo.service;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.User;
import com.shiro.demo.pojo.UserPage;
import java.util.List;
/**
* @author changchao
*/
public interface UserService {
/**
* 登录逻辑
* 1、先根据用户名查询用户对象
* 2、如果有用户对象，则继续匹配密码
* 如果没有用户对象，则抛出异常
*
* @param username
* @param password
* @return
*/
User login(String username, String password);
/**
* 根据用户id查询权限列表
*
* @param userId
* @return
*/
List<Permission> selectPermissionsByUserId(Integer userId);
/**
* 根据用户id查询角色昵称
*
* @param userId
* @return
*/
List<String> selectRoleSnsByUserId(Integer userId);
/**
* 根据用户ID获取菜单列表
*
* @param userId
* @return
*/
List<List<Permission>> selectMenusByUserId(Integer userId);
/**
* 获取用户列表
*
* @return
*/
UserPage selectUserPage(User user);
/**
* 添加用户信息,并关联角色表
*
* @param user
* @return
*/
User add(User user);
/**
* 根据id获取用户信息
*
* @param userId
* @return
*/
User selectUserById(Integer userId);
/**
* 提交用户修改数据
*
* @param user
* @return
*/
User update(User user);
/**
* 修改用户当前状态
*
* @param user
* @return
*/
Integer updateStatusById(User user);
/**
* 删除选择用户
* @param user
* @return
*/
Integer deleteUserById(User user);
/**
* 根据用户名加载用户对象（用于登录使用）
* @param username
* @return
*/
User loadByUsername(String username);
/**
* 修改密码
* @param user
* @return
*/
Integer updatePwd(User user);
/**
* 根据用户id获取角色id列表
* @param id
* @return
*/
List<Integer> selectRoleIdByUserId(Integer id);
}
src/main/java/com/shiro/demo/service/imp/DeptServiceImpl.java deleted 100644 → 0
package com.shiro.demo.service.imp;
import com.shiro.demo.dao.DeptDao;
import com.shiro.demo.pojo.Dept;
import com.shiro.demo.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:14
*/
@Service
@Transactional
public class DeptServiceImpl implements DeptService {
@Autowired
private DeptDao deptDao;
/**
* 获取部门列表
* @return
*/
@Override
public List<Dept> selectDepts() {
return deptDao.selectDepts();
}
}
src/main/java/com/shiro/demo/service/imp/PermissionServiceImpl.java deleted 100644 → 0
package com.shiro.demo.service.imp;
import com.shiro.demo.dao.PermissionDao;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.PermissionPage;
import com.shiro.demo.service.PermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* @author changchao
* @desc 权限&菜单业务层
* @date 2017/10/26 10:54
*/
@Service
public class PermissionServiceImpl implements PermissionService {
@Autowired
private PermissionDao permissionDao;
/**
* 获取所有权限
*
* @return
*/
@Override
public Permission selectPermission() {
List<Permission> permissions = permissionDao.selectPermission();
List<Permission> permissions0 = getFirstPermissions(permissions);
Permission permission = new Permission();
permission.setChildMenu(permissions0);
return permission;
}
/**
* 根据条件获取权限列表
*
* @param permission
* @return
*/
@Override
public PermissionPage selectPermissionPage(Permission permission) {
List<Permission> permissions = permissionDao.selectPermissionsByCondition(permission);
Integer count = permissionDao.selectPermissionsCountByCondition(permission);
PermissionPage permissionPage = new PermissionPage();
permissionPage.setCount(count);
permissionPage.setData(permissions);
return permissionPage;
}
/**
* 添加权限&菜单
*
* @param permission
* @return
*/
@Override
public Integer add(Permission permission) {
Integer flag = permission.getFlag();
if (flag == null) {
permission.setFlag(0);
}
Integer i = null;
try {
i = permissionDao.add(permission);
} catch (Exception e) {
return 0;
}
return i;
}
/**
* 根据条件获取权限列表
*
* @param permission
* @return
*/
@Override
public PermissionPage selectMenuPage(Permission permission) {
List<Permission> permissions = permissionDao.selectMenusByCondition(permission);
Integer count = permissionDao.selectMenusCountByCondition(permission);
PermissionPage permissionPage = new PermissionPage();
permissionPage.setCount(count);
permissionPage.setData(permissions);
return permissionPage;
}
/**
* 获取未生成菜单的选项,排除'系统管理'和'系统资源'
*
* @return
*/
@Override
public List<Permission> selectNoSetMenus() {
return permissionDao.selectNoSetMenus();
}
/**
* 获取所有父级菜单
*
* @return
*/
@Override
public List<Permission> selectAllPermissions() {
List<Permission> allPermission = permissionDao.selectAllPermissions();
for (int i = 0; i < allPermission.size(); i++) {
if (allPermission.get(i).getParantid() != 0) {
//一级菜单
Permission permission = allPermission.get(i);
permission.setMenuname("|---" + permission.getMenuname());
}
}
return allPermission;
}
/**
* 菜单的添加,修改
*
* @param permission
* @return
*/
@Override
public Integer updatePermissionById(Permission permission) {
return permissionDao.updatePermissionById(permission);
}
/**
* 根据id获取权限数据
*
* @param permissionId
* @return
*/
@Override
public Permission selectPermissionById(Integer permissionId) {
return permissionDao.selectPermissionById(permissionId);
}
/**
* 根据id修改菜单启用状态
*
* @param permission
* @return
*/
@Override
public Integer updateFlagById(Permission permission) {
return permissionDao.updateFlagById(permission);
}
/**
* 根据id删除权限
*
* @param permission
* @return
*/
@Override
public Integer deletePermissionById(Permission permission) {
return permissionDao.deletePermissionById(permission);
}
/**
* 更新角色,删除授权并重新进行授权
*
* @param
* @param
* @return
*/
@Override
public Integer update(Permission permission) {
return permissionDao.update(permission);
}
/**
* 删除菜单
*
* @param permission
* @return
*/
@Override
public Integer deleteMenuById(Permission permission) {
return permissionDao.updateMenuById(permission);
}
/**
* 获取顶级菜单
*
* @param permissions
* @return
*/
private List<Permission> getFirstPermissions(List<Permission> permissions) {
List<Permission> permissions1 = new ArrayList<>();
//顶级权限
for (Permission permission : permissions) {
//设置顶级权限
if (permission.getParantid() == null || "".equals(permission.getPermission()) || permission.getParantid() == 0) {
List<Permission> permissions2 = getPermissions(permissions, permission);
permission.setChildMenu(permissions2);
permissions1.add(permission);
//System.out.println("顶级权限" + permissions1);
}
}
return permissions1;
}
/**
* 递归调用菜单
*
* @param permissions
* @param permission
* @return
*/
private List<Permission> getPermissions(List<Permission> permissions, Permission permission) {
List<Permission> permissions2 = new ArrayList<>();
//一级权限
for (Permission permission2 : permissions) {
if (permission.getId().equals(permission2.getParantid())) {
permissions2.add(permission2);
List<Permission> permissions3 = getPermissions(permissions, permission2);
permission2.setChildMenu(permissions3);
//System.out.println("权限" + permissions2);
}
}
return permissions2;
}
}
src/main/java/com/shiro/demo/service/imp/RoleServiceImpl.java deleted 100644 → 0
package com.shiro.demo.service.imp;
import com.shiro.demo.dao.RoleDao;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.RoleAndPermission;
import com.shiro.demo.pojo.RolePage;
import com.shiro.demo.pojo.User;
import com.shiro.demo.service.RoleService;
import com.shiro.demo.util.TokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 13:17
*/
@Service
@Transactional
public class RoleServiceImpl implements RoleService {
@Autowired
private RoleDao roleDao;
/**
* 获取角色列表
*
* @return
*/
@Override
public List<Role> selectRoles() {
User user = TokenUtil.getUser();
Role role=roleDao.selectRoleByUserId(user.getUserId());
List<Role> roles = roleDao.selectRoles();
if (role.getId()>=2){
for (int i = 0; i < roles.size(); i++) {
if (roles.get(i).getId()==1||roles.get(i).getId()==2){
roles.remove(i);
i--;
}
}
}
return roles;
}
/**
* 获取角色列表(分页)
*
* @param role
* @return
*/
@Override
public RolePage selectRolePage(Role role) {
List<Role> data = roleDao.selectRoleByCondition(role);
for (Role role1 : data) {
List<Role> roles = roleDao.selectPermissionByRoleId(role1.getRoleId());
String permission = "";
for (Role role2 : roles) {
if (role2 != null) {
permission += role2.getPermission() + " ";
}
}
role1.setPermission(permission);
//System.out.println(permission);
}
Integer count = roleDao.selectRoleCountByCondition(role);
RolePage rolePage = new RolePage();
rolePage.setCount(count);
rolePage.setData(data);
return rolePage;
}
/**
* 添加角色信息,并进行授权
*
* @param role
* @return
*/
@Override
public Role add(Role role) {
//添加角色,并返回主键
int i = roleDao.add(role);
//进行授权
if (role.getPermission() != null) {
String[] permissions = role.getPermission().split(",");
List<RoleAndPermission> roleAndPermissions = new ArrayList<>();
for (int j = 0; j < permissions.length; j++) {
RoleAndPermission roleAndPermission = new RoleAndPermission();
Integer permission = Integer.parseInt(permissions[j]);
roleAndPermission.setRoleId(role.getRoleId());
roleAndPermission.setPermissionId(permission);
roleAndPermissions.add(roleAndPermission);
}
int j = roleDao.batchAddRoleAndPermission(roleAndPermissions);
}
return role;
}
/**
* 根据ID修改角色信息
*
* @param roleId
* @return
*/
@Override
public Role selectRoleById(Integer roleId) {
Role role = roleDao.selectRoleById(roleId);
List<Role> roles = roleDao.selectPermissionByRoleId(roleId);
String permission = "";
for (Role role2 : roles) {
if (role2 != null) {
permission += role2.getPermission() + " ";
}
}
role.setPermission(permission);
return role;
}
/**
* 修改角色,删除授权并重新授权
*
* @param role
* @return
*/
@Override
public Role update(Role role) {
//修改角色
int a=roleDao.update(role);
//删除角色授权
int b=roleDao.delectPermissionByRoleId(role.getRoleId());
//进行授权
if (role.getPermission() != null) {
String[] permissions = role.getPermission().split(",");
List<RoleAndPermission> roleAndPermissions = new ArrayList<>();
for (int j = 0; j < permissions.length; j++) {
RoleAndPermission roleAndPermission = new RoleAndPermission();
Integer permission = Integer.parseInt(permissions[j]);
roleAndPermission.setRoleId(role.getRoleId());
roleAndPermission.setPermissionId(permission);
roleAndPermissions.add(roleAndPermission);
}
int c= roleDao.batchAddRoleAndPermission(roleAndPermissions);
}
return role;
}
/**
* 删除角色,并删除授权
* @param role
* @return
*/
@Override
public Integer deleteRoleById(Role role) {
int i=roleDao.deleteRoleById(role.getRoleId());
int j= roleDao.delectPermissionByRoleId(role.getRoleId());
if (i + j >= 2) {
return 1;
}else{
return 0;
}
}
}
src/main/java/com/shiro/demo/service/imp/UserServiceImpl.java deleted 100644 → 0
package com.shiro.demo.service.imp;
import com.shiro.demo.dao.RoleDao;
import com.shiro.demo.dao.UserDao;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.Role;
import com.shiro.demo.pojo.User;
import com.shiro.demo.pojo.UserPage;
import com.shiro.demo.service.UserService;
import com.shiro.demo.util.MenuUtil;
import com.shiro.demo.util.ShiroKit;
import com.shiro.demo.util.TokenUtil;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
@Resource
private UserDao userDao;
@Resource
private RoleDao roleDao;
/**
* 登录逻辑
* 1、先根据用户名查询用户对象
* 2、如果有用户对象，则继续匹配密码
* 如果没有用户对象，则抛出异常
*
* @param username
* @param password
* @return
*/
@Override
public User login(String username, String password) {
User user = userDao.findByUserName(username);
// 密码匹配的工作交给 Shiro 去完成
if (user == null) {
// 因为缓存切面的原因,在这里就抛出用户名不存在的异常
throw new UnknownAccountException("用户名不存在(生产环境中应该写:用户名和密码的组合不正确)");
} else if (user.getStatus() == 0) {
throw new LockedAccountException("用户已经被禁用，请联系管理员启用该账号");
}
return user;
}
/**
* 根据用户id查询权限列表
*
* @param userId
* @return
*/
@Override
public List<Permission> selectPermissionsByUserId(Integer userId) {
List<Permission> permissions = userDao.selectPermissionsByUserId(userId);
/*if (roleIds.contains(1)){
//超级管理员
}*/
return permissions;
}
/**
* 根据用户id查询角色昵称
*
* @param userId
* @return
*/
@Override
public List<String> selectRoleSnsByUserId(Integer userId) {
return userDao.selectRoleSnsByUserId(userId);
}
/**
* 根据用户ID获取菜单列表
*
* @param userId
* @return
*/
@Override
public List<List<Permission>> selectMenusByUserId(Integer userId) {
List<Integer> roleIds = userDao.selectRoleIdByUserId(userId);
List<Permission> permissions = null;
//如果角色id包含1,说明当前登录用户拥有超级管理员身份
if (roleIds.contains(1)) {
permissions = userDao.selectAllMenus();
} else {
permissions = userDao.selectMenusByUserId(userId);
}
List<List<Permission>> list = null;
if (permissions.size() > 0) {
list = MenuUtil.getMenus(permissions);
}
for (int i = 0; i < list.size(); i++) {
if (list.get(i).size() == 0) {
list.remove(i);
i--;
}
}
return list;
}
/**
* 获取用户列表
*
* @return
*/
@Override
public UserPage selectUserPage(User user) {
List<User> data = userDao.selectUserByCondition(user);
User token = TokenUtil.getUser();
Role role = roleDao.selectRoleByUserId(token.getUserId());
if (role.getId() >= 2) {
for (int i = 0; i < data.size(); i++) {
if (data.get(i).getRoleId() == 1 || data.get(i).getRoleId() == 2) {
data.remove(i);
i--;
}
}
}
Integer count = userDao.selectUserCountByCondition();
UserPage userPage = new UserPage();
userPage.setCount(count);
userPage.setData(data);
return userPage;
}
/**
* 添加用户信息,并关联角色表
*
* @param user
* @return
*/
@Override
public User add(User user) {
if (user.getPassword() == null||user.getPassword()=="") {
user.setPassword("000000");
}
// 使用用户名作为盐值，MD5 算法加密
// user.setPassword(ShiroKit.md5(user.getPassword(), user.getUsername()));
String hashAlgorithmName = "MD5";
Object credentials = user.getPassword();
Object salt = ByteSource.Util.bytes(user.getUsername());
int hashIterations = 1024;
Object result = new SimpleHash(hashAlgorithmName, credentials, salt, hashIterations);
user.setPassword(result.toString());
User u = userDao.findByUserName(user.getUsername());
//判断要插入的目标对象是否存在
if (u == null) {
Date now=new Date();
int i = userDao.insert(user);
int j = userDao.insertUserRole(user);
} else {
user = new User();
}
return user;
}
/**
* 根据id获取用户信息
*
* @param userId
* @return
*/
@Override
public User selectUserById(Integer userId) {
return userDao.selectUserById(userId);
}
/**
* 提交用户修改数据
*
* @param user
* @return
*/
@Override
public User update(User user) {
User u = userDao.findByUserId(user.getUserId());
user.setId(u.getId());
user.setDeptname(u.getDeptname());
user.setRolename(u.getRolename());
if (!u.equals(user)) {
if (!(u.getPassword()).equals(user.getPassword())) {
// 使用用户名作为盐值，MD5 算法加密
user.setPassword(ShiroKit.md5(user.getPassword(), user.getUsername()));
}
/*//修改用户
int update = userDao.update(user);
//删除用户角色关联
int deleteUserRole = userDao.delectUserRole(user);
//重新添加用户角色关联
int addUserRole = userDao.addUserRole(user);*/
}
//修改用户
int update = userDao.update(user);
//删除用户角色关联
int deleteUserRole = userDao.delectUserRole(user);
//重新添加用户角色关联
int addUserRole = userDao.addUserRole(user);
return user;
}
/**
* 修改用户当前状态
*
* @param user
* @return
*/
@Override
public Integer updateStatusById(User user) {
int i = userDao.updateStatusById(user);
return i;
}
/**
* 删除选择用户
*
* @param user
* @return
*/
@Override
public Integer deleteUserById(User user) {
int i = userDao.deleteUserById(user);
int i1 = userDao.delectUserRole(user);
if (i + i1 >= 2) {
return 1;
} else {
return 0;
}
}
/**
* 根据用户名加载用户对象（用于登录使用）
* @param username
* @return
*/
@Override
public User loadByUsername(String username) {
return userDao.loadByUserName(username);
}
/**
* 修改密码
* @param user
* @return
*/
@Override
public Integer updatePwd(User user) {
user.setPassword(ShiroKit.md5(user.getPassword(),user.getUsername()));
return userDao.updatePwd(user);
}
/**
* 根据用户id获取角色id列表
* @param id
* @return
*/
@Override
public List<Integer> selectRoleIdByUserId(Integer id) {
return userDao.selectRoleIdByUserId(id);
}
}
src/main/java/com/shiro/demo/shiro/cache/BaseCacheService.java deleted 100644 → 0
package com.shiro.demo.shiro.cache;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
/**
* Created by changchao on 16/9/21.
* 注意:该基础缓存服务类中使用的缓存都是 Spring 框架提供的缓存
*
*/
public class BaseCacheService implements InitializingBean {
/**
* Spring 的 Cache
*/
@Autowired
private CacheManager cacheManager;
private Cache cache;
private String cacheName;
public void setCacheManager(CacheManager cacheManager) {
this.cacheManager = cacheManager;
}
public void setCache(Cache cache) {
this.cache = cache;
}
public void setCacheName(String cacheName) {
this.cacheName = cacheName;
}
/**
* 在所有的属性设置完成以后,
* 属性 cacheName 就非空
* cacheName 这个 String 对象在我们的项目中就是 ehcache.xml 中配置的字符串
* cache 就可以获得一个缓存对象
*
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
cache = cacheManager.getCache(cacheName);
}
// 以下是自定义的方法
/**
* 清空缓存中所有的对象
*/
public void clear(){
cache.clear();
}
/**
* 将一个对象放入缓存
* @param key
* @param value
*/
public void put(String key,Object value){
cache.put(key,value);
}
/**
* 将一个对象移出缓存
* @param key
*/
public void evict(String key){
cache.evict(key);
}
/**
* 从缓存中获得一个对象
* @param key
* @return
*/
public Object get(String key){
Cache.ValueWrapper vw = cache.get(key);
if(vw!=null){
return vw.get();
}
return null;
}
}
src/main/java/com/shiro/demo/shiro/cache/EhCacheManager.java deleted 100644 → 0
package com.shiro.demo.shiro.cache;
import net.sf.ehcache.Ehcache;
import org.apache.commons.io.IOUtils;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.ehcache.EhCache;
import org.apache.shiro.config.ConfigurationException;
import org.apache.shiro.io.ResourceUtils;
import org.apache.shiro.util.Destroyable;
import org.apache.shiro.util.Initializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* Created by changchao on 2017/8/29
*/
public class EhCacheManager implements CacheManager, Initializable, Destroyable {
private static final Logger log = LoggerFactory.getLogger(org.apache.shiro.cache.ehcache.EhCacheManager.class);
protected net.sf.ehcache.CacheManager manager;
private boolean cacheManagerImplicitlyCreated = false;
private String cacheManagerConfigFile = "classpath:org/apache/shiro/cache/ehcache/ehcache.xml";
public EhCacheManager() {
}
public net.sf.ehcache.CacheManager getCacheManager() {
return this.manager;
}
public void setCacheManager(net.sf.ehcache.CacheManager manager) {
this.manager = manager;
}
public String getCacheManagerConfigFile() {
return this.cacheManagerConfigFile;
}
public void setCacheManagerConfigFile(String classpathLocation) {
this.cacheManagerConfigFile = classpathLocation;
}
protected InputStream getCacheManagerConfigFileInputStream() {
String configFile = this.getCacheManagerConfigFile();
InputStream inputStream = null;//new
try {
inputStream = ResourceUtils.getInputStreamForPath(configFile);
byte[] b = IOUtils.toByteArray(inputStream);
InputStream in = new ByteArrayInputStream(b);
return in;
//return ResourceUtils.getInputStreamForPath(configFile);
} catch (IOException var3) {
throw new ConfigurationException("Unable to obtain input stream for cacheManagerConfigFile [" + configFile + "]", var3);
}finally {
IOUtils.closeQuietly(inputStream);
}
}
@Override
public final <K, V> Cache<K, V> getCache(String name) throws CacheException {
if (log.isTraceEnabled()) {
log.trace("Acquiring EhCache instance named [" + name + "]");
}
try {
Ehcache cache = this.ensureCacheManager().getEhcache(name);
if (cache == null) {
if (log.isInfoEnabled()) {
log.info("Cache with name '{}' does not yet exist. Creating now.", name);
}
this.manager.addCache(name);
cache = this.manager.getCache(name);
if (log.isInfoEnabled()) {
log.info("Added EhCache named [" + name + "]");
}
} else if (log.isInfoEnabled()) {
log.info("Using existing EHCache named [" + ((Ehcache) cache).getName() + "]");
}
return new EhCache((Ehcache) cache);
} catch (net.sf.ehcache.CacheException var3) {
throw new CacheException(var3);
}
}
@Override
public final void init() throws CacheException {
this.ensureCacheManager();
}
private net.sf.ehcache.CacheManager ensureCacheManager() {
try {
if (this.manager == null) {
if (log.isDebugEnabled()) {
log.debug("cacheManager property not set. Constructing CacheManager instance... ");
}
this.manager = new net.sf.ehcache.CacheManager(this.getCacheManagerConfigFileInputStream());
if (log.isTraceEnabled()) {
log.trace("instantiated Ehcache CacheManager instance.");
}
this.cacheManagerImplicitlyCreated = true;
if (log.isDebugEnabled()) {
log.debug("implicit cacheManager created successfully.");
}
}
return this.manager;
} catch (Exception var2) {
throw new CacheException(var2);
}
}
@Override
public void destroy() {
if (this.cacheManagerImplicitlyCreated) {
try {
net.sf.ehcache.CacheManager cacheMgr = this.getCacheManager();
cacheMgr.shutdown();
} catch (Exception var2) {
if (log.isWarnEnabled()) {
log.warn("Unable to cleanly shutdown implicitly created CacheManager instance. Ignoring (shutting down)...");
}
}
this.cacheManagerImplicitlyCreated = false;
}
}
}
src/main/java/com/shiro/demo/shiro/cache/UserServiceAspect.java deleted 100644 → 0
package com.shiro.demo.shiro.cache;
import com.shiro.demo.pojo.User;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Service;
/**
* Created by changchao on 16/9/22.
*/
@Service
@Aspect
@EnableAspectJAutoProxy // 开启 AOP ,作用同 <aop:aspectj-autoproxy/>
public class UserServiceAspect extends BaseCacheService{
private static final Logger logger = LoggerFactory.getLogger(UserServiceAspect.class);
/**
* id 前缀
*/
private String idPrefix = "id-";
/**
* 用户名前缀
*/
private String usernamePrefix = "username-";
public UserServiceAspect(){
this.setCacheName("shiro-userCache");
}
/**
* target 表明只针对某个类实现 AOP 代理
*/
@Pointcut("target(com.shiro.demo.service.imp.UserServiceImpl)")
public void userServicePointcut(){
}
/**
* 增加
* 删除
* 登录的方法
*
* 这三个方法不应该被缓存
*/
@Pointcut("execution(* add(..))|| execution(* update(..)) || execution(* login(..))")
public void userPutPointcut(){
}
/**
* 加载和按照用户名加载的方法要缓存起来
*/
@Pointcut("execution(* load(..)) || execution(* loadByUsername(..))")
public void userReadPointcut(){
}
@Pointcut(value = "execution(* delete(*)) && args(arg)",argNames = "arg")
public void userEvictPointcut(Object arg){
}
/**
* 当执行删除操作的时候的增强逻辑(目前暂时没有提供删除功能)
* @param arg
*/
@After(value = "userServicePointcut() && userEvictPointcut(arg)",argNames = "arg")
public void userEvictAdvice(Object arg){
logger.debug("------ UserServiceAspect ------ 删除增强 ----- 参数 ----- " + arg);
super.evict(idPrefix + arg);
}
/**
* 当发生增加、更新、登录操作的时候缓存一下对象(更新一次缓存)
* @param rel
*/
// 返回通知,可以访问到方法的返回值
// 注意 AfterReturning 配置必须有argNames参数，且参数值和 returning 值一样，
// 这样在织入代码里面便可通过 returning 的值获取被织入函数的返回值。
@AfterReturning(pointcut = "userServicePointcut() && userPutPointcut()",returning = "rel")
public void userPutAdvice(Object rel){
// rel 表示返回值
logger.debug("--- UserService 切面 ----- 返回值 => " + rel);
// 首先使用返回通知访问到这个对象
put((User) rel);
}
/**
* 加载数据的时候的增强逻辑
* @param pjp
* @return
* @throws Throwable
*/
@Around(value = "userServicePointcut() && userReadPointcut()")
public Object userReadPointcut(ProceedingJoinPoint pjp) throws Throwable{
String methodName = pjp.getSignature().getName();
Object[] args = pjp.getArgs();
Object arg = args.length > 0 ? args[0] : null;
String key = null;
boolean isId = false;
if("load".equals(methodName)){
isId = true;
key = idPrefix + arg;
}else if("loadByUsername".equals(methodName)){
key = usernamePrefix + arg;
}
User user = null;
if(isId){
user = (User)super.get(key);
}else {
// 先根据用户名从缓存中找到 id
String idKey = idPrefix + super.get(key);
user = (User) super.get(idKey);
}
if(user!=null){
return user;
}
return pjp.proceed();
}
/**
* 【重要】
* 缓存一个对象的具体流程
* 1、底层永远使用 id 前缀来缓存这个对象;
* 2、通过其它属性访问对象的时候,缓存 id 属性
* @param rel
*/
private void put(User rel){
super.put(idPrefix + rel.getId(),rel);
// 建立了一个 用户名前缀和 id 之间的关系
super.put(usernamePrefix + rel.getUsername(),rel.getId());
}
}
src/main/java/com/shiro/demo/shiro/filter/PermissionCheckFilter.java deleted 100644 → 0
package com.shiro.demo.shiro.filter;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Created by changchao on 2018/6/22.
*/
public class PermissionCheckFilter extends AccessControlFilter {
private String errorUrl;
private static final Logger logger = LoggerFactory.getLogger(PermissionCheckFilter.class);
public String getErrorUrl() {
return errorUrl;
}
public void setErrorUrl(String errorUrl) {
this.errorUrl = errorUrl;
}
/**
* 表示是否允许访问 ，如果允许访问返回true，否则false；
* @param servletRequest
* @param servletResponse
* @param o 表示写在拦截器中括号里面的字符串 mappedValue 就是 [urls] 配置中拦截器参数部分
* @return
* @throws Exception
*/
@Override
protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
Subject subject = getSubject(servletRequest,servletResponse);
String url = getPathWithinApplication(servletRequest);
logger.debug("当前用户正在访问的 url => " + url+"-------------");
//System.out.println(subject.isPermitted(url));
return subject.isPermitted(url);
}
/**
* onAccessDenied：表示当访问拒绝时是否已经处理了；如果返回 true 表示需要继续处理；如果返回 false 表示该拦截器实例已经处理了，将直接返回即可。
* @param servletRequest
* @param servletResponse
* @return
* @throws Exception
*/
@Override
protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
logger.debug("当 isAccessAllowed 返回 false 的时候，才会执行 method onAccessDenied ");
HttpServletRequest request =(HttpServletRequest) servletRequest;
HttpServletResponse response =(HttpServletResponse) servletResponse;
response.sendRedirect(request.getContextPath() + this.errorUrl);
// 返回 false 表示已经处理，例如页面跳转啥的，表示不在走以下的拦截器了（如果还有配置的话）
return false;
}
}
src/main/java/com/shiro/demo/shiro/permission/UrlPermission.java deleted 100644 → 0
package com.shiro.demo.shiro.permission;
import org.apache.shiro.authz.Permission;
import org.apache.shiro.util.AntPathMatcher;
import org.apache.shiro.util.PatternMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Created by changchao on 2018/6/22.
*/
public class UrlPermission implements Permission {
private static final Logger logger = LoggerFactory.getLogger(UrlPermission.class);
// 在 Realm 的授权方法中,由数据库查询出来的权限字符串
private String url;
public UrlPermission(String url){
this.url = url;
}
/**
* 一个很重要的方法,用户判断 Realm 中设置的权限和从数据库或者配置文件中传递进来的权限信息是否匹配
* 如果 Realm 的授权方法中，一个认证主体有多个权限，会进行遍历，直到匹配成功为止
* this.url 是在遍历状态中变化的
*
* urlPermission.url 是从 subject.isPermitted(url)
* 传递到 UrlPermissionResolver 中传递过来的,就一个固定值
*
* @param permission
* @return
*/
@Override
public boolean implies(Permission permission) {
if(!(permission instanceof UrlPermission)){
return false;
}
//
UrlPermission urlPermission = (UrlPermission)permission;
PatternMatcher patternMatcher = new AntPathMatcher();
logger.debug("this.url(来自数据库中存放的通配符数据),在 Realm 的授权方法中注入的 => " + this.url);
logger.debug("urlPermission.url(来自浏览器正在访问的链接) => " + urlPermission.url);
boolean matches = patternMatcher.matches(this.url,urlPermission.url);
logger.debug("matches => " + matches);
return matches;
}
}
src/main/java/com/shiro/demo/shiro/permission/UrlPermissionResolver.java deleted 100644 → 0
package com.shiro.demo.shiro.permission;
import org.apache.shiro.authz.Permission;
import org.apache.shiro.authz.permission.PermissionResolver;
import org.apache.shiro.authz.permission.WildcardPermission;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Created by changchao on 2018/6/22.
*/
public class UrlPermissionResolver implements PermissionResolver {
private static final Logger logger = LoggerFactory.getLogger(UrlPermissionResolver.class);
/**
* 经过调试发现
* subject.isPermitted(url) 中传入的字符串
* 和自定义 Realm 中传入的权限字符串集合都要经过这个 resolver
* @param s
* @return
*/
@Override
public Permission resolvePermission(String s) {
logger.debug("s => " + s);
if(s.startsWith("/")){
return new UrlPermission(s);
}
return new WildcardPermission(s);
}
}
src/main/java/com/shiro/demo/shiro/realm/MyRealm.java deleted 100644 → 0
package com.shiro.demo.shiro.realm;
import com.shiro.demo.pojo.Permission;
import com.shiro.demo.pojo.User;
import com.shiro.demo.service.UserService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.SimplePrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
/**
* Created by changchao on 2018/6/22.
*/
public class MyRealm extends AuthorizingRealm {
private static final Logger logger = LoggerFactory.getLogger(MyRealm.class);
@Autowired
private UserService userService;
/**
* 授权
*
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
logger.info("--- MyRealm doGetAuthorizationInfo ---");
System.out.println("--- MyRealm doGetAuthorizationInfo ---");
// 获得经过认证的主体信息
User user = (User) principalCollection.getPrimaryPrincipal();
System.out.println("-------------realm------------------"+user);
Integer userId = user.getId();
List<Permission> permissions = userService.selectPermissionsByUserId(userId);
List<String> roleSns = userService.selectRoleSnsByUserId(userId);
List<String> resStrList = new ArrayList<>();
for (Permission permission : permissions) {
if (permission != null) {
resStrList.add(permission.getUrl());
}
}
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.setRoles(new HashSet<>(roleSns));
info.setStringPermissions(new HashSet<>(resStrList));
// 以上完成了动态地对用户授权
logger.debug("role => " + roleSns);
logger.debug("permission => " + resStrList);
logger.info("role => " + roleSns);
logger.info("permission => " + resStrList);
return info;
}
/**
* 认证
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
logger.info("--- MyRealm doGetAuthenticationInfo ---");
System.out.println("--- MyRealm doGetAuthenticationInfo ---");
String username = authenticationToken.getPrincipal().toString();
String password = new String((char[]) authenticationToken.getCredentials());
// 以后我们使用 Spring 管理 Shiro 的时候，就不必要这样得到 UserService 了
// userService = (IUserService) InitServlet.getBean("userService");
// User user = userService.login(username,password);
// 这里应该使用 load 方法，比对用户名的密码的环节应该交给 Shiro 这个框架去完成
// 在测试调试的时候发现,这里还是应该使用 login 判断,因为登录不成功的原因有很多,
// 可以在登录的逻辑里面抛出各种异常
// 再到 subject.login(token) 里面去捕获对应的异常
// 显示不同的消息到页面上
User user = userService.login(username, password);
if (user != null) {
// 第 1 个参数可以传一个实体对象，然后在认证的环节可以取出
// 第 2 个参数应该传递在数据库中“正确”的数据，然后和 token 中的数据进行匹配
// SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), getName());
// 设置盐值
// info.setCredentialsSalt(ByteSource.Util.bytes(username.getBytes()));
String realmName = getName();
//4). 盐值.
ByteSource credentialsSalt = ByteSource.Util.bytes(username);
SimpleAuthenticationInfo info = null; //new SimpleAuthenticationInfo(principal, credentials, realmName);
info = new SimpleAuthenticationInfo(user, user.getPassword(), credentialsSalt, realmName);
return info;
}
return null;
}
@Override
protected void clearCachedAuthenticationInfo(PrincipalCollection principals) {
Cache c = getAuthenticationCache();
logger.info("清除【认证】缓存之前");
for (Object o : c.keys()) {
logger.info(o + " , " + c.get(o));
}
super.clearCachedAuthenticationInfo(principals);
logger.info("调用父类清除【认证】缓存之后");
for (Object o : c.keys()) {
logger.info(o + " , " + c.get(o));
}
// 添加下面的代码清空【认证】的缓存
User user = (User) principals.getPrimaryPrincipal();
SimplePrincipalCollection spc = new SimplePrincipalCollection(user.getUsername(), getName());
super.clearCachedAuthenticationInfo(spc);
logger.info("添加了代码清除【认证】缓存之后");
int cacheSize = c.keys().size();
logger.info("【认证】缓存的大小:" + c.keys().size());
if (cacheSize == 0) {
logger.info("说明【认证】缓存被清空了。");
}
}
@Override
protected void clearCachedAuthorizationInfo(PrincipalCollection principals) {
logger.info("清除【授权】缓存之前");
Cache c = getAuthorizationCache();
for (Object o : c.keys()) {
logger.info(o + " , " + c.get(o));
}
super.clearCachedAuthorizationInfo(principals);
logger.info("清除【授权】缓存之后");
int cacheSize = c.keys().size();
logger.info("【授权】缓存的大小:" + cacheSize);
for (Object o : c.keys()) {
logger.info(o + " , " + c.get(o));
}
if (cacheSize == 0) {
logger.info("说明【授权】缓存被清空了。");
}
}
}
src/main/java/com/shiro/demo/util/DateTimeUtil.java deleted 100644 → 0
package com.shiro.demo.util;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Date;
/**
* 时间日期转换
* Created by changchao on 2017/8/28
*/
public class DateTimeUtil {
//时间格式化
final static SimpleDateFormat sdfDateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//日期格式化
final static SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd");
/**
* 时间转字符串
*
* @return
*/
public static String dateTimeToLocalString(Date fromDateTime) {
String toDateTime = sdfDateTime.format(fromDateTime);
return toDateTime;
}
/**
* 日期转字符串
*
* @return
*/
public static String dateToLocalString(Date fromDateTime) {
String toDateTime = sdfDate.format(fromDateTime);
return toDateTime;
}
/**
* 字符串转日期&时间
*
* @param fromDateTime
* @return
*/
public static Date localStringToDateOrTime(String fromDateTime) {
Date date = null;
try {
if (fromDateTime.length() <= 10) {
//日期字符串转日期
date = sdfDate.parse(fromDateTime);
}else if (fromDateTime.length() >= 10) {
//时间字符串转时间
date = sdfDateTime.parse(fromDateTime);
}
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
/**
* 获取时间差(H)
*
* @param oDate
* @param nDate
* @return
*/
public static long diffH(Date oDate, Date nDate) {
long oDateTime = oDate.getTime();
long nDateTime = nDate.getTime();
long diffH = (nDateTime - oDateTime) / (1000 * 60 * 60);
return diffH;
}
public static void main(String[] args) {
Date date1 = localStringToDateOrTime("2017-08-30 11:11:11");
long l = diffH(date1, new Date());
System.out.println(l);
System.out.println(dateToLocalString(new Date()));
System.out.println(dateTimeToLocalString(new Date()));
System.out.println(localStringToDateOrTime("2017-08-30 11:11:11"));
LocalDate date=LocalDate.now();
LocalTime time=LocalTime.now();
System.out.println(date+" "+time);
}
}
src/main/java/com/shiro/demo/util/HttpRequestUtil.java deleted 100644 → 0
package com.shiro.demo.util;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.HttpHostConnectException;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.*;
import java.net.ConnectException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
/**
* java接口对接方法工具类
*/
public class HttpRequestUtil {
private static Logger logger = LoggerFactory.getLogger(HttpRequestUtil.class);
/**
* 创建httpClient
*
* @return
*/
private static CloseableHttpClient createSSLInsecureClient() {
SSLContext sslcontext = createSSLContext();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new HostnameVerifier() {
@Override
public boolean verify(String paramString, SSLSession paramSSLSession) {
return true;
}
});
CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
return httpclient;
}
/**
* 获取初始化sslContext
*
* @return
*/
private static SSLContext createSSLContext() {
SSLContext sslcontext = null;
try {
sslcontext = SSLContext.getInstance("TLS");
sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new SecureRandom());
} catch (NoSuchAlgorithmException e) {
logger.error("HttpRequestUtil.createSSLContext: " + e.getMessage());
} catch (KeyManagementException e) {
logger.error("HttpRequestUtil.createSSLContext: " + e.getMessage());
}
return sslcontext;
}
public static String doPost(String url, String json) throws Exception {
CloseableHttpClient client = null;
//json="{\"limit\": 0,\"page\": 0,\"dateBegin\": \"2017-9-1T03:14:15.426Z\",\"dateEnd\": \"2017-10-12T03:14:15.427Z\"}";
try {
if (StringUtils.startsWith(url, "https")) {
client = createSSLInsecureClient();
} else /*if (StringUtils.startsWith(url, "http")) */{
client = HttpClients.createDefault();
}
HttpPost post = new HttpPost(url);
if (!StringUtils.isEmpty(json)) {
StringEntity s = new StringEntity(json, "UTF-8");
s.setContentEncoding("UTF-8");
s.setContentType("application/json");
post.setEntity(s);
}
CloseableHttpResponse response = client.execute(post);
try {
if (response != null && response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
return EntityUtils.toString(response.getEntity(), "UTF-8");
}
} finally {
if (response != null) {
response.close();
}
}
} catch (Exception e) {
if (e instanceof HttpHostConnectException || e.getCause() instanceof ConnectException) {
throw new ConnectException("连接服务器" + url + "失败： " + e.getMessage());
}
logger.error("HttpRequestUtil.doPost: " + e.getMessage());
} finally {
if (client != null) {
try {
client.close();
} catch (Exception e) {
}
}
}
return "";
}
public static String doGet(String url) throws Exception {
CloseableHttpClient client = null;
try {
if (StringUtils.startsWith(url, "https")) {
client = createSSLInsecureClient();
} else {
client = HttpClients.createDefault();
}
HttpGet httpget = new HttpGet(url);
CloseableHttpResponse response = client.execute(httpget);
try {
if (response != null && HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {
return EntityUtils.toString(response.getEntity(), "UTF-8");
}
} finally {
if (response != null) {
response.close();
}
}
} catch (Exception e) {
if (e instanceof HttpHostConnectException || e.getCause() instanceof ConnectException) {
throw e;
}
logger.error("HttpRequestUtil.doGet: " + e.getMessage());
} finally {
if (client != null) {
try {
client.close();
} catch (Exception e) {
// this exception can be ignored
}
}
}
return "";
}
/**
* 自定义静态私有类
*/
private static class TrustAnyTrustManager implements X509TrustManager {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
@Override
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[]{};
}
}
}
src/main/java/com/shiro/demo/util/JsonDateTimeValueProcessor.java deleted 100644 → 0
package com.shiro.demo.util;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* @Author: changchao
* @Description: 时间转换器
* @Created: 2017/10/12 12:13
*/
public class JsonDateTimeValueProcessor implements JsonValueProcessor {
private String format ="yyyy-MM-dd HH:mm:ss";
public JsonDateTimeValueProcessor() {
super();
}
public JsonDateTimeValueProcessor(String format) {
super();
this.format = format;
}
@Override
public Object processArrayValue(Object paramObject,
JsonConfig paramJsonConfig) {
return process(paramObject);
}
@Override
public Object processObjectValue(String paramString, Object paramObject,
JsonConfig paramJsonConfig) {
return process(paramObject);
}
private Object process(Object value){
if(value instanceof Date){
SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
return sdf.format(value);
}
return value == null ? "" : value.toString();
}
}
src/main/java/com/shiro/demo/util/JsonDateValueProcessor.java deleted 100644 → 0
package com.shiro.demo.util;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* @Author: changchao
* @Description: 日期转换器
* @Created: 2017/10/12 12:13
*/
public class JsonDateValueProcessor implements JsonValueProcessor {
private String format ="yyyy-MM-dd";
public JsonDateValueProcessor() {
super();
}
public JsonDateValueProcessor(String format) {
super();
this.format = format;
}
@Override
public Object processArrayValue(Object paramObject,
JsonConfig paramJsonConfig) {
return process(paramObject);
}
@Override
public Object processObjectValue(String paramString, Object paramObject,
JsonConfig paramJsonConfig) {
return process(paramObject);
}
private Object process(Object value){
if(value instanceof Date){
SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
return sdf.format(value);
}
return value == null ? "" : value.toString();
}
}
src/main/java/com/shiro/demo/util/MenuUtil.java deleted 100644 → 0
package com.shiro.demo.util;
import com.shiro.demo.pojo.Permission;
import java.util.ArrayList;
import java.util.List;
/**
* @author changchao
* @desc
* @date 2017/10/26 11:36
*/
public class MenuUtil {
public static List<List<Permission>> getMenus(List<Permission> resources) {
//系统菜单列表
List<Permission> adminList = new ArrayList<>();
//监控菜单列表
List<Permission> monitorList = new ArrayList<>();
//预警菜单列表
List<Permission> warningList = new ArrayList<>();
//分析菜单列表
List<Permission> analysisList = new ArrayList<>();
//决策菜单列表
List<Permission> decidingList = new ArrayList<>();
//菜单列表集合
List<List<Permission>> list = new ArrayList<>();
Permission menu = new Permission();
for (Permission resource : resources) {
if (resource.getParantid() == 0) {
menu.setMenuname(resource.getMenuname());
menu.setId(resource.getId());
menu.setUrl(resource.getUrl());
menu.setZindex(resource.getZindex());
menu.setParantid(resource.getParantid());
menu.setChildMenu(getMenus(resource.getId(), resources));
if (menu.getId() == 1000) {
monitorList.add(menu);
} else if (menu.getId() == 2000) {
warningList.add(menu);
} else if (menu.getId() == 3000) {
analysisList.add(menu);
} else if (menu.getId() == 4000) {
decidingList.add(menu);
} else if (menu.getId() == 5000) {
adminList.add(menu);
}
}
menu = new Permission();
}
list.add(monitorList);
list.add(warningList);
list.add(analysisList);
list.add(decidingList);
list.add(adminList);
return list;
}
public static List<Permission> getMenus(Integer id, List<Permission> resources) {
List<Permission> lists = new ArrayList<>();
for (Permission resource : resources) {
Permission menu = new Permission();
Integer parantid = resource.getParantid();
if (id.equals(parantid)) {
menu.setMenuname(resource.getMenuname());
menu.setId(resource.getId());
menu.setUrl(resource.getUrl());
menu.setZindex(resource.getZindex());
menu.setParantid(resource.getParantid());
menu.setChildMenu(getMenus(resource.getId(), resources));
lists.add(menu);
}
}
return lists;
}
}
src/main/java/com/shiro/demo/util/PinyinUtil.java deleted 100644 → 0
package com.shiro.demo.util;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
/**
* @Author: changchao
* @Description: 汉字转化为拼音的工具类
* @Created: 2017/9/22 15:04
*/
public class PinyinUtil {
public static enum Type {
UPPERCASE, //大写
LOWERCASE, //小写
}
/**
* 获取汉字串拼音首字母，英文字符不变
*
* @param chinese 汉字串
* @return 汉语拼音首字母
*/
public static String getFirstSpell(String chinese, Type type) {
StringBuffer pybf = new StringBuffer();
char[] arr = chinese.toCharArray();
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
if (type == null || type == Type.LOWERCASE) {
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
} else {
defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);
}
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
for (int i = 0; i < arr.length; i++) {
if (arr[i] > 128) {
try {
String[] temp = PinyinHelper.toHanyuPinyinStringArray(arr[i], defaultFormat);
if (temp != null) {
pybf.append(temp[0].charAt(0));
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
pybf.append(arr[i]);
}
}
return pybf.toString().replaceAll("\\W", "").trim();
}
/**
* 获取汉字串拼音，英文字符不变
*
* @param chinese 汉字串
* @param
* @return 汉语拼音
*/
public static String getFullSpell(String chinese, Type type) {
StringBuffer pybf = new StringBuffer();
char[] arr = chinese.toCharArray();
HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
if (type == null || type == Type.LOWERCASE) {
defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
} else {
defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);
}
defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
for (int i = 0; i < arr.length; i++) {
if (arr[i] > 128) {
try {
pybf.append(PinyinHelper.toHanyuPinyinStringArray(arr[i], defaultFormat)[0]);
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
pybf.append(arr[i]);
}
}
return pybf.toString();
}
public static void main(String[] args) throws BadHanyuPinyinOutputFormatCombination {
System.out.println(PinyinUtil.getFirstSpell("我爱中国", Type.UPPERCASE));
System.out.println(PinyinUtil.getFullSpell("我爱中国", Type.UPPERCASE));
}
}
src/main/java/com/shiro/demo/util/ShiroKit.java deleted 100644 → 0
package com.shiro.demo.util;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.util.ByteSource;
/**
* Created by changchao on 2018/6/22.
*/
public class ShiroKit {
public static String md5(String originPassword,String username){
String hashAlgorithmName = "MD5";
Object credentials = originPassword;
Object salt = ByteSource.Util.bytes(username);
int hashIterations = 1024;
Object result = new SimpleHash(hashAlgorithmName, credentials, salt, hashIterations);
return result.toString();
}
/* public static void main(String[] args) {
System.out.println(md5("000000","admin"));
}*/
public static void main(String[] args) {
String hashAlgorithmName = "MD5";
Object credentials = "000000";
Object salt = ByteSource.Util.bytes("user");
int hashIterations = 1024;
Object result = new SimpleHash(hashAlgorithmName, credentials, salt, hashIterations);
System.out.println(result);
}
}
src/main/java/com/shiro/demo/util/Test.java deleted 100644 → 0
package com.shiro.demo.util;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
public class Test {
private static String firstDay;
private static String lastDay;
public static void main(String[] args) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
//获取前月的第一天
Calendar cal_1=Calendar.getInstance();//获取当前日期
cal_1.add(Calendar.MONTH, -1);
cal_1.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
firstDay = format.format(cal_1.getTime());
System.out.println("-----1------firstDay:"+firstDay);
//获取前月的最后一天
Calendar cale = Calendar.getInstance();
cale.set(Calendar.DAY_OF_MONTH,0);//设置为1号,当前日期既为本月第一天
lastDay = format.format(cale.getTime());
System.out.println("-----2------lastDay:"+lastDay);
//获取当前月第一天：
Calendar c = Calendar.getInstance();
c.add(Calendar.MONTH, 0);
c.set(Calendar.DAY_OF_MONTH,1);//设置为1号,当前日期既为本月第一天
String first = format.format(c.getTime());
System.out.println("===============first:"+first);
//获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
String last = format.format(ca.getTime());
System.out.println("===============last:"+last);
}
/**
* 字符串的日期格式的计算
*/
public static int daysBetween(String smdate,String bdate) throws ParseException{
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
cal.setTime(sdf.parse(smdate));
long time1 = cal.getTimeInMillis();
cal.setTime(sdf.parse(bdate));
long time2 = cal.getTimeInMillis();
long between_days=(time2-time1)/(1000*3600*24);
return Integer.parseInt(String.valueOf(between_days));
}
}
\ No newline at end of file
src/main/java/com/shiro/demo/util/TokenUtil.java deleted 100644 → 0
package com.shiro.demo.util;
import com.shiro.demo.pojo.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
/**
* @author changchao
* @desc Shiro管理下的Token工具类
* @date 2017/10/25 11:31
*/
public class TokenUtil {
/**
* 登录
*
* @param
* @param user
* @param rememberMe @return
*/
public static User login(User user, boolean rememberMe) {
Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword());
//token.setRememberMe(rememberMe);
// rememberme
token.setRememberMe(true);
subject.login(token);
return getUser();
}
/**
* 获取当前登录的用户User对象
*
* @return
*/
public static User getUser() {
return (User) SecurityUtils.getSubject().getPrincipal();
}
}
src/main/java/com/xzxtshiro/controller/LoginController.java
package com.xzxtshiro.controller;
import com.xzxtshiro.pojo.SysPermissionNew;
import com.xzxtshiro.pojo.SysUser;
import com.xzxtshiro.service.SysUserService;
import com.xzxtshiro.util.TokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
/**
* @author liuys
* @desc
......@@ -17,6 +22,9 @@ import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class LoginController {
@Autowired
SysUserService userService;
@RequestMapping(value = "/login",method = RequestMethod.GET)
public String login(){
return "login";
......@@ -63,7 +71,19 @@ public class LoginController {
msg = "用户名或密码不正确";
} finally {
if (msg == null) {
res="================Login shiro success==============";
SysUser user1 = TokenUtil.getUser();
List<List<SysPermissionNew>> oldlist= userService.selectMenusByUserId(user1);
//System.out.println(list);
model.addAttribute("list", oldlist);
List<SysPermissionNew> list=userService.selectSysPermissionNewByUserId(user.getId());
StringBuffer perList = new StringBuffer();
for (SysPermissionNew per:list) {
if (per.getId()!=null){
perList.append(per.getId()+",");
}
}
res = perList.toString();
//res="================Login shiro success==============";
}else{
res="================Login shiro error================";
}
......
src/main/resources/msqlspring/applicationContext-myqsldao.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 数据库连接池 -->
<!-- 加载配置文件 -->
<context:property-placeholder location="classpath:resource/*.properties" />
<!-- 数据库连接池 -->
<bean id="dataSource_new" class="com.alibaba.druid.pool.DruidDataSource"
destroy-method="close">
<property name="url" value="${jdbc.mysql.url}" />
<property name="username" value="${jdbc.mysql.username}" />
<property name="password" value="${jdbc.mysql.password}" />
<property name="driverClassName" value="${jdbc.mysql.driver}" />
<property name="maxActive" value="10" />
<property name="minIdle" value="5" />
</bean>
<!-- 配置sqlsessionFactory -->
<bean id="sqlSessionFactory_new" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>
<property name="dataSource" ref="dataSource_new"></property>
<!-- 自动扫描mapping.xml文件 -->
<property name="mapperLocations" value="classpath*:/com/shiro/demo/mapper/*.xml"></property>
<!-- 配置pojo别名 -->
<property name="typeAliasesPackage" value="com.shiro.demo.pojo" />
</bean>
<!-- 配置扫描包，加载mapper代理对象 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.shiro.demo.dao"></property>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory_new"></property>
</bean>
<!-- 如果dao和mapper在mapper包里，只需要在扫描生产所有的dao层对象扫描-->
<!-- 配置sqlsessionFactory -->
<!--<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>
<property name="dataSource" ref="dataSource"></property>
</bean>
&lt;!&ndash; 配置扫描包，加载mapper代理对象 &ndash;&gt;
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.cc.hczzdpgl.mapper"></property>
</bean>-->
</beans>
\ No newline at end of file
src/main/resources/msqlspring/applicationContext-mysqlservice.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 扫描包加载Service实现类 -->
<context:component-scan base-package="com.shiro.demo.service.imp"></context:component-scan>
<context:component-scan base-package="com.shiro.demo.service"></context:component-scan>
<!-- 配置 扫描 @Service -->
<context:component-scan base-package="com.shiro.demo.shiro.cache" />
</beans>
\ No newline at end of file
src/main/resources/msqlspring/applicationContext-mysqltrans.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 数据源 -->
<property name="dataSource" ref="dataSource_new" />
</bean>
<!-- 通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 传播行为 -->
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="add*" propagation="REQUIRED" />
<tx:method name="create*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- 切面 -->
<!-- <aop:config>
<aop:advisor advice-ref="txAdvice"
pointcut="execution(* com.shiro.demo.service.*.*(..))" />
</aop:config>-->
<aop:config>
<aop:advisor advice-ref="txAdvice"
pointcut="execution(* com.shiro.demo.service.*.*(..))" />
</aop:config>
</beans>
\ No newline at end of file
src/main/resources/spring/applicationContext-jedis.xml deleted 100644 → 0
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="30" />
<!-- 最大空闲连接数 -->
<property name="maxIdle" value="10" />
<!-- 每次释放连接的最大数目 -->
<property name="numTestsPerEvictionRun" value="1024" />
<!-- 释放连接的扫描间隔（毫秒） -->
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<!-- 连接最小空闲时间 -->
<property name="minEvictableIdleTimeMillis" value="1800000" />
<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
<property name="maxWaitMillis" value="1500" />
<!-- 在获取连接的时候检查有效性, 默认false -->
<property name="testOnBorrow" value="true" />
<!-- 在空闲时检查有效性, 默认false -->
<property name="testWhileIdle" value="true" />
<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
<property name="blockWhenExhausted" value="false" />
</bean>
<!-- jedis客户端单机版 -->
<bean id="redisClient" class="redis.clients.jedis.JedisPool">
<constructor-arg name="host" value="192.168.1.102"></constructor-arg>
<constructor-arg name="port" value="6379"></constructor-arg>
<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean>
<bean id="jedisClient" class="com.xzxtshiro.redis.impl.JedisClientSingle"/>
<!-- jedis集群版配置 -->
<!--<bean id="redisClient" class="redis.clients.jedis.JedisCluster">
<constructor-arg name="nodes">
<set>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7001"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7002"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7003"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7004"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7005"></constructor-arg>
</bean>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.193.128"></constructor-arg>
<constructor-arg name="port" value="7006"></constructor-arg>
</bean>
</set>
</constructor-arg>
<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean>
<bean id="jedisClientCluster" class="com.taotao.rest.dao.impl.JedisClientCluster"></bean>-->
</beans>
\ No newline at end of file
src/main/webapp/resources/common/common.js
......@@ -84,6 +84,7 @@ function setTree(data,treeId,type,kid,vid,glcs) {
}
$("#"+vid).val(thisName);
closeTree();
layer.close(layer.index);
},
}
};
......@@ -109,7 +110,7 @@ function checkTree(treeId){
layer.open({
type: 1,
area:['400px', '430px'],
title:'请选择',
title:'请选择(双击可进行选中)',
skin: 'layui-layer-demo', //加上边框
content: $("#"+treeId)
});
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment