lancé à travers chargeur de classe?

Comment puis-je faire cela:

class Foo {
  public static Foo get() throws Exception {
    ClassLoader cl = new URLClassLoader(new URL[]{"foo.jar"}, null); //Foo.class is in foo.jar
    return (Foo)cl.loadClass("Foo").newInstance(); //fails on class cast
  }
}

Ce dont j'ai besoin est pour la JVM de considérer les Foo instance de cl comme si elle est une instance de Foo à partir du chargeur de classe de l'exécution du code.

J'ai vu ces approches, aucun d'entre eux bon pour moi (l'exemple ci-dessus est un jouet exemple):

  1. Charge de la classe (ou une autre interface) par un chargeur de classe parent à la fois le code d'appel et créé chargeur de classe
  2. Sérialiser et désérialiser l'objet.
InformationsquelleAutor IttayD | 2010-04-07
  1. 25

    Pas possible. Identité de classe comprend le nom complet et le chargeur de classes.

    Coulage d'un objet à une classe du même nom chargé par les différents chargeurs de classes n'est pas différent que d'essayer de jeter un String à Integer, parce que ces classes pourraient être vraiment complètement différent malgré le fait d'avoir le même nom.

    • Donc, si on ne peut même pas lancer ces nouvelles instances, comment pouvons-nous les utiliser? Si tout ce que nous pouvons faire est de Object obj = cl.loadClass("Foo").newInstance();, alors comment pouvons-nous appeler les méthodes de la nouvelle instance de Foo?
    • eh bien, vous pourriez utiliser la réflexion. Mais le cas le plus pratique est d'avoir les classes étendre des classes ou de mettre en œuvre des interfaces à partir d'un chargeur de classe parent dans la hiérarchie de délégation qui sont également à la disposition du reste du code. Mais dans l'exemple de code, il n'y a pas de chargeur de classe parent (deuxième paramètre du constructeur est nul)...
    • La performance de la deuxième option, être plus rapide que l'utilisation de la réflexion? Ou est-il vrai qu'il utilise en interne une réflexion de toute façon?
    • la deuxième option fonctionne exactement comme les classes à partir de la même chargeur de classe serait, de sorte qu'il est plus rapide que l'utilisation de la réflexion; mais cet écart diminue avec chaque nouvelle version de la JVM de toute façon.
    InformationsquelleAutor Michael Borgwardt
  2. 8

    Je viens de passer les deux derniers jours aux prises avec ce problème et j'ai enfin eu le problème à l'aide de java réflexion:

    //'source' is from another classloader
final Object source = events[0].getSource();

if (source.getClass().getName().equals("org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptThread")) {

    //I cannot cast to 'org.eclipse.wst.jsdt.debug.internal.core.model.JavaScriptThread'
    //so I invoke the method 'terminate()' manually
    Method method = source.getClass().getMethod("terminate", new Class[] {});
    method.invoke(source, new Object[] {});
}

    Espère que cela aide quelqu'un.

    • Comment pouvons-nous le faire sans réflexion? Si chaque méthode unique de chaque objet chargé par notre chargeur de classe doit être appelée via la réflexion, ne serait-ce pas sérieusement ralentir l'ensemble du programme?
    InformationsquelleAutor viragoboy
  3. 6

    Si la classe qui ont besoin d'être exprimées implémente Serializable alors:

    private <T> T castObj(Object o) throws IOException, ClassNotFoundException {
    if (o != null) {
        ByteArrayOutputStream baous = new ByteArrayOutputStream();
        {
            ObjectOutputStream oos = new ObjectOutputStream(baous);
            try {
                oos.writeObject(o);
            } finally {
                try {
                    oos.close();
                } catch (Exception e) {
                }
            }
        }

        byte[] bb = baous.toByteArray();
        if (bb != null && bb.length > 0) {
            ByteArrayInputStream bais = new ByteArrayInputStream(bb);
            ObjectInputStream ois = new ObjectInputStream(bais);
            T res = (T) ois.readObject();
            return res;
        }
    }
    return null;
}

    utilisation:

    Object o1; //MyObj from different class loader
MyObj o2 = castObj(o1);
    • Je veux juste souligner que l'utilisation de la sérialisation est équivalente à la profondeur de la copie de champs entre les objets. Cependant, il n'a pas de "copier" le corps de méthode. Donc MyObj (Une) chargé par le principal du chargeur de classe et MyObj (B) extrait de la coutume de la chargeuse sont différents et que la plupart des champs de la correspondance de contenu.
    InformationsquelleAutor wit
  4. 3

    Peut-être quelque chose à l'aide d'interfaces et de java.lang.reflect.Proxy serait fonction de vos préférences. À l'aide d'un InvocationHandler qui trouve et invoque la méthode de la classe cible. (Remarque, tout mobile-code de sécurité que vous avez sera tourné à travers si vous faites cela.)

    InformationsquelleAutor Tom Hawtin - tackline
  5. 2

    Pas possible de jeter dans différents classLoader.

    Vous avez cette solution de contournement avec Gson, exemple convertir l'Objet de YourObject (Object est un YourObject classe, mais dans d'autres classLoader):

    Object o = ... 
Gson gson = new Gson();
YourObject yo = gson.fromJson(gson.toJson(o), YourObject.class);

    - Je utiliser cette solution de contournement parce que j'ai compiler n'importe quel code java dans une Application web (Tomcat). Cette solution de contournement exécuter dans la production.

    • C'est génial! Cela peut être un hack, mais il a résolu un vraiment ennuyeux de déploiement de problème pour moi.
    InformationsquelleAutor sgrillon
  6. 0

    C'est un vieux post où je suis arrivé parce que je voulais faire presque la même chose, mais une version plus simple de lui...

    Il fonctionne réellement si les deux Foo et les chargés de classe (dans mon cas, à partir d'un .java classfile dans un autre package) étendre la même classe, dire, AbstractTestClass.

    Morceaux de code:

    public AbstractTestClass load(String toLoad) {
    try{
        Class test = Class.forName("testsFolder.testLoadable");
        Constructor ctorlist[] = test.getDeclaredConstructors();
        for(Constructor aConstructor : ctorlist){
           if(...){//find the good constructor
              Object loadedTest = aConstructor.newInstance(new Object[]{/*params*/});
              return (AbstractTestClass) test;
           }
        }
    }catch(...){}
    return new defaultTestClass();
}

    De cette façon, je peux insérer la classe chargée dans un ArrayList<AbstractTestClass>.

    • vous chargez "test" à partir de la même classe loader. En outre, même si vous spécifiez un autre, il aura besoin d'être un enfant de la classe actuelle chargeur ou vous ne seriez pas en mesure de mettre à AbstractTestClass
    • vous avez raison, il doit étendre la classe parent (Foo dans la question). N'était-il pas le point de la question: "à considérer les Foo instance de cl comme si elle est une instance de Foo"?
    InformationsquelleAutor Aname