public class MyNameResolverProvider extends NameResolverProvider {

  /**
   * The constant containing the scheme that will be used by this factory.
   */
  public static final String STATIC_SCHEME = "static";

  private static final Pattern PATTERN_COMMA = Pattern.compile(",");

  @Nullable
  @Override
  public NameResolver newNameResolver(final URI targetUri, final NameResolver.Args args) {
    if (STATIC_SCHEME.equals(targetUri.getScheme())) {
      return of(targetUri.getAuthority(), args.getDefaultPort());
    }
    return null;
  }

  /**
   * Creates a new {@link NameResolver} for the given authority and attributes.
   *
   * @param targetAuthority The authority to connect to.
   * @param defaultPort The default port to use, if none is specified.
   * @return The newly created name resolver for the given target.
   */
  private NameResolver of(final String targetAuthority, int defaultPort) {
    requireNonNull(targetAuthority, "targetAuthority");
    // Determine target ips
    final String[] hosts = PATTERN_COMMA.split(targetAuthority);
    final List<EquivalentAddressGroup> targets = new ArrayList<>(hosts.length);
    for (final String host : hosts) {
      final URI uri = URI.create("//" + host);
      int port = uri.getPort();
      if (port == -1) {
        port = defaultPort;
      }
      targets.add(new EquivalentAddressGroup(new InetSocketAddress(uri.getHost(), port)));
    }
    if (targets.isEmpty()) {
      throw new IllegalArgumentException("Must have at least one target, but was: " + targetAuthority);
    }
    return new MyStaticNameResolver(targetAuthority, targets);
  }

  @Override
  public String getDefaultScheme() {
    return STATIC_SCHEME;
  }

  @Override
  protected boolean isAvailable() {
    return true;
  }

  @Override
  protected int priority() {
    return 4; // Less important than DNS
  }

  @Override
  public String toString() {
    return "StaticNameResolverProvider [scheme=" + getDefaultScheme() + "]";
  }
}

public class MyStaticNameResolver extends NameResolver {

  private final String authority;
  private final ResolutionResult result;

  /**
   * Creates a static name resolver with only a single target server.
   *
   * @param authority The authority this name resolver was created for.
   * @param target The target address of the server to use.
   */
  public MyStaticNameResolver(final String authority, final EquivalentAddressGroup target) {
    this(authority, ImmutableList.of(requireNonNull(target, "target")));
  }

  /**
   * Creates a static name resolver with multiple target servers.
   *
   * @param authority The authority this name resolver was created for.
   * @param targets The target addresses of the servers to use.
   */
  public MyStaticNameResolver(final String authority, final Collection<EquivalentAddressGroup> targets) {
    this.authority = requireNonNull(authority, "authority");
    if (requireNonNull(targets, "targets").isEmpty()) {
      throw new IllegalArgumentException("Must have at least one target");
    }
    this.result = ResolutionResult.newBuilder()
      .setAddresses(ImmutableList.copyOf(targets))
      .build();
  }

  /**
   * Creates a static name resolver with multiple target servers.
   *
   * @param authority The authority this name resolver was created for.
   * @param result The resolution result to use..
   */
  public MyStaticNameResolver(final String authority, final ResolutionResult result) {
    this.authority = requireNonNull(authority, "authority");
    this.result = requireNonNull(result, "result");
  }

  @Override
  public String getServiceAuthority() {
    return this.authority;
  }

  @Override
  public void start(final Listener2 listener) {
    listener.onResult(this.result);
  }

  @Override
  public void refresh() {
    // Does nothing
  }

  @Override
  public void shutdown() {
    // Does nothing
  }

  @Override
  public String toString() {
    return "StaticNameResolver [authority=" + this.authority + ", result=" + this.result + "]";
  }
}