Java tutorial
/* * Copyright 2012 astamuse company,Ltd. * * 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 com.astamuse.asta4d.data; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.reflect.FieldUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.astamuse.asta4d.Configuration; import com.astamuse.asta4d.Context; import com.astamuse.asta4d.data.annotation.ContextData; import com.astamuse.asta4d.data.annotation.ContextDataSet; import com.astamuse.asta4d.util.Java8Paranamer; import com.astamuse.asta4d.util.Java8ParanamerBytecodeScanWrapper; import com.astamuse.asta4d.util.annotation.AnnotatedPropertyInfo; import com.astamuse.asta4d.util.annotation.AnnotatedPropertyUtil; import com.astamuse.asta4d.util.annotation.ConvertableAnnotationRetriever; import com.thoughtworks.paranamer.AdaptiveParanamer; import com.thoughtworks.paranamer.AnnotationParanamer; import com.thoughtworks.paranamer.DefaultParanamer; import com.thoughtworks.paranamer.Paranamer; /** * This class is a function holder to supply functionalities about data injection * * @author e-ryu * */ @SuppressWarnings({ "rawtypes", "unchecked" }) public class InjectUtil { private final static Logger logger = LoggerFactory.getLogger(InjectUtil.class); private static final String ContextDataSetSingletonMapKey = "ContextDataSetSingletonMapKey#" + InjectUtil.class.getName(); public static final String ContextDataNotFoundScope = "#ContextDataNotFoundScope"; public static final String ContextDataTypeUnMatchScope = "#ContextDataTypeUnMatchScope"; /** * A class that present the injectable target information * * @author e-ryu * */ private static class TargetInfo { AnnotatedPropertyInfo propertyInfo; String name; String scope; TypeUnMacthPolicy typeUnMatch; ContextDataSetFactory contextDataSetFactory; boolean isContextDataSetSingletonInContext; Class<?> type; boolean isContextDataHolder; Object defaultValue; void fixForPrimitiveType() { TypeInfo typeInfo = new TypeInfo(type); type = typeInfo.getType(); defaultValue = typeInfo.getDefaultValue(); } ContextDataHolder createDataHolderInstance() throws InstantiationException, IllegalAccessException { if (isContextDataHolder) { return (ContextDataHolder) type.newInstance(); } else { return new ContextDataHolder(type); } } } private static class MethodInfo extends TargetInfo { Method method; } private static class FieldInfo extends TargetInfo { Field field; } private static class InstanceWireTarget { List<FieldInfo> setFieldList = new ArrayList<>(); List<FieldInfo> getFieldList = new ArrayList<>(); List<MethodInfo> setMethodList = new ArrayList<>(); List<MethodInfo> getMethodList = new ArrayList<>(); } private final static ConcurrentHashMap<String, InstanceWireTarget> InstanceTargetCache = new ConcurrentHashMap<>(); private final static ConcurrentHashMap<Method, List<TargetInfo>> MethodTargetCache = new ConcurrentHashMap<>(); private final static Paranamer paranamer = new AdaptiveParanamer(new DefaultParanamer(), new Java8ParanamerBytecodeScanWrapper(), new AnnotationParanamer(), new Java8Paranamer()); public final static Object retrieveContextDataSetInstance(Class cls, String searchName, String searchScope) throws DataOperationException { try { ContextDataSet cds = ConvertableAnnotationRetriever.retrieveAnnotation(ContextDataSet.class, cls.getAnnotations()); if (cds == null) { throw new NullPointerException( "Could not find any ContextDataSet convertable annotation on given class:" + cls.getName()); } TargetInfo info = new TargetInfo(); info.contextDataSetFactory = cds.factory().newInstance(); info.isContextDataSetSingletonInContext = cds.singletonInContext(); info.defaultValue = null; info.name = searchName; info.scope = searchScope; info.type = cls; info.typeUnMatch = TypeUnMacthPolicy.EXCEPTION; ContextDataHolder result = findValueForTarget(info, null); if (result == null) { return null; } else { return result.getValue(); } } catch (IllegalAccessException | InstantiationException e) { throw new DataOperationException(e.getMessage(), e); } } /** * Set the value of all the fields marked by {@link ContextData} of the given instance. * * @param instance * @throws DataOperationException */ public final static void injectToInstance(Object instance) throws DataOperationException { InstanceWireTarget target = getInstanceTarget(instance); for (FieldInfo fi : target.setFieldList) { try { ContextDataHolder valueHolder = null; if (fi.isContextDataHolder) { valueHolder = (ContextDataHolder) FieldUtils.readField(fi.field, instance); } if (valueHolder == null) { valueHolder = fi.createDataHolderInstance(); } Class searchType = valueHolder.getTypeCls(); if (searchType == null) { throw new DataOperationException(fi.field.getName() + " should be initialized at first or we can not retrieve the type you want since it is a type of CotnextDataHolder. " + "You can also define an extended class to return the type class, in this case, you do not need to initialized it by your self"); } ContextDataHolder foundData = findValueForTarget(fi, searchType); handleTypeUnMatch(instance, fi, foundData); if (fi.isContextDataHolder) { transferDataHolder(foundData, valueHolder); FieldUtils.writeField(fi.field, instance, valueHolder, true); } else { FieldUtils.writeField(fi.field, instance, foundData.getValue(), true); } } catch (IllegalAccessException | IllegalArgumentException | InstantiationException e) { throw new DataOperationException("Exception when inject value to " + fi.field.toString(), e); } } for (MethodInfo mi : target.setMethodList) { try { ContextDataHolder valueHolder = mi.createDataHolderInstance(); Class searchType = valueHolder.getTypeCls(); if (searchType == null) { throw new DataOperationException(mi.method.getName() + " cannot initialize an instance of " + valueHolder.getClass().getName() + ". You should define an extended class to return the type class"); } ContextDataHolder foundData = findValueForTarget(mi, searchType); handleTypeUnMatch(instance, mi, foundData); if (mi.isContextDataHolder) { transferDataHolder(foundData, valueHolder); mi.method.invoke(instance, valueHolder); } else { mi.method.invoke(instance, foundData.getValue()); } } catch (IllegalAccessException | IllegalArgumentException | InstantiationException | InvocationTargetException e) { throw new DataOperationException("Exception when inject value to " + mi.method.toString(), e); } } } private static void handleTypeUnMatch(Object instance, FieldInfo target, ContextDataHolder valueHolder) throws DataOperationException { handleTypeUnMatch(instance, target.field, null, null, -1, target, valueHolder); } private static void handleTypeUnMatch(Object instance, MethodInfo target, ContextDataHolder valueHolder) throws DataOperationException { handleTypeUnMatch(instance, null, target.method, null, -1, target, valueHolder); } private static void handleTypeUnMatch(Method method, int methodParameterIndex, TargetInfo target, ContextDataHolder valueHolder) throws DataOperationException { handleTypeUnMatch(null, null, null, method, methodParameterIndex, target, valueHolder); } private static void handleTypeUnMatch(Object instance, Field field, Method setter, Method method, int methodParameterIndex, TargetInfo target, ContextDataHolder valueHolder) throws DataOperationException { // type unmatched if (ContextDataTypeUnMatchScope.equals(valueHolder.getScope())) { switch (target.typeUnMatch) { case EXCEPTION: String msg = "Found data(%s) cannot be coverted from [%s] to [%s]."; msg = String.format(msg, valueHolder.getFoundOriginalData(), valueHolder.getFoundOriginalData().getClass(), target.type); throw new DataOperationException(msg); case DEFAULT_VALUE: valueHolder.setData(valueHolder.getName(), valueHolder.getScope(), target.defaultValue); break; case DEFAULT_VALUE_AND_TRACE: ContextDataHolder traceHolder = new ContextDataHolder(); transferDataHolder(valueHolder, traceHolder); if (field != null) { InjectTrace.saveInstanceInjectionTraceInfo(instance, field, traceHolder); } else if (setter != null) { InjectTrace.saveInstanceInjectionTraceInfo(instance, setter, traceHolder); } else if (method != null) { InjectTrace.saveMethodInjectionTraceInfo(method, methodParameterIndex, traceHolder); } valueHolder.setData(valueHolder.getName(), valueHolder.getScope(), target.defaultValue); break; } } } private static void transferDataHolder(ContextDataHolder from, ContextDataHolder to) { to.setData(from.getName(), from.getScope(), from.getFoundOriginalData(), from.getValue()); } private static ContextDataHolder findValueForTarget(TargetInfo targetInfo, Class overrideSearchType) throws DataOperationException { Context context = Context.getCurrentThreadContext(); ContextDataFinder dataFinder = Configuration.getConfiguration().getContextDataFinder(); Class searchType = overrideSearchType == null ? targetInfo.type : overrideSearchType; ContextDataHolder valueHolder = dataFinder.findDataInContext(context, targetInfo.scope, targetInfo.name, searchType); if (valueHolder == null && targetInfo.contextDataSetFactory != null) { Object value; if (targetInfo.isContextDataSetSingletonInContext) { // this map was initialized when the context was initialized HashMap<String, Object> cdSetSingletonMap = context.getData(ContextDataSetSingletonMapKey); // we must synchronize it to avoid concurrent access on the map synchronized (cdSetSingletonMap) { String clsName = targetInfo.type.getName(); value = cdSetSingletonMap.get(clsName); if (value == null) { value = targetInfo.contextDataSetFactory.createInstance(targetInfo.type); injectToInstance(value); cdSetSingletonMap.put(clsName, value); } } } else { value = targetInfo.contextDataSetFactory.createInstance(targetInfo.type); injectToInstance(value); } valueHolder = new ContextDataHolder(targetInfo.name, targetInfo.scope, value); } else if (valueHolder == null) { valueHolder = new ContextDataHolder(targetInfo.name, ContextDataNotFoundScope, targetInfo.defaultValue); } return valueHolder; } /** * Retrieve values from fields marked as reverse injectable of given instance. * * There are only limited scopes can be marked as injectable. See {@link Configuration#setReverseInjectableScopes(List)}. * * NOT SUPPORTED ANY MORE!!! * * @param instance * @throws DataOperationException */ @Deprecated public final static void setContextDataFromInstance(Object instance) throws DataOperationException { try { Context context = Context.getCurrentThreadContext(); InstanceWireTarget target = getInstanceTarget(instance); Object value; for (FieldInfo fi : target.getFieldList) { value = FieldUtils.readField(fi.field, instance, true); context.setData(fi.scope, fi.name, value); } for (MethodInfo mi : target.getMethodList) { value = mi.method.invoke(instance); context.setData(mi.scope, mi.name, value); } } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { String msg = String.format("Exception when inject value from instance of [%s] to Context.", instance.getClass().toString()); throw new DataOperationException(msg, e); } } private final static InstanceWireTarget getInstanceTarget(Object instance) throws DataOperationException { boolean cacheEnable = Configuration.getConfiguration().isCacheEnable(); InstanceWireTarget target = null; if (cacheEnable) { String key = instance.getClass().getName(); target = InstanceTargetCache.get(key); if (target == null) { target = createInstanceTarget(instance); InstanceTargetCache.put(key, target); } } else { target = createInstanceTarget(instance); } return target; } private final static InstanceWireTarget createInstanceTarget(Object instance) throws DataOperationException { InstanceWireTarget target = new InstanceWireTarget(); Class<?> cls = instance.getClass(); List<AnnotatedPropertyInfo> propertyList = AnnotatedPropertyUtil.retrieveProperties(cls); try { for (AnnotatedPropertyInfo prop : propertyList) { ContextData cd = prop.getAnnotation(ContextData.class); if (prop.getField() != null) { Field field = prop.getField(); FieldInfo fi = new FieldInfo(); fi.propertyInfo = prop; fi.name = prop.getName(); fi.field = field; fi.type = field.getType(); fi.isContextDataHolder = ContextDataHolder.class.isAssignableFrom(fi.type); fi.scope = cd.scope(); fi.typeUnMatch = cd.typeUnMatch(); fi.fixForPrimitiveType(); ContextDataSet cdSet = ConvertableAnnotationRetriever.retrieveAnnotation(ContextDataSet.class, fi.type.getAnnotations()); if (cdSet == null) { fi.contextDataSetFactory = null; } else { fi.contextDataSetFactory = cdSet.factory().newInstance(); fi.isContextDataSetSingletonInContext = cdSet.singletonInContext(); } target.setFieldList.add(fi); } else {// for method MethodInfo mi = new MethodInfo(); mi.propertyInfo = prop; mi.name = prop.getName(); mi.method = prop.getSetter(); if (mi.method == null) { throw new DataOperationException( "Could not find setter method for annotated property:" + prop.getName()); } mi.type = mi.method.getParameterTypes()[0]; mi.isContextDataHolder = ContextDataHolder.class.isAssignableFrom(mi.type); mi.scope = cd.scope(); mi.typeUnMatch = cd.typeUnMatch(); mi.fixForPrimitiveType(); ContextDataSet cdSet = ConvertableAnnotationRetriever.retrieveAnnotation(ContextDataSet.class, mi.type.getAnnotations()); if (cdSet == null) { mi.contextDataSetFactory = null; } else { mi.contextDataSetFactory = cdSet.factory().newInstance(); mi.isContextDataSetSingletonInContext = cdSet.singletonInContext(); } target.setMethodList.add(mi); } } } catch (InstantiationException | IllegalAccessException e) { throw new DataOperationException( "Exception occured on generating injection information of " + instance.getClass(), e); } return target; } /** * Retrieve value from {@link Context} for given Method by configured {@link ContextDataFinder} * * @param method * given method * @return Retrieved values * @throws DataOperationException */ public final static Object[] getMethodInjectParams(Method method) throws DataOperationException { ContextDataFinder dataFinder = Configuration.getConfiguration().getContextDataFinder(); return getMethodInjectParams(method, dataFinder); } /** * Retrieve value from {@link Context} for given Method by given {@link ContextDataFinder} * * @param method * given method * @param dataFinder * given ContextDataFinder * @return Retrieved values * @throws DataOperationException */ public final static Object[] getMethodInjectParams(Method method, ContextDataFinder dataFinder) throws DataOperationException { try { List<TargetInfo> targetList = getMethodTarget(method); Object[] params = new Object[targetList.size()]; if (params.length == 0) { return params; } TargetInfo target; ContextDataHolder valueHolder, foundData; Class searchType; for (int i = 0; i < params.length; i++) { target = targetList.get(i); valueHolder = target.createDataHolderInstance(); searchType = valueHolder.getTypeCls(); if (searchType == null) { throw new DataOperationException(method.getName() + " cannot initialize an instance of " + valueHolder.getClass().getName() + ". You should define an extended class to return the type class"); } foundData = findValueForTarget(target, searchType); handleTypeUnMatch(method, i, target, foundData); if (target.isContextDataHolder) { transferDataHolder(foundData, valueHolder); params[i] = valueHolder; } else { params[i] = foundData.getValue(); } } return params; } catch (InstantiationException | IllegalAccessException e) { throw new DataOperationException("create instance failed.", e); } } private final static List<TargetInfo> getMethodTarget(Method method) throws InstantiationException, IllegalAccessException { boolean cacheEnable = Configuration.getConfiguration().isCacheEnable(); List<TargetInfo> targetList = null; if (cacheEnable) { targetList = MethodTargetCache.get(method); if (targetList == null) { targetList = createMethodTarget(method); MethodTargetCache.put(method, targetList); } } else { targetList = createMethodTarget(method); } return targetList; } private final static List<TargetInfo> createMethodTarget(Method method) throws InstantiationException, IllegalAccessException { Class<?>[] types = method.getParameterTypes(); List<TargetInfo> targetList = new ArrayList<>(); if (types.length == 0) { return targetList; } Annotation[][] annotations = method.getParameterAnnotations(); String[] parameterNames = paranamer.lookupParameterNames(method); TargetInfo target; ContextData cd; ContextDataSet cdSet; for (int i = 0; i < types.length; i++) { target = new TargetInfo(); target.type = types[i]; target.isContextDataHolder = ContextDataHolder.class.isAssignableFrom(target.type); cd = ConvertableAnnotationRetriever.retrieveAnnotation(ContextData.class, annotations[i]); cdSet = ConvertableAnnotationRetriever.retrieveAnnotation(ContextDataSet.class, target.type.getAnnotations()); target.name = cd == null ? "" : cd.name(); target.scope = cd == null ? "" : cd.scope(); target.typeUnMatch = cd == null ? TypeUnMacthPolicy.EXCEPTION : cd.typeUnMatch(); if (StringUtils.isEmpty(target.name)) { target.name = parameterNames[i]; } if (cdSet == null) { target.contextDataSetFactory = null; } else { target.contextDataSetFactory = cdSet.factory().newInstance(); target.isContextDataSetSingletonInContext = cdSet.singletonInContext(); } target.fixForPrimitiveType(); targetList.add(target); } return targetList; } public static final void initContext(Context context) { context.setData(ContextDataSetSingletonMapKey, new HashMap()); } }