Java ProxyFactoryBean类代码示例

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
private AclPredicateTargetSource installAclPredicateTargetSource() {
  synchronized (cachedCriteriaQuery) {
    Predicate restriction = cachedCriteriaQuery.getRestriction();

    if (restriction instanceof Advised) {
      Advised advised = (Advised) restriction;
      if (advised.getTargetSource() instanceof AclPredicateTargetSource) {
        return (AclPredicateTargetSource) advised.getTargetSource();
      }
    }

    AclPredicateTargetSource targetSource = new AclPredicateTargetSource(em.getCriteriaBuilder(), restriction);
    ProxyFactoryBean factoryBean = new ProxyFactoryBean();
    factoryBean.setTargetSource(targetSource);
    factoryBean.setAutodetectInterfaces(true);
    Predicate enhancedPredicate = (Predicate) factoryBean.getObject();
    logger.debug("ACL Jpa Specification target source initialized for criteria {}", cachedCriteriaQuery);

    // install proxy inside criteria
    cachedCriteriaQuery.where(enhancedPredicate);
    return targetSource;
  }
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Test
@DirtiesContext
public void upgradeAllOrNothing() throws Exception {
	TestUserService testUserService = new TestUserService(users.get(3).getId());
	testUserService.setUserDao(this.userDao);
	testUserService.setMailSender(mailSender);
	
	ProxyFactoryBean txProxyFactoryBean = context.getBean("&userService", ProxyFactoryBean.class);
	txProxyFactoryBean.setTarget(testUserService);
	
	UserService txUserService = (UserService) txProxyFactoryBean.getObject();

	userDao.deleteAll();

	for (User user : users)
		userDao.add(user);

	try {
		txUserService.upgradeLevels();
		fail("TestUserServiceException expected");
	} catch (TestUserServiceException e) {
	}
	checkLevel(users.get(1), false); // 오류 이전에 Update 한 사용자의 Level이 바뀌었나 확인
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Test
public void proxyFactoryBean() {
	ProxyFactoryBean pfBean = new ProxyFactoryBean();
	pfBean.setTarget(new HelloTarget());
	pfBean.addAdvice(new UppercaseAdvice());
	pfBean.setInterfaces(new Class[] { Hello.class }); // 생략해도 됨.

	Hello proxiedHandler = (Hello) pfBean.getObject();

	assertThat(proxiedHandler.sayHello("JUNG"), is("HELLO JUNG"));
	assertThat(proxiedHandler.sayHi("JUNG"), is("HI JUNG"));
	assertThat(proxiedHandler.sayThankYou("JUNG"), is("THANK YOU JUNG"));
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Test
public void pointcutAdvisor() {
	ProxyFactoryBean pfBean = new ProxyFactoryBean();
	pfBean.setTarget(new HelloTarget());

	NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
	pointcut.setMappedName("sayH*");

	pfBean.addAdvisor(new DefaultPointcutAdvisor(pointcut,
			new UppercaseAdvice()));

	Hello proxiedHello = (Hello) pfBean.getObject();

	assertThat(proxiedHello.sayHello("Jung"), is("HELLO JUNG"));
	assertThat(proxiedHello.sayHi("Jung"), is("HI JUNG"));
	assertThat(proxiedHello.sayThankYou("Jung"), is("Thank you Jung"));
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
private void checkAdvice(Object target,
		Pointcut pointcut, boolean adviced) {
	ProxyFactoryBean pfBean = new ProxyFactoryBean();
	pfBean.setTarget(target);
	pfBean.addAdvisor(new DefaultPointcutAdvisor(pointcut, new UppercaseAdvice()));
	Hello proxiedHello = (Hello)pfBean.getObject();
	
	if (adviced) {
		assertThat(proxiedHello.sayHello("Jung"), is("HELLO JUNG"));
		assertThat(proxiedHello.sayHi("Jung"), is("HI JUNG"));
		assertThat(proxiedHello.sayThankYou("Jung"), is("Thank you Jung"));			
	}
	else {
		assertThat(proxiedHello.sayHello("Jung"), is("Hello Jung"));
		assertThat(proxiedHello.sayHi("Jung"), is("Hi Jung"));
		assertThat(proxiedHello.sayThankYou("Jung"), is("Thank you Jung"));			
	}
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
private Environment environmentForImage(int maxWidth, boolean invert) {
	Map<String, Object> specification = new HashMap<>();
	specification.put("banner.image.width", maxWidth);
	specification.put("banner.image.invert", invert);
	ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setInterfaces(Environment.class);
	proxyFactoryBean.addAdvice((MethodInterceptor) invocation -> {
		String containsProperty = "containsProperty";
		String getProperty = "getProperty";
		List<String> toHandle = Arrays.asList(containsProperty, getProperty);
		String methodName = invocation.getMethod().getName();
		if (toHandle.contains(methodName)) {
			String key = String.class.cast(invocation.getArguments()[0]);
			if (methodName.equals(containsProperty)) {
				return (specification.containsKey(key) || this.environment.containsProperty(key));
			}
			if (methodName.equals(getProperty)) {
				return specification.getOrDefault(key, this.environment.getProperty(key));
			}
		}
		return invocation.getMethod().invoke(this.environment, invocation.getArguments());
	});
	return Environment.class.cast(proxyFactoryBean.getObject());
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
public <T> T lookup(String serviceName, Class<T> serviceInterface) {
    log.debug("Looking up service '{}' with interface '{}'", serviceName, serviceInterface.getSimpleName());

    String importProxyName = serviceName + BEAN_DEF_SUFFIX;

    if (!context.containsBean(importProxyName)) {
        RootBeanDefinition proxyBeanDef = new RootBeanDefinition(ProxyFactoryBean.class);

        proxyBeanDef.setRole(ROLE_INFRASTRUCTURE);
        proxyBeanDef.getPropertyValues().add("targetSource",
                new LookupTargetSource(serviceName, serviceInterface, serviceName + TARGET_SOURCE_SUFFIX, context));

        ((BeanDefinitionRegistry) beanFactory).registerBeanDefinition(importProxyName, proxyBeanDef);
    }

    return context.getBean(importProxyName, serviceInterface);
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
private ProxyFactoryBean createProxyFactoryBean(IService rawService, boolean proxyTargetClass) throws ClassNotFoundException {
	final ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setProxyInterfaces(new Class<?>[]{IService.class});
	proxyFactoryBean.setTarget(rawService);
	proxyFactoryBean.setProxyTargetClass(proxyTargetClass);
	return proxyFactoryBean;
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
private static <T> T proxyAdvice(T t, Advice methodInterceptor) {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
    proxyFactoryBean.setTargetClass(t.getClass());
    proxyFactoryBean.setTarget(t);
    proxyFactoryBean.addAdvice(methodInterceptor);
    return (T) proxyFactoryBean.getObject();
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
public static <T> T proxyAdvice(T t, Advice methodInterceptor) {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
    proxyFactoryBean.setTargetClass(t.getClass());
    proxyFactoryBean.setTarget(t);
    proxyFactoryBean.addAdvice(methodInterceptor);
    return (T) proxyFactoryBean.getObject();
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
		throws BeansException {
	logger.debug("................MiniDaoBeanFactory................ContextRefreshed...................");
	try {
		//循环传入的MiniDao配置
		for(String pack : packagesToScan){
			if(org.apache.commons.lang.StringUtils.isNotEmpty(pack)){
			   Set<Class<?>> classSet = PackagesToScanUtil.getClasses(pack);
			   for(Class<?> miniDaoClass : classSet){
				   if(miniDaoClass.isAnnotationPresent(MiniDao.class)){
					   //单独加载一个接口的代理类
					   ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
					   proxyFactoryBean.setBeanFactory(beanFactory);
					   proxyFactoryBean.setInterfaces(new Class[]{miniDaoClass});
					   proxyFactoryBean.setInterceptorNames(new String[]{"miniDaoHandler"});
					   String beanName = MiniDaoUtil.getFirstSmall(miniDaoClass.getSimpleName());
					   if(!beanFactory.containsBean(beanName)){
						   
						   //logger.info(".................MiniDaoBean.................init...................."+miniDaoClass.getName());
						   logger.info("MiniDao Interface [/"+miniDaoClass.getName()+"/] onto Spring Bean '"+beanName+"'");
						   beanFactory.registerSingleton(beanName,proxyFactoryBean.getObject());
					   }
				   }
			   }
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Bean(name = "amazonDynamoDB")
public ProxyFactoryBean amazonDynamoDbProxy() {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();

    proxyFactoryBean.setTarget(amazonDynamoDB());
    proxyFactoryBean.setInterceptorNames("retryInterceptor");
    return proxyFactoryBean;
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Bean
public ProxyFactoryBean amazonEC2Proxy() {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();

    proxyFactoryBean.setTarget(amazonEC2());
    proxyFactoryBean.setInterceptorNames("retryInterceptor");

    return proxyFactoryBean;
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Bean
public ProxyFactoryBean amazonS3Proxy() {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();

    proxyFactoryBean.setTarget(amazonS3());
    proxyFactoryBean.setInterceptorNames("retryInterceptor");

    return proxyFactoryBean;
}
 

import org.springframework.aop.framework.ProxyFactoryBean; //导入依赖的package包/类
@Bean (name = "amazonDynamoDbMapper")
public ProxyFactoryBean amazonDynamoDbMapperProxy() {
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();

    proxyFactoryBean.setTarget(dynamoDBMapper());
    proxyFactoryBean.setInterceptorNames("retryInterceptor");

    return proxyFactoryBean;
}