Java AnnotatedMethod.getAnnotated方法代码示例

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public Delegating(BasicBeanDescription paramBasicBeanDescription, AnnotatedConstructor paramAnnotatedConstructor, AnnotatedMethod paramAnnotatedMethod)
{
  TypeBindings localTypeBindings = paramBasicBeanDescription.bindingsForBeanType();
  if (paramAnnotatedConstructor != null)
  {
    this._creator = paramAnnotatedConstructor;
    this._ctor = paramAnnotatedConstructor.getAnnotated();
    this._factoryMethod = null;
    this._valueType = localTypeBindings.resolveType(paramAnnotatedConstructor.getParameterType(0));
    return;
  }
  if (paramAnnotatedMethod != null)
  {
    this._creator = paramAnnotatedMethod;
    this._ctor = null;
    this._factoryMethod = paramAnnotatedMethod.getAnnotated();
    this._valueType = localTypeBindings.resolveType(paramAnnotatedMethod.getParameterType(0));
    return;
  }
  throw new IllegalArgumentException("Internal error: neither delegating constructor nor factory method passed");
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public StringBased(Class<?> paramClass, AnnotatedConstructor paramAnnotatedConstructor, AnnotatedMethod paramAnnotatedMethod)
{
  this._valueClass = paramClass;
  Constructor localConstructor;
  Method localMethod;
  if (paramAnnotatedConstructor == null)
  {
    localConstructor = null;
    this._ctor = localConstructor;
    localMethod = null;
    if (paramAnnotatedMethod != null)
      break label45;
  }
  while (true)
  {
    this._factoryMethod = localMethod;
    return;
    localConstructor = paramAnnotatedConstructor.getAnnotated();
    break;
    label45: localMethod = paramAnnotatedMethod.getAnnotated();
  }
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
/**
 * Method that will try to construct a {@link BeanSerializer} for
 * given class. Returns null if no properties are found.
 */
public JsonSerializer<Object> findBeanSerializer(JavaType type, SerializationConfig config,
                                                 BasicBeanDescription beanDesc)
{
    // First things first: we know some types are not beans...
    if (!isPotentialBeanType(type.getRawClass())) {
        return null;
    }
    // [JACKSON-80]: Support @JsonValue, alternative to bean method introspection.
    AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
    if (valueMethod != null) {
        /* Further, method itself may also be annotated to indicate
         * exact JsonSerializer to use for whatever value is returned...
         */
        JsonSerializer<Object> ser = findSerializerFromAnnotation(config, valueMethod);
        return new JsonValueSerializer(valueMethod.getAnnotated(), ser);
    }
    return constructBeanSerializer(config, beanDesc);
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public PropertyBased(AnnotatedConstructor ctor, SettableBeanProperty[] ctorProps,
                            AnnotatedMethod factory, SettableBeanProperty[] factoryProps)
{
    // We will only use one: and constructor has precedence over factory
    SettableBeanProperty[] props;
    if (ctor != null) {
        _ctor = ctor.getAnnotated();
        _factoryMethod = null;
        props = ctorProps;
    } else if (factory != null) {
        _ctor = null;
        _factoryMethod = factory.getAnnotated();
        props = factoryProps;
    } else {
        throw new IllegalArgumentException("Internal error: neither delegating constructor nor factory method passed");
    }
    _properties = new HashMap<String, SettableBeanProperty>();
    for (SettableBeanProperty prop : props) {
        _properties.put(prop.getPropertyName(), prop);
    }
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public final JsonSerializer<?> findSerializerByPrimaryType(JavaType paramJavaType, SerializationConfig paramSerializationConfig, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty, boolean paramBoolean)
  throws JsonMappingException
{
  Class localClass = paramJavaType.getRawClass();
  Object localObject;
  if (JsonSerializable.class.isAssignableFrom(localClass))
    if (JsonSerializableWithType.class.isAssignableFrom(localClass))
      localObject = StdSerializers.SerializableWithTypeSerializer.instance;
  do
  {
    return localObject;
    return StdSerializers.SerializableSerializer.instance;
    AnnotatedMethod localAnnotatedMethod = paramBasicBeanDescription.findJsonValueMethod();
    if (localAnnotatedMethod != null)
    {
      JsonSerializer localJsonSerializer = findSerializerFromAnnotation(paramSerializationConfig, localAnnotatedMethod, paramBeanProperty);
      return new JsonValueSerializer(localAnnotatedMethod.getAnnotated(), localJsonSerializer, paramBeanProperty);
    }
    if (InetAddress.class.isAssignableFrom(localClass))
      return InetAddressSerializer.instance;
    if (TimeZone.class.isAssignableFrom(localClass))
      return TimeZoneSerializer.instance;
    localObject = this.optionalHandlers.findSerializer(paramSerializationConfig, paramJavaType);
  }
  while (localObject != null);
  if (Number.class.isAssignableFrom(localClass))
    return StdSerializers.NumberSerializer.instance;
  if (Enum.class.isAssignableFrom(localClass))
    return EnumSerializer.construct(localClass, paramSerializationConfig, paramBasicBeanDescription);
  if (Calendar.class.isAssignableFrom(localClass))
    return StdSerializers.CalendarSerializer.instance;
  if (java.util.Date.class.isAssignableFrom(localClass))
    return StdSerializers.UtilDateSerializer.instance;
  return (JsonSerializer<?>)null;
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public StringBased(Class<?> valueClass, AnnotatedConstructor ctor,
                     AnnotatedMethod factoryMethod)
{
    _valueClass = valueClass;
    _ctor = (ctor == null) ? null : ctor.getAnnotated();
    _factoryMethod = (factoryMethod == null) ? null : factoryMethod.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public NumberBased(Class<?> valueClass,
                  AnnotatedConstructor intCtor, AnnotatedMethod ifm,
                  AnnotatedConstructor longCtor, AnnotatedMethod lfm)
{
    _valueClass = valueClass;
    _intCtor = (intCtor == null) ? null : intCtor.getAnnotated(); 
    _longCtor = (longCtor == null) ? null : longCtor.getAnnotated();
    _intFactoryMethod = (ifm == null) ? null : ifm.getAnnotated();
    _longFactoryMethod = (lfm == null) ? null : lfm.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public Delegating(AnnotatedConstructor ctor, AnnotatedMethod factory)
{
           if (ctor != null) {
               _ctor = ctor.getAnnotated();
               _factoryMethod = null;
               _valueType = TypeFactory.type(ctor.getParameterType(0));
           } else if (factory != null) {
               _ctor = null;
               _factoryMethod = factory.getAnnotated();
               _valueType = TypeFactory.type(factory.getParameterType(0));
           } else {
               throw new IllegalArgumentException("Internal error: neither delegating constructor nor factory method passed");
           }
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public final JsonSerializer<?> findSerializerByPrimaryType(JavaType paramJavaType, SerializationConfig paramSerializationConfig, BasicBeanDescription paramBasicBeanDescription, BeanProperty paramBeanProperty, boolean paramBoolean)
{
  Class localClass = paramJavaType.getRawClass();
  Object localObject;
  if (JsonSerializable.class.isAssignableFrom(localClass))
    if (JsonSerializableWithType.class.isAssignableFrom(localClass))
      localObject = SerializableWithTypeSerializer.instance;
  do
  {
    return localObject;
    return SerializableSerializer.instance;
    AnnotatedMethod localAnnotatedMethod = paramBasicBeanDescription.findJsonValueMethod();
    if (localAnnotatedMethod != null)
    {
      Method localMethod = localAnnotatedMethod.getAnnotated();
      if (paramSerializationConfig.isEnabled(SerializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS))
        ClassUtil.checkAndFixAccess(localMethod);
      return new JsonValueSerializer(localMethod, findSerializerFromAnnotation(paramSerializationConfig, localAnnotatedMethod, paramBeanProperty), paramBeanProperty);
    }
    if (InetAddress.class.isAssignableFrom(localClass))
      return InetAddressSerializer.instance;
    if (TimeZone.class.isAssignableFrom(localClass))
      return TimeZoneSerializer.instance;
    localObject = this.optionalHandlers.findSerializer(paramSerializationConfig, paramJavaType);
  }
  while (localObject != null);
  if (Number.class.isAssignableFrom(localClass))
    return StdSerializers.NumberSerializer.instance;
  if (Enum.class.isAssignableFrom(localClass))
    return EnumSerializer.construct(localClass, paramSerializationConfig, paramBasicBeanDescription);
  if (Calendar.class.isAssignableFrom(localClass))
    return CalendarSerializer.instance;
  if (java.util.Date.class.isAssignableFrom(localClass))
    return DateSerializer.instance;
  return null;
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public AnyGetterWriter(AnnotatedMethod paramAnnotatedMethod, MapSerializer paramMapSerializer)
{
  this._anyGetter = paramAnnotatedMethod.getAnnotated();
  this._serializer = paramMapSerializer;
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public MethodProperty(String paramString, JavaType paramJavaType, TypeDeserializer paramTypeDeserializer, Annotations paramAnnotations, AnnotatedMethod paramAnnotatedMethod)
{
  super(paramJavaType, paramTypeDeserializer, paramAnnotations);
  this._annotated = paramAnnotatedMethod;
  this._setter = paramAnnotatedMethod.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public SetterlessProperty(String paramString, JavaType paramJavaType, TypeDeserializer paramTypeDeserializer, Annotations paramAnnotations, AnnotatedMethod paramAnnotatedMethod)
{
  super(paramJavaType, paramTypeDeserializer, paramAnnotations);
  this._annotated = paramAnnotatedMethod;
  this._getter = paramAnnotatedMethod.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public FactoryBasedDeserializer(Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod)
{
  super();
  this._enumClass = paramClass;
  this._factory = paramAnnotatedMethod.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public SettableAnyProperty(BeanProperty paramBeanProperty, AnnotatedMethod paramAnnotatedMethod, JavaType paramJavaType)
{
  this._property = paramBeanProperty;
  this._type = paramJavaType;
  this._setter = paramAnnotatedMethod.getAnnotated();
}
 

import org.codehaus.jackson.map.introspect.AnnotatedMethod; //导入方法依赖的package包/类
public PropertyBased(AnnotatedConstructor paramAnnotatedConstructor, SettableBeanProperty[] paramArrayOfSettableBeanProperty1, AnnotatedMethod paramAnnotatedMethod, SettableBeanProperty[] paramArrayOfSettableBeanProperty2)
{
  SettableBeanProperty[] arrayOfSettableBeanProperty;
  if (paramAnnotatedConstructor != null)
  {
    this._ctor = paramAnnotatedConstructor.getAnnotated();
    this._factoryMethod = null;
    arrayOfSettableBeanProperty = paramArrayOfSettableBeanProperty1;
  }
  Object[] arrayOfObject;
  while (true)
  {
    this._properties = new HashMap();
    arrayOfObject = null;
    int i = 0;
    int j = arrayOfSettableBeanProperty.length;
    while (true)
      if (i < j)
      {
        SettableBeanProperty localSettableBeanProperty = arrayOfSettableBeanProperty[i];
        this._properties.put(localSettableBeanProperty.getName(), localSettableBeanProperty);
        if (localSettableBeanProperty.getType().isPrimitive())
        {
          if (arrayOfObject == null)
            arrayOfObject = new Object[j];
          arrayOfObject[i] = ClassUtil.defaultValue(localSettableBeanProperty.getType().getRawClass());
        }
        i++;
        continue;
        if (paramAnnotatedMethod != null)
        {
          this._ctor = null;
          this._factoryMethod = paramAnnotatedMethod.getAnnotated();
          arrayOfSettableBeanProperty = paramArrayOfSettableBeanProperty2;
          break;
        }
        throw new IllegalArgumentException("Internal error: neither delegating constructor nor factory method passed");
      }
  }
  this._defaultValues = arrayOfObject;
}