Eu li e percebi que entidades (objetos de dados - para JPA ou serialização) com injeções são uma má ideia. Aqui está o meu design atual (todos os campos apropriados têm getters e setter eserialVersionUID que deixo cair por brevidade).

Este é o objeto pai que é o cabeçalho do gráfico de composição da entidade. Este é o objeto que serializo.

public class State implements Serializable {

    List<AbstractCar> cars = new ArrayList<>();

    List<AbstractPlane> planes = new ArrayList<>();

   // other objects similar to AbstractPlane as shown below
}

AbstractPlane e suas subclasses são apenas classes simples, sem injeções:

public abstract class AbstractPlane implements Serializable {
    long serialNumber;
}

public class PropellorPlane extends AbstractPlane {
    int propellors;
}

public class EnginePlane extends AbstractPlane {
    List<Engine> engines = new ArrayList<>(); // Engine is another pojo
}

// etc.

Por outro lado, cada tipo de carro concreto requer um gerente que tenha algum comportamento e também alguma forma específica de dados:

public abstract class AbstractCar implements Serializable {
    long serialNumber;

    abstract CarData getData();

    abstract void operate(int condition);

    abstract class CarData {
        String type;
        int year;
    }
}

public class Car1 extends AbstractCar {

    @Inject
    Car1Manager manager;

    Car1Data data = new Car1Data(); // (getter exists per superclass requirement)

    void operate(int i) { // logic looks weird but makes the example
        if (i < 0)
            return manager.operate(data);
        else if (i > 1)
            return manager.operate(data, i);
    }

    class Car1Data extends CarData {
        int property1;

        {
            type = "car1";
            year = 1;
        }
    }
}

public class Car2 extends AbstractCar {

    @Inject
    Car2Manager manager;

    Car2Data data = new Car2Data();

    void operate(int i) {
        if (i < 31)
            return manager.operate(data);
    }

    class Car2Data extends CarData {
        char property2;

        {
            type = "car2";
            year = 12;
        }
    }
}

// etc.

oCarxManager estão@Stateless beans que executam operações nos dados (a correspondênciaCarxData) dado a eles. Eles mesmos usam injeções de muitos outros grãos e são todas subclasses deAbstractCarManager. Existem O (100) tipos de carros e gerentes correspondentes.

O problema ao serializar oState é que serializar a lista de carros abstratos não funciona bem com as injeções nas subclasses. Estou procurando um design que dissocie a injeção do processo de economia de dados.

Minhas perguntas relacionadas anteriores:Como serializar um feijão injetado? eComo posso dizer ao contêiner CDI para "ativar" um bean?