public static CustomConverter findCustomConverterByClass(Class<?> customConverterClass, List<CustomConverter> externalConverters) { CustomConverter converterInstance = null; // search among injected customconverters for a match if (externalConverters != null) { for (CustomConverter customConverterObject : externalConverters) { if (customConverterObject.getClass().isAssignableFrom(customConverterClass)) { // we have a match converterInstance = customConverterObject; } } } // if converter object instances were not injected, then create new // instance // of the converter for each conversion // TODO : Should we really create it each time? if (converterInstance == null) { converterInstance = (CustomConverter) ReflectionUtils.newInstance(customConverterClass); } return converterInstance; }
public static CustomConverter findCustomConverterByClass(Class<?> customConverterClass, List<CustomConverter> externalConverters) { CustomConverter converterInstance = null; // search among injected customconverters for a match if (externalConverters != null) { for (CustomConverter customConverterObject : externalConverters) { if (customConverterObject.getClass().isAssignableFrom(customConverterClass)) { // we have a match converterInstance = customConverterObject; } } } // if converter object instances were not injected, then create new // instance // of the converter for each conversion // TODO : Should we really create it each time? if (converterInstance == null) { converterInstance = (CustomConverter) ReflectionUtils.newInstance(customConverterClass); } return converterInstance; }
private Object mapUsingCustomConverter(Class<?> customConverterClass, Class<?> srcFieldClass, Object srcFieldValue, Class<?> destFieldClass, Object existingDestFieldValue, FieldMap fieldMap, boolean topLevel) { CustomConverter converterInstance = null; // search our injected customconverters for a match if (customConverterObjects != null) { for (CustomConverter customConverterObject : customConverterObjects) { if (customConverterClass.isInstance(customConverterObject)) { // we have a match converterInstance = customConverterObject; } } } // if converter object instances were not injected, then create new instance // of the converter for each conversion // TODO : Should we really create it each time? if (converterInstance == null) { converterInstance = (CustomConverter) ReflectionUtils.newInstance(customConverterClass); } return mapUsingCustomConverterInstance(converterInstance, srcFieldClass, srcFieldValue, destFieldClass, existingDestFieldValue, fieldMap, topLevel); }
private boolean evaluateCondition(Class<?> conditionClass, Class<?> srcFieldClass, Object srcFieldValue, Class<?> destFieldType, Object destFieldValue, FieldMap fieldMapping, MappingContext context) { FieldMappingCondition conditionInstance = null; if (conditionObjects != null) { for (FieldMappingCondition conditionObject : conditionObjects) { if (conditionObject.getClass().isAssignableFrom(conditionClass)) { // we have a match conditionInstance = conditionObject; } } } // if converter object instances were not injected, then create new // instance of the converter for each conversion // TODO : Should we really create it each time? if (conditionInstance == null) { conditionInstance = (FieldMappingCondition) ReflectionUtils.newInstance(conditionClass); } return evaluateConditionInstance(conditionInstance, srcFieldClass, srcFieldValue, destFieldType, destFieldValue, context); }
private boolean evaluateCondition(Class<?> conditionClass, Class<?> srcFieldClass, Object srcFieldValue, Class<?> destFieldType, Object destFieldValue, FieldMap fieldMapping, MappingContext context) { FieldMappingCondition conditionInstance = null; if (conditionObjects != null) { for (FieldMappingCondition conditionObject : conditionObjects) { if (conditionObject.getClass().isAssignableFrom(conditionClass)) { // we have a match conditionInstance = conditionObject; } } } // if converter object instances were not injected, then create new // instance of the converter for each conversion // TODO : Should we really create it each time? if (conditionInstance == null) { conditionInstance = (FieldMappingCondition) ReflectionUtils.newInstance(conditionClass); } return evaluateConditionInstance(conditionInstance, srcFieldClass, srcFieldValue, destFieldType, destFieldValue, context); }
private Object evaluateCollectionItemDiscriminator(Class<?> discriminatorClass, Class<?> srcFieldClass, Object srcFieldValue, Class<?> destFieldType, Object destCollection, FieldMap fieldMapping, MappingContext context) { CollectionItemDiscriminator collectionItemDiscriminatorInstance = null; if (collectionItemDiscriminatorObjects != null) { for (CollectionItemDiscriminator disciminatorObject : collectionItemDiscriminatorObjects) { if (disciminatorObject.getClass().isAssignableFrom(discriminatorClass)) { // we have a match collectionItemDiscriminatorInstance = disciminatorObject; } } } // if discriminator object instances were not injected, then create new // instance of the converter for each conversion // TODO : Should we really create it each time? if (collectionItemDiscriminatorInstance == null) { collectionItemDiscriminatorInstance = (CollectionItemDiscriminator) ReflectionUtils.newInstance(discriminatorClass); } return evaluateCollectionItemDiscriminatorInstance(collectionItemDiscriminatorInstance, srcFieldClass, srcFieldValue, destFieldType, destCollection, context); }
private <T> T wireBean(Class<T> type) { final T bean = ReflectionUtils.newInstance(type); Field[] destFields = type.getDeclaredFields(); for (Field field : destFields) { Inject inject = field.getAnnotation(Inject.class); if (inject != null) { Class<?> fieldType = field.getType(); try { if (field.get(bean) == null) { Object dependency = wireBean(fieldType); field.set(bean, dependency); } } catch (IllegalAccessException e) { throw new MappingException("Field annotated with @Inject is not accessible : " + field.getName(), e); } } } Object[] instance = beans.get(type); if (instance == null) { instance = new Object[1]; beans.put(type, instance); } instance[0] = bean; return bean; }
private Object evaluateCollectionItemDiscriminator(Class<?> discriminatorClass, Class<?> srcFieldClass, Object srcFieldValue, Class<?> destFieldType, Object destCollection, FieldMap fieldMapping, MappingContext context) { CollectionItemDiscriminator collectionItemDiscriminatorInstance = null; if (collectionItemDiscriminatorObjects != null) { for (CollectionItemDiscriminator disciminatorObject : collectionItemDiscriminatorObjects) { if (disciminatorObject.getClass().isAssignableFrom(discriminatorClass)) { // we have a match collectionItemDiscriminatorInstance = disciminatorObject; } } } // if discriminator object instances were not injected, then create new // instance of the converter for each conversion // TODO : Should we really create it each time? if (collectionItemDiscriminatorInstance == null) { collectionItemDiscriminatorInstance = (CollectionItemDiscriminator) ReflectionUtils .newInstance(discriminatorClass); } return evaluateCollectionItemDiscriminatorInstance(collectionItemDiscriminatorInstance, srcFieldClass, srcFieldValue, destFieldType, destCollection, context); }
Object factory = ReflectionUtils.newInstance(objectFactory); Method method = null; try {
Object factory = ReflectionUtils.newInstance(objectFactory); Method method = null; try {
private void registerProxyResolver(GlobalSettings globalSettings, BeanContainer beanContainer) { String proxyResolverName = globalSettings.getProxyResolverName(); if (!DozerConstants.DEFAULT_PROXY_RESOLVER_BEAN.equals(proxyResolverName)) { DozerClassLoader initializedClassLoader = beanContainer.getClassLoader(); Class<? extends DozerProxyResolver> proxyResolverType = loadBeanType(proxyResolverName, initializedClassLoader, DozerProxyResolver.class); DozerProxyResolver proxyResolverBean = ReflectionUtils.newInstance(proxyResolverType); beanContainer.setProxyResolver(proxyResolverBean); } }
private void registerClassLoader(GlobalSettings globalSettings, ClassLoader classLoader, BeanContainer beanContainer) { String classLoaderName = globalSettings.getClassLoaderName(); if (!DozerConstants.DEFAULT_CLASS_LOADER_BEAN.equals(classLoaderName)) { DefaultClassLoader defaultClassLoader = new DefaultClassLoader(classLoader); Class<? extends DozerClassLoader> classLoaderType = loadBeanType(classLoaderName, defaultClassLoader, DozerClassLoader.class); DozerClassLoader classLoaderBean = ReflectionUtils.newInstance(classLoaderType); beanContainer.setClassLoader(classLoaderBean); } }
public Object create(BeanCreationDirective directive) { Class<?> classToCreate = directive.getActualClass(); String factoryName = directive.getFactoryName(); String factoryBeanId = directive.getFactoryId(); // By default, use dest object class name for factory bean id String beanId = !MappingUtils.isBlankOrNull(factoryBeanId) ? factoryBeanId : classToCreate.getName(); BeanFactory factory = factoryCache.get(factoryName); if (factory == null) { Class<?> factoryClass = MappingUtils.loadClass(factoryName); if (!BeanFactory.class.isAssignableFrom(factoryClass)) { MappingUtils.throwMappingException("Custom bean factory must implement " + BeanFactory.class.getName() + " interface : " + factoryClass); } factory = (BeanFactory) ReflectionUtils.newInstance(factoryClass); // put the created factory in our factory map factoryCache.put(factoryName, factory); } Object result = factory.createBean(directive.getSrcObject(), directive.getSrcClass(), beanId); log.debug("Bean instance created with custom factory -->\n Bean Type: {}\n Factory Name: {}", result.getClass().getName(), factoryName); if (!classToCreate.isAssignableFrom(result.getClass())) { MappingUtils.throwMappingException("Custom bean factory (" + factory.getClass() + ") did not return correct type of destination data object. Expected : " + classToCreate + ", Actual : " + result.getClass()); } return result; }
public Object create(MappingParameters params, BeanCreationDirective directive) { Class<?> classToCreate = directive.getActualClass(); String factoryName = directive.getFactoryName(); String factoryBeanId = directive.getFactoryId(); // By default, use dest object class name for factory bean id String beanId = !MappingUtils.isBlankOrNull(factoryBeanId) ? factoryBeanId : classToCreate.getName(); BeanFactory factory = factoryCache.get(factoryName); if (factory == null) { Class<?> factoryClass = MappingUtils.loadClass(factoryName); if (!BeanFactory.class.isAssignableFrom(factoryClass)) { MappingUtils.throwMappingException("Custom bean factory must implement " + BeanFactory.class.getName() + " interface : " + factoryClass); } factory = (BeanFactory) ReflectionUtils.newInstance(factoryClass); // put the created factory in our factory map factoryCache.put(factoryName, factory); } if (factory instanceof MappingParamsAware) { ((MappingParamsAware) factory).setMappingParams(params); } Object result = factory.createBean(directive.getSrcObject(), directive.getSrcClass(), beanId); log.debug("Bean instance created with custom factory -->\n Bean Type: {}\n Factory Name: {}", result.getClass().getName(), factoryName); if (!classToCreate.isAssignableFrom(result.getClass())) { MappingUtils.throwMappingException("Custom bean factory (" + factory.getClass() + ") did not return correct type of destination data object. Expected : " + classToCreate + ", Actual : " + result.getClass()); } return result; }
.getName() + " interface : " + factoryClass); factory = (BeanFactory) ReflectionUtils.newInstance(factoryClass);
DozerProxyResolver.class); DozerClassLoader classLoaderBean = ReflectionUtils.newInstance(classLoaderType); DozerProxyResolver proxyResolverBean = ReflectionUtils.newInstance(proxyResolverType);