AOP实现简单用户权限

 AOP（Aspect Orient Programming），作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。

 

看一个简单的例子：

定义一个简单的切面CommonAspect

 

/**
 * AOP拦截类，主要定义拦截点，切面拦截可以使用多个拦截点。
 */
@Component
@Aspect
public class CommonAspect {
 /**
  * 切入点。
  */
 @Pointcut("within(com.wjy.crm.common..*)")
 public void commonPackage() {
 } 
 /**
  * 使用环绕通知对用户操作做简单的权限检查
  * @param joinPoint
  * @return
  */
 @Around("commonPackage()")
 public Object userCheck(ProceedingJoinPoint joinPoint) {
  return securityCheckUtil.userCheck(joinPoint);
 } 
 
 private SecurityCheckUtil securityCheckUtil; 

 public SecurityCheckUtil getSecurityCheckUtil() {
  return securityCheckUtil;
 }

 public void setSecurityCheckUtil(SecurityCheckUtil securityCheckUtil) {
  this.securityCheckUtil = securityCheckUtil;
 }
}

 

----------切面拦截的具体实现类

 

@Component("securityCheckUtil")
public class SecurityCheckUtil {
 
 private static final Logger log = Logger.getLogger(SecurityCheckUtil.class); 
 
 /**
  * Check 是否是系统用户.
  */
 public Object userCheck(ProceedingJoinPoint joinPoint) {
  return checkUser(joinPoint,2,"此用户不是系统用户！");
 }
 
 /**
  * 得到返回对象.
  */
 @SuppressWarnings("unchecked")
 private Object getReturnObject(ProceedingJoinPoint joinPoint) {
  Object result = null;
  try {
   MethodInvocationProceedingJoinPoint point = (MethodInvocationProceedingJoinPoint)joinPoint;
   MethodSignature signature = (MethodSignature)point.getSignature();
   Class c = signature.getReturnType();
   result = c.newInstance();
  } catch (Exception e) {
   return null;
  }
  return result;
 }
 
 /**
  * 设置返回对象的属性值
  */
 private Object initObject(Object bean,String message) {
  try {
   BeanUtils.setProperty(bean, "success", false);
   BeanUtils.setProperty(bean, "info", message);
  } catch (IllegalAccessException e) {
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   e.printStackTrace();
  }
  return bean;
 } 
 
 /**
  * 获得用户对象
  */
 private User getUser(ProceedingJoinPoint joinPoint) {
  HeclaUser user = null;
  Object[] args = joinPoint.getArgs();
  for(Object obj:args) {
   if(obj instanceof User) {
    user = (User)obj;
    break;
   }
  }
  return user;
 }
 
 /**
  * 进行用户简单权限检查
  */
 private Object checkUser(ProceedingJoinPoint joinPoint,int userType,String message) {
  log.debug(String.format("开始拦截%s方法，检查用户是否冻结或者注销！", joinPoint.getSignature()));
  Object result = null;
  User user = getUser(joinPoint);
  Object resultVoid = getReturnObject(joinPoint);
  log.error(String.format("开始检查用户权限：%s", user==null?"":user.getNickName()));
  try {
   if(null != user) {
    if(null == user){
     return initObject(resultVoid,"此用户不存在！");
    }
    if(null == user.getChannelType() || user.getChannelId() == null){
     return initObject(resultVoid,"此用户已被注销！");
    }
    if(user.getChannelType() == userType){
     return initObject(resultVoid,message);
    }
    if(user.getChannelType() == 2 && user.getPointId() == null){
     return initObject(resultVoid,"此用户已被注销！");
    }         
   }
   result = joinPoint.proceed();
  } catch (Throwable e) {
   e.printStackTrace();
  }
  log.error(String.format("检查用户权限：%s结束", user == null ? null : user.getNickName()));
  return result;
 }
}

 

----------下面是AOP的一些基本概念知识

切面(Aspect):对横切关注点的抽象,这个关注点可能会横切多个对象, 上面简单例子的CommonAspect就是一个切面，可以由@Aspect注解定义一个bean对象为切面对象。

连接点(JoinPoint):被拦截到的点,程序执行过程中的某一方法，例子里面com.wjy.crm.common包下面的所有方法

 

切入点(Pointcut):对哪些连接点进行拦截的定义例子用@Pointcut("within(com.wjy.crm.common..*)")来定义切入点。

 

通知(Advice):在特定的连接点，AOP框架执行的动作.包括前置通知（在JoinPoint之前执行的通知）、后置通知（JoinPoint退出的时候执行的通知）、例外通知（方法抛出异常退出是的通知）、最终通知（JoinPoint正常完成后执行的通知）和环绕通知（环绕通知在一个方法执行之前和之后执行。它使得通知有机会既在一个方法执行之前又在执行之后运行）。本例用的是环绕通知

 

引入（Introduction）:添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。

 

目标对象（Target Object）:被一个或者多个切面所通知的对象。

 

AOP代理（AOP Proxy）:AOP框架创建的对象，在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。

 

织入（Weaving）:组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。