2. 程式人生 > >基於mybatis攔截器實現資料許可權

基於mybatis攔截器實現資料許可權

阿新 • • 發佈：2018-12-05

資料許可權是很多系統常見的功能，實現的方式也是很多的，最近在做專案的時候，自己基於mybatis攔截器做了一個數據許可權的功能。

**功能設計

a)  需要做資料許可權功能的表加上一個許可權id欄位。

許可權id可以不僅僅是組織，還可以是其他自定義的欄位，用來做資料許可權，如：

主鍵Id

欄位1

欄位2

欄位3

許可權id

1

xxx

xxx

xxx

A001

2

xxx

xxx

xxx

A002

3

xx

xxx

xxx

A003

 

b)  1.分配許可權id給資料角色；2.分配角色給員工， 這樣就實現了許可權的分配。

c)   員工-崗位-組織的關係如下，可以加一個開關，可以選擇是否同時選用預設組織的許可權資料。      

d)  取到步驟b)和c)的許可權id列表後，組裝到sql裡面進行如下查詢：

select   *  from  table  where  許可權id   in  (‘A001’,’A002’,’A003’)

e) 為了減少程式碼的耦合性，採取註解的方式，在mapper.java的查詢方法上面加註解：

**前臺頁面參考

測試表：

CREATE TABLE `lcp_test_auth` (
  `test_auth_id` bigint(20) NOT NULL COMMENT '主鍵ID',
  `attr1` varchar(64) NOT NULL COMMENT '欄位1',
  `org_id` bigint(20) NOT NULL COMMENT '組織id',
  `warehouse_id` bigint(20) NOT NULL COMMENT '倉庫id',
  `created_by` bigint(20) DEFAULT NULL,
  `creation_date` datetime DEFAULT CURRENT_TIMESTAMP,
  `last_updated_by` bigint(20) DEFAULT NULL,
  `last_update_date` datetime DEFAULT CURRENT_TIMESTAMP,
  `object_version_number` bigint(20) DEFAULT '1',
  `request_id` bigint(20) DEFAULT NULL,
  `program_id` bigint(20) DEFAULT NULL,
  `last_update_login` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`test_auth_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='資料許可權測試表';

 

 

**後臺功能實現

a) mybatis攔截器的xml配置，先在xml中配置好plugins，也就是自定義攔截器的類

 

b) 編寫自己的攔截器類，我在攔截器裡面需要做的事情是：

1.得到將要執行的原來的sql；

2.從request裡面得到當前登入的使用者的資訊；

3.根據當前使用者資訊查詢其擁有的許可權資料；

4.根據許可權資料拼接sql並修改原sql；

5.sql執行，完。

關於mybatis攔截器的內容可以參考：https://blog.csdn.net/xiao_jun_0820/article/details/70308253

下面是我的mybatis攔截類，其中DataAuth 是我的註解類，AuthSqlSource是我的sqlSource類，僅作為參考(直接copy肯定是跑不起來的，嘿嘿)

package com.fsl.lcp.interceptor;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
import org.apache.ibatis.reflection.wrapper.DefaultObjectWrapperFactory;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.fsl.lcp.annotation.DataAuth;
import com.fsl.lcp.auth.dto.AuthorityResource;
import com.fsl.lcp.auth.service.IAuthorityResourceService;
import com.fsl.lcp.auth.service.IDataRoleResourceService;
import com.fsl.lcp.auth.sqlsource.AuthSqlSource;
import com.hand.hap.core.components.ApplicationContextHelper;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Properties;

import javax.servlet.http.HttpServletRequest;

/**
 * mybatis資料許可權攔截器
 * @author tanqian
 * 2018年11月29日
 */
@Intercepts({@Signature(method = "query", type = Executor.class,
	args = { MappedStatement.class, Object.class,RowBounds.class, ResultHandler.class })})
public class AuthLcpInterceptor implements Interceptor {
	
	private static final Logger log = LoggerFactory.getLogger(AuthLcpInterceptor.class);
	
	private ApplicationContext beanFactory;
	
	private IAuthorityResourceService iAuthorityResourceService;
	
	private IDataRoleResourceService iDataRoleResourceService;
	
	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}

	@Override
	public void setProperties(Properties properties) {
	}

	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		//初始化bean
		this.loadService();
		
		MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
		// 獲取方法上的資料許可權註解，如果沒有註解，則直接通過
		DataAuth dataAuth = getPermissionByDelegate(mappedStatement);
		if (dataAuth == null) {
			return invocation.proceed();
		}
		// 獲取request資訊，得到當前登入使用者資訊
		RequestAttributes req = RequestContextHolder.getRequestAttributes();
		if (req == null) {
			return invocation.proceed();
		}
		//處理request
		HttpServletRequest request = ((ServletRequestAttributes) req).getRequest();
		//如果request裡面的使用者/員工資訊為空，則直接拋異常
		if(request.getSession().getAttribute("employeeId") == null || request.getSession().getAttribute("userId") == null){
			throw new RuntimeException("此查詢為許可權資料，必須是擁有員工和使用者屬性的賬號登入才可以查詢！");
		}
		//employeeId
		Long employeeId = Long.valueOf(request.getSession().getAttribute("employeeId").toString());
		//userId
		Long userId = Long.valueOf(request.getSession().getAttribute("userId").toString());
		//處理組織許可權資料，並返回組織許可權sql
		String orgAuthSql = this.dealOrgAuth(dataAuth,employeeId);
		//處理資料許可權資料，並返回資料許可權sql
		String authSql = this.dealResourceSql(dataAuth,userId);
	
		//如果兩種sql都為空，那直接返回
		if("".equals(orgAuthSql.trim()) && "".equals(authSql.trim())){
			return invocation.proceed();
		}
		log.info("待拼接sql：組織許可權sql："+orgAuthSql + "，資料許可權sql：" + authSql);
		//原sql
		String sql = mappedStatement.getBoundSql(invocation.getArgs()[1]).getSql();
		//處理sql拼接
		this.permissionSql(sql,orgAuthSql,authSql,invocation);
		
		return invocation.proceed();

	}

	/**
	 * 處理資料許可權資料，並返回資料許可權sql
	 * @param dataAuth
	 * @param userId
	 * @return
	 */
	private String dealResourceSql(DataAuth dataAuth, Long userId) {
		String authSql = "";
		//資料許可權註解
		String resourceCode = dataAuth.resourceCode();
		if(!resourceCode.equals("")){
			List<AuthorityResource> resourceList = iAuthorityResourceService.selectAuthSqlByUserIdAndResourceCode(userId, resourceCode);
			if(resourceList.size() > 0){
				authSql = resourceList.get(0).getAuthorityResourceSql();
			}
		}
		return authSql;
	}

	/**
	 * 處理組織許可權資料，並返回組織許可權sql
	 * @param dataAuth
	 * @param employeeId 
	 * @return
	 */
	private String dealOrgAuth(DataAuth dataAuth, Long employeeId) {
		String orgAuthSql = "";
		//組織許可權註解
		String orgAuth = dataAuth.orgAuth();
		//組織欄位註解
		String authOrgId = dataAuth.authOrgId();
		if(orgAuth.equals("Y")){
			String orgIdList = iDataRoleResourceService.getDefaultChildUnitList(employeeId);
			orgAuthSql = orgIdList == null ? "" : authOrgId + " in (" + orgIdList + ")";
		}
		return orgAuthSql;
	}

	/**
	 * 獲取資料許可權註解資訊
	 * 
	 * @param mappedStatement
	 * @return
	 */
	private DataAuth getPermissionByDelegate(MappedStatement mappedStatement) {
		DataAuth dataAuth = null;
		try {
			String id = mappedStatement.getId();
			String className = id.substring(0, id.lastIndexOf("."));
			String methodName = id.substring(id.lastIndexOf(".") + 1, id.length());
			final Class<?> cls = Class.forName(className);
			final Method[] method = cls.getMethods();
			for (Method me : method) {
				if (me.getName().equals(methodName) && me.isAnnotationPresent(DataAuth.class)) {
					dataAuth = me.getAnnotation(DataAuth.class);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dataAuth;
	}

	/**
	 * 許可權sql包裝
	 * @param sql 原sql
	 * @param authSql 資料許可權sql 
	 * @param orgAuthSql 組織許可權sql
	 * @param invocation
	 */
	private void permissionSql(String sql,String orgAuthSql, String authSql, Invocation invocation) {
		final Object[] args = invocation.getArgs();
		MappedStatement statement = (MappedStatement) args[0];
		Object parameterObject = args[1];
		BoundSql boundSql = statement.getBoundSql(parameterObject);
		MappedStatement newStatement = newMappedStatement(statement, new AuthSqlSource(boundSql));
		MetaObject msObject = MetaObject.forObject(newStatement, new DefaultObjectFactory(), new DefaultObjectWrapperFactory(), new DefaultReflectorFactory());
		//sql拼接
		if("".equals(authSql.trim()) && (!"".equals(orgAuthSql.trim()))){
			if(sql.toUpperCase().contains("WHERE")){
				sql = sql + " AND " + orgAuthSql;
			}else{
				sql = sql + " WHERE " + orgAuthSql;
			}
		}else{
			if("".equals(orgAuthSql.trim())){
				sql = sql + " " + authSql;
			}else{
				sql = sql + " "+ authSql + " AND " + orgAuthSql;
			}
			
		}
		//sql替換
		msObject.setValue("sqlSource.boundSql.sql", sql);
		args[0] = newStatement;
	}
	
	/**
	 * MappedStatement包裝
	 * @param ms
	 * @param newSqlSource
	 * @return
	 */
	private MappedStatement newMappedStatement(MappedStatement ms, SqlSource newSqlSource) {
		MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), newSqlSource,
				ms.getSqlCommandType());
		builder.resource(ms.getResource());
		builder.fetchSize(ms.getFetchSize());
		builder.statementType(ms.getStatementType());
		builder.keyGenerator(ms.getKeyGenerator());
		if (ms.getKeyProperties() != null && ms.getKeyProperties().length != 0) {
			StringBuilder keyProperties = new StringBuilder();
			for (String keyProperty : ms.getKeyProperties()) {
				keyProperties.append(keyProperty).append(",");
			}
			keyProperties.delete(keyProperties.length() - 1, keyProperties.length());
			builder.keyProperty(keyProperties.toString());
		}
		builder.timeout(ms.getTimeout());
		builder.parameterMap(ms.getParameterMap());
		builder.resultMaps(ms.getResultMaps());
		builder.resultSetType(ms.getResultSetType());
		builder.cache(ms.getCache());
		builder.flushCacheRequired(ms.isFlushCacheRequired());
		builder.useCache(ms.isUseCache());

		return builder.build();
	}
	
	
    /**
     * 載入注入的bean
     */
    private void loadService() {
        if (null == beanFactory) {
            beanFactory = ApplicationContextHelper.getApplicationContext();
            if(null == beanFactory){
            	return;
            }
        }
        if (iAuthorityResourceService == null) {
        	iAuthorityResourceService = beanFactory.getBean(IAuthorityResourceService.class);
        }
        if (iDataRoleResourceService == null) {
        	iDataRoleResourceService = beanFactory.getBean(IDataRoleResourceService.class);
        }
        
    }
	
	 
}

DataAuth註解類：

package com.fsl.lcp.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 資料許可權實現的註解
 * @author tanqian
 * @date 2018年11月21日
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataAuth {
	/**
	 * 1.許可權資源code，許可權資源定義頁面設定的，指明這次查詢需要使用哪條資源sql </br>
	 * 2.如果定義了資源sql，卻沒有分配給當前登陸的使用者，則不會返回任何資料</br>
	 * 3.輸入不存在的資源code，也不會返回任何資料</br>
	 * 4.定義的sql寫的有問題的，會產生不可預知的錯誤
	 * @return
	 */
	String resourceCode() default "";
	/**
	 * orgAuth </br>
	 * 組織許可權，Y代表開啟，N和不寫代表不開啟
	 * @return
	 */
	String orgAuth() default "";
	/**
	 * authOrgId </br>
	 * 許可權組織欄位，orgAuth=Y的時候必須寫，否則無法獲取哪個表的哪個欄位是組織欄位</br>
	 * 值為："許可權業務表的別名.組織欄位名"</br>
	 * 如：原sql為"select * from 許可權業務表  auth, 業務表A ya where auth.org_id=123",</br>
	 * 則該註解應填值為："auth.org_id"
	 * @return
	 */
	String authOrgId() default "";
}

AuthSqlSource類，我是因為基於我們自己的hap框架，必須繼承我們框架的PageSqlSource類，自己寫的話，可以直接實現SqlSource介面 ：

package com.fsl.lcp.auth.sqlsource;

import org.apache.ibatis.mapping.BoundSql;

import com.github.pagehelper.sqlsource.PageSqlSource;
/**
 * 攔截器需要的SqlSource，必須繼承自hap修改後的PageSqlSource
 * @author tanqian
 * 2018年11月29日
 */
public 	class AuthSqlSource extends PageSqlSource {
	private BoundSql boundSql;

	public AuthSqlSource(BoundSql boundSql) {
		this.boundSql = boundSql;
	}

	@Override
	public BoundSql getBoundSql(Object parameterObject) {
		return boundSql;
	}

	@Override
	protected BoundSql getDefaultBoundSql(Object parameterObject) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	protected BoundSql getCountBoundSql(Object parameterObject) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	protected BoundSql getPageBoundSql(Object parameterObject) {
		// TODO Auto-generated method stub
		return null;
	}
}

c)現在就可以進行測試了，寫個最簡單的controller-service-mapper來測試就行，我僅貼出mapper.java的程式碼了：

package com.fsl.lcp.test.mapper;

import com.hand.hap.mybatis.common.Mapper;

import java.util.List;

import com.fsl.lcp.annotation.DataAuth;
import com.fsl.lcp.test.dto.TestAuth;

public interface TestAuthMapper extends Mapper<TestAuth>{


	@DataAuth(orgAuth="Y",authOrgId="lta.org_id")
	List<TestAuth> testOrgAuth();
	
	@DataAuth(resourceCode="test_auth")
	List<TestAuth> testDefineAuth();

	@DataAuth(resourceCode="test_auth",orgAuth="Y",authOrgId="lta.org_id")
	List<TestAuth> testOrgAndDefineAuth();
	


}

 

相關推薦

基於mybatis攔截器實現資料許可權

資料許可權是很多系統常見的功能，實現的方式也是很多的，最近在做專案的時候，自己基於mybatis攔截器做了一個數據許可權的功能。 **功能設計 a)  需要做資料許可權功能的表加上一個許可權id欄位。 許可權id可以不僅僅是組織，還可以是其他自定義的欄位，用來做資料許可權，

Mybatis攔截器之資料許可權過濾與分頁整合

解決方案之改SQL 原sql SELECT a.id AS "id", a.NAME AS "name", a.sex_cd AS "sexCd", a.org_id AS "orgId", a.STATUS AS "status", a.create_org_id AS "createOrgId"

通過spring抽象路由數據源+MyBatis攔截器實現數據庫自動讀寫分離

註入 兩個 -- 事情 rem 使用註解 connect key值 -m 前言 之前使用的讀寫分離的方案是在mybatis中配置兩個數據源，然後生成兩個不同的SqlSessionTemplate然後手動去識別執行sql語句是操作主庫還是從庫。如下圖所示： 好處是，你

mybatis攔截器實現查看sql執行效率

nth 內部 設置 work check sel nts mage view package cc.zeelan.common.utils; import java.lang.reflect.Field; import java.sql.Statement; impor

代理模式的實際運用-以mybatis攔截器實現原理為例

之前在寫mybatis攔截器的時候，因為不懂原理，琢磨了很久，不知道怎麼寫，在網上找了很多資料，才知道mybatis的攔截器主要還是通過代理實現的，而且我在之前的博文中剛好學習了代理模式。更精細的是，在mybatis對代理的應用上，不管是封裝易用性，減少程式碼耦合度上，都可以讓我之前寫的

利用Mybatis攔截器實現分頁查詢

手寫Mybatis攔截器 版本 Spring Boot 2.0.3.RELEASE Mybatis自定義攔截器 如果有閱讀過我之前一篇部落格 Hibernate 重新整理上下文 的朋友應該還記得 Hibernate 的上下文中可以新增自定義的事件監聽器。當初是為

基於mybatis 攔截器修改sql

背景：公司的分庫分表中介軟體有一個自定義路由的功能，即指定需要路由的表字尾，需要在sql尾部加一段引數來指向該表 因此寫了一個攔截器來實現這個功能，因此如果您需要利用攔截器來修改sql的話可以參考此方法 達到的效果：mybatis的 mapper上加上路由引數物件，攔

用struts的攔截器實現使用者許可權控制

 步驟1、匯入struts2的庫。   步驟2、編寫Interceptor類。 package com.voicesoft.Interceptor; import com.opensymphony.xwork2.Action; import com.opensymphon

Springboot2（22）Mybatis攔截器實現

原始碼地址 springboot2教程系列 MyBatis提供了一種外掛(plugin)的功能，雖然叫做外掛，但其實這是攔截器功能 MyBatis 允許攔截的介面 MyBatis 允許你在已對映語句執行過程中的某一點進行攔截呼叫。預設情況下，

mybatis攔截器實現資料庫表水平切分

           攔截器主要的作用是讀取配置，根據配置的切分策略和欄位，來切分表，然後替換原執行的SQL,從而實現自動切分，上程式碼： @Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = {

【Struts2進階】Struts2攔截器實現基於Url的許可權管理

Struts2的攔截器只能攔截Action，攔截器是AOP的一種實現方式，可以使我們的系統架構更鬆散（耦合度低），可以插拔，容易互換，程式碼不改變的情況下很容易滿足客戶需求。 專案的許可權管理模組就使

myBatis學習筆記（10）——使用攔截器實現分頁查詢

條件 iba execute rri itl alias property gen func 1. Page package com.sm.model; import java.util.List; public class Page<T&g

Mybatis攔截器（插件實現原理）

通過 source hand page fault PE ace sign targe 在mybatis的mybatis.cfg.xml中插入： <plugins> <plugin inter

Mybatis（攔截器實現）通用mapper及全ORM實現（四）

到目前為止，我們通過mybatis的攔截器完成了一些基礎mapper的功能，接下來我們來看看如何能夠實現一個物件關係對映的全ORM操作。 實體與表、列的定義已經完成了，那剩下要做的就是： 1、定義如何通過物件方式編寫sql語句 2、把查詢物件轉譯成sql去查詢 3、把查詢結

Mybatis（攔截器實現）通用mapper及全ORM實現（五）-- springboot+mybatis多資料來源設定

本篇實際上和mybatisext專案並沒有太大關係了，但在實際專案中脫離不開多個數據源，尤其是主從分離，同樣網上一些資料大同小異而且大部分並不能真正解決問題，所以單獨提出來說一下 假設我們就是要解決一個主從分離，資料來源定義在了application.properties中

Flume攔截器---實現按照時間生成資料目錄

Flume中的攔截器（interceptor），當Source讀取events傳送到Sink的時候，在events header中加入一些有用的資訊，或者對events的內容進行過濾，完成初步的資料清洗。這在實際業務場景中非常有用，Flume-ng 1.7中目前提供了以下攔截器： Tim

SSM整合系列之 通過Mybatis攔截器獲取SQL語句 實現SQL監控

摘要：Mybatis為我們提供了一個Interceptor介面，通過實現該介面就可以定義我們自己的攔截器，MyBatis攔截器介面提供的3個方法中，plugin方法用於某些處理器(Handler)的構建過程。interceptor方法用於處理代理類的執行。setProperties方法用

使用基於servlet的攔截器實現訂單提交控制Demo

首先提交訂單前需要進行庫存校驗等一系列的準備操作流程，故可以在提交訂單流程的基礎上進行攔截器的預提交操作。 具體Demo如下： 首先編輯攔截器： package com.sanbang.interceptors; import org.apache.log4j.Log

【Spring MVC】教程——使用攔截器實現許可權控制

之前一直都在用mvc的攔截器許可權控制，後來上網也研究了一些這方面的知識，下面就直接分享下我對mvc的攔截器的理解，通過專案來分析吧。。。 1、首先準備對應的架包 2、看看專案的架構 3、基本的web.xml檔案 ? 1 2 3 4 5 6 7 8 9 10 11

springboot 實現攔截器許可權過濾，以及用攔截器實現操作日誌功能（二）

接上文 繼承WebMvcConfigurerAdapter 類，新增 上文寫的攔截類 具體程式碼如下： package com.hcmony.web.interceptor; import org