wie man eine Klasse zur Laufzeit zurückübersetzt

Kurze Antwort

• Nicht Durchlaufen alle geladenen Klassen aus der Instrumentation. Stattdessen prüfen, den Namen der Klasse übergeben, um den Transformator und die, wenn Sie mit Ihrer Ziel-Klasse, dann verwandeln. Ansonsten, einfach den vergangen classfileBuffer unverändert.
• Machen das set-up-Anrufe, die außerhalb des Transformators (d.h. in Ihrem Fall, haben Sie die folgenden Informationen von Ihrem agent) so initialisieren Sie Ihren Transformator mit den Namen der Klasse, die Sie suchen zu transformieren (innere format also statt foo.bar.SnafuSie werden auf der Suche nach Spiel gegen foo/bar/Snafu. Dann fügen Sie den Transformator, rufen Sie retransform und entfernen Sie dann den Transformator.
• Um retransform, müssen Sie den tatsächlichen [pre-transform] - Klasse, die Sie finden können, durch aufrufen Klasse.Vorname (in der agentmain), oder wenn Sie unbedingt müssen, könnten Sie finden es in Intrumentation.getAllLoadedClasses() als letzten Ausweg. Wenn das Ziel der Klasse noch nicht geladen wurde, müssen Sie den classloader zu nennen Klasse.forName(name, boolean classloader) in diesem Fall übergeben Sie die URL der Ziel-Klasse class-path in der agent-main string args.

Lange Antwort

Hier ein paar Empfehlungen:

1. Trennen Sie die operation, die Sie aufrufen in 2 getrennte Vorgänge:
   1. Den agent installieren. Dies muss nur einmal gemacht werden.
   2. Transformation der Ziel-Klasse[es]. Sie können dies tun wollen n Zeiten.
2. Würde ich umsetzen 1.2 durch die Registrierung ein einfaches JMX-MBean, wenn Sie den Agenten installieren. Diese MBean sollte eine operation wie public void transformClass(String className). und sollte initialisiert mit einer Referenz auf den Agenten erworben Instrumentation Instanz. Die MBean-Klasse, - Schnittstelle und der erforderlichen 3rd-party-Klassen aufgenommen werden sollten, in Ihre Agenten loaded.jar. Es sollte auch enthalten Ihre ModifyMethodTest - Klasse (die ich annehmen, dass es bereits tut).
3. Gleichzeitig, dass die Installation des agent-Glas, auch die Installation von management agent von $JAVA_HOME/lib/management-agent.jar die wird aktivieren Sie die management-Agenten, so dass Sie aufrufen können und die Transformation in die MBean, den Sie zu registrieren.
4. Parametrisierung der DemoTransformer Klasse zu akzeptieren, die innere form der name der Klasse, die Sie transformieren möchten. (d.h. wenn Sie die Binärdatei Klassenname foo.bar.Snafudie innere form wird foo/bar/Snafu. Wie Ihr DemoTransformer Instanz beginnt sich zu verwandeln Rückrufe, Ignoriere alle Klassennamen, die nicht mit der internen form-Klasse von Ihnen angegebenen Namen. (also einfach wieder die classfileBuffer unverändert)
5. Ihre Transformators MBean transformclass an Betrieb sollte dann:
   1. Konvertiert den übergebenen Klassennamen zu internen form.
   2. Erstellen Sie eine neue DemoTransformer, vorbei an die innere form Klassenname.
   3. Registrieren DemoTransformer Instanz mit Instrumentation.addTransformer(theNewDemoTransformer, true) .
   4. Nennen Instrumentation.retransformClasses(ClassForName(className)) (mit binären Klasse name, der an die MBean-operation). Wenn dieser Aufruf gibt, Ihre Klasse transformiert werden.
   5. Entfernen Sie den Transformator mit Intrumentation.removeTransformer(theNewDemoTransformer).

Folgende ist eine ungetestete Annäherung an das, was ich meine:

Transformator MBean

public interface TransformerServiceMBean {
    /**
     * Transforms the target class name
     * @param className The binary name of the target class
     */
    public void transformClass(String className);
}

Transformator Service

public class TransformerService implements TransformerServiceMBean {
    /** The JVM's instrumentation instance */
    protected final Instrumentation instrumentation;

    /**
     * Creates a new TransformerService
     * @param instrumentation  The JVM's instrumentation instance 
     */
    public TransformerService(Instrumentation instrumentation) {
        this.instrumentation = instrumentation;
    }

    /**
     * {@inheritDoc}
     * @see com.heliosapm.shorthandexamples.TransformerServiceMBean#transformClass(java.lang.String)
     */
    @Override
    public void transformClass(String className) {
        Class<?> targetClazz = null;
        ClassLoader targetClassLoader = null;
        //first see if we can locate the class through normal means
        try {
            targetClazz = Class.forName(className);
            targetClassLoader = targetClazz.getClassLoader();
            transform(targetClazz, targetClassLoader);
            return;
        } catch (Exception ex) { /* Nope */ }
        //now try the hard/slow way
        for(Class<?> clazz: instrumentation.getAllLoadedClasses()) {
            if(clazz.getName().equals(className)) {
                targetClazz = clazz;
                targetClassLoader = targetClazz.getClassLoader();
                transform(targetClazz, targetClassLoader);
                return;             
            }
        }
        throw new RuntimeException("Failed to locate class [" + className + "]");
    }

    /**
     * Registers a transformer and executes the transform
     * @param clazz The class to transform
     * @param classLoader The classloader the class was loaded from
     */
    protected void transform(Class<?> clazz, ClassLoader classLoader) {
        DemoTransformer dt = new DemoTransformer(clazz.getName(), classLoader);
        instrumentation.addTransformer(dt, true);
        try {
            instrumentation.retransformClasses(clazz);
        } catch (Exception ex) {
            throw new RuntimeException("Failed to transform [" + clazz.getName() + "]", ex);
        } finally {
            instrumentation.removeTransformer(dt);
        }       
    }
}

Die Klasse Transformator

public class DemoTransformer implements ClassFileTransformer {
    /** The internal form class name of the class to transform */
    protected String className;
    /** The class loader of the class */
    protected ClassLoader classLoader;
    /**
     * Creates a new DemoTransformer
     * @param className The binary class name of the class to transform
     * @param classLoader The class loader of the class
     */
    public DemoTransformer(String className, ClassLoader classLoader) {
        this.className = className.replace('.', '/');
        this.classLoader = classLoader;
    }

    /**
     * {@inheritDoc}
     * @see java.lang.instrument.ClassFileTransformer#transform(java.lang.ClassLoader, java.lang.String, java.lang.Class, java.security.ProtectionDomain, byte[])
     */
    @Override
    public byte[] transform(ClassLoader loader, String className,
            Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
            byte[] classfileBuffer) throws IllegalClassFormatException {
        if(className.equals(this.className) && loader.equals(classLoader)) {
            return new ModifyMethodTest(classfileBuffer).modiySleepMethod();
        }
        return classfileBuffer;
    }

}

Der Agent

public class AgentMain {

    public static void agentmain (String agentArgs, Instrumentation inst) throws Exception {
        TransformerService ts = new TransformerService(inst);
        ObjectName on = new ObjectName("transformer:service=DemoTransformer");
        //Could be a different MBeanServer. If so, pass a JMX Default Domain Name in agentArgs
        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
        server.registerMBean(ts, on);
        //Set this property so the installer knows we're already here
        System.setProperty("demo.agent.installed", "true");     
    }

}

Des Agent-Installationsprogramms

public class AgentInstaller {
    /**
     * Installs the loader agent on the target JVM identified in <code>args[0]</code>
     * and then transforms all the classes identified in <code>args[1..n]</code>.
     * @param args The target JVM pid in [0] followed by the classnames to transform
     */
    public static void main(String[] args)  {
        String agentPath = "D:\\work\\workspace\\myjar\\loaded.jar";
        String vid = args[0]; 
        VirtualMachine vm = VirtualMachine.attach(vid);
        //Check to see if transformer agent is installed
        if(!vm.getSystemProperties().contains("demo.agent.installed")) {
            vm.loadAgent(agentPath);  
            //that property will be set now, 
            //and the transformer MBean will be installed
        }
        //Check to see if connector is installed
        String connectorAddress = vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress", null);
        if(connectorAddress==null) {
            //It's not, so install the management agent
            String javaHome = vm.getSystemProperties().getProperty("java.home");
            File managementAgentJarFile = new File(javaHome + File.separator + "lib" + File.separator + "management-agent.jar");
            vm.loadAgent(managementAgentJarFile.getAbsolutePath());
            connectorAddress = vm.getAgentProperties().getProperty("com.sun.management.jmxremote.localConnectorAddress", null);
            //Now it's installed
        }
        //Now connect and transform the classnames provided in the remaining args.
        JMXConnector connector = null;
        try {
            //This is the ObjectName of the MBean registered when loaded.jar was installed.
            ObjectName on = new ObjectName("transformer:service=DemoTransformer");
            //Here we're connecting to the target JVM through the management agent
            connector = JMXConnectorFactory.connect(new JMXServiceURL(connectorAddress));
            MBeanServerConnection server = connector.getMBeanServerConnection();
            for(int i = 1; i < args.length; i++) {
                String className = args[i];
                //Call transformClass on the transformer MBean
                server.invoke(on, "transformClass", new Object[]{className}, new String[]{String.class.getName()});
            }
        } catch (Exception ex) {
            ex.printStackTrace(System.err);
        } finally {
            if(connector!=null) try { connector.close(); } catch (Exception e) {}
        }
        //Done. (Hopefully)
    }
}

================= UPDATE =================

Hey Nick; Ja, das ist eine der Beschränkungen der aktuellen (z.B. Java 5-8) Klasse Transformatoren.
Zitat aus der Instrumentation javadoc:

"Die retransformation ändern kann Methode Körper, Konstanten-pool und
Attribute. Die retransformation muss nicht hinzufügen, entfernen oder umbenennen von Feldern
oder Methoden, ändern Sie die Signaturen der Methoden, oder ändern Sie die Vererbung.
Diese Einschränkungen vielleicht aufgehoben werden in zukünftigen Versionen. Die class-Datei
bytes werden nicht überprüft, verifiziert und installiert, bis nach dem
Transformationen angewendet wurden, wenn die resultierenden bytes werden in Fehler
diese Methode wirft eine Ausnahme."

Nebenbei bemerkt, ist diese Einschränkung ist dokumentiert verbatim für die Neudefinition Klassen zu.

Als solche, haben Sie 2 Möglichkeiten:

1. Nicht das hinzufügen von neuen Methoden. Dies ist Häufig sehr begrenzt und disqualifiziert die Verwendung von sehr Häufig byte-code-AOP-Muster, wie die Methode
   Verpackung. Je nachdem welcher byte-code-manipulation-Bibliothek, die Sie verwenden, können Sie in der Lage zu injizieren alle Funktionen, die Sie wollen, in
   die vorhandenen Methoden. Manche Bibliotheken machen dies einfacher als anderen. Oder, sollte ich sagen, manche Bibliotheken machen dies einfacher als anderen.

2. Transform der Klasse vor die Klasse geladen. Diese verwendet die gleiche Allgemeine Muster der code, den wir bereits besprochen, außer dass Sie nicht auslösen
   die Transformation durch den Aufruf retransformClasses. Eher, Sie registrieren die ClassFileTransformer zum durchführen der Transformation vor die Klasse geladen wird
   und Ihr Ziel-Klasse wird geändert, wenn es ist erste Klasse geladen. In diesem Fall sind Sie ziemlich frei, um die Klasse ändern irgendeiner Weise, die Sie
   wie, vorausgesetzt, das Endprodukt kann noch validiert werden. Schlagen die Anwendung auf dem Schlag (D. H. bekommen Sie Ihre ClassFileTransformer
   registriert, bevor die Anwendung lädt die Klasse) benötigen wahrscheinlich einen Befehl wie javaagent, obwohl, wenn Sie haben eine strenge Kontrolle
   der Lebenszyklus Ihrer Anwendung ist es möglich, dies zu tun, in der mehr traditionellen application-layer-code. Als ich sagte, Sie brauchen nur zu machen
   Sie sicher, dass der Transformator registriert, bevor der Ziel-Klasse geladen wird.

Einer anderen Variante #2 Sie können in der Lage sein zu verwenden, ist simulieren eine Marke neue Klasse mit einem neuen classloader. Wenn Sie erstellen eine neue
isolierten classloader, die nicht Delegierte zu den bestehenden [geladen] Klasse, aber hat Zugang zu den [entladen] Ziel der Klasse byte-code,
Sie sind im wesentlichen die Reproduktion der Anforderungen von #2 oben, da die JVM ist der Auffassung, dass dies eine BRANDNEUE Klasse.

================ UPDATE ================

In Ihrer letzten Kommentare, habe ich das Gefühl, ich habe den Faden verloren, ein bisschen, wo Sie sind. Jedenfalls, Oracle JDK 1.6 definitiv unterstützt retransform. Ich bin nicht allzu vertraut mit ASM, aber der Letzte Fehler, den Sie geschrieben zeigt an, dass die ASM-transformation irgendwie geändert die Klasse schema ist nicht zulässig, so dass die retransform gescheitert.

Dachte ich, ein funktionsfähiges Beispiel möchte hinzufügen, mehr Klarheit. Die gleichen Klassen wie oben (plus eine test-Klasse namens Person) sind hier. Es gibt ein paar änderungen/Ergänzungen:

• Die Transformation in die TransformerService jetzt hat 3 Parameter:
  1. Die binären Klasse name
  2. Den Namen der Methode zu instrument
  3. Einer [regulären] Ausdruck der Signatur der Methode. (wenn der Wert null oder leer ist, mit allen Unterschriften)
  4. Die eigentliche bytecode-Modifikation erfolgt mit Javassist in der ModifyMethodTest Klasse. Alle, die Instrumentierung tut, ist, eine System.aus.printlndie wie folgt aussieht: -->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
• Die AgentInstaller (was hat die demo Haupt -) nur selbst installiert die agent-und die Transformations-service. (Einfacher für Dev/Demo-Zwecke, aber immer noch arbeiten mit anderen JVMs)
• Sobald der agent ist selbst-installiert ist, wird der main-thread erzeugt eine Person Instanz und nur Schleifen, ruft die Person, die zwei sayHello Methoden.

Vor zu transformieren, dass die Ausgabe sieht wie folgt aus.

Temp File:c:\temp\com.heliosapm.shorthandexamples.AgentMain8724970986698386534.jar
Installing AgentMain...
AgentMain Installed
Agent Loaded
Instrumentation Deployed:true
Hello [0]
Hello [0]
Hello [1]
Hello [-1]
Hello [2]
Hello [-2]

Mensch hat 2 sayHello Methoden, nimmt sich ein intder andere nimmt eine String. (Die String-one druckt nur das negativ des loop-index).

Nachdem ich die AgentInstaller, der agent installiert ist und der Mensch aufgerufen wird, in einer Schleife, Verbinde ich den JVM mit JConsole:

Navigiere ich zu der TransformerService MBean und berufen sich auf die transformclass an Betrieb. Ich liefere die voll qualifizierte Klasse [binary] Namen, den Namen der Methode zu instrument, und ein regex-Ausdruck (I)V die Spiele nur die sayHello Methode nimmt ein int als argument. (Oder ich liefern könnte .*- oder-nichts-zu-match-alle überladungen). Führe ich den Betrieb.

Nun, wenn ich zurück an die laufende JVM und untersuchen Sie die Ausgabe:

Examining class [com/heliosapm/shorthandexamples/Person]
Instrumenting class [com/heliosapm/shorthandexamples/Person]
[ModifyMethodTest] Adding [System.out.println("\n\t-->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]");]
[ModifyMethodTest] Intrumented [1] methods

    -->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
Hello [108]
Hello [-108]

    -->Invoked method [com.heliosapm.shorthandexamples.Person.sayHello((I)V)]
Hello [109]
Hello [-109]

Getan. Methode instrumentiert.

Halten Sie im Verstand, den Grund der retransform zulässig ist, weil der Javassist-bytecode-änderung, keine änderungen außer einschleusen von code in eine vorhandene Methode.

Sinn ?

InformationsquelleAutor der Antwort Nicholas