Как скомпилировать jar файл мода

Обновлено: 07.07.2024

Есть запакованная, рабочая программа.
Я распаковал её винраром - получил папку с файлами:

META-INF/MANIFEST.MF
META-INF/SECURE_K.RSA
META-INF/SECURE_K.SF
bla.class
bla2.class
bla3.class

И далее куча файлов с расширением *.class.

Я так понял, сама программа - это манифест и классы, файлы SECURE_K.* - это для архива и они сами сгенерируются при упаковке?
Удаляю ненужные файлы.(два).

С классами понятно, они нужны, их не надо трогать.

Дальше, в манифесте, кроме этого:

Нужно удалить список файлов из манифеста, он тоже сам сгенерируется?

В общем хочу чтобы все хеши заново были прописаны (я изменил несколько классов), вручную долго это делать.

Оставляю в папке только манифест (5 строк, без списка файлов), далее командой:
Синтаксис:
jar cf 'имя'.jar входные_файлы_через_пробел

Я ввожу в JDK
jar cf applet.jar bla.class bla2.class bla3.class

Как в список файлов включить манифест и нужно ли его включать?

Я уже год не могу скомпилировать этот уродский архив.

Добавлено через 43 минуты

Не получилось.
Архив создался, все файлы в нём, папка META-INF, в ней MANIFEST.MF с таким содержанием:

Manifest-Version: 1.0
Created-By: 1.8.0_73 (Oracle Corporation)

Добавлено через 6 часов 39 минут

Всё, запаковал - работает.
Часть нашел(как мало инфы на эту тему в интернете), остальное додумал.

Извлекаем винраром всё из *.jar файла в какую - нибудь папку.
Получаем в ней папку META-INF(в ней файлы MANIFEST.MF и возможно SECURE_K.RSA, SECURE_K.SF) и сколько - то файлов *.class.

Далее, если хотим что-то изменить, нужно декомпилировать файлы *.class(это и есть сам апплет).
Хотя возможно и такое, что исходники были в архиве, смотрите файлы *.java.
В этом поможет например этот онлайн ресурс.
Выбираем файл *.class, ниже находится поле Select a decompiler с радиокнопками, ставим Fernflower - это самый стабильный метод(по мнению кого - то из интернета).

Жмём Upload and Decompile, ждём несколько секунд и появляется кнопка скачать, и декомпилированный код для просмотра ниже.

Далее, создаём папку проекта где угодно, но удобнее делать это ближе к корню, я сделал:
D:\Project.
Вставляем в неё все извлечённые из *.jar файлы *.class.
Создаём папку, например src и кидаем туда все файлы *.java(это исходники, которые декомпилировали из файлов *.class).

Далее создаём Упаковка.cmd(или *.bat) файл для упаковки классов в архив *.jar, и пишем туда:

D:\Programs\Java\bin\jar.exe - каталог JDK (подразумевается, что он у вас уже установлен).
cfm - с - будем запаковывать в архив, f - указано имя архива, m - будут добавлены параметры в манифест.
Circuit.jar - имя создаваемого архива.
manifest.txt - из этого файла, будут добавляться параметры в MANIFEST.MF архива.
*.class - маска файлов, говорит о том, что упакованы будут все файлы с расширением class.
*
pause - для того, чтобы консоль не закрылась, и в случае чего, можно было посмотреть ошибки.

Эти параметры создаются сами(версия манифеста и JDK):
Берём остальные параметры, и записываем их в ранее созданный manifest.txt:

Как указывать чтобы были добавлены цифровые подписи я не знаю, но этого хватит для работоспособности *.jar.

Вот и всё, по упаковке, жмём 2 раза по батнику Упаковка.cmd, и архив готов.

А по исходникам, по исходникам вот что, они у нас в папке D:\Project\src, меняем в них что хотим.
Создаём в этой папке Скомпилировать.cmd(или *.bat), и пишем туда:

D:\Programs\Java\bin\javac.exe - каталог JDK.
Circuit.java - это самый главный класс, с него начинается аплет, его можно узнать в том же MANIFEST.MF(Main-Class: Circuit)

__________________
Помощь в написании контрольных, курсовых и дипломных работ здесь

Не получается скомпилировать jar файл
Добрый вечер. Пытаюсь написать плагин. Создаю по инструкции отсюда. Создаю пакет, в нём класс. .

Как создать .jar через утилиту jar.exe
Я начинаю идти в WikiHOW, потом я там делаю все правильно, Конец создания файла сложный, я пишу jar.

Как в java создать исполн jar файл для выполнения с целью, что бы потом код этого jar нельзя было использовать
(Новичок) Добрый день. Подскажи пожалуйста, как быть. Как создать jar файл что бы потом его код.

Объединить .jar и /lib в один .jar
Допустим у меня примерно такая структура программы после сборки . \app\abc.jar.

Затрудняюсь скомпилировать, просто скомпилировать
У меня Microsoft Visual Studio 2012 ultimate и в связи с тем, что я только только начала осваивать.

Как преобразовать jar в sh
Всем привет, сегодня закончил верстать программу собрал в jar пакет, но хочется его преобразовать в.

Как создавать jar
Недавно начал учить Java. Возник вопрос как создавать самостоятельные проги на Java (вроде.

Программирование в IDE — прекрасно: связанность зависимостей кода, удобный дебаг, понятное тестирование, темная тема. Так вот, благодаря IDE разработка развивается семимильными шагами. Но она расслабляет. С каждым днем, погружаясь в функционал IDE, разработчик привыкает к коммиту одной кнопкой или сборке двумя кликами. Гораздо хуже обстоит ситуация с новичками в программировании, которые с самого начала работают в IDE, игнорируя работу в командной строке. Например, в Intellij IDEA компиляция Java приложения демонстрируется загрузочным баром в нижней панели, а все параметры компиляции, обработка classpath и прочих прелестей Java-жизни остается за кадром. Предлагаем поговорить о компиляции в Java без IDE. Для запуска примеров в статье следует убедиться, что на вашей машине установлена JDK 1.7 и старше.

Как скомпилировать программу?

Есть исходный код в файле с именем НазваниеКласса.java;
Если в коде нет ошибок, он компилируется в байт-код (в файл НазваниеКласса.class);
Программа запускается.

Для чего нужна команда javac

Окей, первый пункт выполнен. Идем дальше, чтобы понять: скомпилировать — это как? :) В этом нам поможет команда javac, в аргументе которой необходимо указать нужный файл: Если нет ошибок в коде, рядом с файлом Test.java появится файл Test.class. Это и есть скомпилированный байт-код. Теперь его нужно запустить. Здесь используется команда java, запускающая байт-код: На скриншоте видно, что в выводе получаем какие-то иероглифы: очевидно, это сбитая кодировка. Как правило это происходит в системе Windows. Для корректного отображения кириллицы в консоли, есть следующие команды: Они меняют текущую кодовую страницу командной консоли на время работы текущего окна. Попробуем еще раз: Это говорит приложение из командной строки. Знать принцип работы команды javac очень полезно, так как эта команда лежит в основе любой системы сборки проектов.

Компиляция и выполнение нескольких классов

Для работы с несколькими классами нужен classpath. Он похож на файловую систему, в которой содержатся классы, а функцию папок выполняют пакеты (packages). На этом этапе стоит задуматься об отделении файлов исходного кода от скомпилированных файлов. Как правило исходники находятся в каталоге src, а скомпилированные классы — в bin. Например, у нас есть класс Box и класс BoxMachine , в котором содержится метод main . Класс Box : Он находится в пакете src, это необходимо зафиксировать. Класс BoxMachine : Этот класс также находится в пакете src. В методе main он создает пять объектов класса Box разного размера и выводит в консоль информацию о них. Чтобы скомпилировать эту группу классов, необходимо из главного каталога (в котором лежат папки src и bin) использовать команду javac с аргументами: -d — флаг, после которого следует указать расположение, куда попадут скомпилированные классы. Это очень удобно, так как перекладывать, например, 1000 классов — очень трудоемкий процесс. bin — название папки. ./src/* — расположение исходных файлов. * указывает, что необходимо скомпилировать все файлы. Теперь скомпилированные классы появились в папке bin. Для их запуска используется команда java из той же директории, также с аргументами: -classpath — флаг, после которого следует указать местоположение скомпилированных классов. Java будет искать главный класс и все сопутствующие именно в этой директории. ./bin — название папки, в которой находятся скомпилированные классы. BoxMachine — название главного класса. Как и в первом случае, не следует указывать .class , так как это название класса, а не файла. Вывод:

Создание JAR-файлов

Чтобы программу было легко переносить и запускать, можно собрать скомпилированные классы в jar-файл — архив классов. Главное отличие от zip или rar-архивов — наличие файла манифеста. В этом манифесте указывается главный класс, который будет запускаться при выполнении jar-файла, classpath, а также много дополнительной информации. В главном каталоге создадим файл manifest.mf. Его содержимое будет следующим: main-class указывает класс, который содержит метод main и будет выполнен при запуске. class-path — путь к скомпилированным классам или дополнительным библиотекам. Настало время собрать настоящую программу без IDE с помощью команды jar: -cmf — флаг, после которого следует указать путь к файлу манифеста. manifest.mf — путь к манифесту. box-machine.jar — название выходного jar-файла. -С — флаг, после которого указывается путь к скомпилированным классам. . — путь, куда будет помещен jar-файл. В нашем случае —это главный каталог. Теперь можно запустить. Запуск jar-файлов выполняется также с помощью команды java, но следом нужно указать флаг -jar : он говорит о том, что запускается Jar-файл, а второй аргумент — путь к jar -файлу, включая расширение: Вывод:

Компиляция в Java без IDE: обзор систем сборок

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

Как скомпилировать Java?

Самые известные системы сборки на Java — это Ant, Maven и Gradle. Среди нет плохой или хорошей: каждая из них создана для решения определенных задач. Рассмотрим каждую из них подробнее.

mkdir — создание директорий
delete — удаление файлов и директорий
javac — компиляция Java–кода
java — запуск скомпилированного кода

Maven

Maven предлагает несколько другой подход к сборке проектов. Здесь разработчик скорее описывает свой проект и дополнительные инструменты, которые использует, в отличие от Ant, где сборка — это последовательность действий. Maven популярен среди разработчиков благодаря простому управлению зависимостями и удобной интеграции со всеми средами разработки. При работе с Maven придерживаются такой структуры проекта: Правила сборки, зависимости и прочее описывается в файле pom.xml. Как правило он находится в главной папке проекта. При запуске Maven проверяет структуру и синтаксис файла, предупреждая об ошибках. В главной директории рядом с папками bin и src создаем файл pom.xml, внутрь добавляем: Далее в командной строке выполняем команду mvn: Теперь в папке bin есть папка src, в которой находятся скомпилированные классы. В pom.xml в теге build определена цель сборки — компиляция, директории файлов исходного кода и результата компиляции, а также имя проекта. У Maven есть множество целей сборки и плагинов для запуска тестирования, создания Jar-файлов, сборки дистрибутивов и других задач.

Gradle

Это самая молодая система сборки, которая основывается на Ant и Maven. Главное отличие — работа на базе ациклического графа для определения порядка выполнения задач. Это очень полезно при более сложных задачах, например, инкрементальных и многопроектных сборках. При сборке с помощью Gradle также рекомендуется придерживаться структуры папок проекта Maven. Кстати, файл для сборки в Gradle он называется build.gradle и выглядит гораздо меньше, чем у Maven. Пример для наших классов: В файле происходит подключение плагинов, определение директории файлов исходного кода (если не используется структура проектов Maven), директория результатов сборки, имя главного класса, а также задачи по умолчанию. За запуск сборки отвечает команда gradle в директории, где лежит файл build.gradle:

Заключение

На первый взгляд, умение компиляции и сборки кода без IDE кажется бесполезным. Действительно, зачем мучиться с командными строками и гуглить все команды, когда есть уютная IDEшечка с плагинами, автопроверкой всего что можно (современные IDE разве что уровень IQ не проверяют) и интеграцией с популярными системами. Однако практика показывает, что умение собирать код без среды разработки и понимание каждого шага этого процесса — суровая необходимость. Этот навык сэкономит немало нервных клеток и времени вам и вашей компании. Освоить работу в IDE, попрактиковаться в написании кода и, конечно же, получить фундаментальные основы по программированию на Java вы можете здесь — на JavaRush. Пора вернуться к обучению :)

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

Наш проект будет состоять всего из двух классов, причём один будет вызывать метод другого.

Класс Other, единственный метод которого выводит строку текста на экран:

public class Other public String getMessage() return "Привет, мир!" ;
>
>

Сохраним этот текст как есть в файл, имя которого обязательно должно совпадать с именем класса, т.е. Other.java.

Класс Main:

class Main public static void main(String. args) Other other = new Other();
System.out.println(other.getMessage());
>
>

Поскольку здесь есть статичный метод main(), то этот класс может использовать как точка начала работы нашего приложения (так называемый «Main-Class»). Внутри мы создаём экземпляр класса Other, вызываем его единственный метод и выводим результат на экран.

Сохраним исходники этого класса в файле Main.java.

Теперь мы готовы к тому, чтобы скомпилировать написанный нами код. Для этого используется утилита javac, которая поставляется вместе с jdk. Выполним эту команду в той папке, где лежат оба наших файла:

Опция -d указывает, какие именно файлы мы хотим скомпилировать. В результате в нашей папке помимо исходников появится иерархическая структура папок и файлов:

├── Main.java
├── Other.java
└── ru
└── devmark
├── helper
│ └── Other.class
└── Main.class

class-файлы - это бинарные файлы с байт-кодом, которые может обрабатывать виртуальная машина Java. Обратите внимание, что каждый класс компилируется в свой собственный файл. Таким образом достигается модульность нашего приложения. Более того, скомпилированный класс будет работать в любой операционной системе на любой java-машине.

Но когда мы говорим о приложении, то ожидаем увидеть один файл, а не кучу папок. Давайте упакуем наши class-файлы в jar-архив. В этом нам поможет одноимённая утилита.

Опция c говорит, что нужно создать новый архив, f задаёт имя будущего архива, а e указывает полное имя main-класса. В конце указываем папку, в которой лежает все class-файлы.

В результате вы получите файл lesson1.jar, который готов к запуску:

В результате на экране вы увидите приветствие, которые генерирует наш класс Other.

Примечательно, что jar-архив - это обычный zip-архив определённой структуры. Открыв его любым архиватором вы увидите наши class-файлы в иерархии пакетов, а также папку META-INF с файлом MANIFEST.MF. Этот файл содержит вспомогательную информацию об архиве.

У меня этот файл манифеста выглядит так, но у вас может отличаться:

Manifest-Version: 1 . 0
Created-By: 9 . 0 . 4 (Oracle Corporation)
Main-Class: ru.devmark.Main

Здесь указано, в какой версии java был создан архив, а также указан Main-Class. Как видите, ничего сложного.

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

Команды java и javac редко используются Java-программистами. Такие инструменты, как Maven и Gradle делают их почти не нужными. Однако Maven и Gradle до сих пор не предоставляют полную поддержку для Java 9, поэтому, если вы хотите начать использовать её уже сейчас или просто хотите узнать некоторые полезные тонкости до официального релиза, стоит научиться вызывать java , javac и jar для управления своим кодом.

Статья призвана показать примеры использования этих команд, а также то, как эти команды изменились по сравнению с прошлыми версиями Java. Дополнительно будут рассмотрены новые инструменты: jdeps и jlink . Предполагается, что вы хоть немного знакомы с предыдущими версиями команд java / javac / jar и с модульной системой Java 9.

Установка Java 9

Сперва необходимо установить Java 9. Вы можете скачать её с сайта Oracle, но рекомендуется использовать SdkMAN!, так как в будущем он позволит вам с легкостью переключаться между разными версиями Java.

Можно установить SdkMAN! с помощью этой команды:

Посмотрите, какая сборка является последней:

Затем установите Java 9:

Теперь, если у вас установлены другие версии Java, вы можете переключаться между ними с помощью команды:

Компиляция и запуск «по-старому»

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

Возьмем этот простой Java-класс:

Теперь, так как мы не использовали никаких особенностей Java 9, мы можем скомпилировать всё как обычно:

Команда создаст файл класса out/app/Main.class . Запустить его можно так же, как и в прошлых версиях:

Программа выведет Hello Java 9 .

Revolut , Санкт-Петербург, Москва, можно удалённо , По итогам собеседования

Теперь создадим библиотеку Greeting также без особенностей Java 9, чтобы посмотреть, как это работает.

Создадим файл greeting/ser/lib/Greeting.java со следующим кодом:

Изменим класс Main для использования нашей библиотеки:

Скомпилируем эту библиотеку:

Чтобы показать, как работают оригинальные Java-библиотеки, мы превратим эту библиотеку в jar-файл без дескрипторов модулей Java 9:

Команда создаст файл libs/lib.jar , содержащий класс lib.Greeting .

Просмотреть информацию о jar-файле можно с помощью опции tf :

Команда должна вывести:

Теперь для компиляция app.Main нам необходимо указать компилятору, где найти класс lib.Greeting .

Используем для этого cp (classpath):

И то же самое для запуска программы:

Мы можем упаковать приложение в jar-файл:

И затем запустить его:

Вот так выглядит структура нашего проекта на данный момент:

Модуляризация проекта

Пока что ничего нового, но давайте начнем модуляризацию нашего проекта. Для этого создадим модульный дескриптор (всегда называется module-info.java и размещается в корневой директории src/ ):

Команда для компиляции модуля в Java 9 отличается от того, что мы видели раньше. Использование старой команды с добавлением модуля к списку файлов приводит к ошибке:

Чтобы понять, почему наш код не компилируется, необходимо понять, что такое безымянные модули.

Любой класс, который загружается не из именованного модуля, автоматически выполняет часть безымянного модуля. В примере выше перед созданием модульного дескриптора наш код не был частью какого-либо модуля, следовательно, он был ассоциирован с безымянным модулем. Безымянный модуль — это механизм совместимости. Проще говоря, это позволяет разработчику использовать в приложениях Java 9 код, который не был модуляризирован. По этой причине код, относящийся к безымянному модулю, имеет правила сродни Java 8 и ранее: он может видеть все пакеты, экспортируемые из других модулей, и все пакеты безымянного модуля.

Когда модульный дескриптор добавляется к модулю, его код больше не является частью безымянного модуля и не может видеть код других модулей, пока не импортирует их. В случае выше модуль com.app не требует никаких модулей, поэтому модуль библиотеки Greeting для него не виден. Он может видеть только пакеты модуля java.base .

Модули в Java 9, за исключением неуловимого безымянного модуля описанного выше, должны объявлять, какие другие модули им необходимы. В случае с модулем com.app единственным требованием является библиотека Greeting. Но, как вы могли догадаться, эта библиотека (как и другие библиотеки, не поддерживающие Java 9) не является модулем Java 9. Как же нам включить её в проект?

В таком случае вам нужно знать имя jar-файла. Если у вас есть зависимость от библиотеки, которая не была конвертирована в модуль Java 9, вам надо знать, какой jar-файл вызывается для этой библиотеки, потому что Java 9 переведёт имя файла в валидный модуль.

Это называется автоматический модуль.

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

Чтобы узнать имя автоматического модуля, компилятор конвертирует неальфанумерические, поэтому что-то вроде slf4j-api-1.7.25.jar превратится в имя модуля sl4j.api .

У нас есть библиотека с именем lib.jar . Давайте переименуем jar-файл в greetings-1.0.jar :

Это более стандартное имя файла, и теперь мы можем сказать Java включить автоматический модуль с приемлемым именем greetings . И можем вызывать его из com.app модуля:

Модули не добавлены в classpath . Как и обычные jar-файлы, они используют новый флаг --module-path (-p) . Теперь мы можем скомпилировать наши модули следующей командой:

Чтобы запустить app.Main командой java мы можем использовать новый флаг --module (-m) , который принимает либо имя модуля, либо шаблон module-name/main-class :

И мы получим вывод Hi, there .

Для создания и использования app.jar в качестве исполняемого jar-файла выполните следующие команды:

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

Модуляризация библиотек

Для модуляризации библиотеки нельзя сделать ничего лучше, чем использовать jdeps — инструмент для статистического анализа, который является частью Java SE.

Например, команда, которая позволяет увидеть зависимости нашей небольшой библиотеки, выглядит так:

А вот результат её выполнения:

Как и ожидалось, библиотека зависит только от java.base модуля.

Мы знаем, что com.app зависит от модуля greetings . Давайте попробуем использовать jdeps , чтобы он подтвердил нам это. Для этого нужно удалить файлы module-info.calss и app.jar и затем запустить jdeps :

Хорошо, но можно лучше. Мы можем попросить jdeps автоматически сгенерировать модульный дескриптор для набора jar-файлов. Просто укажите ему, куда сохранять сгенерированные файлы (например, в папку generated-mods ), и где находятся jar-файлы:

Команда создаст два файла: generated-mods/app/module-info.java и generated-mods/greetings/module-info.java со следующим содержимым:

Теперь мы можем добавить сгенерированный дескриптор для нашей библиотеки в её исходный код, переупаковать её, и у нас получится полностью модульное приложение:

Теперь у нас есть полностью модуляризированные библиотека и приложение. После удаления сгенерированных и бинарных файлов, структура нашего приложения выглядит следующим образом:

Обратите внимание, что для получения хороших данных от jdeps вы должны предоставить местоположение всех jar-файлов, которые используются в приложении, чтобы он мог составить полный граф модуля.

Наиболее простым способом получить список всех jar-файлов, которые используются в библиотеке, является использование скрипта Gradle. Он выведет пути локальных jar-файлов для всех зависимостей библиотек, которые вы добавите в секцию зависимостей, и скачает их, если необходимо:

Если у вас нет Gradle, вы можете использовать SdkMAN! для его установки:

Для получения списка зависимостей используйте следующую команду:

Полученную информацию передайте jdeps для анализа и автоматической генерации метаданных.

Это файл, который jdeps выводит для javaslang.match :

Создание собственного образа среды выполнения

С помощью jlink Java-приложения могут распространяться как образы, которые не требуют установки JVM.

Следующая команда создает образ для нашего com.app модуля без оптимизации, сжатия или отладочной информации:

Меньший размер может быть достигнут использованием некоторых флагов jlink , таких как --strip-debug и --compress :

Размер пакетов можно посмотреть с помощью команды du -sh :

Для запуска приложения используйте предоставляемый лаунчер в директории bin :

На этом всё. Разбор нововведений в Java 9 предлагаем прочитать в нашей статье.

Читайте также: