com.alibaba.fastjson.annotation.JSONField Java Examples

/**
 * <p class="detail">
 * 功能:判断字段类型是否为时间类型,若字段写了多个注解则优先级为DateTimeFormat(spring)>JSONField(fastjson)>JsonFormat(jackson),异常就返回""
 * </p>
 *
 * @param className :类名
 * @param fieldName :字段名
 * @return boolean
 * @author Kings
 * @date 2019.11.02
 */
private String getDayPattern(String className, String fieldName) {
    try {
        Class<?> parseClass = Class.forName(className);
        DateTimeFormat dateTimeFormat = parseClass.getDeclaredField(fieldName).getAnnotation(DateTimeFormat.class);
        if (dateTimeFormat != null) {
            return dateTimeFormat.pattern();
        }
        JSONField jsonField = parseClass.getDeclaredField(fieldName).getAnnotation(JSONField.class);
        if (jsonField != null) {
            return jsonField.format();
        }
        JsonFormat jsonFormat = parseClass.getDeclaredField(fieldName).getAnnotation(JsonFormat.class);
        if (jsonFormat != null) {
            return jsonFormat.pattern();
        }
        return "";
    } catch (Exception e) {
        return "";
    }
}
 

/**
 * <p class="detail">
 * 功能:判断字段类型是否为时间类型,若字段写了多个注解则优先级为DateTimeFormat(spring)>JSONField(fastjson)>JsonFormat(jackson),异常就返回""
 * </p>
 *
 * @param className :类名
 * @param fieldName :字段名
 * @return boolean
 * @author Kings
 * @date 2019.11.02
 */
private String getDayPattern(String javaDirPath,String className, String fieldName) {
    try {
        Class<?> parseClass = getCompileClass(javaDirPath,className);
        DateTimeFormat dateTimeFormat = parseClass.getDeclaredField(fieldName).getAnnotation(DateTimeFormat.class);
        if (dateTimeFormat != null) {
            return dateTimeFormat.pattern();
        }
        JSONField jsonField = parseClass.getDeclaredField(fieldName).getAnnotation(JSONField.class);
        if (jsonField != null) {
            return jsonField.format();
        }
        JsonFormat jsonFormat = parseClass.getDeclaredField(fieldName).getAnnotation(JsonFormat.class);
        if (jsonFormat != null) {
            return jsonFormat.pattern();
        }
        
        return "";
    } catch (Exception e) {
        return "";
    }
}
 

/**
 * Gets a query that can be used to query the subclass objects in this relation.
 *
 * @param clazz The AVObject subclass.
 * @return A AVQuery that restricts the results to objects in this relations.
 */
@JSONField(serialize=false)
public AVQuery<T> getQuery(Class<T> clazz) {
  if (getParent() == null || StringUtil.isEmpty(getParent().getObjectId())) {
    throw new IllegalStateException("unable to encode an association with an unsaved AVObject");
  }

  Map<String, Object> map = new HashMap<String, Object>();
  map.put("object", Utils.mapFromPointerObject(AVRelation.this.getParent()));
  map.put("key", AVRelation.this.getKey());

  String targetClassName = getTargetClass();
  if (StringUtil.isEmpty(targetClassName)) {
    targetClassName = getParent().getClassName();
  }
  AVQuery<T> query = new AVQuery<T>(targetClassName, clazz);
  query.addWhereItem("$relatedTo", null, map);
  if (StringUtil.isEmpty(getTargetClass())) {
    query.getParameters().put("redirectClassNameForKey", this.getKey());
  }

  return query;
}
 

public MyFieldSerializer(FieldInfo fieldInfo){
    
    this.fieldInfo = fieldInfo;
    fieldInfo.setAccessible(true);

    this.double_quoted_fieldPrefix = '"' + fieldInfo.getName() + "\":";

    this.single_quoted_fieldPrefix = '\'' + fieldInfo.getName() + "\':";

    this.un_quoted_fieldPrefix = fieldInfo.getName() + ":";

    JSONField annotation = fieldInfo.getAnnotation(JSONField.class);
    if (annotation != null) {
        for (SerializerFeature feature : annotation.serialzeFeatures()) {
            if (feature == SerializerFeature.WriteMapNullValue) {
                writeNull = true;
            }
        }
    }
}
 

@JSONField(serialize = false)
public Map<String, String> getRmqProperties() {
    HashMap<String, String> propertyMap = new HashMap<>();
    if (StringUtils.isNotBlank(getKey()))
        propertyMap.put(MessageConst.PROPERTY_KEYS, getKey());
    if (StringUtils.isNotBlank(getTags()))
        propertyMap.put(MessageConst.PROPERTY_TAGS, getTags());
    propertyMap.put(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX, createUniqID());

    Map<String, String> msgProperties = this.getMsgProperties();
    if (msgProperties != null) {
        propertyMap.putAll(msgProperties);
    }

    // PROPERTY_WAIT_STORE_MSG_OK 这个属性没用。
    //propertyMap.put(MessageConst.PROPERTY_WAIT_STORE_MSG_OK, Boolean.toString(true));
    return propertyMap;
}
 

/**
 * Get data stream in blocking mode.
 * @return data stream.
 * @throws Exception for file not found or io problem.
 */
@JSONField(serialize = false)
public InputStream getDataStream() throws Exception {
  String filePath = "";
  if(!StringUtil.isEmpty(localPath)) {
    filePath = localPath;
  } else if (!StringUtil.isEmpty(cachePath)) {
    filePath = cachePath;
  } else if (!StringUtil.isEmpty(getUrl())) {
    File cacheFile = FileCache.getIntance().getCacheFile(getUrl());
    if (null == cacheFile || !cacheFile.exists()) {
      FileDownloader downloader = new FileDownloader();
      downloader.execute(getUrl(), cacheFile);
    }
    if (null != cacheFile) {
      filePath = cacheFile.getAbsolutePath();
    }
  }
  if(!StringUtil.isEmpty(filePath)) {
    logger.d("dest file path=" + filePath);
    return FileCache.getIntance().getInputStreamFromFile(new File(filePath));
  }
  logger.w("failed to get dataStream.");
  return null;
}
 

@JSONField(serialize = false)
public Endpoint getEndpoint() {
  Endpoint endpoint = new Endpoint();
  endpoint.setIp(ip);
  endpoint.setPort(port);
  return endpoint;
}
 

@JSONField(serialize = false)
public Map<Long, List<Long>> getConsumeModeLongMapper() {
    if (MapUtils.isEmpty(consumeModeMapper)) {
        return null;
    }
    Map<Long, List<Long>> mapper = Maps.newHashMap();
    for (Map.Entry<String, List<Long>> entry : consumeModeMapper.entrySet()) {
        mapper.put(Long.parseLong(entry.getKey()), Lists.newArrayList(entry.getValue()));
    }
    return mapper;
}
 

/**
 * 读取get set方法
 * 
 * @param cls
 * @param methods
 * @param fmmap
 * @param haveJSONField
 */
private static void register(Class<?> cls, Method[] methods, Map<String, FieldMethod> fmmap,
		boolean haveJSONField) {
	Field[] fields = cls.getDeclaredFields();
	for (Field field : fields) {
		try {
			if (Modifier.isStatic(field.getModifiers())) {
				continue;
			}
			JSONField fieldAnnotation = field.getAnnotation(JSONField.class);
			if (haveJSONField && fieldAnnotation == null) {
				continue;
			}
			String fieldGetName = parGetName(field);
			String fieldSetName = ReflectUtil.parSetName(field);
			Method fieldGetMet = getGetMet(methods, fieldGetName);
			Method fieldSetMet = ReflectUtil.getSetMet(methods, fieldSetName);
			if (fieldGetMet != null && fieldSetMet != null) {
				FieldMethod fgm = new FieldMethod(fieldGetMet, fieldSetMet, field);
				fmmap.put(fgm.getName(), fgm);
			} else {
				System.out.println("找不到set或get方法 " + cls.getName() + " field:" + field.getName());
			}
		} catch (Exception e) {
			System.out.println("register field:" + cls.getName() + ":" + field.getName() + " " + e);
			continue;
		}
	}
	Class<?> scls = cls.getSuperclass();
	if (scls != null) {
		register(scls, scls.getDeclaredMethods(), fmmap, haveJSONField);
	}
}
 

@JSONField(serialize = false)
public void setEncryptPassword(String password) {
    if(StringUtils.isNotBlank(password)){
        this.password = DbConfigEncryption.encrypt(password);
    }else{
        this.password = "";
    }
}
 

private static String getJSONFieldName(Field field) {
    JSONField annotation = field.getAnnotation(JSONField.class);
    if(annotation!=null){
        return annotation.name();
    }
    return UNKNOWN;
}
 

@JSONField(serialize = false)
public RemotingCommandType getType() {
    if (this.isResponseType()) {
        return RemotingCommandType.RESPONSE_COMMAND;
    }

    return RemotingCommandType.REQUEST_COMMAND;
}
 

@JSONField(serialize = false)
public Map<Long, List<Long>> getConsumeModeLongMapper() {
    if (MapUtils.isEmpty(consumeModeMapper)) {
        return null;
    }
    Map<Long, List<Long>> mapper = Maps.newHashMap();
    for (Map.Entry<String, List<Long>> entry : consumeModeMapper.entrySet()) {
        mapper.put(Long.parseLong(entry.getKey()), Lists.newArrayList(entry.getValue()));
    }
    return mapper;
}
 

/**
 * 获取参数Key Set
 * @return
 */
@JSONField(serialize=false)
public Set<String> getParamKeys() {
    if (operationParam == null) {
        return new HashSet<>(0);
    }

    return operationParam.keySet();
}
 

public DefaultFieldDeserializer(ParserConfig config, Class<?> clazz, FieldInfo fieldInfo){
    super(clazz, fieldInfo);
    JSONField annotation = fieldInfo.getAnnotation();
    if (annotation != null) {
        Class<?> deserializeUsing = annotation.deserializeUsing();
        customDeserilizer = deserializeUsing != null && deserializeUsing != Void.class;
    }
}
 

/**
 * Get request endpoint.
 * @return endpoint.
 */
@JSONField(serialize = false)
public String getRequestRawEndpoint() {
  if (StringUtil.isEmpty(getObjectId())) {
    return "/1.1/classes/" + this.getClassName();
  } else {
    return "/1.1/classes/" + this.getClassName() + "/" + getObjectId();
  }
}
 

@JsonIgnore
@JSONField(serialize = false, deserialize = false)
public void deserializeFields() {
    this.skillList = JSONObject.parseObject(skillStr, new TypeReference<List<SkillRule>>(){});
}
 

@JSONField(name="_id")
public String get_id() {
    return _id;
}
 

@JSONField(name="_id")
public void set_id(String _id) {
    this._id = _id;
}
 

@JSONField(ordinal = 6)
public Permission getIssue() {
    return issue;
}
 

@JSONField(name="media_id")
public String getMediaId() {
	return mediaId;
}
 

/**
 * 是否是rpc-oneway
 * @return ;
 */
@JSONField(serialize = false)
public boolean isOnewayRPC() {
    int bits = 1 << RPC_ONEWAY;
    return (this.flag & bits) == bits;
}
 

@JSONField(name = "total_supply")
public String getTotalSupply() {
    return totalSupply.toString();
}
 

/**
 * 获取通过此类型请求而获取到的参数的返回值的类型
 */
@Override
@JSONField(serialize = false)
default Class<? extends GroupInfo> resultType(){
    return GroupInfo.class;
}
 

/**
 * 获取通过此类型请求而获取到的参数的返回值的类型
 */
@Override
@JSONField(serialize = false)
default Class<? extends GroupMemberInfo> resultType(){
    return GroupMemberInfo.class;
}
 

/**
 * 获取通过此类型请求而获取到的参数的返回值的类型
 */
@Override
@JSONField(serialize = false)
default Class<? extends BanList> resultType(){
    return BanList.class;
}
 

@Override
@JSONField(deserialize = false, serialize = false)
public String getDomain() {
    return super.getDomain();
}
 

/**
 * 获取通过此类型请求而获取到的参数的返回值的类型
 */
@Override
@JSONField(serialize = false)
default Class<? extends GroupTopNote> resultType(){
    return GroupTopNote.class;
}
 

@JSONField(serialize = false)
public HttpServletRequest getOriginRequest() {
    return originRequest;
}
 

@JSONField(name = "Device")
public String getDevice() {
	return Device;
}