How to use org.jdbi.v3.core.qualifier

/**
 * Column mapper for Java {@code @NVarchar String} qualified type.
 */
@NVarchar
class NVarcharMapper implements ColumnMapper<String> {
  @Override
  public String map(ResultSet r, int columnNumber, StatementContext ctx) throws SQLException {
    return r.getNString(columnNumber);
  }
}

@Reversed
@UpperCase
static class ReversedUpperCaseStringMapper implements ColumnMapper<String> {
  @Override
  public String map(ResultSet r, int columnNumber, StatementContext ctx) throws SQLException {
    return reverse(r.getString(columnNumber)).toUpperCase();
  }
}

@Override
public boolean equals(Object obj) {
  return obj instanceof Foo && ((Foo) obj).value() == value();
}

@Reversed
public class ReversedStringMapper implements ColumnMapper<String> {
  @Override
  public String map(ResultSet r, int columnNumber, StatementContext ctx) throws SQLException {
    return Reverser.reverse(r.getString(columnNumber));
  }
}

@Override
public boolean equals(Object obj) {
  return obj instanceof Bar && ((Bar) obj).value().equals(value());
}

@UpperCase
static class UpperCaseStringMapper implements ColumnMapper<String> {
  @Override
  public String map(ResultSet r, int columnNumber, StatementContext ctx) throws SQLException {
    return r.getString(columnNumber).toUpperCase();
  }
}

@Foo(4)
private static class QualifiedClass {
  QualifiedClass(@Foo(5) String param) {}
}

@Reversed
public class ReversedStringArgumentFactory extends AbstractArgumentFactory<String> {
  public ReversedStringArgumentFactory() {
    super(Types.VARCHAR);
  }

  @Override
  protected Argument build(String value, ConfigRegistry config) {
    return (pos, stmt, ctx) -> stmt.setString(pos, Reverser.reverse(value));
  }
}

@Reversed
@UpperCase
static class ReversedUpperCaseStringArgumentFactory extends AbstractArgumentFactory<String> {
  ReversedUpperCaseStringArgumentFactory() {
    super(Types.VARCHAR);
  }
  @Override
  protected Argument build(String value, ConfigRegistry config) {
    return (pos, stmt, ctx) -> stmt.setString(pos, reverse(value).toUpperCase());
  }
}

/**
 * Argument factory for {@code @NVarchar String} qualified type.
 */
@NVarchar
class NVarcharArgumentFactory extends AbstractArgumentFactory<String> {
  NVarcharArgumentFactory() {
    super(Types.NVARCHAR);
  }

  @Override
  protected Argument build(String value, ConfigRegistry config) {
    return (pos, stmt, ctx) -> stmt.setNString(pos, value);
  }
}

@UpperCase
static class UpperCaseArgumentFactory extends AbstractArgumentFactory<String> {
  UpperCaseArgumentFactory() {
    super(Types.VARCHAR);
  }
  @Override
  protected Argument build(String value, ConfigRegistry config) {
    return (pos, stmt, ctx) -> stmt.setString(pos, value.toUpperCase());
  }
}

  QualifiedClass(@Foo(5) String param) {}
}

@Reversed
class ReversedStringMapperFactory implements ColumnMapperFactory {
  @Override
  public Optional<ColumnMapper<?>> build(Type type, ConfigRegistry config) {
    if (String.class.equals(type)) {
      return Optional.of((rs, col, ctx) -> Reverser.reverse(rs.getString(col)));
    }
    return Optional.empty();
  }
}

  @NVarchar
  public static class QualifiedBean extends BaseBean {}
}

@Reversed
// split comma separated list and reverse each element
public static class ReversedListStringMapper implements ColumnMapper<List<String>> {
  @Override
  public List<String> map(ResultSet r, int columnNumber, StatementContext ctx) throws SQLException {
    return Splitter.on(",")
      .splitToList(r.getString(columnNumber))
      .stream()
      .map(Reverser::reverse)
      .collect(toList());
  }
}

@Reversed
public String name() {
  return name;
}

public QualifiedConstructorParamThing(int id, @Reversed String name) {
  this.id = id;
  this.name = name;
}

@Reversed
public String getName() {
  return name;
}

@Reversed
public void setName(String name) {
  this.name = name;
}

public void setName(@Reversed String name) {
  this.name = name;
}