Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.apache.shiro.guice; import java.beans.PropertyDescriptor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import com.google.inject.Binder; import com.google.inject.ConfigurationException; import com.google.inject.Injector; import com.google.inject.Key; import com.google.inject.MembersInjector; import com.google.inject.Provider; import com.google.inject.TypeLiteral; import com.google.inject.matcher.Matcher; import com.google.inject.matcher.Matchers; import com.google.inject.multibindings.MapBinder; import com.google.inject.name.Names; import com.google.inject.spi.TypeEncounter; import com.google.inject.spi.TypeListener; import com.google.inject.util.Types; import org.apache.commons.beanutils.PropertyUtils; import org.apache.shiro.SecurityUtils; /** * TypeListener that injects setter methods on Shiro objects. */ class BeanTypeListener implements TypeListener { public static final Package SHIRO_GUICE_PACKAGE = ShiroModule.class.getPackage(); public static final Package SHIRO_PACKAGE = SecurityUtils.class.getPackage(); private static Matcher<Class> shiroMatcher = Matchers.inSubpackage(SHIRO_PACKAGE.getName()); private static Matcher<Class> shiroGuiceMatcher = Matchers.inSubpackage(SHIRO_GUICE_PACKAGE.getName()); private static Matcher<Class> classMatcher = ShiroMatchers.ANY_PACKAGE .and(shiroMatcher.and(Matchers.not(shiroGuiceMatcher))); public static final Matcher<TypeLiteral> MATCHER = ShiroMatchers.typeLiteral(classMatcher); private static final String BEAN_TYPE_MAP_NAME = "__SHIRO_BEAN_TYPES__"; static final Key<?> MAP_KEY = Key.get(Types.mapOf(TypeLiteral.class, BeanTypeKey.class), Names.named(BEAN_TYPE_MAP_NAME)); private static final Set<Class<?>> WRAPPER_TYPES = new HashSet<Class<?>>( Arrays.asList(Byte.class, Boolean.class, Character.class, Double.class, Float.class, Integer.class, Long.class, Short.class, Void.class)); public <I> void hear(TypeLiteral<I> type, final TypeEncounter<I> encounter) { PropertyDescriptor propertyDescriptors[] = PropertyUtils.getPropertyDescriptors(type.getRawType()); final Map<PropertyDescriptor, Key<?>> propertyDependencies = new HashMap<PropertyDescriptor, Key<?>>( propertyDescriptors.length); final Provider<Injector> injectorProvider = encounter.getProvider(Injector.class); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { if (propertyDescriptor.getWriteMethod() != null && Modifier.isPublic(propertyDescriptor.getWriteMethod().getModifiers())) { Type propertyType = propertyDescriptor.getWriteMethod().getGenericParameterTypes()[0]; propertyDependencies.put(propertyDescriptor, createDependencyKey(propertyDescriptor, propertyType)); } } encounter.register(new MembersInjector<I>() { public void injectMembers(I instance) { for (Map.Entry<PropertyDescriptor, Key<?>> dependency : propertyDependencies.entrySet()) { try { final Injector injector = injectorProvider.get(); Object value = injector.getInstance(getMappedKey(injector, dependency.getValue())); dependency.getKey().getWriteMethod().invoke(instance, value); } catch (ConfigurationException e) { // This is ok, it simply means that we can't fulfill this dependency. // Is there a better way to do this? } catch (InvocationTargetException e) { throw new RuntimeException("Couldn't set property " + dependency.getKey().getDisplayName(), e); } catch (IllegalAccessException e) { throw new RuntimeException( "We shouldn't have ever reached this point, we don't try to inject to non-accessible methods.", e); } } } }); } private static Key<?> getMappedKey(Injector injector, Key<?> key) { Map<TypeLiteral, BeanTypeKey> beanTypeMap = getBeanTypeMap(injector); if (key.getAnnotation() == null && beanTypeMap.containsKey(key.getTypeLiteral())) { return beanTypeMap.get(key.getTypeLiteral()).key; } else { return key; } } @SuppressWarnings({ "unchecked" }) private static Map<TypeLiteral, BeanTypeKey> getBeanTypeMap(Injector injector) { return (Map<TypeLiteral, BeanTypeKey>) injector.getInstance(MAP_KEY); } private static Key<?> createDependencyKey(PropertyDescriptor propertyDescriptor, Type propertyType) { if (requiresName(propertyType)) { return Key.get(propertyType, Names.named("shiro." + propertyDescriptor.getName())); } else { return Key.get(propertyType); } } private static boolean requiresName(Type propertyType) { if (propertyType instanceof Class) { Class<?> aClass = (Class<?>) propertyType; return aClass.isPrimitive() || aClass.isEnum() || WRAPPER_TYPES.contains(aClass) || CharSequence.class.isAssignableFrom(aClass); } else { return false; } } static void ensureBeanTypeMapExists(Binder binder) { beanTypeMapBinding(binder).addBinding(TypeLiteral.get(BeanTypeKey.class)).toInstance(new BeanTypeKey(null)); } static <T> void bindBeanType(Binder binder, TypeLiteral<T> typeLiteral, Key<? extends T> key) { beanTypeMapBinding(binder).addBinding(typeLiteral).toInstance(new BeanTypeKey(key)); } private static MapBinder<TypeLiteral, BeanTypeKey> beanTypeMapBinding(Binder binder) { return MapBinder.newMapBinder(binder, TypeLiteral.class, BeanTypeKey.class, Names.named(BEAN_TYPE_MAP_NAME)); } private static class BeanTypeKey { Key<?> key; private BeanTypeKey(Key<?> key) { this.key = key; } } }