@Override public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException { Class<?> targetClass = AopUtils.getTargetClass(bean); final RabbitListener classLevelListener = AnnotationUtils.findAnnotation(bean.getClass(), RabbitListener.class); final List<Method> multiMethods = new ArrayList<Method>(); ReflectionUtils.doWithMethods( targetClass, new ReflectionUtils.MethodCallback() { @Override public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { RabbitListener rabbitListener = AnnotationUtils.getAnnotation(method, RabbitListener.class); if (rabbitListener != null) { processAmqpListener(rabbitListener, method, bean, beanName); } if (classLevelListener != null) { RabbitHandler rabbitHandler = AnnotationUtils.getAnnotation(method, RabbitHandler.class); if (rabbitHandler != null) { multiMethods.add(method); } } } }); if (classLevelListener != null) { processMultiMethodListener(classLevelListener, multiMethods, bean, beanName); } return bean; }
private Class<?> getTargetClass(Object targetObject) { Class<?> targetClass = targetObject.getClass(); if (AopUtils.isAopProxy(targetObject)) { targetClass = AopUtils.getTargetClass(targetObject); if (targetClass == targetObject.getClass()) { try { // Maybe a proxy with no target - e.g. gateway Class<?>[] interfaces = ((Advised) targetObject).getProxiedInterfaces(); if (interfaces != null && interfaces.length == 1) { targetClass = interfaces[0]; } } catch (Exception e) { if (logger.isDebugEnabled()) { logger.debug("Exception trying to extract interface", e); } } } } else if (org.springframework.util.ClassUtils.isCglibProxyClass(targetClass)) { Class<?> superClass = targetObject.getClass().getSuperclass(); if (!Object.class.equals(superClass)) { targetClass = superClass; } } return targetClass; }
@Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { Method[] methods = AopUtils.getTargetClass(bean).getDeclaredMethods(); for (Method method : methods) { if (method.isAnnotationPresent(MethodLimiter.class)) { MethodLimiter methodLimiter = method.getAnnotation(MethodLimiter.class); // 获取zkclient ZKClusterClient client = ZookeeperClientMakerFactory.getInstance().getZKClusterClient("zkClient"); String name = methodLimiter.name(); int rate = methodLimiter.rate(); // 创建rateLimiter RateLimiterFactory.getInstance().putIfAbsent(name, new RateLimiter().create(name, rate)); String path = PATH_PREFIX + "/" + name; if (!client.isExsit(path)) { // 创建节点 client.createNode( path, String.valueOf(rate), com.foxxy.git.zookeeper.CreateMode.PERSISTENT); } client.registerConnectionListener(new LimiterRateMonitorListener(path)); client.registerNodeListener(path, new LimiterRateMonitorListener(path)); } } return bean; }
@Override public Object postProcessAfterInitialization(final Object bean, String beanName) { if (!this.nonAnnotatedClasses.contains(bean.getClass())) { final Set<Method> annotatedMethods = new LinkedHashSet<Method>(1); Class<?> targetClass = AopUtils.getTargetClass(bean); ReflectionUtils.doWithMethods( targetClass, new MethodCallback() { @Override public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { for (Scheduled scheduled : AnnotationUtils.getRepeatableAnnotation( method, Schedules.class, Scheduled.class)) { processScheduled(scheduled, method, bean); annotatedMethods.add(method); } } }); if (annotatedMethods.isEmpty()) { this.nonAnnotatedClasses.add(bean.getClass()); } } return bean; }
private void prepareEvaluationContext( StandardEvaluationContext context, Object method, Class<? extends Annotation> annotationType) { Class<?> targetType = AopUtils.getTargetClass(this.targetObject); if (method instanceof Method) { context.registerMethodFilter(targetType, new FixedMethodFilter((Method) method)); if (expectedType != null) { Assert.state( context .getTypeConverter() .canConvert( TypeDescriptor.valueOf(((Method) method).getReturnType()), TypeDescriptor.valueOf(expectedType)), "Cannot convert to expected type (" + expectedType + ") from " + method); } } else if (method == null || method instanceof String) { AnnotatedMethodFilter filter = new AnnotatedMethodFilter(annotationType, (String) method, this.requiresReply); Assert.state( canReturnExpectedType(filter, targetType, context.getTypeConverter()), "Cannot convert to expected type (" + expectedType + ") from " + method); context.registerMethodFilter(targetType, filter); } context.setVariable("target", targetObject); }
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof AopInfrastructureBean) { // Ignore AOP infrastructure such as scoped proxies. return bean; } Class<?> targetClass = AopUtils.getTargetClass(bean); if (targetClass == null) { // Can't do much here. return bean; } if (AopUtils.canApply(this.asyncAnnotationAdvisor, targetClass)) { if (bean instanceof Advised) { ((Advised) bean).addAdvisor(this.asyncAnnotationAdvisor); return bean; } else { ProxyFactory proxyFactory = new ProxyFactory(bean); // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig. proxyFactory.copyFrom(this); proxyFactory.addAdvisor(this.asyncAnnotationAdvisor); return proxyFactory.getProxy(this.beanClassLoader); } } else { // No async proxy needed. return bean; } }
/** * Intercept the given method invocation, submit the actual calling of the method to the correct * task executor and return immediately to the caller. * * @param invocation the method to intercept and make asynchronous * @return {@link Future} if the original method returns {@code Future}; {@code null} otherwise. */ public Object invoke(final MethodInvocation invocation) throws Throwable { Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass); specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod); Future<?> result = determineAsyncExecutor(specificMethod) .submit( new Callable<Object>() { public Object call() throws Exception { try { Object result = invocation.proceed(); if (result instanceof Future) { return ((Future<?>) result).get(); } } catch (Throwable ex) { ReflectionUtils.rethrowException(ex); } return null; } }); if (Future.class.isAssignableFrom(invocation.getMethod().getReturnType())) { return result; } else { return null; } }
public static Class<?> getGenericTypeFromBean(Object object) { Class<?> clazz = object.getClass(); if (AopUtils.isAopProxy(object)) { clazz = AopUtils.getTargetClass(object); } return getGenericType(clazz); }
/** {@InheritDoc} */ @Override public List<BeanDetail> getBeanDetails() { if (this.allBeans == null) { // initialize BeanDetail list List<BeanDetail> beans = new ArrayList<BeanDetail>(); BeanDetail springBeanDetail; // get the list of bean names List<String> names = this.getBeanNames(); for (String beanName : names) { springBeanDetail = new BeanDetail(); springBeanDetail.setBeanName(beanName); Object bean; String beanType; springBeanDetail.setAliases(Arrays.asList(this.ctx.getAliases(beanName))); bean = this.ctx.getBean(beanName); beanType = bean.getClass().getName(); // Manage proxied beans // If the bean is proxied then its type is modiified. We // detect // it and get the correct target type if (AopUtils.isAopProxy(bean)) { beanType = AopUtils.getTargetClass(bean).getName(); springBeanDetail.setProxied(true); } springBeanDetail.setBeanType(beanType); springBeanDetail.setPrototype(this.ctx.isPrototype(beanName)); springBeanDetail.setSingleton(this.ctx.isSingleton(beanName)); springBeanDetail.setBean(this.ctx.getBean(beanName)); if (this.configurablebeanFactory != null) { BeanDefinition beanDefinition = this.configurablebeanFactory.getBeanDefinition(beanName); springBeanDetail.setBeanType(beanDefinition.getBeanClassName()); springBeanDetail.setDescription(beanDefinition.getDescription()); springBeanDetail.setScope(beanDefinition.getScope()); springBeanDetail.setLazyInit(beanDefinition.isLazyInit()); springBeanDetail.setAbstract(beanDefinition.isAbstract()); } beans.add(springBeanDetail); } this.allBeans = beans; } return this.allBeans; }
/** * Determine if a given {@link FacesWrapperFactory} is suitable by resolving generic arguments. * * @param factory the factory to test * @return <tt>true</tt> if the <tt>factory</tt> is supported, otherwise <tt>false</tt> */ @SuppressWarnings({"rawtypes", "unchecked"}) private boolean isFactorySupported(FacesWrapperFactory factory) { Class typeArg = GenericTypeResolver.resolveTypeArgument(factory.getClass(), FacesWrapperFactory.class); if (typeArg == null) { Class targetClass = AopUtils.getTargetClass(factory); if (targetClass != factory.getClass()) { typeArg = GenericTypeResolver.resolveTypeArgument(targetClass, FacesWrapperFactory.class); } } return (typeArg == null || typeArg.isAssignableFrom(this.typeClass)); }
@Override public boolean isAccessGranted(UI ui, String beanName, View view) { final PreAuthorize viewSecured = applicationContext.findAnnotationOnBean(beanName, PreAuthorize.class); if (viewSecured == null) { logger.trace("No @PreAuthorize annotation found on view {}. Granting access.", beanName); return true; } else if (security.hasAccessDecisionManager()) { final Class<?> targetClass = AopUtils.getTargetClass(view); final Method method = ClassUtils.getMethod( targetClass, "enter", com.vaadin.navigator.ViewChangeListener.ViewChangeEvent.class); final MethodInvocation methodInvocation = MethodInvocationUtils.createFromClass(targetClass, method.getName()); final Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); final AccessDecisionManager accessDecisionManager = security.getAccessDecisionManager(); final ExpressionBasedAnnotationAttributeFactory attributeFactory = new ExpressionBasedAnnotationAttributeFactory( new DefaultMethodSecurityExpressionHandler()); final Collection<ConfigAttribute> attributes = Collections.singleton( (ConfigAttribute) attributeFactory.createPreInvocationAttribute(null, null, viewSecured.value())); try { accessDecisionManager.decide(authentication, methodInvocation, attributes); logger.trace("Access to view {} was granted by access decision manager", beanName); return true; } catch (InsufficientAuthenticationException e) { logger.trace( "Access to view {} was denied because of insufficient authentication credentials", beanName); return false; } catch (AccessDeniedException e) { logger.trace("Access to view {} was denied", beanName); return false; } } else { logger.warn( "Found view {} annotated with @PreAuthorize but no access decision manager. Granting access.", beanName); return true; } }
@SuppressWarnings("deprecation") public void getNonAnnotatedTransactionalServices() { /* We only want to run getNonAnnotatedTransactionalSerivces once. * The tests actually just read the Maps that are generated here. */ if (incorrectlyAnnotatedTransactionalServices != null) { return; } incorrectlyAnnotatedTransactionalServices = new HashMap<String, Class<? extends Object>>(); nonAnnotatedTransactionalServices = new HashMap<String, String>(); doubleAnnotatedTransactionalServices = new HashMap<String, String>(); String[] beanNames = SpringContext.getBeanNames(); for (String beanName : beanNames) { if (beanName.endsWith("-parentBean")) { continue; } Object bean = null; try { bean = SpringContext.getBean(beanName); } catch (BeanIsAbstractException ex) { // do nothing, ignore } catch (Exception e) { LOG.warn("Caught exception while trying to obtain service: " + beanName); LOG.warn(e.getClass().getName() + " : " + e.getMessage(), e); } if (bean != null) { Class<? extends Object> beanClass = bean.getClass(); if (beanClass.getName().matches(".*\\$Proxy.*")) { beanClass = AopUtils.getTargetClass(bean); } if (beanClass.getName().startsWith("org.kuali") && !Modifier.isAbstract(beanClass.getModifiers()) && !beanClass.getName().endsWith("DaoOjb") && !beanClass.getName().endsWith("DaoJdbc") && !beanClass.getName().endsWith("Factory") && !beanClass.getName().contains("Lookupable") && !isClassAnnotated(beanName, beanClass)) { incorrectlyAnnotatedTransactionalServices.put(beanName, beanClass); } } } return; }
private Object applyAdvice(Object bean, PointcutAdvisor advisor, ClassLoader beanClassLoader) { Class<?> targetClass = AopUtils.getTargetClass(bean); if (AopUtils.canApply(advisor.getPointcut(), targetClass)) { if (bean instanceof Advised) { ((Advised) bean).addAdvisor(advisor); return bean; } else { ProxyFactory proxyFactory = new ProxyFactory(bean); proxyFactory.addAdvisor(advisor); /** * N.B. it's not a good idea to use proxyFactory.setProxyTargetClass(true) here because it * forces all the integration components to be cglib proxyable (i.e. have a default * constructor etc.), which they are not in general (usually for good reason). */ return proxyFactory.getProxy(beanClassLoader); } } return bean; }
@Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean == null) { return bean; } Class beanClass = AopUtils.getTargetClass(bean); if (beanClass == null) { return bean; } RemotingService remotingService = AnnotationUtils.findAnnotation(beanClass, RemotingService.class); if (remotingService != null) { SpaceRemotingServiceExporter exporter; if (StringUtils.hasLength(remotingService.exporter())) { exporter = (SpaceRemotingServiceExporter) applicationContext.getBean(remotingService.exporter()); if (exporter == null) { throw new IllegalArgumentException( "Failed to find exporter under name [" + remotingService.exporter() + "] for bean [" + beanName + "]"); } } else { Map exporters = applicationContext.getBeansOfType(SpaceRemotingServiceExporter.class); if (exporters.isEmpty()) { throw new IllegalArgumentException( "No service exporters are defined within the context, can't register remote service bean [" + beanName + "]"); } if (exporters.size() > 1) { throw new IllegalStateException( "More than one service exporter are defined within the context, please specify the exact service exported to register with"); } exporter = (SpaceRemotingServiceExporter) exporters.values().iterator().next(); } exporter.addService(beanName, bean); } return bean; }
public void setRepositories(Collection<CrudRepository> repositories) { for (CrudRepository repository : repositories) { Class<?> repoClass = AopUtils.getTargetClass(repository); Field infoField = ReflectionUtils.findField(repoClass, "entityInformation"); ReflectionUtils.makeAccessible(infoField); Method m = ReflectionUtils.findMethod(repository.getClass(), "getTargetSource"); ReflectionUtils.makeAccessible(m); try { SingletonTargetSource targetRepo = (SingletonTargetSource) m.invoke(repository); EntityInformation entityInfo = (EntityInformation) infoField.get(targetRepo.getTarget()); Class<?>[] intfs = repository.getClass().getInterfaces(); String name = StringUtils.uncapitalize(intfs[0].getSimpleName().replaceAll("Repository", "")); this.repositories.put( entityInfo.getJavaType(), new RepositoryCacheEntry(name, repository, entityInfo, null)); } catch (Throwable t) { throw new IllegalStateException(t); } } }
@Test public void testDefaultConfiguration() { this.context = new AnnotationConfigEmbeddedWebApplicationContext(); this.context.register( AuthorizationAndResourceServerConfiguration.class, MinimalSecureWebApplication.class); this.context.refresh(); this.context.getBean(AUTHORIZATION_SERVER_CONFIG); this.context.getBean(RESOURCE_SERVER_CONFIG); this.context.getBean(OAuth2MethodSecurityConfiguration.class); ClientDetails config = this.context.getBean(BaseClientDetails.class); AuthorizationEndpoint endpoint = this.context.getBean(AuthorizationEndpoint.class); UserApprovalHandler handler = (UserApprovalHandler) ReflectionTestUtils.getField(endpoint, "userApprovalHandler"); ClientDetailsService clientDetailsService = this.context.getBean(ClientDetailsService.class); ClientDetails clientDetails = clientDetailsService.loadClientByClientId(config.getClientId()); assertThat(AopUtils.isJdkDynamicProxy(clientDetailsService), equalTo(true)); assertThat( AopUtils.getTargetClass(clientDetailsService).getName(), equalTo(ClientDetailsService.class.getName())); assertThat(handler instanceof ApprovalStoreUserApprovalHandler, equalTo(true)); assertThat(clientDetails, equalTo(config)); verifyAuthentication(config); }
/** * Finds the annotated rule executors by searching the bean factory. Also registers XML-configured * rule executors. * * @throws BeansException on a bad. */ @PostConstruct public void registerRuleExecutors() throws BeansException { if (addDefaultRuleExecutors) { addDefaultRuleExecutors(); } Map<String, Object> ruleExecutorBeans = ((ListableBeanFactory) beanFactory).getBeansWithAnnotation(ConfiguredRuleExecutor.class); for (String springName : ruleExecutorBeans.keySet()) { RuleExecutor<?, ?> ruleExecutor = (RuleExecutor<?, ?>) ruleExecutorBeans.get(springName); String ruleName = AnnotationUtils.findAnnotation( AopUtils.getTargetClass(ruleExecutor), ConfiguredRuleExecutor.class) .name(); setCustomRuleExecutor(ruleName, ruleExecutor); } if (beanRegistrants != null) { for (KeyedBeanRegistrant registrant : beanRegistrants) { setCustomRuleExecutor( registrant.getKey(), (RuleExecutor<?, ?>) beanFactory.getBean(registrant.getBeanName())); } } }
@Override public boolean postProcessAfterInstantiation(final Object bean, String beanName) throws BeansException { Class beanClass = AopUtils.getTargetClass(bean); if (beanClass == null) { return true; } ReflectionUtils.doWithFields( beanClass, new ReflectionUtils.FieldCallback() { public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException { ExecutorScriptingExecutor executorScriptingExecutor = field.getAnnotation(ExecutorScriptingExecutor.class); if (executorScriptingExecutor != null) { ExecutorSpaceRemotingProxyFactoryBean factoryBean = new ExecutorSpaceRemotingProxyFactoryBean(); factoryBean.setGigaSpace(findGigaSpaceByName(executorScriptingExecutor.gigaSpace())); factoryBean.setTimeout(executorScriptingExecutor.timeout()); factoryBean.setMetaArgumentsHandler(new ScriptingMetaArgumentsHandler()); factoryBean.setRemoteInvocationAspect(new LazyLoadingRemoteInvocationAspect()); factoryBean.setRemoteRoutingHandler(new ScriptingRemoteRoutingHandler()); factoryBean.setServiceInterface(ScriptingExecutor.class); factoryBean.afterPropertiesSet(); field.setAccessible(true); field.set(bean, factoryBean.getObject()); } EventDrivenScriptingExecutor eventDrivenScriptingExecutor = field.getAnnotation(EventDrivenScriptingExecutor.class); if (eventDrivenScriptingExecutor != null) { EventDrivenSpaceRemotingProxyFactoryBean factoryBean = new EventDrivenSpaceRemotingProxyFactoryBean(); factoryBean.setTimeout(eventDrivenScriptingExecutor.timeout()); factoryBean.setFifo(eventDrivenScriptingExecutor.fifo()); factoryBean.setGigaSpace( findGigaSpaceByName(eventDrivenScriptingExecutor.gigaSpace())); factoryBean.setMetaArgumentsHandler(new ScriptingMetaArgumentsHandler()); factoryBean.setRemoteInvocationAspect(new LazyLoadingRemoteInvocationAspect()); factoryBean.setRemoteRoutingHandler(new ScriptingRemoteRoutingHandler()); factoryBean.setServiceInterface(ScriptingExecutor.class); factoryBean.afterPropertiesSet(); field.setAccessible(true); field.set(bean, factoryBean.getObject()); } EventDrivenProxy eventDrivenProxy = field.getAnnotation(EventDrivenProxy.class); if (eventDrivenProxy != null) { EventDrivenSpaceRemotingProxyFactoryBean factoryBean = new EventDrivenSpaceRemotingProxyFactoryBean(); factoryBean.setTimeout(eventDrivenProxy.timeout()); factoryBean.setFifo(eventDrivenProxy.fifo()); factoryBean.setGigaSpace(findGigaSpaceByName(eventDrivenProxy.gigaSpace())); factoryBean.setAsyncMethodPrefix(eventDrivenProxy.asyncMethodPrefix()); factoryBean.setMetaArgumentsHandler( (MetaArgumentsHandler) createByClassOrFindByName( applicationContext, eventDrivenProxy.metaArgumentsHandler(), eventDrivenProxy.metaArgumentsHandlerType())); factoryBean.setRemoteInvocationAspect( (RemoteInvocationAspect) createByClassOrFindByName( applicationContext, eventDrivenProxy.remoteInvocationAspect(), eventDrivenProxy.remoteInvocationAspectType())); factoryBean.setRemoteRoutingHandler( (RemoteRoutingHandler) createByClassOrFindByName( applicationContext, eventDrivenProxy.remoteRoutingHandler(), eventDrivenProxy.remoteRoutingHandlerType())); factoryBean.setServiceInterface(field.getType()); factoryBean.afterPropertiesSet(); field.setAccessible(true); field.set(bean, factoryBean.getObject()); } ExecutorProxy executorProxy = field.getAnnotation(ExecutorProxy.class); if (executorProxy != null) { ExecutorSpaceRemotingProxyFactoryBean factoryBean = new ExecutorSpaceRemotingProxyFactoryBean(); factoryBean.setGigaSpace(findGigaSpaceByName(executorProxy.gigaSpace())); factoryBean.setTimeout(executorProxy.timeout()); factoryBean.setBroadcast(executorProxy.broadcast()); factoryBean.setMetaArgumentsHandler( (MetaArgumentsHandler) createByClassOrFindByName( applicationContext, executorProxy.metaArgumentsHandler(), executorProxy.metaArgumentsHandlerType())); factoryBean.setRemoteInvocationAspect( (RemoteInvocationAspect) createByClassOrFindByName( applicationContext, executorProxy.remoteInvocationAspect(), executorProxy.remoteInvocationAspectType())); factoryBean.setRemoteRoutingHandler( (RemoteRoutingHandler) createByClassOrFindByName( applicationContext, executorProxy.remoteRoutingHandler(), executorProxy.remoteRoutingHandlerType())); factoryBean.setRemoteResultReducer( (RemoteResultReducer) createByClassOrFindByName( applicationContext, executorProxy.remoteResultReducer(), executorProxy.remoteResultReducerType())); factoryBean.setReturnFirstResult(executorProxy.returnFirstResult()); factoryBean.setServiceInterface(field.getType()); factoryBean.afterPropertiesSet(); field.setAccessible(true); field.set(bean, factoryBean.getObject()); } } }); return true; }
public Object invoke(final MethodInvocation invocation) throws Throwable { // Work out the target class: may be {@code null}. // The TransactionAttributeSource should be passed the target class // as well as the method, which may be from an interface. Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); // If the transaction attribute is null, the method is non-transactional. final TransactionAttribute txAttr = getTransactionAttributeSource() .getTransactionAttribute(invocation.getMethod(), targetClass); final PlatformTransactionManager tm = determineTransactionManager(txAttr); final String joinpointIdentification = methodIdentification(invocation.getMethod(), targetClass); if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { // Standard transaction demarcation with getTransaction and commit/rollback calls. TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); Object retVal = null; try { // This is an around advice: Invoke the next interceptor in the chain. // This will normally result in a target object being invoked. retVal = invocation.proceed(); } catch (Throwable ex) { // target invocation exception completeTransactionAfterThrowing(txInfo, ex); throw ex; } finally { cleanupTransactionInfo(txInfo); } commitTransactionAfterReturning(txInfo); return retVal; } else { // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in. try { Object result = ((CallbackPreferringPlatformTransactionManager) tm) .execute( txAttr, new TransactionCallback<Object>() { public Object doInTransaction(TransactionStatus status) { TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status); try { return invocation.proceed(); } catch (Throwable ex) { if (txAttr.rollbackOn(ex)) { // A RuntimeException: will lead to a rollback. if (ex instanceof RuntimeException) { throw (RuntimeException) ex; } else { throw new ThrowableHolderException(ex); } } else { // A normal return value: will lead to a commit. return new ThrowableHolder(ex); } } finally { cleanupTransactionInfo(txInfo); } } }); // Check result: It might indicate a Throwable to rethrow. if (result instanceof ThrowableHolder) { throw ((ThrowableHolder) result).getThrowable(); } else { return result; } } catch (ThrowableHolderException ex) { throw ex.getCause(); } } }
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException { // first sift through and get all the methods // then get all the annotations // then build the metadata and register the metadata final Class<?> targetClass = AopUtils.getTargetClass(bean); final org.activiti.spring.annotations.ActivitiComponent component = targetClass.getAnnotation(org.activiti.spring.annotations.ActivitiComponent.class); ReflectionUtils.doWithMethods( targetClass, new ReflectionUtils.MethodCallback() { @SuppressWarnings("unchecked") public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException { State state = AnnotationUtils.getAnnotation(method, State.class); String processName = component.processKey(); if (StringUtils.hasText(state.process())) { processName = state.process(); } String stateName = state.state(); if (!StringUtils.hasText(stateName)) { stateName = state.value(); } Assert.notNull(stateName, "You must provide a stateName!"); Map<Integer, String> vars = new HashMap<Integer, String>(); Annotation[][] paramAnnotationsArray = method.getParameterAnnotations(); int ctr = 0; int pvMapIndex = -1; int procIdIndex = -1; for (Annotation[] paramAnnotations : paramAnnotationsArray) { ctr += 1; for (Annotation pa : paramAnnotations) { if (pa instanceof ProcessVariable) { ProcessVariable pv = (ProcessVariable) pa; String pvName = pv.value(); vars.put(ctr, pvName); } else if (pa instanceof ProcessVariables) { pvMapIndex = ctr; } else if (pa instanceof ProcessId) { procIdIndex = ctr; } } } ActivitiStateHandlerRegistration registration = new ActivitiStateHandlerRegistration( vars, method, bean, stateName, beanName, pvMapIndex, procIdIndex, processName); registry.registerActivitiStateHandler(registration); } }, new ReflectionUtils.MethodFilter() { public boolean matches(Method method) { return null != AnnotationUtils.getAnnotation(method, State.class); } }); return bean; }
private Class<?> getBeanClass(Object bean) { Class<?> targetClass = AopUtils.getTargetClass(bean); return (targetClass != null) ? targetClass : bean.getClass(); }