/* * Copyright 2002-2011 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.flex.core; import java.lang.reflect.Field; import java.util.Iterator; import java.util.List; import org.springframework.aop.framework.ProxyFactory; import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.flex.config.MessageBrokerConfigProcessor; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; import org.springframework.util.ReflectionUtils; import flex.messaging.MessageBroker; import flex.messaging.endpoints.BaseHTTPEndpoint; import flex.messaging.endpoints.Endpoint; import flex.messaging.endpoints.amf.AMFFilter; /** * Processor that applies advice to configured BlazeDS (Servlet based) endpoints by wrapping them in Spring AOP proxies. * * <p> * This processor will be automatically configured through the <code>message-broker</code> xml configuration namespace * tag. * * @author Jeremy Grelle * @author Rohit Kumar */ public class EndpointConfigProcessor implements MessageBrokerConfigProcessor, BeanClassLoaderAware { private final EndpointAdvisor[] advisors; private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader(); public EndpointConfigProcessor(List<EndpointAdvisor> advisors) { Assert.notEmpty(advisors, "A non-empty list of EndpointServiceMessagePointcutAdvisors is required"); this.advisors = advisors.toArray(new EndpointAdvisor[advisors.size()]); } /** * * {@inheritDoc} */ public MessageBroker processAfterStartup(MessageBroker broker) { Iterator<String> i = broker.getEndpoints().keySet().iterator(); while (i.hasNext()) { String key = i.next(); Endpoint endpoint = (Endpoint) broker.getEndpoints().get(key); // Use proxy only in case of Servlet based Endpoints if (endpoint instanceof BaseHTTPEndpoint) { ProxyFactory factory = new ProxyFactory(); factory.setProxyTargetClass(true); factory.addAdvisors(this.advisors); factory.setTarget(endpoint); factory.setFrozen(true); Endpoint proxy = (Endpoint) factory.getProxy(this.proxyClassLoader); fixFilterChain(endpoint, proxy); broker.getEndpoints().put(key, proxy); } } return broker; } /** * * {@inheritDoc} */ public MessageBroker processBeforeStartup(MessageBroker broker) { return broker; } /** * * {@inheritDoc} */ public void setBeanClassLoader(ClassLoader classLoader) { this.proxyClassLoader = classLoader; } private void fixFilterChain(Object endpoint, Object proxy) { // This is a nasty workaround, required because the advised Endpoint // passes a reference to itself to some of the filters in the chain. // It would be nice if the endpoints actually exposed their filter chain for // easier modification. Field filterChainField = ReflectionUtils.findField(endpoint.getClass(), "filterChain"); if (filterChainField != null) { Assert.isAssignable(AMFFilter.class, filterChainField.getType(), "filterChain field is expected to be of type AMFFilter"); ReflectionUtils.makeAccessible(filterChainField); AMFFilter filter = (AMFFilter) ReflectionUtils.getField(filterChainField, endpoint); while (filter != null) { Field endpointField = ReflectionUtils.findField(filter.getClass(), "endpoint"); if (endpointField != null) { ReflectionUtils.makeAccessible(endpointField); ReflectionUtils.setField(endpointField, filter, proxy); } filter = filter.getNext(); } } } }