void cacheMeasurementClass(final Class<?>... classVarAgrs) {
  for (Class<?> clazz : classVarAgrs) {
    if (CLASS_FIELD_CACHE.containsKey(clazz.getName())) {
      continue;
    }
    ConcurrentMap<String, Field> initialMap = new ConcurrentHashMap<>();
    ConcurrentMap<String, Field> influxColumnAndFieldMap = CLASS_FIELD_CACHE.putIfAbsent(clazz.getName(), initialMap);
    if (influxColumnAndFieldMap == null) {
      influxColumnAndFieldMap = initialMap;
    }

    Class<?> c = clazz;
    while (c != null) {
      for (Field field : c.getDeclaredFields()) {
        Column colAnnotation = field.getAnnotation(Column.class);
        if (colAnnotation != null) {
          influxColumnAndFieldMap.put(colAnnotation.name(), field);
        }
      }
      c = c.getSuperclass();
    }
  }
}
 

/**
 * Adds field map from object by reflection using {@link org.influxdb.annotation.Column}
 * annotation.
 *
 * @param pojo POJO Object with annotation {@link org.influxdb.annotation.Column} on fields
 * @return the Builder instance
 */
public Builder addFieldsFromPOJO(final Object pojo) {

  Class<? extends Object> clazz = pojo.getClass();
  while (clazz != null) {

    for (Field field : clazz.getDeclaredFields()) {

      Column column = field.getAnnotation(Column.class);

      if (column == null) {
        continue;
      }

      field.setAccessible(true);
      String fieldName = column.name();
      addFieldByAttribute(pojo, field, column, fieldName);
    }
  clazz = clazz.getSuperclass();
}

  if (this.fields.isEmpty()) {
    throw new BuilderException("Class " + pojo.getClass().getName()
        + " has no @" + Column.class.getSimpleName() + " annotation");
  }

  return this;
}
 

private void addFieldByAttribute(final Object pojo, final Field field, final Column column,
    final String fieldName) {
  try {
    Object fieldValue = field.get(pojo);

    TimeColumn tc = field.getAnnotation(TimeColumn.class);
    if (tc != null && Instant.class.isAssignableFrom(field.getType())) {
      Optional.ofNullable((Instant) fieldValue).ifPresent(instant -> {
        TimeUnit timeUnit = tc.timeUnit();
        if (timeUnit == TimeUnit.NANOSECONDS || timeUnit == TimeUnit.MICROSECONDS) {
          this.time = BigInteger.valueOf(instant.getEpochSecond())
                                .multiply(NANOSECONDS_PER_SECOND)
                                .add(BigInteger.valueOf(instant.getNano()))
                                .divide(BigInteger.valueOf(TimeUnit.NANOSECONDS.convert(1, timeUnit)));
        } else {
          this.time = TimeUnit.MILLISECONDS.convert(instant.toEpochMilli(), timeUnit);
          this.precision = timeUnit;
        }
        this.precision = timeUnit;
      });
      return;
    }

    if (column.tag()) {
      if (fieldValue != null) {
        this.tags.put(fieldName, (String) fieldValue);
      }
    } else {
      if (fieldValue != null) {
        this.fields.put(fieldName, fieldValue);
      }
    }

  } catch (IllegalArgumentException | IllegalAccessException e) {
    // Can not happen since we use metadata got from the object
    throw new BuilderException(
        "Field " + fieldName + " could not found on class " + pojo.getClass().getSimpleName());
  }
}
 

public <T> void save(final T model) {
  throwExceptionIfMissingAnnotation(model.getClass());
  cacheMeasurementClass(model.getClass());

  ConcurrentMap<String, Field> colNameAndFieldMap = getColNameAndFieldMap(model.getClass());

  try {
    Class<?> modelType = model.getClass();
    String measurement = getMeasurementName(modelType);
    String database = getDatabaseName(modelType);
    String retentionPolicy = getRetentionPolicy(modelType);
    TimeUnit timeUnit = getTimeUnit(modelType);
    long time = timeUnit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    Point.Builder pointBuilder = Point.measurement(measurement).time(time, timeUnit);

    for (String key : colNameAndFieldMap.keySet()) {
      Field field = colNameAndFieldMap.get(key);
      Column column = field.getAnnotation(Column.class);
      String columnName = column.name();
      Class<?> fieldType = field.getType();

      if (!field.isAccessible()) {
        field.setAccessible(true);
      }

      Object value = field.get(model);

      if (column.tag()) {
        /** Tags are strings either way. */
        pointBuilder.tag(columnName, value.toString());
      } else if ("time".equals(columnName)) {
        if (value != null) {
          setTime(pointBuilder, fieldType, timeUnit, value);
        }
      } else {
        setField(pointBuilder, fieldType, columnName, value);
      }
    }

    Point point = pointBuilder.build();

    if ("[unassigned]".equals(database)) {
      influxDB.write(point);
    } else {
      influxDB.write(database, retentionPolicy, point);
    }

  } catch (IllegalAccessException e) {
    throw new InfluxDBMapperException(e);
  }
}