001// Copyright 2006, 2007, 2008, 2010 The Apache Software Foundation
002//
003// Licensed under the Apache License, Version 2.0 (the "License");
004// you may not use this file except in compliance with the License.
005// You may obtain a copy of the License at
006//
007// http://www.apache.org/licenses/LICENSE-2.0
008//
009// Unless required by applicable law or agreed to in writing, software
010// distributed under the License is distributed on an "AS IS" BASIS,
011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012// See the License for the specific language governing permissions and
013// limitations under the License.
014
015package org.apache.tapestry5.ioc.internal.services;
016
017import java.beans.BeanInfo;
018import java.beans.IntrospectionException;
019import java.beans.Introspector;
020import java.beans.PropertyDescriptor;
021import java.lang.annotation.Annotation;
022import java.lang.reflect.Method;
023import java.lang.reflect.Modifier;
024import java.util.Arrays;
025import java.util.LinkedList;
026import java.util.List;
027import java.util.Map;
028
029import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
030import org.apache.tapestry5.ioc.services.ClassPropertyAdapter;
031import org.apache.tapestry5.ioc.services.PropertyAccess;
032
033@SuppressWarnings("unchecked")
034public class PropertyAccessImpl implements PropertyAccess
035{
036    private final Map<Class, ClassPropertyAdapter> adapters = CollectionFactory.newConcurrentMap();
037
038    @Override
039    public Object get(Object instance, String propertyName)
040    {
041        return getAdapter(instance).get(instance, propertyName);
042    }
043
044    @Override
045    public void set(Object instance, String propertyName, Object value)
046    {
047        getAdapter(instance).set(instance, propertyName, value);
048    }
049
050    @Override
051    public Annotation getAnnotation(Object instance, String propertyName, Class<? extends Annotation> annotationClass) {
052    return getAdapter(instance).getAnnotation(instance, propertyName, annotationClass);
053    }
054
055
056    /**
057     * Clears the cache of adapters and asks the {@link Introspector} to clear its cache.
058     */
059    @Override
060    public synchronized void clearCache()
061    {
062        adapters.clear();
063
064        Introspector.flushCaches();
065    }
066
067    @Override
068    public ClassPropertyAdapter getAdapter(Object instance)
069    {
070        return getAdapter(instance.getClass());
071    }
072
073    @Override
074    public ClassPropertyAdapter getAdapter(Class forClass)
075    {
076        ClassPropertyAdapter result = adapters.get(forClass);
077
078        if (result == null)
079        {
080            result = buildAdapter(forClass);
081            adapters.put(forClass, result);
082        }
083
084        return result;
085    }
086
087    /**
088     * Builds a new adapter and updates the _adapters cache. This not only guards access to the adapter cache, but also
089     * serializes access to the Java Beans Introspector, which is not thread safe. In addition, handles the case where
090     * the class in question is an interface, accumulating properties inherited from super-classes.
091     */
092    private synchronized ClassPropertyAdapter buildAdapter(Class forClass)
093    {
094        // In some race conditions, we may hit this method for the same class multiple times.
095        // We just let it happen, replacing the old ClassPropertyAdapter with a new one.
096
097        try
098        {
099            BeanInfo info = Introspector.getBeanInfo(forClass);
100
101            List<PropertyDescriptor> descriptors = CollectionFactory.newList();
102
103            addAll(descriptors, info.getPropertyDescriptors());
104
105            // Introspector misses:
106            // - interface methods not implemented in an abstract class (TAP5-921)
107            // - default methods (TAP5-2449)
108            addPropertiesFromExtendedInterfaces(forClass, descriptors);
109
110            addPropertiesFromScala(forClass, descriptors);
111
112
113            return new ClassPropertyAdapterImpl(forClass, descriptors);
114        }
115        catch (Throwable ex)
116        {
117            throw new RuntimeException(ex);
118        }
119    }
120
121    private static <T> void addAll(List<T> list, T[] array)
122    {
123        if (array.length > 0){
124            list.addAll(Arrays.asList(array));
125        }
126    }
127
128    private static <T> void addInterfacesRecursively(List<Class> list, Class<?> clazz)
129    {
130        Class<?>[] interfaces = clazz.getInterfaces();
131        for (int i = 0; i < interfaces.length; i++) {
132          Class<?> iface = interfaces[i];
133          addInterfacesRecursively(list, iface);
134          list.add(iface);
135        }
136    }
137
138    private static void addPropertiesFromExtendedInterfaces(Class forClass, List<PropertyDescriptor> descriptors)
139            throws IntrospectionException
140    {
141
142        Class[] interfaces = forClass.getInterfaces();
143        if (interfaces.length == 0){
144            return;
145        }
146        LinkedList<Class> queue = CollectionFactory.newLinkedList();
147        // Seed the queue
148        addInterfacesRecursively(queue, forClass);
149
150        while (!queue.isEmpty())
151        {
152            Class c = queue.removeFirst();
153
154            BeanInfo info = Introspector.getBeanInfo(c);
155
156            // Duplicates occur and are filtered out in ClassPropertyAdapter which stores
157            // a property name to descriptor map.
158            addAll(descriptors, info.getPropertyDescriptors());
159        }
160    }
161
162    private void addPropertiesFromScala(Class forClass, List<PropertyDescriptor> descriptors)
163            throws IntrospectionException
164    {
165        for (Method method : forClass.getMethods())
166        {
167            addPropertyIfScalaGetterMethod(forClass, descriptors, method);
168        }
169    }
170
171    private void addPropertyIfScalaGetterMethod(Class forClass, List<PropertyDescriptor> descriptors, Method method)
172            throws IntrospectionException
173    {
174        if (!isScalaGetterMethod(method))
175            return;
176
177        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(method.getName(), forClass, method.getName(),
178                null);
179
180        // found a getter, looking for the setter now
181        try
182        {
183            Method setterMethod = findScalaSetterMethod(forClass, method);
184
185            propertyDescriptor.setWriteMethod(setterMethod);
186        }
187        catch (NoSuchMethodException e)
188        {
189            // ignore
190        }
191
192        // check if the same property was already discovered with java bean accessors
193
194        addScalaPropertyIfNoJavaBeansProperty(descriptors, propertyDescriptor, method);
195    }
196
197    private void addScalaPropertyIfNoJavaBeansProperty(List<PropertyDescriptor> descriptors,
198            PropertyDescriptor propertyDescriptor, Method getterMethod)
199    {
200        boolean found = false;
201
202        for (PropertyDescriptor currentPropertyDescriptor : descriptors)
203        {
204            if (currentPropertyDescriptor.getName().equals(getterMethod.getName()))
205            {
206                found = true;
207
208                break;
209            }
210        }
211
212        if (!found)
213            descriptors.add(propertyDescriptor);
214    }
215
216    private Method findScalaSetterMethod(Class forClass, Method getterMethod) throws NoSuchMethodException
217    {
218        return forClass.getMethod(getterMethod.getName() + "_$eq", getterMethod.getReturnType());
219    }
220
221    private boolean isScalaGetterMethod(Method method)
222    {
223        try
224        {
225            return Modifier.isPublic(method.getModifiers()) && method.getParameterTypes().length == 0
226                    && !method.getReturnType().equals(Void.TYPE)
227                    && method.getDeclaringClass().getDeclaredField(method.getName()) != null;
228        }
229        catch (NoSuchFieldException ex)
230        {
231            return false;
232        }
233    }
234}