权限管理框架实现（1）--Struts切面处理

最新推荐文章于 2019-06-06 15:49:38 发布
最新推荐文章于 2019-06-06 15:49:38 发布
阅读量98 收藏 1
点赞数
文章标签： java json runtime
原文链接：https://my.oschina.net/u/3627638/blog/1489211
版权

要做一款权限架构，就要适用几个流行的相关框加，struts2是我们公司首先需要考虑的，考虑到侵入性，决定通过切面的方式，在每个Action前进行权限验证，基本思路是：

        1，自定义通用权限注解

        2，开发抽象切面，预留传入uid的接口

        3，配置struts切面，做权限拦截


以下源码是对上边功能的实现：

1，权限注解

/**
 * 自定义权限注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Authority {

    /**
     * 权限码
     * @return
     */
    String authorityCode();

}

2，sturts抽象切面

public abstract class ELInterceptor implements Interceptor {

    private IVerificationUser verificationUser;
    private ILogicUserAreaFranchiseeService logicUserAreaFranchiseeService;
    private Result result = new Result(true);

    @Override
    public void destroy() {
        // TODO Auto-generated method stub

    }

    protected final Log log = LogFactory.getLog(this.getClass());

    @Override
    public void init() {

    }

    /**
     * 拦截类并作权限验证
     * @param invocation
     * @return
     * @throws Exception
     */
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        log.info("=intercept=>Authority Intercept");
        // TODO Auto-generated method stub
        String methodName = invocation.getProxy().getMethod();
        Method currentMethod = invocation.getAction().getClass().getMethod(methodName);
        Method[] methods = invocation.getAction().getClass().getMethods();
        initAuthCode(methods);

        String isTest = (String) ServletActionContext.getRequest().getParameter("authistest");

        //如果该方法请求是需要进行验证的时候执行以下逻辑
        if (currentMethod.isAnnotationPresent(Authority.class)) {
            //取得权限验证的注解
            Authority authority = currentMethod.getAnnotation(Authority.class);

            log.info("=intercept=> get authorityCode");
            //取得当前请求的注解的authorityCode
            String authorityCode = authority.authorityCode();

             /* *
             * 然后可以在此判断当前用户是否拥有对应的权限，如果没有可以跳到指定的无权限提示页面，如果拥有则可以
             * 继续往下执行。
             **/
            boolean ispass =false;
            ispass = Boolean.parseBoolean(getFromVm(authorityCode));
            if (ispass){
                if(isTest==null ||isTest.trim().isEmpty()){
                    return invocation.invoke();
                }else{
                    return "hasauth";
                }
            } else {
                log.info("=intercept=> user not have  this authorityCode");
                writeJson("<html auth='NOAUTH'></html>");
                return "noauth";
            }
        }
        log.info("<=intercept=>Authority Intercept");
        if(isTest==null ||isTest.trim().isEmpty()){
            return invocation.invoke();
        }else{
            return "hasauth";
        }
    }

    private Boolean checkOnline(AuthCheckDomain authCheckDomain){
        boolean isPass = false;
        AuthorityUser authorityUser =null;
        PublicResult<Boolean> publicResult =verificationUser.hasAuth(authCheckDomain);
        if(publicResult!=null&&publicResult.isSuccess()){
            isPass = publicResult.getResult();
            if(publicResult.getAuthorityUser()!=null ){
                authorityUser=publicResult.getAuthorityUser();
                authorityUser.setCreated(new Date());
                AuthCache.authMap.put(authCheckDomain.getAuthCode().trim(),authorityUser);
            }
        }
        return isPass;
    }

    private void writeJson(String json){
        try {
            HttpServletResponse response = ServletActionContext.getResponse();
            response.setHeader("contentType", "application/json;charset=UTF-8");
            response.setCharacterEncoding("UTF-8");
            response.setDateHeader("Expires", 0L);
            response.setHeader("Cache-Control", "no-cache");
            response.setHeader("Pragma", "no-cache");
            ServletOutputStream out = response.getOutputStream();
            out.write(json.getBytes("UTF-8"));
            out.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private void initAuthCode(Method[] methods){
        for(Method currentMethod :methods){
            //如果该方法请求是需要进行验证的时候执行以下逻辑
            if (currentMethod.isAnnotationPresent(Authority.class)) {
                //取得权限验证的注解
                Authority authority = currentMethod.getAnnotation(Authority.class);

                log.info("=intercept=> get authorityCode");
                //取得当前请求的注解的authorityCode
                String authorityCode = authority.authorityCode();
                isAuthPass(authorityCode);
            }
        }

        toVm(result);
    }

    private boolean  isAuthPass(String authorityCode){
        log.info("=isAuthPass=>");
        AuthCheckDomain authCheckDomain = new AuthCheckDomain();
        Long uid=getUid();
        String ip=getIP();
        UserAreaFranchisee userArea =  getUserArea(uid);
        Long provinceId=null;
        Long cityId=null;
        Long townId=null;
        if(userArea!=null){
            provinceId=Long.valueOf(userArea.getProvinceid());
            cityId=Long.valueOf(userArea.getCityid());
            townId=Long.valueOf(userArea.getCountyid());
        }

        authCheckDomain.setAuthCode(authorityCode);
        authCheckDomain.setUid(uid);
        authCheckDomain.setIp(ip);
        authCheckDomain.setProvinceId(provinceId);
        authCheckDomain.setCityId(cityId);
        authCheckDomain.setTownId(townId);

        boolean ispass = false;
        AuthorityUser authorityUser =null;
        if(AuthCache.authMap!=null && AuthCache.authMap.containsKey(authorityCode) && AuthCache.authMap.get(authorityCode)!=null ){
            authorityUser = AuthCache.authMap.get(authorityCode);
            int nowLong = DateUtil.getCurrentTime();
            long checkTime = nowLong-(authorityUser.getCreated().getTime()/1000);
            if(checkTime> RedisIntValueUtils.MapExpireSeconds.getIntValue()){
                ispass = checkOnline(authCheckDomain);
            }
            ispass=CheckAuth.hasAuth(authorityUser,authCheckDomain);
        }else{
            ispass=checkOnline(authCheckDomain);
        }

        toVmAuthPass(authorityCode, ispass);
        return ispass;
    }

    private void toVmAuthPass(String authCode,boolean isPass){
        result.addDefaultModel(authCode,isPass);
    }


    private void toVm(Result result){
        ValueStack context = ActionContext.getContext().getValueStack();
        Set set = result.keySet();
        Iterator resultCode = set.iterator();
        context.set("textProvider", this);
        context.set("datePickerLocale", this.getDatePickerLocale());

        String text;
        while(resultCode.hasNext()) {
            text = (String)resultCode.next();
            context.set(text, result.get(text));
        }
    }

    private String getFromVm(String authCode){
        ValueStack context = ActionContext.getContext().getValueStack();
        Map map = (Map)context.peek();
        String result = ((Boolean)map.get(authCode)).toString();
        return result;
    }

    private String getDatePickerLocale() {
        String locale = this.getLocale().toString().toLowerCase();
        String[] arr = locale.split("_");
        if(arr[0].equals("en")) {
            locale = arr[0];
        } else {
            locale = arr[0] + "-" + arr[1];
        }

        return locale;
    }

    public Locale getLocale() {
        ActionContext ctx = ActionContext.getContext();
        if(ctx != null) {
            return ctx.getLocale();
        } else {
            return null;
        }
    }

    private UserAreaFranchisee getUserArea(Long uid){
        UserAreaFranchisee userAreaFranchisee = null;
        String userJson = RedisUtils.get(RedisKeyUtils.Redis_Key_UserArea.getKeyStr()+uid,String.class);
        if(userJson==null || userJson.trim().isEmpty()){
            userAreaFranchisee =  getUserAreaByDubbo(uid);
            try {
                if (userAreaFranchisee != null) {
                    RedisUtils.set(RedisKeyUtils.Redis_Key_UserArea.getKeyStr() + uid, JSON.toJSONString(userAreaFranchisee), RedisIntValueUtils.Redis_ExpireSeconds_UserArea.getIntValue());
                }
            }catch (Exception e){
                log.error("=getUserArea=>set reids error",e);
            }
        }else{
            try {
                userAreaFranchisee = JSON.parseObject(userJson, UserAreaFranchisee.class);
            }catch(Exception e){
                log.error("=getUserArea=> json error",e);
                userAreaFranchisee=null;
            }
        }

        return userAreaFranchisee;

    }

    private UserAreaFranchisee getUserAreaByDubbo(Long uid){
        com.el.common.result.PublicResult<UserAreaFranchisee> result =null;
        try {
            result = logicUserAreaFranchiseeService.getUserAreaFranchisee(uid.intValue());
        }catch (Exception e){
            log.error("==>error" ,e);
            result=null;
        }
        if(result==null || !result.isSuccess() || result.getResult()==null){
            return null;
        }else{
            return result.getResult();
        }
    }

    private Long getProvinceId(Long uid) {
        return null;
    }

    public Long getCityId(Long uid) {
        return null;
    }


    public Long getTownId(Long uid) {
        return null;
    }



    public abstract Long getUid();
    public abstract String getIP();

    public IVerificationUser getVerificationUser() {
        return verificationUser;
    }

    public void setVerificationUser(IVerificationUser verificationUser) {
        this.verificationUser = verificationUser;
    }

    public ILogicUserAreaFranchiseeService getLogicUserAreaFranchiseeService() {
        return logicUserAreaFranchiseeService;
    }

    public void setLogicUserAreaFranchiseeService(ILogicUserAreaFranchiseeService logicUserAreaFranchiseeService) {
        this.logicUserAreaFranchiseeService = logicUserAreaFranchiseeService;
    }
}


此处预留了两个抽象方法，依赖具体客户端实现，分别是获取用户id和获取ip

    public abstract Long getUid();
    public abstract String getIP();


具体切面（抽象类实现）

@Service
public  class ELInterceptorImpl extends  ELInterceptor {

    @Autowired
    private IVerificationUser verificationUser;

    @Autowired
    private ILogicUserAreaFranchiseeService logicUserAreaFranchiseeService;

    public  Long getUid(){
        String suid = (String) ServletActionContext.getRequest().getSession().getAttribute("uid");
        Long uid=Long.valueOf((suid==null || suid.isEmpty())?"0":suid);
        return uid;
    }

    @Override
    public String getIP() {
        //这里可以从session里面取得当前的用户
        String suip = (String) ServletActionContext.getRequest().getSession().getAttribute("ip");
        return suip;

    }
}

注意：struts切面抽象类中，两个具体的业务服务不能使用spring自动注入，因为spring是扫描包下的类，有注解的维护一个单例的存在，而抽象类不能实例化，所以会报错，我们可以在具体实现类中，注入两个属性，结果是一样的。

3，struts配置

<interceptors>
            <interceptor name="authIntercept" class="com.el.authority.service.intercept.ELInterceptorImpl"/>
            <interceptor-stack name="strutsDefaultStack">

                <interceptor-ref name="exception"/>
                <interceptor-ref name="alias"/>
                <interceptor-ref name="servletConfig"/>
                <interceptor-ref name="i18n"/>
                <interceptor-ref name="prepare"/>
                <interceptor-ref name="chain"/>
                <interceptor-ref name="debugging"/>
                <interceptor-ref name="scopedModelDriven"/>
                <interceptor-ref name="modelDriven"/>
                <interceptor-ref name="fileUpload">
                    <param name="maximumSize">4194304</param>
                    <!--单个文件最大4M -->
                    <param name="allowedTypes">image/x-png,image/png,image/gif,image/jpeg,image/jpg,image/pjpeg,text/plain,application/octet-stream</param>
                    <param name="allowedExtensions">jpg,jpeg,png,gif,txt,vm</param>
                </interceptor-ref>
                <interceptor-ref name="checkbox"/>
                <interceptor-ref name="multiselect"/>
                <interceptor-ref name="staticParams"/>
                <interceptor-ref name="actionMappingParams"/>
                <interceptor-ref name="params">
                    <param name="excludeParams">dojo\..*,^struts\..*,.*\\u0023.*</param>
                </interceptor-ref>
                <interceptor-ref name="conversionError"/>
                <interceptor-ref name="validation">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
                <interceptor-ref name="workflow">
                    <param name="excludeMethods">input,back,cancel,browse</param>
                </interceptor-ref>
                <interceptor-ref name="authIntercept"/>
            </interceptor-stack>
            <interceptor-stack name="taskInterceptor">
                <interceptor-ref name="strutsDefaultStack"/>
            </interceptor-stack>
        </interceptors>
        <default-interceptor-ref name="taskInterceptor"/>
        <global-results>
            <result name="exception">/WEB-INF/vm/error.vm</result>
            <result name="error">/WEB-INF/vm/error.vm</result>
            <result name="input">/WEB-INF/vm/convertError.vm</result>
            <result name="noauth">/WEB-INF/vm/noauthority.vm</result>
            <result name="hasauth">/WEB-INF/vm/hasauth.vm</result>
        </global-results>

4，struts图示

        下图是struts架构的实现，对应到刚刚的配置文件中，我们就能很容易分辨出切面的切入位置



总结：

        struts切面的实现，网上有很多例子，大家不防多多参考，本文中的例子主要是给大家交代清楚整体结构，通过这些后台代码及配置，我们就能全局对用户权限控制，进行控制，但是还是有些细节，篇幅所限，大家参考后续的文章，其中会介绍ValueStack的使用，前台控件的自动显隐等。






转载于:https://my.oschina.net/u/3627638/blog/1489211

chongtai6075
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
struts1中aop操作日志_SpringBoot应用中使用AOP记录接口访问日志
weixin_27645199的博客
01-20 697
本文主要讲述AOP在mall项目中的应用，通过在controller层建了一个切面来实现接口访问的统一日志记录。AOPAOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发...
struts项目学习笔记
04-08
Struts2 是一个非常优秀的MVC框架，基于Model2 设计模型 由传统Struts1和WebWork两个经典框架发展而来 Struts2框架=Struts2+XWork Strust2 核心功能 允许POJO（Plain Old Java Objects,简单javabean对象,没有继承,没有实现,getter,setter方法）对象 作为Action,没有耦合 Action的execute 默认方法不再与Servlet API耦合，更易测试 支持更多视图技术（JSP(转译java文件,编译成class文件,才可以运行)、(模板技术,html,把数据和模板html一起以流方式输出)FreeMarker、Velocity） 基于AOP(面向切面编程)思想的拦截器机制，更易扩展(不修改源代码的条件下,增强代码功能) 更强大、更易用输入校验功能 整合Ajax支持:json插件 Struts2的今生前世： 1.早期开发模型Servlet+JSP+JavaBean显得力不从心： 流程凌乱、数据传递无序、缺乏辅助功能。 2.MVC模式的轻量级Web应
SpringAop对struts2的Action设置切面织入时报错java.lang.NoSuchMethodException
weixin_30512089的博客
06-25 226
学习springAop，尝试对struts2的Action层使用Aop切面实现日志的打印。 执行出现报错：java.lang.NoSuchMethodException. 查阅资料解决办法：spring中配置<aop:config proxy-target-class="true"/> ，强制使用cglib代理。 分析问题原因： springAop实现默认使用ja...
struts2 拦截器（AOP，面向切面编程）
遗失的世界
08-27 993
1.自定义拦截器 TestAction.java package com.test.struts2.action; import com.opensymphony.xwork2.ActionSupport; public class TestAction extends ActionSupport { @Override public String execute(...
Structs2+Spring实现aop日志与问题解决
shandadadada的博客
07-30 1410
struct2+spring实现sop日志与问题解决
信息办公Struts图书馆管理系统-struts.zip
最新发布
10-27
8. **Struts与Spring集成**：在大型项目中，Struts常与Spring框架结合使用，Spring可以处理依赖注入（DI）和面向切面编程（AOP），为Struts提供更强大的服务管理。 9. **安全性**：Struts提供了安全相关的功能，如...
struts2-spring-plugin-2.3.15.1.jar
06-01
3. **拦截器（Interceptors）**：Struts2-Spring-Plugin可以将Spring的AOP特性引入到Struts2的拦截器链中，允许开发者定义基于切面的业务逻辑，如事务管理、日志记录等。 4. **类型转换（Type Conversion）**：插件...
Struts2框架图书管理系统.rar
06-11
- **Interceptor（拦截器）**：拦截器是Struts2的一个重要特性，它们是AOP（面向切面编程）的概念在Struts2中的体现，可以在Action执行前后进行额外的操作，如日志记录、权限检查等。 - **Value Stack（值栈）**：...
struts-2.3.37-all.rar
06-10
- **拦截器（Interceptors）**：提供AOP（面向切面编程）功能，可以实现如日志、事务管理、权限验证等预定义操作。 - **配置文件**：Struts 2的配置文件通常包括struts.xml，用于配置Action、结果类型、拦截器栈等。...
spring-ssm 框架整合
09-13
Spring、Struts和MyBatis（简称SSM）是常见的三大框架，它们各自专注于不同的层面：Spring提供了强大的依赖注入和面向切面编程功能，Struts则负责处理MVC模式中的控制层逻辑，而MyBatis则是轻量级的持久层框架，方便...
struts2+spring+hibernate分页，事务，自定义切面
07-17
struts2+spring+hibernate分页，事务，自定义切面，事务的配置
Struts2拦截器原理(拦截器设计体现的一种编程理念——面向切面编程AOP)
centre10的专栏
12-05 3018
<br />Struts2的拦截器的设计体现了一种编程的设计理念，即面向切面编程AOP。一个正常的action，在没有interceptor时，直接就执行了。而有了拦截器以后，我们可以在action执行前，加上需要执行的代码，而在action执行完成后，也可以添加需要的执行逻辑代码。<br />通过查看源码，可以发现valueStack被放在request里，如果需要取得valueStack，用request的getAttribute<br /><br /> <br /> <br /> <br /> <br
struts2 + spring +自定义注解+ 拦截器
LiuEP的博客
06-06 548
struts2 + spring +自定义注解+ 拦截器可以实现很多功能自定义注解拦截器struts.xmlweb.xmlAction spring 的拦截器可以实现很多需求，配合上自定义注解的话可以实现例如接口权限控制等。这里不实现具体需求，只做一个整体的效果，话不多说先上代码： 自定义注解 package sy.annotation; import java.lang.annotation...
Struts2注解使用说明
热门推荐
一名清官
02-25 4万+
Struts2注解 1　Struts2注解的作用 使用注解可以用来替换struts.xml配置文件！！！ 2　导包 　　必须导入struts2-convention-plugin-2.3.15.jar包，它在struts2安装包下lib目录中。  3　通过配置文件学习对应的注解 @Action来代替元素！ l  String value()：指定访问路径； l  Resul
面向切面编程（AOP）及其作用
weixin_30612769的博客
04-13 344
在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。 1、面向切面编程（AOP） 　　面向切面编程（AOP）就是对软件系统不同关注点的分离，开发者通过拦截方法调用并在方法调用前后添加辅助代码。 　　AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多了类的公共行为封装到一个可重用的模块，并将其命名为“Aspect”，即切面。 　　所谓“切面”，简单地...
深入分析JavaWeb Item44 -- Struts2开发核心之动作类Action
小平果的欢乐谷
01-06 7747
一、Action动作类(一般用**Action结尾)struts2 的Action可以是POJO(Plain Old Java Object) 为了让用户开发的Action更加规范struts2提供了一个Action接口通过method属性指定Action执行方法没有指定method属性，默认执行execute方法<action name="addCustomer" class="xgp.stru
基于struts的权限控制——简单实现
Brave.Chi 的博客
05-12 1709
struts框架中只有一个ActionServlet,但可以有多个客户化的requestProcesscor。对于struts来说真正做控制的是RequestProecssor和Action。其中Action的process方法最终调用的是RequestProcessor类中的process方法。下面是该方法的源码：public void process(HttpServletRequ
Struts2框架详解：优势与Struts1对比
拦截器是基于AOP（面向切面编程）思想的，允许开发者在特定操作执行前后插入自定义逻辑，例如进行权限验证、日志记录等。这极大地扩展了框架的功能，简化了复杂业务场景的处理。 在类型转换方面，Struts2提供了一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值