键名首字母自动排序
JAVA
<![CDATA[
static final Logger LOGGER = LoggerFactory.getLogger(SignPublisher.class);
private static final HashSet<Class<?>> primitiveClasses = new HashSet<>();
static {
primitiveClasses.add(boolean.class);
primitiveClasses.add(Boolean.class);
primitiveClasses.add(char.class);
primitiveClasses.add(Character.class);
primitiveClasses.add(byte.class);
primitiveClasses.add(Byte.class);
primitiveClasses.add(short.class);
primitiveClasses.add(Short.class);
primitiveClasses.add(int.class);
primitiveClasses.add(Integer.class);
primitiveClasses.add(long.class);
primitiveClasses.add(Long.class);
primitiveClasses.add(float.class);
primitiveClasses.add(Float.class);
primitiveClasses.add(double.class);
primitiveClasses.add(Double.class);
primitiveClasses.add(BigInteger.class);
primitiveClasses.add(BigDecimal.class);
primitiveClasses.add(String.class);
primitiveClasses.add(java.util.Date.class);
primitiveClasses.add(java.sql.Date.class);
primitiveClasses.add(java.sql.Time.class);
primitiveClasses.add(java.sql.Timestamp.class);
}
public static String generateHmacSource(Object obj) throws IllegalAccessException {
if (obj == null){
throw new IllegalArgumentException("the obj is null");
}
StringBuilder hmacSource = new StringBuilder();
append(obj,hmacSource);
LOGGER.debug("generateHmacSource hmacSource:{}",hmacSource.toString());
return hmacSource.toString();
}
private static void sortField(Class<?> clazz,List<String> fields){
Class<?> parent = clazz.getSuperclass();
if (parent != null){
sortField(parent,fields);
}
for (Field field : clazz.getDeclaredFields()) {
fields.add(field.getName());
}
Collections.sort(fields);
}
private static void append(Object entity,List<String> fields,StringBuilder hmacSource) throws IllegalAccessException {
Class<?> clazz = entity.getClass();
for (String fieldName : fields) {
Field field;
try {
field = clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
field = findParentField(entity,fieldName);
}
if (field == null || field.isSynthetic()){
continue;
}
field.setAccessible(true);
Object obj = field.get(entity);
Class<?> type = field.getType();
Type superType = field.getGenericType();
Class<?> genericClass = null;
if(superType instanceof ParameterizedType){
Type[] genericType = ((ParameterizedType)superType).getActualTypeArguments();
genericClass = (Class<?>) genericType[0];
}
if (type.isArray()){
Object[] objects = (Object[]) obj;
if (objects != null && objects.length > 0){
for (Object object : objects) {
append(object,hmacSource);
}
}
}else if(obj instanceof Collection){
Collection collection = (Collection)obj;
Iterator it = collection.iterator();
while (it.hasNext()){
Object next = it.next();
if (genericClass != null && isPrimitiveClass(genericClass)) {
hmacSource.append(next).append("#");
}else
append(next,hmacSource);
}
}else if(obj instanceof Map){
Map map = (Map)obj;
Iterator it = map.keySet().iterator();
while (it.hasNext()){
Object key = it.next();
Object value = map.get(key);
append(value,hmacSource);
}
}else if (obj instanceof Enum){
String strTmp = StringUtils.defaultString(obj.toString(), "");
if (StringUtils.isBlank(strTmp)){
continue;
}else {
hmacSource.append(strTmp).append("#");
}
}else if(isPrimitiveClass(type)){
Object tmp = ObjectUtils.defaultIfNull(obj, "");
if (StringUtils.isBlank(tmp.toString())) {
continue;
} else {
hmacSource.append(tmp).append("#");
}
}else{
if(obj != null){
append(obj,hmacSource);
}
}
}
}
private static void append(Object obj,StringBuilder hmacSource) throws IllegalAccessException {
if(obj == null) return;
List<String> fields = new ArrayList<String>();
Class<?> clazz = obj.getClass();
sortField(clazz,fields);
append(obj,fields,hmacSource);
}
private static Field findParentField(Object obj,String fieldName){
Class parent = obj.getClass().getSuperclass();
Field field = null;
while (parent != null && parent != Object.class){
try {
field = parent.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
parent = parent.getSuperclass();
}
if (field != null) break;
}
return field;
}
private static boolean isPrimitiveClass(Class<?> clazz) {
return clazz != null && primitiveClasses.contains(clazz);
}
]]>
PHP
<![CDATA[
/**
protected function buildJson($para=null)
{
$vars = $para?'':get_object_vars($this);
unset($vars['response_hmac_fields']);
$data = array();
foreach($vars as $k=>$var){
if(is_scalar($var) && $var !== '' && $var !== null){
$data[$k] = $var;
}else if(is_object($var) && $var instanceof AbstractModel){
$data[$k] =array_filter((array) $var);
}else if(is_array($var)){
$data[$k] =array_filter($var);
}
if(empty($data[$k])){
unset($data[$k]);
}
}
ksort($encrypt_str);
$hmacSource = '';
foreach($encrypt_str as $key => $value){
if (is_array($value)) {
ksort($value);
foreach ($value as $key2 => $value2) {
if (is_object($value2)) {
$value2 = array_filter((array)$value2);
ksort($value2);
foreach ($value2 as $oKey => $oValue) {
$oValue .= '#';
$hmacSource .= trim($oValue);
}
} else if(is_array($value2)){
ksort($value2);
foreach ($value2 as $key3 => $value3) {
if (is_object($value3)) {
$value3 = array_filter((array)$value3);
ksort($value3);
foreach ($value3 as $oKey => $oValue) {
$oValue .= '#';
$hmacSource .= trim($oValue);
}
} else{
$value3 .= '#';
$hmacSource .= trim($value3);
}
}
} else{
$value2 .= '#';
$hmacSource .= trim($value2);
}
}
} else {
$value .= '#';
$hmacSource .= trim($value);
}
}
return $hmacSource;
}
]]>
C#
<![CDATA[
var a = JObject.Parse(order.Json); //将a 中的json 解码
string hm = string.Join("", GetValue.Getvalue1(a));
public static List<string> Getvalue1(object inp)
{
var res = new List<string>();
var t = new SortedDictionary<string, JToken>();
switch (inp.GetType().Name)
{
case "JValue":
res.Add(string.Format("{0}", (inp as JValue).Value));
break;
case "JObject":
foreach (var x in (inp as JObject)) t.Add(x.Key, x.Value);
foreach (var x in t)
{
res.AddRange(Getvalue1(x.Value));
if (x.Value is JObject)
{}
else if (x.Value is JArray)
{ }
else
{
if (String.IsNullOrEmpty(x.Value.ToString()))
{}
else
{ res.Add("#");}
} }
break;
case "JArray":
foreach (var x in (inp as JArray)) res.AddRange(Getvalue1(x));
break;
}
return res;
}
]]>
GOLang
<![CDATA[
//根据JSON字符串进行排序后返回顺序拼接字符串
func GetMapSortJson(jsonstr string) (string, error){
map2 := getMapFromJson(jsonstr)
var recResult string
var erro error
//1.定义一个slice
s1 := make([]string, 0, len(map2))
//2.遍历map获取key-->s1中
for key := range map2 {
s1 = append(s1, key)
}
//3.给s1进行排序
//使用sort包下的方法直接排序，不用自己写冒泡了。
sort.Strings(s1)
//4. 遍历s1，map
for _, k := range s1 { // 先下标，再数值
//fmt.Println("type:", reflect.TypeOf(map2[k]))
switch value := map2[k].(type) {
case nil:
fmt.Println(k, "is nil", "null")
case int:
recResult = recResult + strconv.Itoa(value)+"#"
case float64:
recResult = recResult + strconv.FormatFloat(value, 'f', -1, 64)+"#"
case string:
if value != ""{
recResult = recResult + value+"#"
}
case bool:
recResult = recResult +strconv.FormatBool(value)+"#"
case []interface{}:
for _, u := range value {
//fmt.Println("utype:", reflect.TypeOf(u))
if _, ok := u.(map[string]interface {}); ok != true {
recResult = recResult + u.(string) +"#"
}else{
b, berror := json.Marshal(u)
if berror != nil {
erro = berror
}
rec,erro2 := GetMapSortJson(string(b))
if erro2 != nil {
erro = erro2
}
recResult = recResult + rec
}
}
case map[string]interface{}:
b, berror := json.Marshal(value)
if berror != nil {
fmt.Print("berror:", berror)
}
fmt.Println("b:", string(b))
rec,erro2 := GetMapSortJson(string(b))
if erro2 != nil {
erro = erro2
}
recResult = recResult + rec
default:
va := value.(string)
fmt.Println("va:", va)
if va != ""{
recResult = recResult + va+"#"
}
}
}
return recResult,erro
}
]]>
Python
<![CDATA[
def get_sort(dic):
dics2 = ''
dics = dict(sorted(dic.items(),reverse=False))
print("dics-----------------:",dics)
for dics1 in dics :
print(dics1,type(dics[dics1]))
if isinstance(dics[dics1],dict):
dict12 = dics[dics1]
dics2+=get_sort(dict12)
elif isinstance(dics[dics1],str):
if(dics[dics1].strip() !=""):
dics2+=dics[dics1]+'#'
elif type(dics[dics1]).__name__ == "bool":
str_bool = str(dics[dics1])
str_bool_lower = str_bool.lower()
print("bool---------------------;",str_bool_lower)
dics2+=str_bool_lower+'#'
elif type(dics[dics1]).__name__ == "int":
dics2+=str(dics[dics1])+'#'
elif isinstance(dics[dics1],list):
dict12 = dics[dics1]
dic_list = {}
for i in range(len(dict12)):
dic_list.setdefault(i, dict12[i])
print("dic_list------------------:",dic_list)
dics2+=get_sort(dic_list)
return dics2
]]>