JakeWharton/AutoGson.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface AutoGson {
  // A reference to the AutoValue-generated class (e.g. AutoValue_MyClass). This is
  // necessary to handle obfuscation of the class names.
  public Class autoValueClass();
}

public class AutoValueTypeAdapterFactory implements TypeAdapterFactory {
  @Override
  public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<T> rawType = (Class<T>) type.getRawType();

    AutoGson annotation = rawType.getAnnotation(AutoGson.class);
    // Only deserialize classes decorated with @AutoGson.
    if (annotation == null) {
      return null;
    }

    return (TypeAdapter<T>) gson.getAdapter(annotation.autoValueClass());
  }
}

  @AutoValue 
  @AutoGson(autoValueClass = AutoValue_Main_Test.class)
  public abstract static class Test {
    public static Test of(String firstName, String lastName, int age) {
      return new AutoValue_Main_Test(firstName, lastName, age);
    }

    public abstract String firstName();
    public abstract String lastName();
    public abstract int age();
  }

import com.google.auto.value.AutoValue;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import org.junit.Before;
import org.junit.Test;

import static com.google.common.truth.Truth.assert_;

public class AutoValueAdapterFactoryTest {

    private Gson mGson;

    @AutoValue
    @AutoGson(autoValueClass = AutoValue_AutoValueAdapterFactoryTest_Some.class)
    public abstract static class Some {
        public static Some of(String firstName, String lastName, int age) {
            return new AutoValue_AutoValueAdapterFactoryTest_Some(firstName, lastName, age);
        }

        public abstract String firstName();
        public abstract String lastName();
        public abstract int age();
    }

    @Before
    public void setUp() throws Exception {
        mGson = new GsonBuilder()
                .registerTypeAdapterFactory(new AutoValueAdapterFactory())
                .create();
    }

    @Test
    public void testParsing() throws Exception {
        final Some inSome = Some.of("John", "Doe", 100);
        final String json = mGson.toJson(inSome);
        final Some outSome = mGson.fromJson(json, Some.class);

        assert_().that(outSome).isEqualTo(inSome);
    }

}

public final class AutoValueAdapterFactory implements TypeAdapterFactory {
  @SuppressWarnings("unchecked")
  @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    Class<? super T> rawType = type.getRawType();

    // If it's an abstract class, it's likely to be an AutoValue
    int m = rawType.getModifiers();
    if (!Modifier.isAbstract(m)) {
        return null;
    }

    String packageName = rawType.getPackage().getName();
    String className = rawType.getName().substring(packageName.length() + 1).replace('$', '_');
    String autoValueName = packageName + ".AutoValue_" + className;

    try {
      Class<?> autoValueType = Class.forName(autoValueName);
      return (TypeAdapter<T>) gson.getAdapter(autoValueType);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException("Could not load AutoValue type " + autoValueName, e);
    }
  }
}

@AutoValue @AutoGson
public abstract static class Some<T> {
  public static Some <X> of(String firstName, String lastName, int age, X genericData) {
    return new AutoValue_Main_Test<>(firstName, lastName, age, genericData);
  }

  public abstract String firstName();
  public abstract String lastName();
  public abstract int age();
  public abstract T genericData();
}

public class People {
  List<Some<Map<String,String>> someList;
}