Знакомимся с Javassist

Часть первая

Всем большой привет! Перед началом стоит сказать, что библиотека Javassist довольно мощный инструмент, так как стирает почти все границы у того безграничного языка JAVA, позволяя разработчику осуществлять манипуляции связанные с байткодом.

Конечно, получив доступ к байткоду, а ровно и к возможности воздействовать на этот самый байткод вам совсем не обязательно вклиниваться в него. Javassist можно использовать и в “мирных” целях!

При многообразии возможностей не стоит забывать о том, что использовать библиотеку нужно только тогда, когда это действительно необходимо. Использование данного инструмента делает основной код менее понятным, так как после применения Javassist у вас появится второе полноценное приложение, в котором будет жить Java со своей логикой.

Итак, если после всех предостережений вы все же решили использовать эту библиотеку, то давайте начинать!

В этой статье мы рассмотрим Javassist, как инструмент, с помощью которого мы будем вклиниваться в существующий байткод и трансформировать его.

Потребоваться это может в разных случаях. Например, у вас под рукой есть некая библиотека, в которой все классы уже скомпилированы и все зависимости вместе с запускающим методом упакованы в JAR архив. И вот, случилось так, что по какой-то причине вам нужно изменить реализацию того или иного метода. Предположим, вы нашли баг в библиотеке, или возможно требуется, чтобы были выполнены какие-нибудь дополнительные действия, в виде подсчета чего-нибудь, отправки оповещения о том или ином событии при старте вашего приложения и при определенных условиях.

 Как и говорилось выше, после использования Javassist у вас появится второе полноценное приложение, в котором будет жить Java со своей логикой. Почему это происходит? Почему нельзя запаковать все в одно приложение?

Ответ очевиден – приложение не может само себя изменять. Т.е. приложение не может само изменять свой же байткод. Это должен делать кто-то другой. Этот кто-то другой – такое же Java приложение, но заточенное на работу с байткодом.

Итак, теперь мы знаем, что использование второго приложения, в котором и будет крутиться вся логика, связанная с использованием Javassist просто неизбежно. Дело в том, что это самое приложение загружается в JVM первым, разворачивается там и начинает пропускать через себя все классы, которые необходимы для работы уже самого целевого приложения.

Что же происходит под капотом JVM? Каким образом первое приложение с Javassist может пропускать через себя байткод? Как это вообще работает?

Все мы привыкли видеть в Maven такой тег как <manifestFile>. В этом теге указывается путь до файла MANIFEST.MF. В свою очередь в файле манифеста прописывается точка входа в приложение. Всегда это выглядит так: Main-Class: путь до класса.Класс в котором расположен одноименный метод main. Но Javassist в силу своей специфики априори не может запускаться как обычное Java-приложение. Должно быть что-то, что отличает такое “чудо-приложение” от обычного. И, конечно, такая особенность есть. Дело в том, что в приложение Javassist нет привычного для нас всех метода main. Вместо этого метода используется метод, который именуется как premain. В принципе, название говорит само за себя. Этот метод главнее чем метод main. Собственно, потому он и называется premain. Логично, что и содержимое файла манифеста MANIFEST.MF теперь будет другим. Вместо “Main-Class” теперь будет использоваться “Premain-Class:”.

Содержимое MANIFEST.MF с Premain-Class:

Manifest-Version: 1.0
Premain-Class: app.Agent
Built-By: Vasilyev Pavel
Created-By: Apache Maven 3.6.1
Build-Jdk: 1.8.0_201

Листинг 1.

На вкус и цвет…, но все же не несущие особого value параметры я удалю:

Premain-Class: app.Agent

Листинг 2.

Так будет выглядеть MANIFEST.MF, если мы все это будем прописывать руками. Этот манифест в дальнейшем будет зашит в JAR файл и лежать вместе с package, в которых находятся скомпилированные Java-классы. Чтобы избежать лишнего конфигурирования мы воспользуемся плагином, который сам все упакует и подложит куда нужно.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.2.4</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <finalName>agent</finalName>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <manifestEntries>
                            <Premain-Class>app.Agent</Premain-Class>
                        </manifestEntries>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

Листинг 3.

И конечно же мы не можем забыть, собственно, о самой библиотеке Javassist.

<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.20.0-GA</version>
</dependency>

Листинг 4.

В итоге мы имеем Maven-проект с подключенной библиотекой в зависимостях pom.xml.

Весь код pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.agent</groupId>
    <artifactId>javaagent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven-compiler-plugin.source.version>1.8</maven-compiler-plugin.source.version>
        <maven-compiler-plugin.target.version>1.8</maven-compiler-plugin.target.version>
        <maven-compiler-plugin.inherited>true</maven-compiler-plugin.inherited>
        <maven-compiler-plugin.encoding.version>UTF-8</maven-compiler-plugin.encoding.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.20.0-GA</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <scope>compile</scope>
            <version>3.11</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>agent</finalName>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Premain-Class>app.Agent</Premain-Class>
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Листинг 5.

Теперь, когда все готово для упаковки в нужную структуру, можно написать и сам код, который будет исполняться и пропускать через себя байткод скомпилированных классов из другого JAR файла. Но так как мы еще не написали Java-код для целевого Java-проекта, то оставим эту заготовку в виде Maven проекта с подключенной библиотекой, а потом дополним эту заготовку логикой по трансформации исполняемого байткода.

Пишем целевое Java-приложение

Это будет самый обычный java-проект, в котором существует класс Main:

public class Main {

    static int myInt1 = 77;

    public static void main(String[] args) {
        System.out.println("Hello World and myInt1 = " + myInt);
    }
}

Листинг 6.

Наша цель:

Внедрить в байткод класса Main свою реализацию метода main и запустить код на исполнение. Итак, наше целевое приложение для опытов написано! Теперь соберем его в Jar архив и приступим к наполнению логикой нашей заготовки, которую мы бережно написали в первой части.

Работаем с Javassist

Ранее мы подготовили структуру проекта и подключили необходимые зависимости.

Напишем саму логику внедрения в байткод. Для этого создадим класс “Agent” и добавим в него единственный метод “premain”. Данный метод абсолютно такой же как метод “main” в простом классическом приложении типа “Hello World” с той лишь разницей, что метод “main” теперь – “premain” и этот метод принимает на вход два параметра. Хоть разница и не значительная но после применения приставки “pre”, наше приложение перестает быть классическим и его уже не получится так просто собрать в два клика через Intellij Idea.

public static void premain(String agentArgs, Instrumentation instrumentation) {
}

Листинг 7.

Собрать такой проект можно либо руками, компилируя каждый класс, создавая манифест файл, а потом запаковывать все в Jar файл, либо создать Maven проект и автоматизировать всю сборку при помощи определенных “plugin”. Конечно же мы выберем второй вариант, через Maven, так как нам нужно подключить еще и саму библиотеку Javassist.

 Здесь-то нам и пригодится наш подготовленный конфиг файла pom.xml (см.выше).

 Главный метод “premain” создан и теперь нужно написать соответствующую логику по трансформации байткода целевого приложения. Для этого воспользуемся ”Instrumentation”, ссылку на который мы получили в параметрах. Только перед тем, как использовать ”Instrumentation” мы должны добавить класс, в котором будет описана логика по трансформации загружаемого байткода из классов.

Вот сам класс, в котором происходит трансформация байткода (ниже будет пояснение):

public class ClassTransformer implements ClassFileTransformer {

@Override
public byte[] transform(final ClassLoader loader,
                        final String className,
                        final Class<?> classBeingRedefined,
                        final ProtectionDomain protectionDomain,
                        final byte[] classfileBuffer) {

        byte[] byteCode = classfileBuffer;

        if ("com.company.Main".equals(className.replaceAll("/", "."))) {

            try {
                ClassPool pool = ClassPool.getDefault();
                CtClass ctClass = pool.get("com.company.Main");
                CtMethod myMain = ctClass.getDeclaredMethod("main");
                ctClass.removeMethod(myMain);

                CtField toBeDeleted = ctClass.getField("myInt1");
                ctClass.removeField(toBeDeleted);
                CtField ctField = new CtField(CtClass.intType, "myInt1", ctClass);
                ctField.setModifiers(Modifier.STATIC | Modifier.FINAL | Modifier.PUBLIC);
                ctClass.addField(ctField, "123");

                CtField name = CtField.make("static int myInt2 = 45;", ctClass);
                ctClass.addField(name);

                ctClass.addMethod(CtNewMethod.make("public static void main(String[] args) { int localInt = 67; System.out.println(\"Our numbers : \" + myInt1 + \" : \" + myInt2 + \" : \" + localInt);}", ctClass));
                ctClass.addMethod(CtNewMethod.make("public void onEvent(){System.out.println(\"Hello World\");}", ctClass));

                CtMethod[] methods = ctClass.getDeclaredMethods();

                for (CtMethod method : methods) {
                    System.out.println("!!!!!!! + " + method.getName());
                    if (method.getName().equals("main")) {
                        try {
                            method.insertAfter("System.out.println(\"Logging using Agent\");");
                        } catch (CannotCompileException e) {
                            e.printStackTrace();
                        }
                    }
                }
                try {
                    byteCode = ctClass.toBytecode();
                    ctClass.detach();
                    return byteCode;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                ctClass.detach();
                return byteCode;
            } catch (NotFoundException e) {
                System.out.println(e.getMessage());
            } catch (CannotCompileException e) {
                e.printStackTrace();
            }

        }
        return byteCode;
    }
}

Листинг 8.

А теперь добавим это класс в качестве аргумента для метода addTransformer.

instrumentation.addTransformer(new ClassTransformer());

Листинг 9.

Ну, все готово для запуска и проверки трансформации нашего байткода.

 Перед проверкой мы конечно же разберем что происходит в переопределенном методе “transform” (Листинг 8).

Самое первое на что мы обращаем внимание, так это на то, что данный метод возвращает массив байтов. Дело в том, что на вход данного метода одним из параметров подается массив байт от класса, который загружается. Таким образом в метод “transform” попадают абсолютно все классы, которые загружаются в JVM. Точнее не сами классы, а байткод классов. Именно в тот момент, когда в наш метод “transform” попал байткод определенного класса мы можем трансформировать его на свой лад и вернуть байткод, но в уже в “редактированном виде”. Такое “редактирование” называется “трансформация”.

 И сразу же, что приходит в голову, так это то, как мы редактируем байткод, ведь он представлен в шестнадцатеричной системе? Конечно же, разбираться в последовательности закодированных значений довольно не простая задача, да и нам это ни к чему. Ведь специально для таких вот случаев и была написана библиотека Javassist!

С ее помощью, мы будем оперировать байткодом точно так же, как мы оперируем на низком уровне кодом, когда что-то пишем на языке более высокого уровня. Это весьма удобно.

Можно долго дискутировать о том, что программисты уже давно обленились и сейчас мало кто задумывается о том, как вообще происходит сборка проекта, каким образов все упаковывается в один проект и для чего вообще нужен CP, ведь редакторы и плагины позволяют все это делать почти молниеносно, экономя при этом наше драгоценное время и нервы, но размышлять об этом мы здесь не будем.

Начинается самое интересное. Помните, в листинге 6, мы написали нашу стандартную программу из разряда “Hello World”? В нашем варианте мы усовершенствовали “Hello World” и к одноименной фразе добавили еще вывод числа “myInt1”. Теперь наша программа выводит в консоль фразу "Hello World and myInt1 = 77".

Попробуем “трансформировать” байткод класса Main, а именно изменить вывод данной строки, да не просто изменить, а еще попытаемся определить новые переменные, присвоить им значения и вывести все это в консоль!

В листинге 8, видно, что общаться с кодом, через библиотеку Javassist довольно просто. Первое что мы должны сделать – остановиться на том классе, в байткод которого требуется вмешательство. Поэтому обращаемся к переменной “classname” и проверяем на нужном ли классе мы находимся. Если на нужном, то объект, который будет подвержен трансформации найден и можно его начать изменять.

Думаю, что дальше коментарии будут лишними, так как в коде и так все понятно.

Итак, осталось сделать последнее действие – запустить оба наших jar-архива! Это можно сделать командой:

java -javaagent:agent.jar -jar demo.jar

Следует отметить, что запускаемый javaagent – обычная java-программа, а следовательно при запуске можно прописывать все ключи, которые могут быть вам необходимы.

После трансформации наш вывод будет иметь следующий вид:

Our numbers : 123 : 45 : 67

Summary:

Наверное на этом стоит остановиться, потому что чем хотел поделиться я поделился:

- мы научились создавать java-проект, который загружается первым и трансформирует код другого загружаемого проекта, путем пропускания его байткода через себя;

- мы научились писать код для трансформации загружаемого байткода;

- мы научились запускать последовательность созданных jar-файлов javaagent и целевого приложения.

 Надеюсь эта статья помогла тем, кто хочет начать изучение библиотеки Javassist.

Если есть какие-то дополнения и комментарии, то пожалуйста пишите. Буду рад любой обратной связи. Так же прошу поделиться своими знаниями по тонкостям использования данной библиотеки.

Всем большое спасибо и больших успехов!