Java ClassUtil.checkAndFixAccess方法代码示例

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig paramDeserializationConfig, Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod)
{
  Class localClass = paramAnnotatedMethod.getRawParameterType(0);
  Object localObject;
  if (localClass == String.class)
    localObject = null;
  else if ((localClass == Integer.TYPE) || (localClass == Integer.class))
    localObject = Integer.class;
  else if ((localClass == Long.TYPE) || (localClass == Long.class))
    localObject = Long.class;
  else
    throw new IllegalArgumentException("Parameter #0 type for factory method (" + paramAnnotatedMethod + ") not suitable, must be java.lang.String or int/Integer/long/Long");
  if (paramDeserializationConfig.canOverrideAccessModifiers())
    ClassUtil.checkAndFixAccess(paramAnnotatedMethod.getMember());
  return new FactoryBasedDeserializer(paramClass, paramAnnotatedMethod, (Class)localObject);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType)
{
  BeanDescription localBeanDescription = paramDeserializationConfig.introspect(paramJavaType);
  Constructor localConstructor = localBeanDescription.findSingleArgConstructor(new Class[] { String.class });
  if (localConstructor != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localConstructor);
    return new StdKeyDeserializer.StringCtorKeyDeserializer(localConstructor);
  }
  Method localMethod = localBeanDescription.findFactoryMethod(new Class[] { String.class });
  if (localMethod != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return new StdKeyDeserializer.StringFactoryKeyDeserializer(localMethod);
  }
  return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  JsonDeserializer localJsonDeserializer = paramSettableBeanProperty.getValueDeserializer();
  if (((localJsonDeserializer instanceof BeanDeserializerBase)) && (!((BeanDeserializerBase)localJsonDeserializer).getValueInstantiator().canCreateUsingDefault()))
  {
    Class localClass1 = paramSettableBeanProperty.getType().getRawClass();
    Class localClass2 = ClassUtil.getOuterClass(localClass1);
    if ((localClass2 != null) && (localClass2 == this._beanType.getRawClass()))
      for (Constructor localConstructor : localClass1.getConstructors())
      {
        Class[] arrayOfClass = localConstructor.getParameterTypes();
        if ((arrayOfClass.length == 1) && (arrayOfClass[0] == localClass2))
        {
          if (paramDeserializationContext.getConfig().canOverrideAccessModifiers())
            ClassUtil.checkAndFixAccess(localConstructor);
          return new InnerClassProperty(paramSettableBeanProperty, localConstructor);
        }
      }
  }
  return paramSettableBeanProperty;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
/**
 * Method called to see if one of primary per-class annotations
 * (or related, like implementing of {@link JsonSerializable})
 * determines the serializer to use.
 *<p>
 * Currently handles things like:
 *<ul>
 * <li>If type implements {@link JsonSerializable}, use that
 *  </li>
 * <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer
 *    based on that property
 *  </li>
 *</ul>
 *
 * @since 2.0
 */
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov, 
        JavaType type, BeanDescription beanDesc)
    throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    // First: JsonSerializable?
    if (JsonSerializable.class.isAssignableFrom(raw)) {
        return SerializableSerializer.instance;
    }
    // Second: @JsonValue for any type
    AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
    if (valueMethod != null) {
        Method m = valueMethod.getAnnotated();
        if (prov.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(m);
        }
        JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod);
        return new JsonValueSerializer(m, ser);
    }
    // No well-known annotations...
    return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected EnumResolver<?> constructEnumResolver(Class<?> enumClass,
        DeserializationConfig config, AnnotatedMethod jsonValueMethod)
{
    if (jsonValueMethod != null) {
        Method accessor = jsonValueMethod.getAnnotated();
        if (config.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(accessor);
        }
        return EnumResolver.constructUnsafeUsingMethod(enumClass, accessor);
    }
    // [JACKSON-212]: may need to use Enum.toString()
    if (config.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) {
        return EnumResolver.constructUnsafeUsingToString(enumClass);
    }
    return EnumResolver.constructUnsafe(enumClass, config.getAnnotationIntrospector());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
/**
 * Factory method used when Enum instances are to be deserialized
 * using a creator (static factory method)
 * 
 * @return Deserializer based on given factory method, if type was suitable;
 *  null if type can not be used
 */
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
        Class<?> enumClass, AnnotatedMethod factory)
{
    
    // note: caller has verified there's just one arg; but we must verify its type
    Class<?> paramClass = factory.getRawParameterType(0);
    if (paramClass == String.class) {
        paramClass = null;
    } else  if (paramClass == Integer.TYPE || paramClass == Integer.class) {
        paramClass = Integer.class;
    } else  if (paramClass == Long.TYPE || paramClass == Long.class) {
        paramClass = Long.class;
    } else {
        throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory
                +") not suitable, must be java.lang.String or int/Integer/long/Long");
    }
    if (config.canOverrideAccessModifiers()) {
        ClassUtil.checkAndFixAccess(factory.getMember());
    }
    return new FactoryBasedDeserializer(enumClass, factory, paramClass);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider paramSerializerProvider, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  if (JsonSerializable.class.isAssignableFrom(paramJavaType.getRawClass()))
    return SerializableSerializer.instance;
  AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findJsonValueMethod();
  if (localAnnotatedMethod != null)
  {
    Method localMethod = localAnnotatedMethod.getAnnotated();
    if (paramSerializerProvider.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return new JsonValueSerializer(localMethod, findSerializerFromAnnotation(paramSerializerProvider, localAnnotatedMethod));
  }
  return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
private KeyDeserializer _createEnumKeyDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType)
{
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  BeanDescription localBeanDescription = localDeserializationConfig.introspect(paramJavaType);
  JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localBeanDescription.getClassInfo());
  if (localJsonDeserializer != null)
    return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer);
  Class localClass = paramJavaType.getRawClass();
  if (_findCustomEnumDeserializer(localClass, localDeserializationConfig, localBeanDescription) != null)
    return StdKeyDeserializers.constructDelegatingKeyDeserializer(localDeserializationConfig, paramJavaType, localJsonDeserializer);
  EnumResolver localEnumResolver = constructEnumResolver(localClass, localDeserializationConfig, localBeanDescription.findJsonValueMethod());
  Iterator localIterator = localBeanDescription.getFactoryMethods().iterator();
  while (localIterator.hasNext())
  {
    AnnotatedMethod localAnnotatedMethod = (AnnotatedMethod)localIterator.next();
    if (localDeserializationConfig.getAnnotationIntrospector().hasCreatorAnnotation(localAnnotatedMethod))
    {
      if ((localAnnotatedMethod.getParameterCount() == 1) && (localAnnotatedMethod.getRawReturnType().isAssignableFrom(localClass)))
      {
        if (localAnnotatedMethod.getGenericParameterType(0) != String.class)
          throw new IllegalArgumentException("Parameter #0 type for factory method (" + localAnnotatedMethod + ") not suitable, must be java.lang.String");
        if (localDeserializationConfig.canOverrideAccessModifiers())
          ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember());
        return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver, localAnnotatedMethod);
      }
      throw new IllegalArgumentException("Unsuitable method (" + localAnnotatedMethod + ") decorated with @JsonCreator (for Enum type " + localClass.getName() + ")");
    }
  }
  return StdKeyDeserializers.constructEnumKeyDeserializer(localEnumResolver);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected EnumResolver<?> constructEnumResolver(Class<?> paramClass, DeserializationConfig paramDeserializationConfig, AnnotatedMethod paramAnnotatedMethod)
{
  if (paramAnnotatedMethod != null)
  {
    Method localMethod = paramAnnotatedMethod.getAnnotated();
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return EnumResolver.constructUnsafeUsingMethod(paramClass, localMethod);
  }
  if (paramDeserializationConfig.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING))
    return EnumResolver.constructUnsafeUsingToString(paramClass);
  return EnumResolver.constructUnsafe(paramClass, paramDeserializationConfig.getAnnotationIntrospector());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected JsonDeserializer<Object> buildBuilderBasedDeserializer(DeserializationContext paramDeserializationContext, JavaType paramJavaType, BeanDescription paramBeanDescription)
{
  ValueInstantiator localValueInstantiator = findValueInstantiator(paramDeserializationContext, paramBeanDescription);
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  BeanDeserializerBuilder localBeanDeserializerBuilder1 = constructBeanDeserializerBuilder(paramDeserializationContext, paramBeanDescription);
  BeanDeserializerBuilder localBeanDeserializerBuilder2 = localBeanDeserializerBuilder1;
  localBeanDeserializerBuilder1.setValueInstantiator(localValueInstantiator);
  addBeanProps(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addObjectIdReader(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addReferenceProperties(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  addInjectables(paramDeserializationContext, paramBeanDescription, localBeanDeserializerBuilder2);
  JsonPOJOBuilder.Value localValue = paramBeanDescription.findPOJOBuilderConfig();
  String str;
  if (localValue == null)
    str = "build";
  else
    str = localValue.buildMethodName;
  AnnotatedMethod localAnnotatedMethod = paramBeanDescription.findMethod(str, null);
  if ((localAnnotatedMethod != null) && (localDeserializationConfig.canOverrideAccessModifiers()))
    ClassUtil.checkAndFixAccess(localAnnotatedMethod.getMember());
  localBeanDeserializerBuilder2.setPOJOBuilder(localAnnotatedMethod, localValue);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator2 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator2.hasNext())
      localBeanDeserializerBuilder2 = ((BeanDeserializerModifier)localIterator2.next()).updateBuilder(localDeserializationConfig, paramBeanDescription, localBeanDeserializerBuilder2);
  }
  JsonDeserializer localJsonDeserializer = localBeanDeserializerBuilder2.buildBuilderBased(paramJavaType, str);
  if (this._factoryConfig.hasDeserializerModifiers())
  {
    Iterator localIterator1 = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator1.hasNext())
      localJsonDeserializer = ((BeanDeserializerModifier)localIterator1.next()).modifyDeserializer(localDeserializationConfig, paramBeanDescription, localJsonDeserializer);
  }
  return localJsonDeserializer;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
Object readResolve() {
    Class<?> clazz = _serialization.clazz;
    try {
        Method m = clazz.getDeclaredMethod(_serialization.name,
                _serialization.args);
        // 06-Oct-2012, tatu: Has "lost" its security override, may need to force back
        if (!m.isAccessible()) {
            ClassUtil.checkAndFixAccess(m);
        }
        return new AnnotatedMethod(m, null, null);
    } catch (Exception e) {
        throw new IllegalArgumentException("Could not find method '"+_serialization.name
                    +"' from Class '"+clazz.getName());
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
Object readResolve() {
    Class<?> clazz = _serialization.clazz;
    try {
        Field f = clazz.getDeclaredField(_serialization.name);
        // 06-Oct-2012, tatu: Has "lost" its security override, may need to force back
        if (!f.isAccessible()) {
            ClassUtil.checkAndFixAccess(f);
        }
        return new AnnotatedField(f, null);
    } catch (Exception e) {
        throw new IllegalArgumentException("Could not find method '"+_serialization.name
                    +"' from Class '"+clazz.getName());
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
Object readResolve() {
    Class<?> clazz = _serialization.clazz;
    try {
        Constructor<?> ctor = clazz.getDeclaredConstructor(_serialization.args);
        // 06-Oct-2012, tatu: Has "lost" its security override, must force back
        if (!ctor.isAccessible()) {
            ClassUtil.checkAndFixAccess(ctor);
        }
        return new AnnotatedConstructor(ctor, null, null);
    } catch (Exception e) {
        throw new IllegalArgumentException("Could not find constructor with "
                +_serialization.args.length+" args from Class '"+clazz.getName());
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig config, JavaType type)
{
    /* We don't need full deserialization information, just need to
     * know creators.
     */
    BeanDescription beanDesc = config.introspect(type);
    // Ok, so: can we find T(String) constructor?
    Constructor<?> ctor = beanDesc.findSingleArgConstructor(String.class);
    if (ctor != null) {
        if (config.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(ctor);
        }
        return new StdKeyDeserializer.StringCtorKeyDeserializer(ctor);
    }
    /* or if not, "static T valueOf(String)" (or equivalent marked
     * with @JsonCreator annotation?)
     */
    Method m = beanDesc.findFactoryMethod(String.class);
    if (m != null){
        if (config.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(m);
        }
        return new StdKeyDeserializer.StringFactoryKeyDeserializer(m);
    }
    // nope, no such luck...
    return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
private <T extends AnnotatedMember> T _fixAccess(T member)
{
    if (member != null && _canFixAccess) {
        ClassUtil.checkAndFixAccess((Member) member.getAnnotated());
    }
    return member;
}