@Test
 public void testImportXmlWithNamespaceConfig() {
   AnnotationConfigApplicationContext ctx =
       new AnnotationConfigApplicationContext(ImportXmlWithAopNamespaceConfig.class);
   Object bean = ctx.getBean("proxiedXmlBean");
   assertTrue(AopUtils.isAopProxy(bean));
 }
  @Test
  public void testAutoProxyCreatorWithFactoryBeanAndProxyObjectOnly() {
    StaticApplicationContext sac = new StaticApplicationContext();

    MutablePropertyValues pvs = new MutablePropertyValues();
    pvs.add("proxyFactoryBean", "false");
    sac.registerSingleton("testAutoProxyCreator", TestAutoProxyCreator.class, pvs);

    sac.registerSingleton("singletonFactoryToBeProxied", DummyFactory.class);

    sac.refresh();

    TestAutoProxyCreator tapc = (TestAutoProxyCreator) sac.getBean("testAutoProxyCreator");
    tapc.testInterceptor.nrOfInvocations = 0;

    FactoryBean<?> factory = (FactoryBean<?>) sac.getBean("&singletonFactoryToBeProxied");
    assertFalse(AopUtils.isAopProxy(factory));

    TestBean tb = (TestBean) sac.getBean("singletonFactoryToBeProxied");
    assertTrue(AopUtils.isCglibProxy(tb));
    assertEquals(0, tapc.testInterceptor.nrOfInvocations);
    tb.getAge();
    assertEquals(1, tapc.testInterceptor.nrOfInvocations);

    TestBean tb2 = (TestBean) sac.getBean("singletonFactoryToBeProxied");
    assertSame(tb, tb2);
    assertEquals(1, tapc.testInterceptor.nrOfInvocations);
    tb2.getAge();
    assertEquals(2, tapc.testInterceptor.nrOfInvocations);
  }
 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;
 }
  @Test
  public void testGetAnonymousInnerBeanFromScope() throws Exception {
    TestBean bean = (TestBean) this.beanFactory.getBean("outerBean");
    assertFalse(AopUtils.isAopProxy(bean));
    assertTrue(AopUtils.isCglibProxy(bean.getSpouse()));

    BeanDefinition beanDef = this.beanFactory.getBeanDefinition("outerBean");
    BeanDefinitionHolder innerBeanDef =
        (BeanDefinitionHolder) beanDef.getPropertyValues().getPropertyValue("spouse").getValue();
    String name = innerBeanDef.getBeanName();

    MockHttpServletRequest request = new MockHttpServletRequest();
    RequestAttributes requestAttributes = new ServletRequestAttributes(request);
    RequestContextHolder.setRequestAttributes(requestAttributes);

    try {
      assertNull(request.getAttribute("scopedTarget." + name));
      assertEquals("scoped", bean.getSpouse().getName());
      assertNotNull(request.getAttribute("scopedTarget." + name));
      assertEquals(TestBean.class, request.getAttribute("scopedTarget." + name).getClass());
      assertEquals("scoped", ((TestBean) request.getAttribute("scopedTarget." + name)).getName());
    } finally {
      RequestContextHolder.setRequestAttributes(null);
    }
  }
  public static Class<?> getGenericTypeFromBean(Object object) {
    Class<?> clazz = object.getClass();

    if (AopUtils.isAopProxy(object)) {
      clazz = AopUtils.getTargetClass(object);
    }
    return getGenericType(clazz);
  }
 /**
  * 获取目标对象.
  *
  * @param proxy 代理对象
  * @return 目标对象
  */
 public static Object getTarget(final Object proxy) {
   if (!AopUtils.isAopProxy(proxy)) {
     return proxy;
   }
   if (AopUtils.isJdkDynamicProxy(proxy)) {
     return getProxyTargetObject(proxy, "h");
   } else {
     return getProxyTargetObject(proxy, "CGLIB$CALLBACK_0");
   }
 }
  @Test
  public void proxyingOccurs() {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(AsyncConfig.class);
    ctx.refresh();

    AsyncBean asyncBean = ctx.getBean(AsyncBean.class);
    assertThat(AopUtils.isAopProxy(asyncBean), is(true));
    asyncBean.work();
  }
 @Test
 public void transactionProxyIsCreated() {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
   ctx.register(EnableTxConfig.class, TxManagerConfig.class);
   ctx.refresh();
   TransactionalTestBean bean = ctx.getBean(TransactionalTestBean.class);
   assertThat("testBean is not a proxy", AopUtils.isAopProxy(bean), is(true));
   Map<?, ?> services = ctx.getBeansWithAnnotation(Service.class);
   assertThat("Stereotype annotation not visible", services.containsKey("testBean"), is(true));
 }
Esempio n. 9
0
  /**
   * 获取 目标对象
   *
   * @param proxy 代理对象
   * @return
   * @throws Exception
   */
  public static Object getTarget(Object proxy) throws Exception {
    if (!AopUtils.isAopProxy(proxy)) {
      return proxy; // 不是代理对象
    }

    if (AopUtils.isJdkDynamicProxy(proxy)) {
      return getJdkDynamicProxyTargetObject(proxy);
    } else { // cglib
      return getCglibProxyTargetObject(proxy);
    }
  }
Esempio n. 10
0
  /** {@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;
  }
 private static Object getInjectableInstance(Object o) {
   if (AopUtils.isAopProxy(o)) {
     final Advised aopResource = (Advised) o;
     try {
       return aopResource.getTargetSource().getTarget();
     } catch (Exception e) {
       LOGGER.log(Level.SEVERE, "Could not get target object from proxy.", e);
       throw new RuntimeException("Could not get target object from proxy.", e);
     }
   } else {
     return o;
   }
 }
  @Test
  public void succeedsWhenJdkProxyAndScheduledMethodIsPresentOnInterface()
      throws InterruptedException {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(Config.class, JdkProxyTxConfig.class, RepoConfigB.class);
    ctx.refresh();

    Thread.sleep(50); // allow @Scheduled method to be called several times

    MyRepositoryWithScheduledMethod repository = ctx.getBean(MyRepositoryWithScheduledMethod.class);
    CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
    assertThat("repository is not a proxy", AopUtils.isAopProxy(repository), is(true));
    assertThat("@Scheduled method never called", repository.getInvocationCount(), greaterThan(0));
    assertThat("no transactions were committed", txManager.commits, greaterThan(0));
  }
  @Before
  public void setUp() throws Exception {
    ClassPathXmlApplicationContext ctx =
        new ClassPathXmlApplicationContext(getClass().getSimpleName() + ".xml", getClass());
    AdviceBindingTestAspect afterAdviceAspect = (AdviceBindingTestAspect) ctx.getBean("testAspect");

    testBeanProxy = (ITestBean) ctx.getBean("testBean");
    assertTrue(AopUtils.isAopProxy(testBeanProxy));

    // we need the real target too, not just the proxy...
    testBeanTarget = (TestBean) ((Advised) testBeanProxy).getTargetSource().getTarget();

    mockCollaborator = createNiceMock(AdviceBindingCollaborator.class);
    afterAdviceAspect.setCollaborator(mockCollaborator);
  }
 @Override
 protected void applyReceiveOnlyAdviceChain(Collection<Advice> chain) {
   if (AopUtils.isAopProxy(this.source)) {
     for (Advice advice : chain) {
       NameMatchMethodPointcutAdvisor sourceAdvice = new NameMatchMethodPointcutAdvisor(advice);
       sourceAdvice.addMethodName("receive");
       ((Advised) this.source).addAdvice(advice);
     }
   } else {
     ProxyFactory proxyFactory = new ProxyFactory(this.source);
     for (Advice advice : chain) {
       proxyFactory.addAdvice(advice);
     }
     this.source = (MessageSource<?>) proxyFactory.getProxy(getBeanClassLoader());
   }
 }
  @Test
  public void customAsyncAnnotationIsPropagated() {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    ctx.register(CustomAsyncAnnotationConfig.class);
    ctx.refresh();

    Object bean = ctx.getBean(CustomAsyncBean.class);
    assertTrue(AopUtils.isAopProxy(bean));
    boolean isAsyncAdvised = false;
    for (Advisor advisor : ((Advised) bean).getAdvisors()) {
      if (advisor instanceof AsyncAnnotationAdvisor) {
        isAsyncAdvised = true;
        break;
      }
    }
    assertTrue("bean was not async advised as expected", isAsyncAdvised);
  }
Esempio n. 16
0
  public void testNonStaticScript() throws Exception {
    ApplicationContext ctx =
        new ClassPathXmlApplicationContext("jrubyRefreshableContext.xml", getClass());
    Messenger messenger = (Messenger) ctx.getBean("messenger");

    assertTrue("Should be a proxy for refreshable scripts", AopUtils.isAopProxy(messenger));
    assertTrue("Should be an instance of Refreshable", messenger instanceof Refreshable);

    String desiredMessage = "Hello World!";
    assertEquals("Message is incorrect.", desiredMessage, messenger.getMessage());

    Refreshable refreshable = (Refreshable) messenger;
    refreshable.refresh();

    assertEquals("Message is incorrect after refresh.", desiredMessage, messenger.getMessage());
    assertEquals("Incorrect refresh count", 2, refreshable.getRefreshCount());
  }
  @Test
  public void testInt3017DefaultConfig() throws Exception {
    assertSame(
        this.connectionFactory,
        TestUtils.getPropertyValue(this.defaultAdapter, "template.connectionFactory"));
    assertEquals(
        "foo",
        TestUtils.getPropertyValue(this.defaultAdapter, "queueNameExpression", Expression.class)
            .getExpressionString());
    assertTrue(TestUtils.getPropertyValue(this.defaultAdapter, "extractPayload", Boolean.class));
    assertFalse(
        TestUtils.getPropertyValue(this.defaultAdapter, "serializerExplicitlySet", Boolean.class));

    Object handler = TestUtils.getPropertyValue(this.defaultEndpoint, "handler");

    assertTrue(AopUtils.isAopProxy(handler));

    assertSame(((Advised) handler).getTargetSource().getTarget(), this.defaultAdapter);

    assertThat(
        TestUtils.getPropertyValue(handler, "h.advised.advisors.first.item.advice"),
        Matchers.instanceOf(RequestHandlerRetryAdvice.class));
  }
  @Test
  public void testBeanNameAutoProxyCreatorWithFactoryBeanProxy() {
    StaticApplicationContext sac = new StaticApplicationContext();
    sac.registerSingleton("testInterceptor", TestInterceptor.class);

    RootBeanDefinition proxyCreator = new RootBeanDefinition(BeanNameAutoProxyCreator.class);
    proxyCreator.getPropertyValues().add("interceptorNames", "testInterceptor");
    proxyCreator
        .getPropertyValues()
        .add("beanNames", "singletonToBeProxied,&singletonFactoryToBeProxied");
    sac.getDefaultListableBeanFactory()
        .registerBeanDefinition("beanNameAutoProxyCreator", proxyCreator);

    RootBeanDefinition bd = new RootBeanDefinition(TestBean.class);
    sac.getDefaultListableBeanFactory().registerBeanDefinition("singletonToBeProxied", bd);

    sac.registerSingleton("singletonFactoryToBeProxied", DummyFactory.class);

    sac.refresh();

    ITestBean singletonToBeProxied = (ITestBean) sac.getBean("singletonToBeProxied");
    assertTrue(Proxy.isProxyClass(singletonToBeProxied.getClass()));

    TestInterceptor ti = (TestInterceptor) sac.getBean("testInterceptor");
    int initialNr = ti.nrOfInvocations;
    singletonToBeProxied.getName();
    assertEquals(initialNr + 1, ti.nrOfInvocations);

    FactoryBean<?> factory = (FactoryBean<?>) sac.getBean("&singletonFactoryToBeProxied");
    assertTrue(Proxy.isProxyClass(factory.getClass()));
    TestBean tb = (TestBean) sac.getBean("singletonFactoryToBeProxied");
    assertFalse(AopUtils.isAopProxy(tb));
    assertEquals(initialNr + 3, ti.nrOfInvocations);
    tb.getAge();
    assertEquals(initialNr + 3, ti.nrOfInvocations);
  }
Esempio n. 19
0
  @Async
  @Override
  public String facade(String orderId, int waitTime) throws Exception {
    logger.debug("orderService - aop proxy: {}", AopUtils.isAopProxy(orderService));
    logger.debug("orderService - jdk proxy: {}", AopUtils.isJdkDynamicProxy(orderService));
    logger.debug("orderService - cglib proxy: {}", AopUtils.isCglibProxy(orderService));
    this.getOrderService().order(orderId);

    //		String result = null;
    //		Future<String> future = this.getOrderService().update(waitTime);
    //		try {
    //			result = future.get();
    //		} catch (Exception e) {
    //			/**
    //			 * here if we don't catch the exception, the transaction of this
    //			 * 'facade()' method will be committed, as future.get() will throw a
    //			 * ExecutionException which isn't a unchecked exception.
    //			 * <p/>
    //			 * The default behaviour of transaction manager is to rollback if a
    //			 * unchecked exception(RuntimeException) thrown out.
    //			 */
    //			logger.error(e.getMessage());
    //		}
    //
    //		// register a transaction event listener
    //		TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
    //			private boolean committed = false;
    //
    //			@Override
    //			public void suspend() {
    //				logger.debug("suspend()");
    //			}
    //
    //			@Override
    //			public void resume() {
    //				logger.debug("resume()");
    //			}
    //
    //			@Override
    //			public void flush() {
    //				logger.debug("flush()");
    //			}
    //
    //			/**
    //			 * The order of callback methods is as below:
    //			 * <ol>
    //			 * <li>beforeCommit()</li>
    //			 * <li>beforeCompletion()</li>
    //			 * <li>afterCommit()</li>
    //			 * <li>afterCompletion()</li>
    //			 * </ol>
    //			 * If transaction will be rolled back at last, both
    //			 * <code>beforeCommit()</code> and <code>afterCommit()</code> won't
    //			 * be called.
    //			 */
    //			@Override
    //			public void beforeCommit(boolean readOnly) {
    //				logger.debug("beforeCommit()..readOnly: {}", readOnly);
    //			}
    //
    //			@Override
    //			public void beforeCompletion() {
    //				logger.debug("beforeCompletion()");
    //			}
    //
    //			@Override
    //			public void afterCommit() {
    //				logger.debug("afterCommit()");
    //				this.committed = true;
    //			}
    //
    //			@Override
    //			public void afterCompletion(int status) {
    //				logger.debug("afterCompletion()");
    //				logger.debug(committed ? "committed" : "roll back");
    //			}
    //		});
    //
    //		if (waitTime > 5) {
    //			throw new RuntimeException("exception to trigger transaction rollback.");
    //		}
    //		return result;
    return null;
  }