URLClassLoader e l'accessibilità dei metodi del pacchetto-privato

Question

Ho una classe Formula, che si trova nella confezione javaapplication4, che mi carico con un URLClassLoader. Tuttavia, quando lo chiamo da un'altra classe Test1, che si trova nello stesso pacchetto, non posso accedere ai suoi metodi che hanno un modificatore di accesso predefinito (posso accedere ai metodi pubblici).

ottengo la seguente eccezione:

java.lang.IllegalAccessException: Classe javaapplication4.Test1 non può accedere a un membro della classe di javaapplication4.Formula con modificatori ""

Come posso accedere ai metodi package-private di una classe caricata in runtime dallo stesso pacchetto?

Suppongo che sia un problema con l'utilizzo di un caricatore di classi diverso, ma non sono sicuro del perché (ho impostato il genitore di URLClassLoader).

SSCCE riprodurre il problema (percorsi di Windows) - suppongo che il problema è nel metodo loadClass:

public class Test1 { 

    private static final Path TEMP_PATH = Paths.get("C:/temp/"); 

    public static void main(String[] args) throws Exception { 
     String thisPackage = Test1.class.getPackage().getName(); 
     String className = thisPackage + ".Formula"; //javaapplication4.Formula 
     String body = "package " + thisPackage + "; " 
        + "public class Formula {   " 
        + " double calculateFails() { " 
        + "  return 123;   " 
        + " }       " 
        + " public double calculate() {" 
        + "  return 123;   " 
        + " }       " 
        + "}        "; 

     compile(className, body, TEMP_PATH); 
     Class<?> formulaClass = loadClass(className, TEMP_PATH); 

     Method calculate = formulaClass.getDeclaredMethod("calculate"); 
     double value = (double) calculate.invoke(formulaClass.newInstance()); 
     //next line prints 123 
     System.out.println("value = " + value); 

     Method calculateFails = formulaClass.getDeclaredMethod("calculateFails"); 
     //next line throws exception: 
     double valueFails = (double) calculateFails.invoke(formulaClass.newInstance()); 
     System.out.println("valueFails = " + valueFails); 
    } 

    private static Class<?> loadClass(String className, Path path) throws Exception { 
     URLClassLoader loader = new URLClassLoader(new URL[]{path.toUri().toURL()}, Test1.class.getClassLoader()); 
     return loader.loadClass(className); 
    } 

    private static void compile(String className, String body, Path path) throws Exception { 
     List<JavaSourceFromString> sourceCode = Arrays.asList(new JavaSourceFromString(className, body)); 

     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
     StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 
     fileManager.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(path.toFile())); 
     boolean ok = compiler.getTask(null, fileManager, null, null, null, sourceCode).call(); 

     System.out.println("compilation ok = " + ok); 
    } 

    public static class JavaSourceFromString extends SimpleJavaFileObject { 
     final String code; 

     JavaSourceFromString(String name, String code) { 
      super(URI.create("string:///" + name.replace('.', '/') + JavaFileObject.Kind.SOURCE.extension), 
        JavaFileObject.Kind.SOURCE); 
      this.code = code; 
     } 

     @Override 
     public CharSequence getCharContent(boolean ignoreEncodingErrors) { 
      return code; 
     } 
    } 
} 

Answer 1

Una classe in fase di esecuzione è identificata dal sia il suo nome completo e la sua ClassLoader.

Ad esempio, quando si testano due oggetti Class<T> per l'uguaglianza, se hanno lo stesso nome canonico ma sono stati caricati da diversi ClassLoaders, non saranno uguali.

Affinché due classi appartengano allo stesso pacchetto (e, a sua volta, siano in grado di accedere ai metodi package-private), devono essere caricate anche dallo stesso ClassLoader, il che non è il caso qui. Infatti, Test1 viene caricato dal classloader di sistema, mentre la Formula viene caricata da URLClassLoader creata all'interno di loadClass().

Se si specifica un caricatore genitore per URLClassLoader in modo da farlo caricare Test1, vengono comunque utilizzati due caricatori diversi (è possibile verificarlo affermando l'uguaglianza dei caricatori).

Non penso che tu possa fare la classe Formula caricata dallo stesso Test1 ClassLoader (dovresti usare un percorso noto e metterlo sul CLASSPATH), ma ho trovato un modo per fare il contrario : caricamento di un'altra istanza di Test1 nel ClassLoader utilizzato per caricare la formula. Questo è il layout in pseudocodice:

class Test1 { 

    public static void main(String... args) { 
    loadClass(formula); 
    } 

    static void loadClass(location) { 
    ClassLoader loader = new ClassLoader(); 
    Class formula = loader.load(location); 
    Class test1 = loader.load(Test1); 
    // ... 
    Method compute = test1.getMethod("compute"); 
    compute.invoke(test1, formula); 
    } 

    static void compute(formula) { 
    print formula; 
    } 
} 

Ecco il pastebin. Un paio di note: ho specificato un genitore null per URLClassLoader per evitare il problema elencato sopra e ho manipolato le stringhe per raggiungere lo scopo, ma non so quanto questo approccio possa essere robusto in altri scenari di distribuzione. Inoltre, l'URLClassLoader ho usato solo le ricerche in due directory per trovare definizioni di classe, non tutte le voci elencate nel CLASSPATH

Answer 2

La risposta è:

Nel pacchetto sun.reflect.Reflection c'è un metodo chiamato isSameClassPackage (la firma effettiva è private static boolean isSameClassPackage(ClassLoader arg0, String arg1, ClassLoader arg2, String arg3);). Questo metodo è responsabile per decidere se due classi appartengono allo stesso pacchetto o meno.

Il primo controllo questo metodo sta facendo che confronta arg0 e arg2, (i due classloader) se sono diversi, restituisce false.

Quindi, se si utilizzano diversi classloader per le due classi, non corrisponderà.

EDIT: La catena completa di chiamata (su richiesta) è:

Method.invoke() 
Method.checkAccess() -- fallback to the real check 
Method.slowCheckMemberAccess() -- first thing to do to call 
Reflection.ensureMemberAccess() -- check some nulls, then 
Reflection.verifyMemberAccess() -- if public, it,'s OK, otherwise check further 
Reflection.isSameClassPackage(Class, Class) -- get the class loaders of 2 classes 
Reflection.isSameClassPackage(ClassLoader, String, ClassLoader, String) 

Answer 3

ho trovato la spiegazione nel JVM specification 5.4.4 (sottolineatura mia):

Un campo o un metodo R è accessibile a una classe o interfaccia D se e solo se si verifica una delle seguenti condizioni:

• [...]
• R o è protetta o ha accesso predefinito (vale a dire, né pubblico né protetta né privato), ed è dichiarata da una classe nello stesso pacchetto di runtime come D.

e il runtime pacchetto è definito nel specs #5.3:

il pacchetto runtime di una classe o interfaccia è determinato dal nome del pacchetto e definente classe loader della classe o interfaccia.

Bottom line: questo è il comportamento previsto.

Answer 4

Aggiungi c:\temp a java classpath e caricare Formula.class con la stessa ClassLoader come Test1.class

Class<?> formulaClass = Class.forName(className); 

questo risolverà il vostro problema.