@Repository
public class PostRepository {

  private static final Logger log = LoggerFactory.getLogger(PostRepository.class);
  private final JdbcClient jdbcClient;
  private final JdbcTemplate jdbcTemplate;

  public PostRepository(JdbcClient jdbcClient, JdbcTemplate jdbcTemplate) {
    this.jdbcClient = jdbcClient;
    this.jdbcTemplate = jdbcTemplate;
  }

  List<Post> findAll() {
    return jdbcClient.sql("SELECT * FROM post")
            .query(Post.class)
            .list();
  }

  public Optional<Post> findById(String id) {
    return jdbcClient.sql("SELECT id,user_id,title,body FROM post WHERE id = :id")
            .param("id", id)
            .query(Post.class)
            .optional();
  }

  public void create(Post post) {
    int update = jdbcClient.sql("INSERT INTO post (id, user_id, title, body) VALUES (?, ?, ?, ?)")
            .params(List.of(post.id(), post.userId(), post.title(), post.body()))
            .update();
    log.info("Inserted {} rows", update);
  }

  void update(Post post, String id) {
    var updated = jdbcClient.sql("UPDATE post SET user_id = ?, title = ?, body = ? where id = ?")
            .params(List.of(post.userId(),post.title(),post.body(), id))
            .update();

    log.info("Updated {} row(s)", updated);
  }

  void delete(String id) {
    var updated = jdbcClient.sql("DELETE from post where id = :id")
            .param("id", id)
            .update();

    log.info("Deleted {} row(s)", updated);
  }

  List<Post> findByUserId(Integer userId) {
    return jdbcClient.sql("SELECT * FROM post WHERE user_id = :userId")
            .param("userId", userId)
            .query(Post.class)
            .list();
  }

  public void saveAllPosts(List<Post> posts) {
    posts.forEach(this::create);
  }

  public void saveAll(List<Post> posts) {
    for (Post p : posts) {
      jdbcTemplate.update("INSERT INTO post (id,user_id,title,body) " +
                      "VALUES (?, ?, ?,?)",
              p.id(),
              p.userId(),
              p.title(),
              p.body());
    }
  }

}

@RestController
@RequestMapping("/posts")
class PostController {

    private final PostRepository postRepository;

    PostController(PostRepository postRepository) {
        this.postRepository = postRepository;
    }

    @GetMapping("")
    List<Post> findAll() {
        return postRepository.findAll();
    }

    @GetMapping("/user/{userId}")
    List<Post> findByUserId(@PathVariable Integer userId) {
        return postRepository.findByUserId(userId);
    }

}

public interface PostRepository extends ListCrudRepository<Post,Integer> {

    List<Post> findByUserId(Integer userId);

}

public record Post(
        @Id
        Integer id,
        Integer userId,
        @NotEmpty
        String title,
        String body,
        @Version
        Integer version
) {

}

@Component
public class PostClient {

    private final RestTemplate restTemplate;

    public PostClient(RestTemplateBuilder builder) {
        this.restTemplate = builder.build();
    }

    /*
     * Call JsonPlaceholderService to get a list of posts
     */
    public List<Post> findAll() {
        return restTemplate.exchange(
                "https://jsonplaceholder.typicode.com/posts",
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<List<Post>>() {
                }
        ).getBody();
    }

}

@Component
public class PostClient {

    private final RestClient restClient;

    public PostClient(RestClient.Builder builder) {
        this.restClient = builder
                .baseUrl("https://jsonplaceholder.typicode.com/")
                .build();
    }

    public List<Post> findAll() {
        return restClient.get()
                .uri("/posts")
                .retrieve()
                .body(new ParameterizedTypeReference<>() {});
    }

}

public interface PostClient {

    @GetExchange("/posts")
    List<Post> findAll();

    @GetExchange("/posts/{id}")
    Post findById(@PathVariable Integer id);

}

@Bean
PostClient postClient() {
    RestClient restClient = RestClient.create("https://jsonplaceholder.typicode.com/");
    HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(RestClientAdapter.create(restClient)).build();
    return factory.createClient(PostClient.class);
}

    @GetMapping("")
    List<Post> findAll() {
        log.info("Thread: {}", Thread.currentThread());
        return postRepository.findAll();
    }

@ImportRuntimeHints(MyRuntimeHints.ResourcesRegistrar.class)
@Configuration
public class MyRuntimeHints {

    static class ResourcesRegistrar implements RuntimeHintsRegistrar {

        @Override
        public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
            try {
                hints.reflection().registerType(TypeReference.of("org.springframework.data.domain.Unpaged"),
                        builder -> builder
                                .withMembers(MemberCategory.values()));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

}