Una interfaz y dos clases de implementación usan la reflexión para llamar a diferentes clases de implementación

Codificar directamente

Servicio

public interface IStudentService {

    String say(String msg);
}

Dos clases de implementación

@Service
public class AStudentServiceImpl implements IStudentService {

    @Override
    public String say(String msg) {
        return "hello my name is A" + msg;
    }
}


@Service
public class BStudentServiceImpl implements IStudentService{

    @Override
    public String say(String msg) {
        return "hello my name is B" + msg;
    }
}

Clase enumerada

public enum StudentServiceEnum {

    aStudentServiceImpl("AImpl", "com.cache.service.AStudentServiceImpl"),
    bStudentServiceImpl("BImpl", "com.cache.service.BStudentServiceImpl");

    private String mark;
    private String path;

    StudentServiceEnum(String mark, String path) {
        this.mark = mark;
        this.path = path;
    }

    public String getMark() {
        return mark;
    }
    public void setMark(String mark) {
        this.mark = mark;
    }
    public String getPath() {
        return path;
    }
    public void setPath(String path) {
        this.path = path;
    }
}

Llamar por reflejo

public class StudentFactory {

    public static IStudentService getService(String path) {
        try {
            return (IStudentService) Class.forName(path).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

prueba

    @Test
    void test1(){
       IStudentService service = StudentFactory.getService(StudentServiceEnum.bStudentServiceImpl.getPath());
       System.out.println(service.say("aa"));
    }