Spring Aop 权限开发(Java后台管理权限)

最新推荐文章于 2024-06-28 11:03:28 发布
最新推荐文章于 2024-06-28 11:03:28 发布
阅读量2.6k 收藏 4
点赞数 2
分类专栏： AOP权限 文章标签： AOP AOP后台权限开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35243979/article/details/83014178
版权

第一次使用aop开发后台权限，之前使用过aop开发过日志功能。

看了网上很多案例。感觉跟自己想要的还是有一定的区别，然后参照网上的案例，自己摸索写一个。

供大家参考。

1：首先，后台所有的功能菜单都放入数据库中。（用户列表，等这种功能菜单。）

2：后台所有的功能权限也放入到数据库中。（user：拥有用户列表权限，拥有用户列表查看，修改权限，没有删除，新增权限）

数据库要提前建立好。

开发代码：

创建操作枚举（增删改查）

/**
 * 操作枚举
 * 增(INSERT)
 * 删(DELETE)
 * 改(UPDATE)
 * 查(SELECT)
 * @author think
 */
public enum OperationEnum {

 //0：默认可以使用该权限
 //99：没有权限
 INSERT("INSERT","0"),
 DELETE("DELETE","0"),
 UPDATE("UPDATE","0"),
 SELECT("SELECT","0");
 
 private String key;
 private String value;
 
 private OperationEnum(String key,String value) {
  // TODO Auto-generated constructor stub
  this.key = key;
  this.value = value;
 }
 public String getKey() {
  return key;
 }
 public void setKey(String key) {
  this.key = key;
 }
 public String getValue() {
  return value;
 }
 public void setValue(String value) {
  this.value = value;
 }
}

 

创建权限注解，默认只有查询功能。

/**
 * 权限注解
 * @author think
 */
@Retention(RetentionPolicy.RUNTIME)  
@Target(ElementType.METHOD)
@Documented
public @interface Authority {

    OperationEnum value() default OperationEnum.SELECT;
}

 

创建aop工具类

/**
 * 解析权限注解
 * @author think
 */
@Aspect
@Component
public class AnnotationParse {
    @Autowired(required = false)
 private HttpServletRequest request;
 @Autowired
 private ManagerPermissionsService managerPermissionsService;

//对应你的权限注解类，上面一个方法
    @Pointcut("@annotation(com.mag.pro.pojo.aop.Authority)")
    public void operationAuthority() {
    }
    

//执行你的切面方法。

//这里面的权限逻辑没有，

//查询出用户有哪些权限，然后根据获得注解上的 操作权限来判断，该用户是否拥有权限操作。

//这里面有几个坑，

//1：ProceedingJoinPoint  请使用该类 2：一定要有返回值，不然报错搞死你。返回值object类型，不然搞死你。

//3：myExcpetion 是自定义异常，toBeanMap是自己写的方法，用于页面返回json格式，没有写？搞死你。。。

//4：PathKeyEnum 这个是自己定义的 枚举方法，主要存放 code msg entity。就是json格式
    @Around("operationAuthority()")
 public Object selectAuth(ProceedingJoinPoint joinPoint)throws Throwable{
  MyException myException = null;
  //获取controller参数集合，
  Enumeration parameter = request.getParameterNames();
  String users_only_md5 = getUsersId(parameter);
  Object result = "";//aop环绕返回值专用
  
  //当url传递的参数（users_only_id）为空时，则判断出系统异常
  //本来该判断是在controller里面处理的。但是环绕通知会优先执行，导致这里需要进行判断约束
  if(StringUtils.isNullString(users_only_md5)){
   myException = new MyException(PathKeyEnum.ERROR.getKey(),PathKeyEnum.ERROR.getValue(),PathCommonEnum.ERROR.getValue());
   return myException.toArgsUsersId();
  }
  
  //查询出用户所拥有的权限列表
  List<ManagerPermissions> listManagerPermissions = managerPermissionsService.selectManagerPermissionsUsers(users_only_md5);
  
  //当用户权限查询出来为null时，则定义为该用户没有权限
  if(StringUtils.isListNull(listManagerPermissions)){
   myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
   return myException.toBeanMap();
  }
  
  OperationEnum operationEnum = getControllerMethodDescription(joinPoint);
  String controllerUrl = getUrl();

if(StringUtils.isNullString(controllerUrl)){
   myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
   return myException.toBeanMap();
  }


  try{
   //listManagerPermissions 当这个集合不为空时，循环判断str跟集合里的权限是否有存在。
   for (int i = 0; i < listManagerPermissions.size(); i++) {
    if(listManagerPermissions.get(i).getFunction_permissions_controller().equals(controllerUrl)){
     if("SELECT".equals(operationEnum.getKey())){
      if(listManagerPermissions.get(i).getFunction_select() == Integer.parseInt(operationEnum.getValue())){
       result = joinPoint.proceed();
       break;
      }else{
       myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
       return myException.toBeanMap();
      }
     }else if("UPDATE".equals(operationEnum.getKey())){
      if(listManagerPermissions.get(i).getFunction_update() == Integer.parseInt(operationEnum.getValue())){
       result = joinPoint.proceed();
       break;
      }else{
       myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
       return myException.toBeanMap();
      }
     }else if("DELETE".equals(operationEnum.getKey())){
      if(listManagerPermissions.get(i).getFunction_delete() == Integer.parseInt(operationEnum.getValue())){
       result = joinPoint.proceed();
       break;
      }else{
       myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
       return myException.toBeanMap();
      }
     }else if("INSERT".equals(operationEnum.getKey())){
      if(listManagerPermissions.get(i).getFunction_add() == Integer.parseInt(operationEnum.getValue())){
       result = joinPoint.proceed();
       break;
      }else{
       myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
       return myException.toBeanMap();
      }
     }
    }
   }
  } catch (Exception e) {
   // TODO: handle exception
  }
  if("" == result){
   myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
   return myException.toBeanMap();
  }
  return result;
 }
    
    /**
     * 解析注解上的权限
     * @param joinPoint
     * @return
     */
    public static OperationEnum getControllerMethodDescription(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Authority controllerAuthority = method.getAnnotation(Authority.class);
        OperationEnum discription = controllerAuthority.value();
        return discription;
    }

//因为我们这边只需要用户的ID 所以取的id后退出循环
 private String getUsersId(Enumeration parameter){
  while(parameter.hasMoreElements()) {
   String args = (String) parameter.nextElement();
   if("users_only_md5".equals(args)){
    return request.getParameter(args);
   }
  }
  return PathCommonEnum.NULL.getValue();
 }

/**
  * 截取url的controller
  * @return
  */
 private String getUrl(){
  String url = request.getRequestURI();

//url: /xxxx/xx/xxx.htmls

//我这边取的是第二个xx 即controller的mapping值，

//第一个xxxx应该是项目名称 所以下面的 截取需要根据自己的连接来调整值。
  if(!StringUtils.isNullString(url)){
   return url.substring(13,url.lastIndexOf("/"));
  }
  return null;
 }

}

创建自定义异常类：

/**
 * 自定义异常
 * @author think
 */
public class MyException extends RuntimeException{

    private String code;
    private String msg;
    private Object entity;
    
    public MyException(String code, String msg,Object entity) {
        // TODO Auto-generated constructor stub
        this.code = code;
        this.msg = msg;
        this.entity = entity;
    }
    
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public Object getEntity() {
        return entity;
    }
    public void setEntity(Object entity) {
        this.entity = entity;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return JsonMethod.setJsonMethod(code, msg, entity).toString();
    }
    
    /**
     * 返回map格式
     * @return
     */
    public Map<String, Object> toBeanMap(){
        return JsonMethod.setJsonMethod(code, msg, entity);
    }

/**
     * 返回map格式
     * @return
     */
    public Map<String, Object> toArgsUsersId(){
        return JsonMethod.setJsonMethod(code, msg, entity);
    }

创建常量枚举类:

/**
 * 常量key枚举
 * 枚举具有安全性，不可修改性，默认final
 * @author boss 3
 */
public enum PathKeyEnum {
    
    SUCCESS("20000","执行成功"),
    ERROR("90000","系统繁忙,请稍后再试"),
    LOGINE("90001","该环境无法登录后台管理系统"),
    AUTHORITY("90003","权限不足");
    
    private String key;
    private String value;
    
    /**
     * 枚举必须使用私有化
     * @param key
     * @param value
     */
    private PathKeyEnum(String key,String value) {
        this.key = key;
        this.value = value;
    }
    
    /** 获取key值 */
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    /** 获取对应的key的描述 */
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }

下面就是controller类：

/**
     * 查询所有功能菜单
     * @param req
     * @param res
     * @return
     */
    @Authority(OperationEnum.DELETE)//这个就是功能子权限，增删改查，这边我自己写的是测试
    @OperLog(logDescription="查询所有功能菜单")//这个是系统日志aop 目前没有贴处来，可以删除掉
    @RequestMapping(value="selectFunctionPermissions",method=RequestMethod.GET)
    @ResponseBody
    public Map<String, Object> selectFunctionPermissions(HttpServletRequest req,
            HttpServletResponse res){
        res.setCharacterEncoding("UTF-8");
        System.out.println("进入controller");
        List<FunctionPermissions> listFunctionPermissions = functionPermissionsService.selectFunctionPermissions();
        
        if(StringUtils.isListNull(listFunctionPermissions))
            return JsonMethod.setJsonMethod(PathKeyEnum.ERROR.getKey(), PathKeyEnum.ERROR.getValue(), PathCommonEnum.ERROR.getValue());
        return JsonMethod.setJsonMethod(PathKeyEnum.SUCCESS.getKey(), PathKeyEnum.SUCCESS.getValue(), listFunctionPermissions);
    }

spring-mvc.xml配置环绕通知：

 <bean id="aprseAspect" class="com.commons.utils.aop.AnnotationParse"></bean>
    <!-- 环绕通知 -->
    <aop:config>
        <aop:aspect ref="aprseAspect">
            <aop:pointcut id="doPointCut" expression="execution(* com.mag.pro.service..*impl.*(..))"/>  
            <aop:around method="selectAuth" pointcut-ref="doPointCut"/>
        </aop:aspect>
    </aop:config>

最后是测试的效果：

1：@Authority(OperationEnum.DELETE)  当我们将方法定义为delete时请求的效果：

因为数据库里没有值，所以返回无数据。

走了service方法，说明执行了数据库查询。

2：我们将delte改成其他权限，

@Authority(OperationEnum.SELECT)

因为aop判断的是delete，所以select是走异常，是没有权限的。

运行结果是：

以上就是我写的一个后台权限判断。需要在权限aop方法里，加入自己查询到的用户m来遍历判断。

目前aop代码没有优化，if else 三层嵌套，不太好，需要优化下。

(更新：请看底部优化方式)

附上数据库图

1：功能菜单表

2：用户权限表（0：启用 99：禁用）

controller请求的接口

参考该代码时，需要自己创建数据库，直接是运行不了的。

JsonMethod.setJsonMethod 这个方法是我自己封装的一个json格式，各位可以用自己的json格式就行。

还有自己的ssm框架没问题就行。需要框架，可以看我博客里面的融云即时聊天二有csdn下载链接。需要1积分。头疼。

以上已完结，本人运行没有任何问题。如有问题，可以留言。大家互相探讨，有好的建议，优化方法，也可以提出来，大家一起学习，本人小白在此献丑了！！！！

 

更新：权限if 嵌套循环优化

这里使用了状态设计模式来优化代码：

1：创建状态抽象类

/**
 * 权限状态抽象类
 * 使用状态设计模式
 * @author think
 */
public abstract class ConcreteState {

    /**
     * 如果是查询,则返回查询对应的状态信息
     */
    public abstract Object selectOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable;
    
    /**
     * 如果是修改,则返回修改对应的状态信息
     */
    public abstract Object updateOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable;
    
    /**
     * 如果是新增,则返回新增对应的状态信息
     */
    public abstract Object insertOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable;
    
    /**
     * 如果是删除,则返回删除对应的状态信息
     */
    public abstract Object deleteOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable;
    
    /**
     * 如果是启用/禁用,则返回启用/禁用对应的状态信息
     */
    public abstract Object disableOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable;
}

 

2：创建状态实现类

/**
 * 权限状态实现类
 * 使用状态设计模式
 * @author think
 */
public class ConcreteStateImpl extends ConcreteState{
    
    //默认返回map，无需修改
    private final MyException myException = new MyException(PathKeyEnum.AUTHORITY.getKey(),PathKeyEnum.AUTHORITY.getValue(),PathCommonEnum.ERROR.getValue());
    
    /**
     * 如果是查询,则返回查询对应的状态信息
     */
    @Override
    public Object selectOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable{
        // TODO Auto-generated method stub
        if(listManagerPermissions.get(i).getFunction_select() == Integer.parseInt(operationEnum.getValue())){
            return joinPoint.proceed();
        } else {
            return myException.toBeanMap();
        }
    }
    
    /**
     * 如果是修改,则返回修改对应的状态信息
     */
    @Override
    public Object updateOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable{
        // TODO Auto-generated method stub
        if(listManagerPermissions.get(i).getFunction_update() == Integer.parseInt(operationEnum.getValue())){
            return joinPoint.proceed();
        } else {
            return myException.toBeanMap();
        }
    }
    
    /**
     * 如果是新增,则返回新增对应的状态信息
     */
    @Override
    public Object insertOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable{
        // TODO Auto-generated method stub
        if(listManagerPermissions.get(i).getFunction_delete() == Integer.parseInt(operationEnum.getValue())){
            return joinPoint.proceed();
        } else {
            return myException.toBeanMap();
        }
    }
    
    /**
     * 如果是删除,则返回删除对应的状态信息
     */
    @Override
    public Object deleteOperationEnum(List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable{
        // TODO Auto-generated method stub
        if(listManagerPermissions.get(i).getFunction_add() == Integer.parseInt(operationEnum.getValue())){
            return joinPoint.proceed();
        } else {
            return myException.toBeanMap();
        }
    }
    
    /**
     * 如果是启用/禁用,则返回启用/禁用对应的状态信息
     */
    @Override
    public Object disableOperationEnum(List<ManagerPermissions> listManagerPermissions, OperationEnum operationEnum,
            ProceedingJoinPoint joinPoint, int i) throws Throwable {
        // TODO Auto-generated method stub
        if(listManagerPermissions.get(i).getFunction_disable() == Integer.parseInt(operationEnum.getValue())){
            return joinPoint.proceed();
        }else{
            return myException.toBeanMap();
        }
    }
}

该方法在AnnotationParse 类里面写即可

3：创建调用实现类方法

/**
     * 状态设计模式
     * @param stateStr
     * @param listManagerPermissions
     * @param operationEnum
     * @param joinPoint
     * @param i
     * @return
     * @throws Throwable
     */
    private Object stateUtils(String stateStr,List<ManagerPermissions> listManagerPermissions, 
            OperationEnum operationEnum, ProceedingJoinPoint joinPoint, int i) throws Throwable{
        
        ConcreteStateImpl concreteStateImpl = new ConcreteStateImpl();
        
        switch (stateStr) {
            case "SELECT":
                return concreteStateImpl.selectOperationEnum(listManagerPermissions, operationEnum, joinPoint, i);
            case "UPDATE":
                return concreteStateImpl.updateOperationEnum(listManagerPermissions, operationEnum, joinPoint, i);
            case "INSERT":
                return concreteStateImpl.insertOperationEnum(listManagerPermissions, operationEnum, joinPoint, i);
            case "DELETE":
                return concreteStateImpl.deleteOperationEnum(listManagerPermissions, operationEnum, joinPoint, i);
            case "DISABLE":
                return concreteStateImpl.disableOperationEnum(listManagerPermissions, operationEnum, joinPoint, i);
            default:
                return null;
        }
    }

4：修改for循环里面的if代码

只需要这段代码。参数正常传递即可。

这样。if else if 代码优化已完成。并且已测试过。该代码优化运行正常。

HLucky_17
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于java的后台权限管理
03-29
此源码是基于spring+springmvc+ibatis+extJS+Oracle来实现的后台权限管理，包含有所有的jar包，在Eclipse中调试没有问题，系统包含有Oracle的数据库脚本，实现了对资源的权限管理，供大家学习。
AOP应用之权限管理
zhuweisky
08-23 9229
在系统实现中AOP常用于并发、权限管理、事务处理、日志记录、错误处理方面。本文介绍如何使用EnterpriseServerBase类库中的AOP框架来实现权限管理。一个用户是否有权限调用某个操作（方法），是由我们的应用决定了，不同的应用有不同的实现，但是，如果需要使用EnterpriseServerBase类库中的AOP的权限管理，则应用必须实现下面的接口IPermissionVerifier：/
通用数据权限设计与实现（mybatis拦截器 + spring aop）
最新发布
shixiaoyanma的博客
06-28 1243
哈喽~ 大家好，今天给大家分享一下平时在工作当中遇到的数据权限问题。在我们的业务系统中，除了菜单/功能权限外，还有一个非常重要的功能，就是数据权限。数据及权限管理，大多数采用的方案还是硬编码的方式，也就是将这种逻辑以if/else等方式与业务代码耦合在一起，按需做数据权限划分。本文这里采用的是另一种比硬编码相对优雅的方式：mybatis拦截器+spring aop。
java aop管理权限_基于spring aop 权限管理系统原型 - andyj2ee - BlogJava
weixin_30670053的博客
02-27 217
此权限管理系统把待访问的业务层方法做为权限管理中的资源，通过spring aop 对接口方法进行拦截，来实现权限的管理，可以实现细粒度的权限控制。在上文体验了spring aop 一些特性，aop 接口：MethodBeforeAdvice， AfterReturningAdvice， ThrowsAdvice 实现这三个接口分别对方法执行前，后，执行中抛异常等情况进行的，我们要是想做overlo...
Spring Aop 权限开发(Java后台管理权限) (完整版)
qq_35243979的博客
12-19 1361
之前写过一个aop后台管理系统权限功能，发现贴出来的代码不是很完整。可能会造成参考的用户会运行不正常。 下面我将图文结合。贴出完整版代码！此功能不适用所有的aop后台权限。仅限同类型风格之类的可用。 mysql数据库创建权限表和管理员权限表： 该表为后台功能表。 表对应的就是该后台的主要功能，表中间的拼音是功能的 缩写。我这边用来做权限判断使用。 下面是管理员权限列表 这里...
java aop管理权限_[原创][分享]利用Spring中的AOP做权限管理
weixin_30278943的博客
02-27 84
-----------------------------------------------------------------------------------------------------代码如下：接口类的定义：[CODE]package com.dragon.study;public interface ILogin {public void login(String name);...
java后台管理系统，集成权限管理.zip
09-26
Java后台管理系统是一个基于Java编程语言开发的用于企业管理的软件系统，通常包含用户管理、角色管理、权限控制等功能，旨在提供高效、安全的企业级业务处理能力。这个压缩包"java后台管理系统，集成权限管理.zip"很...
App登陆java后台处理和用户权限验证
09-02
本文将深入探讨如何在Java后台上实现这一功能，以满足App的登录需求，并确保用户权限的安全管理。 首先，对于登录功能，App通常会通过发送用户名和密码到服务器来获取一个称为token的凭证。这个token是安全验证用户...
Java通用后台系统+权限管理
03-14
【Java通用后台系统+权限管理】是一个基于Java技术构建的后台管理系统，它的核心特性在于其通用性和可扩展性。这个系统旨在提供一个基础框架，开发者可以根据实际需求进行功能的添加和定制，使得软件开发变得更加...
ssm easyui 权限后台管理系统
01-29
SSM EasyUI 权限后台管理系统是一款基于Struts2、Spring和MyBatis三大主流Java Web框架构建的高效、易用的权限管理平台。EasyUI则是一个轻量级的前端框架，提供了丰富的组件和便捷的API，使得界面设计更加美观且操作...
基于SSM框架简单的后台权限管理系统.rar
01-15
这个"基于SSM框架简单的后台权限管理系统"是一个典型的后台管理系统，旨在实现对用户权限的有效控制，便于企业管理后台操作。在这个系统中，我们将深入探讨SSM框架的核心组件及其在权限管理中的应用。 首先，Spring...
java后台权限管理
01-26
java后台权限管理，不错。花钱买的。 大家一起共享。
java通用管理后台（security权限版）
02-24
代码使用技术包含SpringSecurity4.2.3、Hibernate5.x、Lucene5.5.4、SpringMVC & Spring4.3.9、Bootstrap3.3.7、HTML5、JDK7+、MySQL、Maven 适用于个人练习，企业二次开发。 之前提供的两个版本忘记附上数据库账号密码，一并补充。 Hibernate版本访问地址：http://localhost:8080/jeefw/login.jsp， 账号：3228979148@qq.com 密码：skynet168 Mybatis版本访问地址：http://localhost:8080/mbfw，账号：admin 密码：1
java spring AOP权限控制
01-15
传统的应用程序实现 J2EE容器实现 AOP下的应用程序权限控制实现
一个免费的java权限后台管理系统框架
01-23
技术支持：www.walkersoft.net。 java权限后台开发框架，采用spring + srpingsecurity + springMVC + Hibernate + freemarker + jquery 等技术实现，页面及源文件打包发布程序。 完整的功能应用，包括：后台权限、人员机构、参数代码、角色权限、上传文件、日志管理等内容。 您可以直接在其上面开发业务模块，具体下载和演示可访问：www.walkersoft.net。 开发文档整理中，很快会更新到网站中。希望能和广大开发者交流，并提供更多支持。 2019-08-16更新 请下载最新版：https://download.csdn.net/download/pxzsky/10587447 积分过多，不是个人原因，csdn改版后就这样了，你懂的，不再一一回复。
spring+springmvc+mybatis项目案例实现用户角色权限管理
03-17
使用spring+springmvc框架 整合了Mybatis持久层框架 整合Druid用于数据库连接，并使用Druid对业务层监控spring jdbc 整合EhCache，对Mybatis的二级缓存进行管理和对spring进行缓存管理 整合FastJson对指定http类型的数据进行转换 整合hibernate.validator校验器对controller接口参数进行校验 使用了springmvc统一异常处理 使用了FormattingConversionServiceFactoryBean对于传入参数中日期或数字字符串进行数据转换和数据格式化 使用了SpringContextHolder方便在自定义线程中调用spring已经实例的bean，如使用service 使用了urlrewrite filter进行地址重写，实现伪静态页面 使用了sitemesh对网页进行布局和修饰 使用了loginFilter对访问进行登录过滤 使用了CheckCodeServlet生成验证码图片
aop 权限
qq_34787240的博客
09-14 270
Aspectj与androidM的Permission简单结合   https://m.aliyun.com/jiaocheng/780701.html
Spring AOP权限管理
nature_fly088的专栏
11-04 3543
此权限管理系统把待访问的业务层方法做为权限管理中的资源，通过spring aop 对接口方法进行拦截，来实现权限的管理，可以实现细粒度的权限控制。 在上文体验了spring aop 一些特性，aop 接口：MethodBeforeAdvice， AfterReturningAdvice， ThrowsAdvice 实现这三个接口分别对方法执行前，后，执行中抛异常等情况进行的，我们要是想做ove
aop权限
蔡定努
02-27 232
package com.stu.aoppermission.anno; import java.lang.annotation.*; /** * desc： 自定义注解 * create 2020-02-27 16:27 * version 1.0.0 * * @author cdn */ @Target(ElementType.METHOD) @Retention(R...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值