Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind;
  
Class that defines how names of JSON properties ("external names") are derived from names of POJO methods and fields ("internal names"), in cases where they are not auto-detected and no explicit annotations exist for naming. Methods are passed information about POJO member for which name is needed, as well as default name that would be used if no custom strategy was used.

Default implementation returns suggested ("default") name unmodified.

Note that the strategy is guaranteed to be called once per logical property (which may be represented by multiple members; such as pair of a getter and a setter), but may be called for each: implementations should not count on exact number of times, and should work for any member that represent a property.

In absence of a registered custom strategy, default Java property naming strategy is used, which leaves field names as is, and removes set/get/is prefix from methods (as well as lower-cases initial sequence of capitalized characters).

 
 @SuppressWarnings("serial")
 public abstract class PropertyNamingStrategy
     implements java.io.Serializable
 {
     /*
     /**********************************************************
     /* API
     /**********************************************************
      */

    
Method called to find external name (name used in JSON) for given logical POJO property, as defined by given field.

Parameters:
config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
field Field used to access property
defaultName Default name that would be used for property in absence of custom strategy
Returns:
Logical name to use for property that the field represents
 
     public String nameForField(MapperConfig<?> configAnnotatedField field,
             String defaultName)
     {
         return defaultName;
     }

    
Method called to find external name (name used in JSON) for given logical POJO property, as defined by given getter method; typically called when building a serializer. (but not always -- when using "getter-as-setter", may be called during deserialization)

Parameters:
config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
method Method used to access property.
defaultName Default name that would be used for property in absence of custom strategy
Returns:
Logical name to use for property that the method represents
 
     public String nameForGetterMethod(MapperConfig<?> configAnnotatedMethod method,
             String defaultName)
     {
         return defaultName;
     }

    
Method called to find external name (name used in JSON) for given logical POJO property, as defined by given setter method; typically called when building a deserializer (but not necessarily only then).

Parameters:
config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
method Method used to access property.
defaultName Default name that would be used for property in absence of custom strategy
Returns:
Logical name to use for property that the method represents
 
     public String nameForSetterMethod(MapperConfig<?> configAnnotatedMethod method,
             String defaultName)
     {
         return defaultName;
     }

    
Method called to find external name (name used in JSON) for given logical POJO property, as defined by given constructor parameter; typically called when building a deserializer (but not necessarily only then).

Parameters:
config Configuration in used: either SerializationConfig or DeserializationConfig, depending on whether method is called during serialization or deserialization
ctorParam Constructor parameter used to pass property.
defaultName Default name that would be used for property in absence of custom strategy
    public String nameForConstructorParameter(MapperConfig<?> configAnnotatedParameter ctorParam,
            String defaultName)
    {
        return defaultName;
    }
    /*
    /**********************************************************
    /* Standard implementations 
    /**********************************************************
     */
    
    public static abstract class PropertyNamingStrategyBase extends PropertyNamingStrategy
    {
        @Override
        public String nameForField(MapperConfig<?> configAnnotatedField fieldString defaultName)
        {
            return translate(defaultName);
        }
        @Override
        public String nameForGetterMethod(MapperConfig<?> configAnnotatedMethod methodString defaultName)
        {
            return translate(defaultName);
        }
        @Override
        public String nameForSetterMethod(MapperConfig<?> configAnnotatedMethod methodString defaultName)
        {
            return translate(defaultName);
        }
        @Override
        public String nameForConstructorParameter(MapperConfig<?> configAnnotatedParameter ctorParam,
                String defaultName)
        {
            return translate(defaultName);
        }
        
        public abstract String translate(String propertyName);
    }
        
    
    /*
    /**********************************************************
    /* Standard implementations 
    /**********************************************************
     */

    
        new LowerCaseWithUnderscoresStrategy();
    
    
A PropertyNamingStrategy that translates typical camel case Java property names to lower case JSON element names, separated by underscores. This implementation is somewhat lenient, in that it provides some additional translations beyond strictly translating from camel case only. In particular, the following translations are applied by this PropertyNamingStrategy.
  • Every upper case letter in the Java property name is translated into two characters, an underscore and the lower case equivalent of the target character, with three exceptions.
    1. For contiguous sequences of upper case letters, characters after the first character are replaced only by their lower case equivalent, and are not preceded by an underscore.
      • This provides for reasonable translations of upper case acronyms, e.g., "theWWW" is translated to "the_www".
    2. An upper case character in the first position of the Java property name is not preceded by an underscore character, and is translated only to its lower case equivalent.
      • For example, "Results" is translated to "results", and not to "_results".
    3. An upper case character in the Java property name that is already preceded by an underscore character is translated only to its lower case equivalent, and is not preceded by an additional underscore.
      • For example, "user_Name" is translated to "user_name", and not to "user__name" (with two underscore characters).
  • If the Java property name starts with an underscore, then that underscore is not included in the translated name, unless the Java property name is just one character in length, i.e., it is the underscore character. This applies only to the first character of the Java property name.
These rules result in the following additional example translations from Java property names to JSON element names.
  • "userName" is translated to "user_name"
  • "UserName" is translated to "user_name"
  • "USER_NAME" is translated to "user_name"
  • "user_name" is translated to "user_name" (unchanged)
  • "user" is translated to "user" (unchanged)
  • "User" is translated to "user"
  • "USER" is translated to "user"
  • "_user" is translated to "user"
  • "_User" is translated to "user"
  • "__user" is translated to "_user" (the first of two underscores was removed)
  • "user__name" is translated to "user__name" (unchanged, with two underscores)
    public static class LowerCaseWithUnderscoresStrategy extends PropertyNamingStrategyBase
    {
        @Override
        public String translate(String input)
        {
            if (input == nullreturn input// garbage in, garbage out
            int length = input.length();
            StringBuilder result = new StringBuilder(length * 2);
            int resultLength = 0;
            boolean wasPrevTranslated = false;
            for (int i = 0; i < lengthi++)
            {
                char c = input.charAt(i);
                if (i > 0 || c != '_'// skip first starting underscore
                {
                    if (Character.isUpperCase(c))
                    {
                        if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_')
                        {
                            result.append('_');
                            resultLength++;
                        }
                        c = Character.toLowerCase(c);
                        wasPrevTranslated = true;
                    }
                    else
                    {
                        wasPrevTranslated = false;
                    }
                    result.append(c);
                    resultLength++;
                }
            }
            return resultLength > 0 ? result.toString() : input;
        }
    }
    
    
See PropertyNamingStrategy.PascalCaseStrategy for details.

Since:
2.1
    public static final PropertyNamingStrategy PASCAL_CASE_TO_CAMEL_CASE =
        new PascalCaseStrategy();
    
    
A PropertyNamingStrategy that translates typical camelCase Java property names to PascalCase JSON element names (i.e., with a capital first letter). In particular, the following translations are applied by this PropertyNamingStrategy.
  • The first lower-case letter in the Java property name is translated into its equivalent upper-case representation.
This rules result in the following example translation from Java property names to JSON element names.
  • "userName" is translated to "UserName"

Since:
2.1
    public static class PascalCaseStrategy extends PropertyNamingStrategyBase
    {
    
Converts camelCase to PascalCase For example, "userName" would be converted to "UserName".

Parameters:
input formatted as camelCase string
Returns:
input converted to PascalCase format
    	@Override
    	public String translate(String input) {
    	    if (input == null || input.length() == 0){
    	        return input// garbage in, garbage out
    	    }
    	    // Replace first lower-case letter with upper-case equivalent
    	    char c = input.charAt(0);
    	    if (Character.isUpperCase(c)) {
    	        return input;
    	    }
    	    StringBuilder sb = new StringBuilder(input);
    	    sb.setCharAt(0, Character.toUpperCase(c));
    	    return sb.toString();
    	}	
    }
New to GrepCode? Check out our FAQ X