Try this in postman:

var jsonData = JSON.parse(responseBody);
postman.setGlobalVariable("token1",(jsonData.results[0].token));

This is an example where you get the token from your JSON reponse and set it in a Global Variable. You can just change it to environment also if you like.

More info about test scripts in postman: https://learning.getpostman.com/docs/postman/scripts/test_examples/

Short answer:

• create a shared interface
• create multiple sub-class of this interface (one per storage) using different spring component names
• use Spring context to retrieve the right bean by name (instead of creating a custom factory)

Now adding a new storage is only adding a new Repository classes with a name

Explanation: As mentioned in the other answer you first need to define a common interface as you can’t use the CrudRepository.save(...). In my example I reuse the same signature as the save method to avoid re-implementing it in the sub-classes of CrudRepository.

public interface MyInterface<T> {
    <S extends T> S save(S entity);
}

Redis Repository:

@Repository("redis") // Here is the name of the redis repo
public class RedisRepository implements MyInterface<MyPojo>  {
    @Override
    public <S extends MyPojo> S save(S entity) {
        entity.setValue(entity.getValue() + " saved by redis");
        return entity;
    }
}

For the other CrudRepository no need to provide an implementation:

@Repository("elastic") // Here is the name of the elastic repo
public interface ElasticRepository  extends CrudRepository<MyPojo, String>, MyInterface<MyPojo> {
}

Now create the version three of your repository with the injection of SpringContext:

@RestController
public class ControllerVersionThree {

    private final ApplicationContext context;

    public ControllerVersionThree(ApplicationContext context) {
        this.context = context;
    }

    @PostMapping(path = "/save")
    public String save(@RequestBody MyRequest myRequest) {
        String whereToSave = myRequest.getWhereToSave();
        MyPojo myPojo = new MyPojo(UUID.randomUUID().toString(), myRequest.getValue());
        // Here, you should check the value of whereToSave to avoid some 'spring injection vulnerabilities'  
        MyInterface<MyPojo> repo = context.getBean(whereToSave, MyInterface.class);
        return repo.save(myPojo).toString();
    }
}

You can check that this is working with a test:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.http.HttpEntity;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ControllerVersionThreeTest {
    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    Dhaval Shah
    void testSaveByRedis() {
        // Given: here 'redis' is the name of th spring beans
        HttpEntity<MyRequest> request = new HttpEntity<>(new MyRequest("redis", "aValue"));

        // When
        String response = restTemplate.postForObject("http://localhost:" + port + "/save", request, String.class);

        // Then
        assertEquals("MyPojo{value='aValue saved by redis'}", response);
    }

}