コード例 #1
0
 @Override
 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
     throws Throwable {
   Object oldProxy = null;
   try {
     oldProxy = AopContext.setCurrentProxy(proxy);
     Object retVal = methodProxy.invoke(this.target, args);
     return processReturnType(proxy, this.target, method, retVal);
   } finally {
     AopContext.setCurrentProxy(oldProxy);
   }
 }
コード例 #2
0
 @Override
 public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
     throws Throwable {
   Object oldProxy = null;
   boolean setProxyContext = false;
   Class<?> targetClass = null;
   Object target = null;
   try {
     if (this.advised.exposeProxy) {
       // Make invocation available if necessary.
       oldProxy = AopContext.setCurrentProxy(proxy);
       setProxyContext = true;
     }
     // May be null. Get as late as possible to minimize the time we
     // "own" the target, in case it comes from a pool...
     target = getTarget();
     if (target != null) {
       targetClass = target.getClass();
     }
     List<Object> chain =
         this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
     Object retVal;
     // Check whether we only have one InvokerInterceptor: that is,
     // no real advice, but just reflective invocation of the target.
     if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
       // We can skip creating a MethodInvocation: just invoke the target directly.
       // Note that the final invoker must be an InvokerInterceptor, so we know
       // it does nothing but a reflective operation on the target, and no hot
       // swapping or fancy proxying.
       Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
       retVal = methodProxy.invoke(target, argsToUse);
     } else {
       // We need to create a method invocation...
       retVal =
           new CglibMethodInvocation(
                   proxy, target, method, args, targetClass, chain, methodProxy)
               .proceed();
     }
     retVal = processReturnType(proxy, target, method, retVal);
     return retVal;
   } finally {
     if (target != null) {
       releaseTarget(target);
     }
     if (setProxyContext) {
       // Restore old proxy.
       AopContext.setCurrentProxy(oldProxy);
     }
   }
 }
コード例 #3
0
ファイル: UserAuthService.java プロジェクト: hugoDD/jeebase
  /**
   * 根据角色获取 权限字符串 如sys:admin
   *
   * @param user
   * @return
   */
  public Set<String> findStringPermissions(User user) {
    Set<String> permissions = Sets.newHashSet();

    Set<Role> roles = ((UserAuthService) AopContext.currentProxy()).findRoles(user);
    for (Role role : roles) {
      for (RoleResourcePermission rrp : role.getResourcePermissions()) {
        Resource resource = resourceService.findOne(rrp.getResourceId());

        String actualResourceIdentity = resourceService.findActualResourceIdentity(resource);

        // 不可用 即没查到 或者标识字符串不存在
        if (resource == null
            || StringUtils.isEmpty(actualResourceIdentity)
            || Boolean.FALSE.equals(resource.getShow())) {
          continue;
        }

        for (Long permissionId : rrp.getPermissionIds()) {
          Permission permission = permissionService.findOne(permissionId);

          // 不可用
          if (permission == null || Boolean.FALSE.equals(permission.getShow())) {
            continue;
          }
          permissions.add(actualResourceIdentity + ":" + permission.getPermission());
        }
      }
    }

    return permissions;
  }
コード例 #4
0
ファイル: UserAuthService.java プロジェクト: hugoDD/jeebase
 public Set<String> findStringRoles(User user) {
   Set<Role> roles = ((UserAuthService) AopContext.currentProxy()).findRoles(user);
   return Sets.newHashSet(
       Collections2.transform(
           roles,
           new Function<Role, String>() {
             @Override
             public String apply(Role input) {
               return input.getRole();
             }
           }));
 }
コード例 #5
0
  /**
   * Implementation of <code>InvocationHandler.invoke</code>.
   *
   * <p>Callers will see exactly the exception thrown by the target, unless a hook method throws an
   * exception.
   */
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation = null;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Class targetClass = null;
    Object target = null;

    try {
      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
        // The target does not implement the equals(Object) method itself.
        return (equals(args[0]) ? Boolean.TRUE : Boolean.FALSE);
      }
      if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
        // The target does not implement the hashCode() method itself.
        return new Integer(hashCode());
      }
      if (!this.advised.opaque
          && method.getDeclaringClass().isInterface()
          && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
        // Service invocations on ProxyConfig with the proxy config...
        return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
      }

      Object retVal = null;

      if (this.advised.exposeProxy) {
        // Make invocation available if necessary.
        oldProxy = AopContext.setCurrentProxy(proxy);
        setProxyContext = true;
      }

      // May be <code>null</code>. Get as late as possible to minimize the time we "own" the target,
      // in case it comes from a pool.
      target = targetSource.getTarget();
      if (target != null) {
        targetClass = target.getClass();
      }

      // Get the interception chain for this method.
      List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

      // Check whether we have any advice. If we don't, we can fallback on direct
      // reflective invocation of the target, and avoid creating a MethodInvocation.
      if (chain.isEmpty()) {
        // We can skip creating a MethodInvocation: just invoke the target directly
        // Note that the final invoker must be an InvokerInterceptor so we know it does
        // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
        retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
      } else {
        // We need to create a method invocation...
        invocation =
            new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
        // Proceed to the joinpoint through the interceptor chain.
        retVal = invocation.proceed();
      }

      // Massage return value if necessary.
      if (retVal != null
          && retVal == target
          && method.getReturnType().isInstance(proxy)
          && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
        // Special case: it returned "this" and the return type of the method
        // is type-compatible. Note that we can't help if the target sets
        // a reference to itself in another returned object.
        retVal = proxy;
      }
      return retVal;
    } finally {
      if (target != null && !targetSource.isStatic()) {
        // Must have come from TargetSource.
        targetSource.releaseTarget(target);
      }
      if (setProxyContext) {
        // Restore old proxy.
        AopContext.setCurrentProxy(oldProxy);
      }
    }
  }