Java - 如何将未知的接口实现传递给泛型方法

Question

I have such issue (of course its just an example). I have processor where I have to repair a car. I have a string as a json of car object. I dont know implementation of ServiceStation and I have only class of car implementation. I have to parse json to car object and provide it to service station. There is any proper solution to achieve this ?

public interface Car {}

public class BMW implements Car {}

public interface ServiceStation<T extends Car> {
    public void repair(T car)
}

public class BMWServiceStation<BMW> {
    public void repair(BMW car) { ... }
}

public class ServiceStationProcessor {

    public void process(String carJson, Settings settings) {
        Class<? extends Car> carClass = settings.getCarClass();
        ServiceStation serviceStation = settings.getServiceStation();

        JavaType javaType = objectMapper.getTypeFactory().constructType(carClass);

        Object<? extends Car> obj = objectMapper.readValue(carJson, javaType); <-- ?? something like this?
        serviceStation.repair(obj)
    }

}

Answer 1

You could have a 'type' field in your json that identifies a concrete Car sub-type (eg 'bmw' or 'mazda'). Then you could use annotations on the Car interface to tell Jackson what to instantiate based on the 'type' value.

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
  @JsonSubTypes.Type(value = BMW.class, name = "bmw"),
  @JsonSubTypes.Type(value = Mazda.class, name = "mazda")
})
@JsonIgnoreProperties(ignoreUnknown = true)
public interface Car {

}

Then it's type-safe and logic in processor simplifies:

public class ServiceStationProcessor {

  public void process(String carJson, Settings settings) {
      ServiceStation serviceStation = settings.getServiceStation();
      Car obj = objectMapper.readValue(carJson, Car.class);
      serviceStation.repair(obj);
  }

}

Answer 2

You can reach your result with a combination of:

• Jackson deserialization of children classes
• A visitor pattern for your service station

Service Station

This is the "visitor" part of the implementation.

You should have one single implementation exposing N methods for the N different concrete types (instead of having N different implementations of the same single-method interface).

Something like this:

public interface ServiceStation {

    void repair(Bmw bmw);

    void repair(Mercedes mercedes);

}

//Single implementation with a dedicated method per type of car
public class ServiceStationImpl implements ServiceStation {

    @Override
    public void repair(Bmw bmw) {
        System.out.println("Repair bmw");
    }

    @Override
    public void repair(Mercedes mercedes) {
        System.out.println("Repair mercedes");
    }
}

Car abstract class and its implementations

This will be the "visited" part of your implementation.

You defined Car as being an interface .

Jackson allows deserialization of sub types but using abstract class rather than interface .

Also, I take chance to add an abstract method which accepts a ServiceStation . That will allow each concrete car implementation to let the ServiceStation (the visitor) "visit" themselves (the visited):

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes(
    {
        @JsonSubTypes.Type(value = Bmw.class, name = "Bmw"),
        @JsonSubTypes.Type(value = Mercedes.class, name = "Mercedes")
    }
)
public abstract class Car {
    public abstract void accept(ServiceStation serviceStation);
}

public final class Bmw extends Car {
    @JsonIgnore
    private final String type = "Bmw";

    @Override
    public void accept(ServiceStation serviceStation) {
        serviceStation.repair(this); //<-- will call the Bmw method of the service station
    }
}

public final class Mercedes extends Car {
    @JsonIgnore
    private final String type = "Mercedes";

    @Override
    public void accept(ServiceStation serviceStation) {
        serviceStation.repair(this); //<-- will call the Mercedes method of the service station
    }
}

Main code

At this point, it becomes as simple as this:

public class ServiceStationProcessor {

    public void process(String carJson, Settings settings) throws JsonProcessingException {
        Class<? extends Car> clazz = settings.getCarClass(); //<-- get the car class as you already do
        ServiceStation serviceStation = settings.getServiceStation(); //<-- get the service station
        objectMapper.readValue(carJson, clazz).accept(serviceStation); //<-- deserialize the json into the concrete car class (Jackson will pick the right type of car), then ask the car to accept the service station (the car will dispatch to the correct type)
    }

}