Серия «Жестокие эксперименты»

Поскольку современные разработчики постоянно жалуются на завышенные требования технических интервью вообще и на мою «дурную практику» написания кода от руки в частности — показываю на личном примере как все это работает.

Жертвам «слабой памяти» посвящается.

Заодно узнаете как можно вести разработку на Java хоть в чистом поле — в самолете, в поезде или на закрытом объекте, без подключения к интернету и документации.

Видео

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

Также ролик можно посмотреть на VK Video и Youtube.

Тестовое окружение

Для большей чистоты эксперимента был взят Live-образ Ubuntu Desktop 24.04.3 LTS, записан на флешку, флешка вставлена в один из рабочих ноутбуков, который затем с нее был загружен.

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

Из инструментов у нас будет лишь текстовый редактор и JDK.

И все.

Что будем писать

Самое простое что можно написать в таких полевых условиях — реверс-шелл HTTP-сервер. На самом деле написать можно много чего, особенно если посмотреть в каталог demo внутри OpenJDK:

Здесь и далее скриншоты из другой системы (Manjaro), чтобы не заморачиваться с их перебрасыванием из Live-системы и добавлением в статью. Тем не менее на видео все описываемые в статье шаги и весь код вбиваются каноничным способом — полностью вручную, на чистой системе, загруженной с Live USB.

Демо

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

Так выглядит демо-проект Notepad, реализующий простейший текстовый редактор:

Так выглядит демо Metalworks, с простейшей реализацией мульти-оконной системы (MDI):

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

Все демо-проекты содержат исходный код в архивах src.zip и собираются без внешних зависимостей.

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

Ручная разработка

В ролике в записи показано как автор последовательно вводит и запускает в работу примерно такой код:

// разумеется я не помню названий абсолютно всех
// импортируемых классов, поэтому тут стоит '*'
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class MyWebServer {

static void handle(Socket s) {
// метод getId() устарел, поэтому его использование в
// последних версиях JDK выдает предупреждение
System.out.println("Thread: %d"
.formatted(Thread.currentThread().getId()));

// самое сложное место, которое удалось повторить на записи
// далеко не с первой попытки
try(PrintWriter out = new PrintWriter(s.getOutputStream());
BufferedReader in = new BufferedReader(
new InputStreamReader(s.getInputStream()));) {
// поскольку используется чтение и запись строк а не байт - читаем
// строку целиком, т.е. до символа \n
String l = in.readLine();
// тут просто показываем в консоль
System.out.println(l);
// этим простым способом читаем только строку запроса,
// которая идет первой, пропустив все заголовки
// \r\n (пустая строка) - признак завершения запроса
while (l==null || l.isEmpty() || "\r\n".equals(in.readLine()));

// тут мы 'в лоб' сравниваем строку HTTP-запроса целиком
// так она выглядит до работы парсера
if ("GET /test HTTP/1.1".equals(l)) {
// поскольку мы реагируем только на один url '/test'
// формируем ниже статичный ответ
String data = "Hello from alex0x08 at "+ new Date();
// так выглядят стандартные поля ответа в 'raw' виде, без обработки
out.println("HTTP/1.1 200 OK");
// 'close' дает указание браузеру разорвать соединение
// с сервером сразу после получения данных
out.println("Connection: close");
// поскольку мы отдаем строку - ставим MIME тип 'text/plain'
out.println("Content-Type: text/plain");
// опционально отдаем размер данных
out.println("Content-Length: " + data.length());
// пустая строка - признак начала блока с данными
out.println();
// отдаем сами данные
out.println(data);
} else {
// во всех остальных случаях формируем ответ 404
out.println("HTTP/1.1 404 Not Found");
out.println("Connection: close");
out.println();
}
// нужно обязательно вызывать поскольку PrintWriter кеширует данные
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
// в любом случае закрываем клиентский сокет
try {s.close();} catch (Exception ee) {}
}
}
// стартовый метод приложения
public static void main(String[] args) throws Exception {
System.out.println("Starting..");
// тоже сложное место, которое было непросто ввести по памяти
ExecutorService p = Executors.newFixedThreadPool(10);
// создание 'серверного' сокета, который будет прослушивать
// указанный порт
// поскольку хост не указан - будут прослушиваться все (0.0.0.0)
ServerSocket ss = new ServerSocket(8089);
// бесконечный цикл, который нужен тк метод accept() - блокирующий
// и выход из него произойдет после получения входящего подключения
while (true) {
// получен клиентский сокет
Socket s = ss.accept();
// запуск асинхронной обработки
p.execute(() -> handle(s));
}
}
}

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

Данный исходный код реализует простейший многопоточный веб-сервер на Java, который отвечает лишь на один URL /test и отдает заранее заданную строку с датой.

Как видите даже столь небольшого количества строк достаточно, чтобы можно было подключиться из современного браузера Chrome:

Компиляция выполняется как и в записи всего одной командой:

javac -cp . MyWebServer.java

После чего появится один единственный class-файл c совпадающим именем. Поскольку пакеты не использовались, для запуска достаточно указать в качестве classpath текущий каталог:

java -cp . MyWebServer

Но это все лирика и понты.

Когда кончается человеческая память

Разумеется невозможно запомнить абсолютно все и рано или поздно вы столкнетесь с названием метода или класса, которые надо где-то подсмотреть.

Для примера, автор при записи видео столкнулся с таким в двух местах:

длинные классы-обертки над потоками (stream) сокета и сложное название статичного метода, создающего экземпляр ExecutorService.

И то и другое получилось правильно ввести далеко не с первой попытки.

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

Невероятно но факт:

подсмотреть названия системных классов и методов можно.. в самом JDK!

Вот это поворот!

В последних версиях JDK появилась интересная утилита jimage, которая находится в каталоге bin (там же где и главные бинарники java и javac).

С помощью этой штуки можно легко посмотреть полные названия всех системных классов:

Правда знание полного имени класса не всегда помогает, поскольку в JDK много вложенных системных классов, которые по идее вызывать снаружи не надо.

Команда для запуска:

jimage list $JAVA_HOME/lib/modules |less

Где переменная JAVA_HOME указывает на каталог с установленной JDK:

Так вы увидите названия всех системных классов, но что делать с методами?

Вытаскиваем сигнатуры методов

Тут тоже есть решение, поскольку эта же самая утилита позволяет распаковывать jmod-файлы в которых находятся системные классы JDK:

jimage extract --dir=/opt/src/tmp $JAVA_HOME/lib/modules

А еще одна утилита javap позволяет посмотреть метаданные class-файла, в том числе сигнатуры всех методов:

cd /opt/src/tmp/jre
javap java.base/java/nio/Bits.class

Так выглядит результат:

Вот этого уже с запасом хватит для полевой разработки в условиях крайнего Севера.

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

Исходники JRE

Если вам совсем повезет, в каталоге JDK/lib будет находиться файл src.zip, внутри которого будут исходники всех системных классов JRE:

«Повезет» — потому что также как и demo, этот файл часто удаляют ментейнеры дистрибутивов Linux, с переносом в отдельный пакет. Но разумеется если он присутствует, то поможет гораздо больше чем все приседания с javap.

В распакованном виде:

Внутри находится исходный код всех классов Java, используемых в JDK:

cat java.base/java/io/Bits.java |less

Для примера, так выглядит исходный код класса java.io.Bits, который мы просматривали выше с помощью javap:

Эпилог

Смысл такой «полевой разработки» — в первую очередь глумеж над джунами проверка реальных практических навыков, которые находятся в голове у программиста, а не где‑то в интернете. К сожалению ныне можно констатировать, что такие навыки являются большой редкостью и мало кто из кандидатов, которых я когда-либо собеседовал могли осилить написание хотя‑бы трети подобного кода.

Кстати в нашем Телеграм-канале выложено первое техническое видео, где впервые получилось проверить всю эту идею.

Статья была опубликована на Хабре, более вольный оригинал статьи как обычно в нашем блоге.

Наш волшебный дикий веб

Что первым делом приходит в голову, когда говорят о «веб-разработке»? Наверное что-то вроде "создание сайтов или веб-приложений"?

Лендинги, сайты-визитки, интернет-магазины или какие-нибудь веб-порталы в ад.

Самые продвинутые из читателей вспомнят PWA или какой-нибудь React Native с Flutter — предел полета фантазии обычного разработчика.

Что плохо:

главное что отделяет человека от великих свершений это его фантазия — точно нельзя сделать только то, что невозможно вообразить.

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

Пожалуйста не пытайтесь рассказывать о таком на интервью в обычных компаниях — пожалейте интервьюера и его нежную психику.

Дичь первая: HTMLang

Не смог пропустить столь жизнеутверждающее описание от автора этого замечательного проекта:

They were laughing that HTML was not a real programming language... WHO"S LAUGHING NOW!!11

Да, это именно то что вы подумали — кто-то будучи сильно не в духе взял общий синтаксис HTML и создал на его основе полноценный язык программирования.

Вот так выглядит реализация знаменитого FizzBuzz:

<!DOCTYPE html>
<html>
<head>
<title>FizzBuzz</title>
</head>
<body>
<h3>Look into the DevTools Console</h3>
<htmlang style="display: none;">
<call target="console.log"><s>Generating FizzBuzz...</s></call>
<for><v>i</v> <n>1</n> <n>100</n>
<cond>
<when>
<eq>
<mod>
<v>i</v>
<n>15</n>
</mod>
<n>0</n>
</eq>
<call target="console.log">
<s>FizzBuzz</s>
</call>
</when>
<when>
<eq>
<mod>
<v>i</v>
<n>3</n>
</mod>
<n>0</n>
</eq>
<call target="console.log">
<s>Fizz</s>
</call>
</when>
<when>
<eq>
<mod>
<v>i</v>
<n>5</n>
</mod>
<n>0</n>
</eq>
<call target="console.log">
<s>Buzz</s>
</call>
</when>
<else>
<call target="console.log"><v>i</v></call>
</else>
</cond>
</for>
</htmlang>
<script src="./HTMLang.js"></script>
</body>
</html>

Не представляю что будет если самому Джоэлу выдать его же знаменитый «FizzBuzz» в такой реализации — есть шанс что старый сишный программист впадет в рекурсию.

Кстати кто там рассказывал на лекциях про «декларативный язык разметки» и «общую неполноценность»?

HTML (от англ. HyperText Markup Language — «язык гипертекстовой разметки») — стандартизированный язык гипертекстовой разметки документов для просмотра веб-страниц в браузере.

Зря старались, автор этого проекта тем временем спокойно пишет в консоль тегами HTML:

<call target="console.log">
<s>FizzBuzz</s>
</call>

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

Дичь вторая: HTML-as-programming-language

Нехорошие мысли терзают многих опытных разработчиков — все та же идея «полноценной разработки на HTML» не дает покоя и автору данного проекта.

Но только он зашел в этом процессе несколько дальше предыдущего.

Как вам например функция на чистом HTML:

<def multiplyFunction returns=int> <!-- You can create functions -->
<param a type=int/>
<param b type=int/>
<return>a * b</return>
</def>

<def main>
<var result type=int>
<!-- Create variables -->
<multiplyFunction>
<!-- and store the result of the function in the variable -->
<param>5</param>
<param>6</param>
</multiplyFunction>
</var>
</def>

Известная библейская истина «многие знания — многие печали» — как раз про этот проект, например я бы очень хотел все это забыть и никогда о подобном не знать.

Но к сожалению уже слишком поздно, поэтому делюсь откровениями:

Да, вы все правильно поняли — это самый настоящий компилятор из HTML в нативный ELF64.

А сейчас совсем поплохеет:

To write code for Adruino/AVR microcontrollers, (Arduino UNO for example) you need to put a DOCTYPE tag in your HTML file.

For example:

<!DOCTYPE avr/atmega328p>

Да, это была оригинальная задумка автора — разработка для микроконтроллеров на HTML, я ничего не придумываю.

К слову, небольшая магия с #include <stdio.h> на скриншоте выше была необходима как раз потому, что компилятор предназначен для микроконтроллеров и не добавляет в генерируемый код на С этот стандартный для обычной ОС заголовок.

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

А мы тем временем переходим к следующему замечательному проекту.

Дичь третья: ass-js

Таким названием и не менее характерным логотипом, авторы честно намекают на суть проекта:

Assembler implemented in JavaScript

Полагаю вы еще никогда не устанавливали компилятор ассемблера с помощью npm? Что ж, все когда‑нибудь бывает в первый раз:

npm i ass-js

Так выглядит классический «Hello, world»:

import {X64} from '../src/index';

const asm = X64();
asm.code(_ => {
_('db', 'Hello World!\n');
_('mov', ['rax', 1]); // 0x48, 0xC7, 0xC0, 0x01, 0x00, 0x00, 0x00
_('mov', ['rdi', 1]);
_('lea', ['rsi', _('rip').disp(-34)]);
_('mov', ['rdx', 13]);
_('syscall');
_('ret');
});

console.log(asm.toString());

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

Вот так выглядит результат работы:

Зато есть отдельный туториал по разбору примера с «Hello world», где по шагам разобрано как оно работает.

Еще нашелся замечательный вопрос к автору:

I was looking at your project and I couldn't figure out a reason as to why I would (and what, rather) implement with this.

Который как бы намекает на уровень треша и угара в этом проекте. Но едем дальше — к следующему отбитому уникальному проекту.

Дичь четвертая: ts2c

Тут все просто и очевидно:

Produces readable C89 code from JS/TS code.

Собственно все кроме смысла существования этого замечательного проекта — понятно и очевидно. Как-то так выглядит весь пайплайн:

Если вам вдруг будет нужен транспилер из Typescript в чистый Си — берите и пользуйтесь, благо проект очень даже рабочий:

npm install -g ts2c

Работает кстати и из браузера:

<script src="https://unpkg.com/typescript"></script>
<script src="ts2c.bundle.js"></script>
<script>
var cCode = ts2c.transpile("console.log('Hello world!')");
alert(cCode);
</script>

Есть даже онлайн версия:

Несмотря на то что автор честно пишет о куче недоработок:

Work in progress: it works, but only about 70% of ES3 specification is currently supported: statements and expressions - 95%, built-in objects - 17%.

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

Дичь пятая: nerd

Как легко и быстро понять что исследуемый проект — дикое, нерабочее и глючное говно?

По описанию, обещающему бесконечные ништяки:

Javascript's God Mode. No VM. No Bytecode. No GC. Just native binaries.

Отсылка к чему-то божественному в описании технического проекта это вообще практически 100% диагноз, можно отбраковывать только по одному этому признаку — врядли ошибетесь.

Как нетрудно догадаться, вместо нормального JavaScript тут тоже что-то свое божественное:

NerdLang is a substract of JS with some additions, focus on efficiency.

И это «свое» скажем так застряло в далеком прошлом:

Supporting EcmaScript 3 standard

На минуточку, 3я редакция стандарта вышла еще в далеком 2000м году.

А сам проект пытается в который раз «натянуть сову на глобус» и залезть туда, где последовательно обломали клыки все крупные корпрорации уровня Google:

Nerd is a JavaScript native compiler aiming to make JavaScript universal, Nerd is able to compile native apps for Windows, Mac, Linux, iOS, Android, Raspberry, STM32 and more.

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

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

Автор настолько суров, что запихал инстукции сборки и линковки модуля работы с сокетами в package.json:

{
..
"version": "0.0.1",
"nerd":
{
"env": ["std"],
"read_only": [],
"lib":
{
"win32":
[
"-D_WIN32_WINNT=0x0600",
"-Wno-narrowing",
"-D_GNU_SOURCE",
"-I{__EXTERN__}/libuv/include/",
"-I{__EXTERN__}/libuv/src/",
"-D_CRT_SECURE_NO_DEPRECATE",
"-D_CRT_NONSTDC_NO_DEPRECATE",
"{__EXTERN__}/libuv/src/*.h",
"{__EXTERN__}/libuv/src/*.c",
"{__EXTERN__}/libuv/src/win/*.h",
"{__EXTERN__}/libuv/src/win/*.c",
"-I {__MODULE__}/httplib/uWS/",
"-I {__MODULE__}/httplib/uSockets/",
"{__MODULE__}/httplib/uSockets/*.c",
"{__MODULE__}/httplib/uSockets/crypto/*.c",
"{__MODULE__}/httplib/uSockets/eventing/*.c",
"-DLIBUS_NO_SSL",
"-DUWS_NO_ZLIB",
"-fpermissive",
"-w",
"-lm",
"-ladvapi32",
"-liphlpapi",
"-lpsapi",
"-lshell32",
"-luser32 ",
"-luserenv",
"-lwsock32",
"-lws2_32"
]
}
}
}

Увидев вот такой package.json, знакомый веб-разработчик решил навсегда уйти из профессии и теперь пасет коз в горах Кавказа. Ну а я всего лишь не рискнул адаптировать такое для сборки под Linux, так что вы останетесь без примера запуска HTTP-сервера на этом чудище.

Дичь шестая: lemon

Наконец последний на сегодня проект, который по сравнению с предыдущими является можно сказать нормальным и где-то даже применимым:

Lemon is a framework for building Javascript runtime software, built on the Chrome V8 Javascript Engine.

Мне он понравился своей предельной простотой (по сравнению со всеми остальными проектами) и легкостью встраивания.

Специально показываю скрипт сборки целиком:

CXX = g++
V8 = engine/lib/v8
define INCLUDE
$(V8)/include
engine/Core.cpp
engine/Environment.cpp
engine/Lemon.cpp
engine/StaticHelpers.cpp
engine/ObjectCreator.cpp
endef
define APP
app/*.cpp
endef
define LIB
$(V8)/out/x64.release/obj/
endef
define OBJ
v8_monolith
endef
export INCLUDE
export APP
export LIB
export OBJ
build:
(CXX) -I " class="formula inline">$INCLUDE $$APP -L $$LIB -l $$OBJ -std=c++0x -pthread -o lemon

И.. это все.

Настолько простую сборку V8 вижу впервые, честно.

Оно действительно собирается одной командой:

Ниже показано как выглядит двойной «Hello, world», в котором есть как часть на JavaScript так и часть на C++ — немного подумав объединил два примера из документации в один.

App.js:

version();
console.log("Превед из JS");
helloworld();

App.hpp:

#ifndef APP
#define APP

#include "../engine/Lemon.hpp"
using v8::Context;

class App : public Lemon {
public:
void Start(int argc, char* argv[]);
void SetupEnvironment();
};
#endif

App.cpp:

#include "App.hpp"

using namespace v8;

static void Log(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(args.GetIsolate());
String::Utf8Value str(args.GetIsolate(), args[0]);
const char* cstr = StaticHelpers::ToCString(str);
fprintf(stdout, "%s", cstr);
fprintf(stdout, "\n");
fflush(stdout);
}
static void HelloWorld(const FunctionCallbackInfo<Value>& args) {
printf("Превед из C++ \n");
}
void App::SetupEnvironment() {
this->CreateGlobalMethod("helloworld", HelloWorld);
}
void App::Start(int argc, char* argv[]) {

for (int i = 1; i < argc; ++i) {
// Get filename of the javascript file to run
const char* filename = argv[i];
// Create a new context for executing javascript code
Local<Context> context = this->CreateLocalContext();
// Enter the new context
Context::Scope contextscope(context);
this->CreateGlobalObject("console")
.SetPropertyMethod("log", Log)
.Register();
// Run the javascript file
this->RunJsFromFile(filename);
}
}

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

Спросите с чего столько радости?

Потому что это самый настоящий V8, не самопал с реализацией ECMAScript «в переводе Гоблина», а именно тот самый движок, который используется в браузере Chrome — со всеми оптимизациями и наворотами.

А значит при определенных усилиях, у вас будет работать практически любой JavaScript код — в вашем нативном приложении, без всяких жирных Node.js и всех проблем с линковкой и версиями.

Словом берите на вооружение, пригодится.

Одной строкой

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

js-ziju

Compile javascript to LLVM IR, x86 assembly and self interpreting

К сожалению оказался прибит гвоздями к определенной версии MacOS, ни нормально собрать ни прогнать тесты под Linux не удалось. Интересен тем что в одном проекте собран и интерпретатор и компилятор, причем в нативный бинарник.

JS-ASM

JavaScript Assembler x86-16

Генерирует готовые COM-файлы времен DOS, но под эмулятором Dosbox они работать отказались.

Duktape

Duktape — embeddable Javascript engine with a focus on portability and compact footprint

Более продвинутый и известный аналог Lemon, который я нашел слишком поздно и не успел посмотреть.

clangor

«clang ported to js» — можно сразу в цитаты добавлять.

Сломанная и сильно устаревшая сборка, но сам проект — очень крутой, поскольку это полноценный компилятор Clang, вытащенный в веб.

Вот тут есть онлайн версия.

llvm.js

LLVM compiled to JavaScript using Emscripten

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

Она же в готовом виде онлайн.

jssat

Compile JS into LLVM IR - JavaScript Static Analysis Tool

Вот тут находится статья про этот проект, но мне собрать так и не удалось.

js2cpp

A toy js -> c++ compiler written in coffeescript. Uses escodegen to write c++ and tern to figure out types.

Опять сильно устаревшая и сломанная сборка.

js-to-c

Compiled implementation of Javascript, targeting C (for fun)

Половина тестов сломана, но сама сборка проходит — не стал детально изучать.

Letter

Letter is a compiler project built in TypeScript using LLVM node bindings.

Очень интересный, но к сожалению устаревший проект — требует 13й LLVM и старую же версию Node.js.

Подружить с новыми версиями LLVM и Node не удалось.

CaptCC

A tiny C compiler written purely in JavaScript.

Еще один интересный, но неработающий проект — сам компилятор отработал, но ассемблерный код отказался собираться.

Эпилог

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

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

Либо умеете быстро бегать и имеете запасное гражданство.

Статья была опубликована на Хабре, куда более вольная версия данной статьи доступна в нашем блоге.

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

— О юный Чандракант! — молвил гриб. — Помни что «вера без дел мертва». Будет непросто. Враг хитер и коварен, сражаться предстоит тайно и его же оружием..

Прошли годы, затем десятилетия.

Паренек выучил английский, закончил хороший индийский ВУЗ и поступил на работу в крупную индийскую компанию, которой «белые варвары» из далекой страны за океаном заказывали разработку программного обеспечения.

Но не забыл храбрый Чандракант — верный сын индийского народа наставления волшебного гриба и дослужившись до должности системного архитектора начал вершить жестокую месть, сражаясь с «белыми варварами» их же собственным информационным оружием.

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

Если код это изложение мысли в виде набора логических конструкций, то этот проект — программная реализация шизофрении.

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

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

Аннотации

У современных языков вроде Java и C# есть такая замечательная вещь как аннотации — метаданные, которые содержат различные метки и дополнительные настройки, связанные с конкретным полем, методом или классом.

Выглядит это обычно так:

@Configuration
@EnableCaching
public class CacheConfig {
@bean
public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(
javax.cache.CacheManager cacheManager) {
return hibernateProperties -> hibernateProperties
.put(ConfigSettings.CACHE_MANAGER, cacheManager);
}
..
}

Все что начинается с символа @ — те самые аннотации, содержащие определенную единицу смысла, в данном случае посвященную настройке Spring Boot.

Но куда чаще аннотации привязываются к полям класса и используются для хранения метаданных, связанных с конкретным полем:

/**
* Сущность 'заказ'
* @since 1.0
* @Author 0x08
*/
@entity
@table(name = "strm_orders")
@indexed
public class Order extends AbstractAuditingEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,
generator = "order_seq")
@SequenceGenerator(name = "order_seq")
@GenericField
private Long id;
@column(name = "customer_id", nullable = false)
private long customerId;
@column(name = "sender_id", nullable = false)
private long senderId;
@Enumerated(EnumType.STRING)
@column(name = "order_status", nullable = false)
private OrderStatus orderStatus = OrderStatus.NEW;
..

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

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

Никто в своем уме не воспринимал аннотации как полную замену всей логики приложения и соответственно не пытался программировать исключительно с помощью аннотаций — запомните этот важный момент.

SOLID

В современном программировании есть такой термин SOLID — акроним, каждая буква которого обозначает отдельную концепцию:

• S: Принцип единственной ответственности (single responsibility principle)

• O: Принцип открытости/закрытости (open-closed principle)

• L: Принцип подстановки Лисков (Liskov substitution principle)

• I: Принцип разделения интерфейса (interface segregation principle)

• D: Принцип инверсии зависимостей (dependency inversion principle)

Как и любая другая абстрактная концепция, SOLID — «за все хорошее против всего плохого», красиво выглядит на бумаге (в книгах) и в виде строчки резюме, но при реальном использовании становится сильно сложнее и не такой красивой.

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

Особенно когда волшебный говорящий гриб нарекает избранным и готовит к великой миссии — мстить «белым варварам» за годы угнетения их же собственным высокотехнологичным оружием.

Часть 0. Архитектурный джихад

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

к нам обратился (через посредников) классический английский джентельмен с лаконичной просьбой «посмотреть проект и если возможно оценить состояние».

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

На этом месте думаю стоит начать выкладывать конкретные примеры этой «индийской истории ужасов», чтобы дорогие читатели начали наконец понимать о чем идет речь.

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

Что никак не уменьшает убойность архитектурных талантов смелого Чандраканта (да не тронет GC его классы), помноженных на мощь его веры в святое дело борьбы с «белыми угнетателями» путем сжигания их мозгов.

Оригинальный проект представлял собой связку из нескольких десятков JEE-приложений, разворачиваемых на «большой» IBM Websphere и соответственно Java 8, но ради упрощения мы адаптировали реализацию для более современной Jakarta 10, со всеми наворотами новых версий Java (см. ниже).

Начнем демонстрацию с чего‑то более‑менее безобидного, хоть как‑то попадающего в рамки адекватности:

..
@WebFilter("/*")
@WebListener
public class Foo implements Filter,ServletContextListener{
// важная переменная
private int someImportantValue = 42;
@override
public void contextInitialized(ServletContextEvent sce) {
final ServletContext sc = sce.getServletContext();
// прокидывание в контекст выполнения собственный инстанс
sc.setAttribute("foo", this);
}
..

@override
public void doFilter(ServletRequest sr,
ServletResponse sr1, FilterChain fc)
throws IOException, ServletException {
final ServletContext sc = sr.getServletContext();
// вытаскивание своего же инстанса из контекста
Foo foo = (Foo)sc.getAttribute("foo");
if (foo.someImportantValue == 42) {
// дальнейшая обработка
..
}
}
..
}

В примере выше храбрый индийский архитектор Чандракант с помощью двух аннотаций, общего контекста и молитв Кришне использовал одну и ту же копию основного объекта в контексте двух разных сущностей в Servlet API (Filter и Listener), с разным жизненным циклом.

Связав их состояние воедино с поистине индийской хитростью — ради нанесения побоев мозгу неподготовленного «белого варвара».

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

@Entity
@Table(name = "t_foo")
@NamedQueries({
@NamedQuery(name = "Foo.fetchAll",
query = "SELECT f FROM Foo f order by f.id desc")
})
@Named
@RequestScoped
public class Foo {
@Id
@SequenceGenerator
@GeneratedValue(strategy = GenerationType.SEQUENCE,
generator = "default_gen")
private Long id;
@size(min = 3, max = 255)
@pattern(regexp = "[a-zA-Z0-9._ -?!]+")
private String title;
..

private transient Foo instance;

@transient
@PersistenceContext
private EntityManager em;

..

public List<Foo> fetchRecords() {
return this.em.createNamedQuery("Foo.fetchAll",Foo.class).getResultList();
}
..
}

Если вы занимались разработкой для J2EE/JEE/Jakarta и видели все эти JPA, JTA, JSF в работе — уже должны были бежать за валидолом. Но если ужасы корпоративной Java-разработки обошли стороной, наверное стоит немного объяснить суть.

На класс Foo в примере выше навешано два типа аннотаций, каждая из которых помечает его использование в разных контекстах и с разным жизненным циклом:

• в качестве сущности (Entity) JPA, отвечающей за связывание с таблицей в базе данных;

• в качестве бина CDI, который может быть использован непосредственно со страницы JSF.

Cо страницы это выглядит это как-то так:

<p>
<ui:repeat value="#{foo.fetchRecords()}" var="record">
<div style="padding-left: 2em; font-style: italic;">
<h:outputText value="#{record.title}"/>
</div>
..
</ui:repeat>
</p>

Но на самом деле тут все еще веселее — посмотрите на поле instance:

private transient Foo instance;

Которое великий индийский гуру использовал в качестве.. DTO!

Таких интересных классов в проекте было не один и не два, а около 700 — целая армия автономных бинов, каждый из которых отвечал только за себя от начала и до конца.

Временами бины вызывали друг-друга, временами делали это по сети, иногда — через очереди сообщений.

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

Несмотря на всю описанную выше жесть, гордый сын индийского народа — архитектор Чандракант (да будут вечно стабильными его сборки) не успокоился, решив окончательно добить белых варваров, живущих за океаном и сжечь им психику таким замечательным API:

..
@WebMethod
@Post
@path("addMessage")
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.TEXT_PLAIN)
@Transactional(Transactional.TxType.REQUIRED)
public String addMessage(
@FormParam("title") String title,
@FormParam("author") String author,
@FormParam("message") String message) {
..
}

..

Если вы отличаете SOAP от REST и тем более знаете что такое JAX-WS и JAX-RS — с кода выше уже должно было морально поплохеть, поскольку сие есть самое натуральное оскорбление чувств верующих в высокие архитектурные принципы.

Для непричастных объясняю:

API состоит из методов, вызываемых удаленно, вебсервис — вариация API, вызываемая через веб, с использованием классических протоколов веба: HTTP/HTTPS.

REST и SOAP — два разных стандарта вебсервисов, один использует JSON, другой — XML (если упрощенно) для обмена сообщениями между клиентом и сервером. JAX‑WS и JAX‑RS — два разных стандарта для разметки методов вебсервиса с помощью аннотаций.

Так что в примере выше один и тот же метод используется одновременно в вебсервисе SOAP и как метод RESTful вебсервиса.

Особую пикантность и новые ощущения во время отладки придает тот факт, что каждый вебсервис — отдельный инстанс класса, со своим жизненным циклом.

А связывались между собой они через все тот же контекст CDI.

Или атрибут ServletContext.

Или через статический синглтон.

Или через контекст EJB.

Или по сети.

Или через очереди сообщений (JMS).

Гордый сын индийского народа любил разнообразие.

Резюмируя:

для того чтобы хотя-бы понять как это все работает, потребовался весь наш многолетний опыт разгребания корпоративных говен — ни в каких поисковиках, wiki, stackoverflow, форумах и досках объявлений ничего подобного не находилось.

Такова сила и мощь индийской инженерной школы.

Часть 1. Одноклассовый энтерпраиз

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

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

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

Затем мы смогли развернуть столь упоротое приложение на всех основных серверах приложений, реализующих API Jakarta 10:

• WildFly

• Open Liberty / IBM WebSphere Liberty

• Eclipse GlassFish

• Payara

Так оно выглядит в работе (основной экран):

Для оформления на этот раз был взят индийский CSS-микрофреймворк с интересным для отечественного слуха названием.

Учим хинди вместе с автором:

FWIW, "choṭā" means "small" in Hindi

Так выглядит основной функционал гостевой книги — добавление новой записи в действии:

Так выглядит авторизация, полноценная авторизация с сессиями:

Теперь показываю работу с API, напоминаю это все еще один и тот же класс на Java.

JAX-WS

Вызов JAX-WS (SOAP) из клиента на Python:

Так выглядит тестовый клиент на Python:

from zeep import Client
# ссылка на wsdl файл
client = Client('http://localhost:9080/madjavaee-1.0.1-RELEASE/MegaBeanService?wsdl')
# вызов тестового метода
result = client.service.doPing()
print(result)

# создание объекта DTO
factory = client.type_factory('http://madjavaee.experiments.Ox08.com/')
message = factory.megaBean(title='new title', author='test@test.com', message='test message')
# вызов метода API для добавления записи
result = client.service.addMessage(message)
print(result)

# получить записи гостевой через API
result = client.service.fetchRecords()
print(result)
# получить количество записей через API
result = client.service.fetchRecordsCount()
print(result)

JAX-RS

Так выглядят в действии вызовы вебсервиса JAX-RS (REST) с помощью curl и браузера:

Команда для добавления поста с помощью curl:

curl -H "Content-Type: application/json" -X POST http://localhost:9080/madjavaee-1.0.1-RELEASE/api/addMessage -d '{"title":"test title2","author":"user@test.com", "message":"some message"}'

Часть 2. Психотронное оружие

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

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

Но сначала немного статистики:

~600 строк из которых ~200 — комментарии, итого ~400 строк на все приложение.

Смотрим и наслаждаемся шедевром:

package com.Ox08.experiments.madjavaee;
// Common Java
import java.io.*;
import java.util.*;
import java.util.logging.*;
// CDI
import jakarta.enterprise.context.*;
import jakarta.inject.*;
// JPA
import jakarta.persistence.*;
import jakarta.persistence.criteria.*;
// JSR 303 Validation API
import jakarta.validation.constraints.*;
// JSF
import jakarta.faces.application.FacesMessage;
import jakarta.faces.context.*;
// JSR 375
import jakarta.security.enterprise.AuthenticationStatus;
import jakarta.security.enterprise.authentication.mechanism.http.*;
import jakarta.security.enterprise.credential.*;
import jakarta.security.enterprise.identitystore.*;
// Servlet API
import jakarta.servlet.*;
import jakarta.servlet.annotation.*;
import jakarta.servlet.http.*;
// JTA
import jakarta.transaction.Transactional;
// JAX-RS
import jakarta.ws.rs.core.*;
import jakarta.ws.rs.ext.*;
import jakarta.ws.rs.*;
// JAX-WS
import jakarta.jws.*;
/**
* This is single class CRUD application, based on recent Java EE stack.
* @author <a href="mailto:alex3.145@gmail.com">Alex Chernyshev</a>
*/
// ordinary JPA entity annotations
@Entity
@Table(name = "t_records")
@NamedQueries({
@NamedQuery(name = "MegaBean.getAllRecords",
query = "SELECT m FROM MegaBean m order by m.id desc")
})
// CDI bean annotation, which used to register instance of this class as CDI managed bean
// This is required for EntityManager injection
@Named
// Java Faces annotation, required to trigger JSF initialization on some servers
@jakarta.faces.annotation.FacesConfig()
//(version = FacesConfig.Version.JSF_2_3) - deprecated in Faces 4.0 and upper
// JSF annotation, required to bypass jsr299 validation see WebContainer.validateJSR299Scope
@Dependent
//@ApplicationScoped or @RequestScoped are not allowed, because of @WebFilter/@WebListener annotations presence
// Servlet 3.0 annotations
// Servlet Filter - another instance of this class will be registered as servlet filter
@WebFilter("/*")
// One more instance will be registered as servlet context listener, to be used as initialization point.
// All because we can't use @ApplicationScoped and @Observes here
@WebListener
// See JSR375 spec for details
@CustomFormAuthenticationMechanismDefinition(
loginToContinue = @LoginToContinue(
loginPage = "/index.xhtml?login=true",
useForwardToLogin = false,
errorPage = "/index.xhtml?login=true&error=true"
)
)
// used only when embedded IdentityStore in use
@jakarta.annotation.security.DeclareRoles({"admin", "user", "demo"})
// JAX-RS annotations
@ApplicationPath("api")
@jakarta.ws.rs.Path("")
// this is required for ExceptionMapper
@jakarta.ws.rs.ext.Provider
// JAX-WS binding (SOAP) Warning: conflicts with JAX-RS on OpenLiberty and Wildfly!
//@WebService
public class MegaBean extends Application implements Serializable,
jakarta.servlet.Filter,
ServletContextListener,
// Because OpenLiberty/IBM Websphere Liberty does not support combination of
// CustomFormAuthenticationMechanismDefinition and HttpAuthenticationMechanism,
// I was required to remove HttpAuthenticationMechanism interface
// Custom IdentityStore does not work without @ApplicationScoped on OpenLiberty
IdentityStore, // see JSR375
ExceptionMapper<Exception> {
public MegaBean() {
// call for JAX-RS parent class
super();
/*
* we need to set some default values to bypass JSR 303 bean validation for
* JAX-RS bean, otherwise, JAX-RS service will not work.
*/
this.author = "no@no.org";
this.createdAt = new Date();
this.message = "no no no";
this.title = "test title";
}
/**
* We need to have an instance of this class as DTO - to transfer data from
* html form
*/
private transient MegaBean current;
/**
* This class is also a CDI managed bean, remember? So here we will inject
* EntityManager
*/
@Transient
@PersistenceContext(unitName = "megaPU")
private EntityManager em;
/**
* Security context maybe null when JAAS API was not initialized, so it's wrapped with @Instance
*/
@Transient
@Inject
private jakarta.enterprise.inject.Instance<jakarta.security.enterprise.SecurityContext> securityContext;
@Transient
@Context
private ServletContext servletContext;
/**
* Ordinary JPA fields
*/
@Id
@SequenceGenerator(name = "default_gen", sequenceName = "w_default_pk_seq")
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "default_gen")
private Long id; // unique id, this sequence will be created automatically too
@Size(min = 3, max = 255)
@Pattern(regexp = "[a-zA-Z0-9._ -?!]+")
private String title; // used also as 'login' field for auth
@Size(min = 3, max = 30)
@Email
private String author; // used also as 'password' field for auth
@Lob
@Column(length = Integer.MAX_VALUE)
@NotBlank(message = "message may not be blank")
private String message; //message body, CLOB/TEXT/BLOB type will be used in database
@Column(name = "created_date", nullable = false)
@Temporal(TemporalType.TIMESTAMP)
@NotNull
protected Date createdAt;
/**
* this called from JSF page to clean up fields on page reload
*/
@WebMethod(exclude = true)
public void init() { resetFields(this); }
/**
* Each and every interface methods should be implemented and marked with
* Annotation WebMethod(exclude = true) used to avoid bug in Apache CXF (Wildfly/OpenLiberty)
* <a href="https://issues.apache.org/jira/browse/CXF-4916">...</a>
* Method 'contextDestroyed' is part of ServletContextListener interface, so must be implemented
*/
@WebMethod(exclude = true)
@Override
public void contextDestroyed(ServletContextEvent sce) {
// not used, but required
}
/**
* Part of ServletContextListener API, used on app start/reload
*/
@Override
@WebMethod(exclude = true)
// transactional is required to let EntityManager do his job
@Transactional(Transactional.TxType.REQUIRED)
public void contextInitialized(ServletContextEvent sce) {
final ServletContext sc = sce.getServletContext();
// due to CDI vs servlet conflict
sc.setAttribute("mega", this);
// we can make it only here due to stackoverflow error in eclipselink
this.current = new MegaBean();
// reset fields back to nulls - to have working JSR303 validation
resetFields(this.current);
// populate JSF version details
addVersionEnv(sc);
// try to add some initial data if database is empty
try {
if (fetchRecordsCount() == 0) {
//create test entity
final MegaBean r = new MegaBean();
r.setCreatedAt(new Date()); r.setAuthor("system@test.org"); r.setMessage("Test message"); r.setTitle("Test title");
em.merge(r);
LOG.info(String.format("automatically added default record: %d", r.getId()));
}
} catch (Exception e) {
LOG.log(Level.WARNING,
String.format("Exception on startup: %s", e.getMessage()), e);
}
}
/**
* JSF bean method, used to save form (from itself)
*/
@WebMethod(exclude = true)
@Transactional(value=Transactional.TxType.REQUIRED,rollbackOn = Exception.class)
public String save() {
// set creation date&time
current.setCreatedAt(new Date());
em.merge(current);
// this is required to reset form fields
this.current = new MegaBean();
resetFields(this.current);
// does redirect
return "/index.xhtml?faces-redirect=true";
}
/**
* Does login action from JSF page
* @throws IOException
* if God was not on our side
*/
@WebMethod(exclude = true)
public void login() throws IOException {
// we need to re-use 2 existing fields, present in this class: 'author for username and 'title' for password
final Credential credential = new UsernamePasswordCredential(author, new Password(title));
final FacesContext facesContext =FacesContext.getCurrentInstance();
final ExternalContext ec = facesContext.getExternalContext();
// should not happen, this is used to avoid class cast
if (!(ec.getRequest() instanceof HttpServletRequest req)
|| !(ec.getResponse() instanceof HttpServletResponse res)) {
ec.getRequestMap().put("login", "true");
facesContext.addMessage(null,
new FacesMessage(FacesMessage.SEVERITY_ERROR, "Login failed", null));
return;
}
// check if JAAS initialized
if (!securityContext.isResolvable()) {
LOG.warning("SecurityContext cannot be resolved!"); return;
}
// try to authenticate programmatically
final AuthenticationStatus status = securityContext.get()
.authenticate(
req, res, AuthenticationParameters.withParams().credential(credential));
if (status == null) {
LOG.warning("JAAS not initialized!"); return;
}
LOG.fine(String.format("auth status: %s",status));
switch (status) {
case SEND_CONTINUE: {
facesContext.responseComplete();
break;
}
case SEND_FAILURE: {
ec.getRequestMap().put("login", "true");
facesContext.addMessage(null,
new FacesMessage(FacesMessage.SEVERITY_ERROR, "Login failed", null));
break;
}
case SUCCESS: {
putCurrentUser(current);
LOG.info(String.format("logged in as %s",current.author));
facesContext.addMessage(null,
new FacesMessage(FacesMessage.SEVERITY_INFO, "Login succeed", null));
// after redirect there will be full page reload
ec.redirect(ec.getRequestContextPath() + "/index.xhtml?ok=true");
break;
}
case NOT_DONE:
facesContext.responseComplete();
break;
}
}
/**
* Does logout action from JSF page
*/
@WebMethod(exclude = true)
public String logout() throws ServletException {
final FacesContext facesContext =FacesContext.getCurrentInstance();
final ExternalContext ec = facesContext.getExternalContext();
// check for impossible state
if (!(ec.getRequest() instanceof HttpServletRequest req)) {
facesContext.addMessage(null,
new FacesMessage(FacesMessage.SEVERITY_ERROR, "Logout failed", null));
return "";
}
req.logout();
ec.invalidateSession();
return "/index.xhtml?faces-redirect=true";
}
/**
* JPA Entity fields
* -------------------------------------------------------------------------------------------
*/
@WebMethod(exclude = true)
public String getAuthor() { return author; }
@WebMethod(exclude = true)
public void setAuthor(String author) { this.author = author; }
@WebMethod(exclude = true)
@jakarta.json.bind.annotation.JsonbTransient
public MegaBean getCurrent() {
return current;
}
@WebMethod(exclude = true)
public Date getCreatedAt() {
return createdAt;
}
@WebMethod(exclude = true)
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
@WebMethod(exclude = true)
public Long getId() {
return id;
}
@WebMethod(exclude = true)
public void setId(Long id) {
this.id = id;
}
@WebMethod(exclude = true)
public String getTitle() {
return title;
}
@WebMethod(exclude = true)
public void setTitle(String title) { this.title = title; }
@WebMethod(exclude = true)
public String getMessage() { return message; }
@WebMethod(exclude = true)
public void setMessage(String message) { this.message = message; }
/**
* JAX-RS & JAX-WS Methods
* -----------------------------------------------------------
* Each method serves for both APIs
* Ping is a test method, which respond plain text
*/
@GET
@jakarta.ws.rs.Path("ping")
@Produces(MediaType.TEXT_PLAIN)
@WebMethod
public String doPing() { return "pong: " + System.currentTimeMillis(); }
/**
* Adds new message to guestbook from API
* @param dto
* new message data
* @return
*/
@WebMethod
@POST
@jakarta.ws.rs.Path("addMessage")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
// for JAX-WS only
@Transactional
public String addMessage(MegaBean dto) {
LOG.info(String.format("prepare to add record %s , %s , %s", author, title, message));
final MegaBean r = new MegaBean();
r.setCreatedAt(new Date()); r.setAuthor(dto.author);
r.setMessage(dto.message); r.setTitle(dto.title);
// for JAX-RS, EntityManager should be injected
if (em!=null && em.isJoinedToTransaction())
return addMessageImpl(r);
// otherwise, take EntityManager from servlet context
// note: access to servletContext from JAX-RS will trigger exception:
// RESTEASY003880: Unable to find contextual data of type: jakarta.servlet.ServletContext
else {
final MegaBean mb = (MegaBean) servletContext.getAttribute("mega");
return mb.addMessageImpl(r);
}
}
/**
* This 'black magic' is required, because JAX-WS does not allow transaction injection on service method
*/
@Transactional(Transactional.TxType.REQUIRED)
@WebMethod(exclude = true)
public String addMessageImpl(MegaBean r) {
try {
r=em.merge(r);
LOG.info(String.format("saved record %d", r.id));
return String.format("Message added: %d %n", r.id);
} catch (Exception e) {
LOG.log(Level.WARNING, e.getMessage(), e);
return String.format("Error on saving: %s", e.getMessage());
}
}
/**
* Uses Criteria API to retrieve count of records
*/
@WebMethod
@GET
@jakarta.ws.rs.Path("recordsCount")
@Produces(MediaType.TEXT_PLAIN)
public Long fetchRecordsCount() {
final EntityManager em = selectEm();
final CriteriaBuilder qb = em.getCriteriaBuilder();
final CriteriaQuery<Long> cq = qb.createQuery(Long.class);
cq.select(qb.count(cq.from(MegaBean.class)));
return em.createQuery(cq).getSingleResult();
}
/**
* API method to retrieve all guestbook records
*/
@WebMethod
@GET
@jakarta.ws.rs.Path("records")
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
public List<MegaBean> fetchRecords() {
return selectEm().createNamedQuery("MegaBean.getAllRecords", MegaBean.class).getResultList();
}
/**
* API method to get currently authenticated user details
*/
@GET
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@jakarta.ws.rs.Path("details")
@WebMethod(exclude = true)
public Response userDetails(@Context SecurityContext sc) {
final java.security.Principal p = sc.getUserPrincipal(); // see sc.getCallerPrincipal() in Jakarta EE;
return p != null ? Response.ok(p.getName()).build() :
Response.status(Response.Status.UNAUTHORIZED).build();
}
/**
* Methods below are required , due to re-use of same class for both JAX-WS
* and JAX-RS
* -------------------------------------------------------------------------------------------------------
*/
// part of IdentityStore API, not used
@Override
@WebMethod(exclude = true)
public Set<String> getCallerGroups(CredentialValidationResult validationResult) {
return Collections.emptySet();
}
@Override
@WebMethod(exclude = true)
public int priority() {
return 100;
}
@Override
@WebMethod(exclude = true)
public Set<ValidationType> validationTypes() {
return DEFAULT_VALIDATION_TYPES;
}
@WebMethod(exclude = true)
@Override
public void init(FilterConfig filterConfig) { }
@WebMethod(exclude = true)
@Override
public void destroy() { }
/**
* this filter is used to redirect from / to actual jsf page
*/
@Override
@WebMethod(exclude = true)
public void doFilter(ServletRequest sr, ServletResponse sr1, FilterChain fc)
throws IOException, ServletException {
final HttpServletRequest request = (HttpServletRequest) sr;
LOG.info(String.format("got request: %s", request.getRequestURI()));
// required for correct characters encoding
request.setCharacterEncoding("UTF-8");
final String p = request.getRequestURI(),
cp = request.getServletContext().getContextPath();
String url = p;
if (p.startsWith(cp)) url = p.substring(cp.length());
if ("/".equals(url) && sr1 instanceof HttpServletResponse hsr)
hsr.sendRedirect(cp + "/index.xhtml");
else fc.doFilter(sr, sr1);
}
/**
* Custom JSR375 validation
* Used in combination with IdentityStore
* @param credential
* @return
*/
@Override
@WebMethod(exclude = true)
public CredentialValidationResult validate(Credential credential) {
// should not happen
if (!(credential instanceof UsernamePasswordCredential userCredential))
return CredentialValidationResult.INVALID_RESULT;
final String login = userCredential.getCaller();
LOG.info(String.format("called validate for %s", login));
if (!USERS.containsKey(login))
return CredentialValidationResult.INVALID_RESULT;
final Map<String, Object> user = USERS.get(login);
// dumb password check
if (!userCredential.compareTo(login, (String) user.get("password")))
return CredentialValidationResult.INVALID_RESULT;
LOG.info(String.format("user %s validated", login));
return new CredentialValidationResult(login, new HashSet<>(Arrays.asList((String[]) user.get("roles"))));
}

/**
* JAX-RS exception handler
*/
@Override
@WebMethod(exclude = true)
public Response toResponse(Exception e) {
LOG.log(Level.WARNING, String.format("Exception on call : %s", e.getMessage()), e);
return Response.status(400).entity(e.getMessage()).type("text/plain").build();
}
// !! required for YASSON parser, otherwise exception will raise:
// Error accessing getter 'getEnclosingConstructor' declared in 'class java.lang.Class'
@Override
@WebMethod(exclude = true)
@jakarta.json.bind.annotation.JsonbTransient
public Set<Class<?>> getClasses() { return Collections.emptySet();}

/*
remove from JAX-RS/JAX-WS output
*/
@Override
@WebMethod(exclude = true)
@jakarta.json.bind.annotation.JsonbTransient
public Set<Object> getSingletons() { return Collections.emptySet();}
/*
remove from JAX-RS/JAX-WS output
*/
@Override
@WebMethod(exclude = true)
@jakarta.json.bind.annotation.JsonbTransient
public Map<String,Object> getProperties() { return Collections.emptyMap();}
/**
* Clean fields for provided instance
* @param m
* bean instance
*/
private void resetFields(MegaBean m) {
m.setAuthor(null); putCurrentUser(m);
m.setCreatedAt(null); m.setId(null);
m.setMessage(null); m.setTitle(null);
}
/**
* JAX-RS and JAX-WS APIs have different lifecycle, for JAX-WS, an EntityManager will be injected by CDI,
* but for JAX-RS is not (not for all servers).
* So we need some selection logic here
*/
private EntityManager selectEm() {
// if EntityManager was not injected
if (this.em!=null) return this.em;
// take instance from servlet context
return ((MegaBean) servletContext.getAttribute("mega")).em;
}
/**
* Get current user from principal
* @return
* current user's name
*/
public static String getCurrentUser() {
final FacesContext ctx = FacesContext.getCurrentInstance();
// if there is no faces context - could happen if current bean was not created by JSF
if (ctx==null || ctx.getExternalContext()==null) return null;
// get principal (the standard way) from current context
final java.security.Principal p = ctx.getExternalContext().getUserPrincipal();
return p == null ? null : p.getName();
}
/**
* Set current user's name to author field of our bean instance
* @param instance
* an instance of MegaBean, used as DTO
*/
private static void putCurrentUser(MegaBean instance) {
final String username = getCurrentUser();
if (username!=null)
instance.setAuthor(username);
}
/**
* Reads JSF version details and store as attribute of ServletContext
* @param sc
*/
private static void addVersionEnv(ServletContext sc) {
final Package facesPackage = FacesContext.class.getPackage();
final StringBuilder sb = new StringBuilder();
if (sc.getServerInfo() !=null)
sb.append(sc.getServerInfo());
if (facesPackage.getImplementationVersion()!=null)
sb.append(facesPackage.getImplementationVersion());
sc.setAttribute("versionLine", sb.toString());
LOG.info(sb.toString());
}
// credentials store, not used under Wildfly/OpenLiberty
private static final Map<String, Map<String, Object>> USERS = new TreeMap<>();
static {
final Map<String, Object> admin_user = new HashMap<>();
admin_user.put("password", "admin");
admin_user.put("roles", new String[]{"admin", "user", "demo"});
USERS.put("admin@test.org", admin_user);

final Map<String, Object> s_user = new HashMap<>();
s_user.put("password", "user");
s_user.put("roles", new String[]{"user"});
USERS.put("user@test.org", s_user);
}
// ordinary JUL logger, will not be serialized/persisted
private static final Logger LOG = Logger.getLogger("MEGA");
}

Выдохнули, перекрестились и хлебнули валидола? Значит самое время рассказать как эта космическая дичь вообще работает.

Часть 3. Препарируя дичь

Начнем с жемчужины индийской архитектурной мысли — использования JPA Entity и работы с Entity в одном и том же классе:

@Entity
@Table(name = "t_records")
@NamedQueries({
@NamedQuery(name = "MegaBean.getAllRecords",
query = "SELECT m FROM MegaBean m order by m.id desc")
})
@Named
..
// ниже в этом же классе
@Transient
@PersistenceContext(unitName = "megaPU")
private EntityManager em;
..
// еще ниже в этом же классе
final MegaBean r = new MegaBean();
r.setCreatedAt(new Date()); r.setAuthor("system@test.org");
r.setMessage("Test message"); r.setTitle("Test title");
em.merge(r);
..

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

Но работает тем не менее все довольно просто:

во время сканирования аннотаций, создаются несколько разных контекстов выполнения для одного и того же класса

Да, оказывается «так можно было».

Аннотация @Entity регистрирует класс в качестве entity JPA, @Table указывает на конкретную таблицу, @NamedQueries и @NamedQuery описывает именованное JPQL-выражение для получения записей из базы - все как в других, нормальных проектах.

А затем начинается чистая шиза:

в этом же классе указывается аннотация @Named, которая превращает класс в управляемый бин CDI, с возможностью связывания зависимых полей.

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

Вставляет сюда:

@Transient
@PersistenceContext(unitName = "megaPU")
private EntityManager em;

Аннотация @Transient нужна для того чтобы скрыть вставляемое через CDI поле от механизма, отвечающего за сохранение данных в JPA.

Servlet API

Следующий интересный с точки зрения клинической психиатрии блок аннотаций отвечает за надругательство над Servlet API:

@Dependent
@WebFilter("/*")
@WebListener

Конечно же так тоже делать нельзя, более того — если попытаетесь комбинировать @RequestScoped,@SessionScoped или @ApplicationScopedи аннотации Servlet API получите отлуп а приложение упадет при установке.

Единственная причина, по которой эта дичь вообще работает — «волшебная» аннотация @Dependent, про которую никто (из моих коллег) никогда не слышал.

Согласно официальному описанию:

The default scope if none is specified; it means that an object exists to serve exactly one client (bean) and has the same lifecycle as that client (bean).

Во всех остальных случаях (для всех остальных scope) будет выбрасываться ошибка при установке. Разгадка находится в методе validateJSR299Scope, аналог которого есть в любой реализации Jakarta API.

Так что суммнарно аннотации @Named и @Dependent позволяют использовать класс в качестве бина для Jakarta Faces и одновременно использовать аннотации из Servlet API — на одном и том же классе.

Тут помимо аннотаций становятся нужны интерфейсы:

..
public class MegaBean extends Application implements Serializable,
jakarta.servlet.Filter,
ServletContextListener,
..

Поэтому у класса появляются обязательные методы, которые необходимо реализовать. Для интерфейса ServletContextListener это метод contextInitialized, ради которого собственно интерфейс и использовался:

..
@Override
@WebMethod(exclude = true)
@Transactional(Transactional.TxType.REQUIRED)
public void contextInitialized(ServletContextEvent sce) {
final ServletContext sc = sce.getServletContext();
// due to CDI vs servlet conflict
sc.setAttribute("mega", this);
// we can make it only here due to stackoverflow error
// in eclipselink
this.current = new MegaBean();
// reset fields back to nulls - to have working JSR303 validation
resetFields(this.current);
// populate JSF version details
addVersionEnv(sc);
// try to add some initial data if database is empty
try {
if (fetchRecordsCount() == 0) {
//create test entity
final MegaBean r = new MegaBean();
r.setCreatedAt(new Date()); r.setAuthor("system@test.org");
r.setMessage("Test message"); r.setTitle("Test title");
em.merge(r);
LOG.info(String.format("automatically added default record: %d", r.getId()));
}
} catch (Exception e) {
LOG.log(Level.WARNING, String.format("Exception on startup: %s", e.getMessage()), e);
}
}
..

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

Кастомная авторизация

Следующий уровень отбитости, хотя и более слабый чем идея с JPA описанная выше:

полностью программная настройка авторизации, силами одних лишь аннотаций.

Конечно после красот Spring Boot все это смотрится как жалкая пародия уже не так мощно, но не забываем что Jakarta это API, у которого есть разные реализации.

И все они обязаны поддерживать вот такое:

..
@CustomFormAuthenticationMechanismDefinition(
loginToContinue = @LoginToContinue(
loginPage = "/index.xhtml?login=true",
useForwardToLogin = false,
errorPage = "/index.xhtml?login=true&error=true"
)
)
// used only when embedded IdentityStore in use
@jakarta.annotation.security.DeclareRoles({"admin", "user", "demo"})
..

Верхняя аннотация «лошадиного размера» отвечает за настройку механизма авторизации — указывает на использование form-based авторизации с дополнительными настройками.

Нижняя @DeclareRoles описывает набор ролей, используемых приложением.

К сожалению аннотация @DeclareRoles работает только в сочетании с IdentityStore, который актвируется не всеми серверами приложений.

Отбитый API

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

На класс на самом деле навешано два разных набора аннотаций, первая отвечает за инициализацию бина в качестве вебсервиса JAX-WS (старый добрый SOAP с XML):

@WebService

Каждый публичный метод, который должен быть скрыт от генератора вебсервисов должен быть помечен специальным образом:

@WebMethod(exclude = true)
public String getAuthor() { return author; }

Также будут пропущены все статичные поля.

Второй набор аннотаций отвечает за инициализацию JAX-RS и с ним все несколько сложнее:

@ApplicationPath("api")
@Path("")
@jakarta.ws.rs.ext.Provider

Помимо стандартных @ApplicationPath и @Path, которые вы точно видели в официальных примерах и более нормальных проектах, тут используется аннотация @Provider.

Нужна она ради метода toResponse, отвечающего за обработку исключений:

@Override
@WebMethod(exclude = true)
public Response toResponse(Exception e) {
LOG.log(Level.WARNING, String.format("Exception on call : %s", e.getMessage()), e);
return Response.status(400).entity(e.getMessage()).type("text/plain").build();
}

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

Часть 4. Сборка и деплой отбитой дичи

Проект целиком выложен в репозиторий на Github, сборка осуществляется с помощью обычного Apache Maven:

mvn clean package

Для сборки и запуска использовалась стандартная OpenJDK 21, которую поддерживают все используемые в статье серверы приложений.

К сожалению установка имеет свою специфику в каждом сервере приложений и временами требует дополнительных шагов настройки.

Самый простой способ увидеть наше «чудо-приложение» в действии — запустить специальный шаг Maven:

mvn liberty:run

После чего запустится скачивание сервера приложений OpenLiberty, его запуск и развертывание туда нашего приложения.

В качестве СУБД на всех серверах приложений использовался встраиваемый Apache Derby, за исключением Payara, где по-умолчанию используется H2.

Open Liberty / IBM Websphere Liberty

Проект OpenLiberty это открытая реализация сервера приложений, активно разрабатываемая IBM. Ее коммерческая версия IBM Websphere Liberty позиционируется как замена «большой» Websphere и основа всех будущих продуктов IBM, создаваемых на базе Websphere.

Вся основная разработка и развитие происходят в Open Liberty, затем переносятся в IBM Websphere Liberty, для которой потом оказывается коммерческая и долговременная поддержка.

Все описанные шаги по развертыванию актуальны и применимы для IBM Websphere Liberty.

Для статьи использовалась Open Liberty версии 25.0.0.5 с профилем Jakarta 10, скачать архив со сборкой можно по ссылке.

Так выглядит наша «адская гостевая» будучи запущенной в Open Liberty:

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

К сожалению OpenLiberty не подхватывает программный IdentityStore, который мы реализовывали в самом бине ради авторизации.

Для обоих действий надо изменить файл server.xml в каталоге:

wlp/usr/servers/defaultServer/server.xml

где wlp — корневой каталог распакованного Open Liberty.

Для регистрации тестового пользователя необходимо добавить блок:

<basicRegistry id="basic" realm="WebRealm">
<user name="admin@test.org" password="admin"/>
<group name="admin">
<member name="admin"/>
</group>
</basicRegistry>

Для пула подключений к базе:

<dataSource id="DefaultDataSource">
<jdbcDriver libraryRef="phlegethLib"/>
<properties.derby.embedded createDatabase="create"
databaseName="shuggDB"/>
<containerAuthData password="y'hah" user="tharanak"/>
</dataSource>

<library id="phlegethLib">
<file name="${server.config.dir}/lib/global/jdbc/derby.jar"/>
<file name="${server.config.dir}/lib/global/jdbc/derbyshared.jar"/>
</library>

Также будет необходимо скопировать JDBC-драйвер для Derby в указанный выше каталог:

wlp/usr/servers/defaultServer/lib/global/jdbc

WAR-файл с нашей адской гостевой копируется в каталог dropins:

cp /opt/work/serial-experiments/madjpa/target/*.war wlp/sr/servers/defaultServer/dropins/

Запущенное приложение доступно по адресу:

http://localhost:9080/madjavaee-1.0.1-RELEASE/index.xhtml

Как уже упоминал выше:

Текущая версия OpenLiberty не дает использовать одновременно JAX-RS и JAX-WS вебсервис, основанный на одном и том же классе.

Хотя в предыдущих версиях прокатывало.

Поэтому придется либо закомментировать аннотацию @WebService для отключения JAX-WS либо набор аннотаций JAX-RS:

@ApplicationPath("api")
@Path("")
@jakarta.ws.rs.ext.Provider

Еще OpenLiberty не умеет генерировать WADL-файл с описанием JAX-RS сервиса, поэтому ссылка на него будет битой.

Wildfly

Wildfly (в девичестве JBoss) — один из самых известных серверов приложений с очень долгой историей. Хотя это изначально открытый проект, как и в случае с разработкой IBM (Websphere Liberty) существует отдельный коммерческий продукт на его основе — Red Hat JBoss Enterprise Application Platform.

Как и в случае с OpenLiberty, смысл существования Wildfly — разработка и обкатка новых фич с помощью коммьюнити, с последующей продажей гоям в виде готового коммерческого продукта за серьезный прайс.

Для статьи использовался Wildfly 36.0.1.Final, архив с которым можно скачать по ссылке.

Так выглядит наше чудо-приложение в работе под управлением Wildfly:

Установка приложения на Wildfly заметно проще — достаточно скопировать WAR-файл с приложением в каталог:

wildfly/standalone/deployments

Поддержка Apache Derby, JDBC-драйвер и пул подключений по-умолчанию уже присутствуют.

К сожалению текущая версия Wildfly (на момент написания статьи) также не активирует программный IdentityStore — тестовый домен JASPIC убрали в настройке по-умолчанию.

Поэтому тестовых пользователей придется создавать вручную с помощью скрипта bin/add-user.sh

Запущенное приложение доступно по адресу:

http://localhost:8080/madjpa/index.xhtml

Eclipse Glassfish

Еще один очень известный проект с длинной историей, некогда разрабатываемый самой компанией Sun Microsystems в качестве эталонной реализации J2EE.

Для статьи использовалась версия 7.0.25 с профилем Jakarta EE Platform, скачать архив со сборкой можно по ссылке.

Так выглядит развертывание и запуск нашего приложения в Glassfish:

Запускается сервер командой bin/startserv

Glassfish поддерживает и похватывает при установке программный IdentityStore (будут работать встроенные в бин учетки) и пул по-умолчанию с Apache Derby и сочетание JAX-WS и JAX-RS вебсервисов на одном и том же классе.

И даже генерацию WADL-файла он тоже поддерживает:

Единственная яркая дичь — за каким-то хреном в последних версиях перестал автоматически запускаться сервер Apache Derby, теперь для его запуска надо запустить консоль управления asadmin и выполнить команду:

start-database

Результат выполнения:

Payara

Наконец последний в сегодняшнем списке и наименее известный в наших краях проект Payara:

When commercial support for GlassFish ended in 2014, Payara Server was created as a fully-supported drop-in replacement. Payara Services was born in 2016 to offer support solutions for the application server.

Да, теперь вы тоже знаете что у Glassifsh оказывается были и коммерческие пользователи, по зову которых появилась эта самая "Payara".

Для статьи использовался Payara Server 6.2025.5 с профилем Full, скачать сборку можно по ссылке.

Запускается командой:

bin/asadmin start-domain

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

Тут все совсем хорошо и никаких дополнительных шагов не требуется совсем, база (H2) запускается по-умолчанию, программный IdentityStore подхватывается автоматически из бина и определяются оба типа вебсервисов — JAX-RS и JAX-WS, которые спокойно работают одновременно.

Эпилог

Перед вами одна из статей, материал для которой автор собирал несколько лет и до последнего не был уверен, что подобную «техноересь» вообще стоит показывать психически здоровым людям, тем более что храбрый индийский архитектор Чандракант (да будут всегда выделяться ресурсы его процессам) все же творил свою лютую месть довольно давно.

Поэтому адаптация его «архитектурного джихада» под современные реалии Java заняла в итоге несколько лет экспериментов и тестов — все ради того чтобы дорогие читатели ощутили на себе с какими ужасами от мира разработки временами приходится иметь дело.

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

Но если столкнетесь с таким на практике и захотите сохранить психику ваших программистов в девственном виде — теперь будете знать кому написать.

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

Проклятая выдача

Наверное все уже в курсе, что социальные сети и поисковые системы постоянно подкручивают ленту выдачи под каждого пользователя на основе его предыдущих запросов и проявленных интересов?

На меня эти алгоритмы тоже начали влиять, но.. особенным образом:

формируя персональную ленту из самой отмороженной компьютерной дичи, которая только есть на свете.

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

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

Все ради того чтобы в очередной раз показать читателям невозможное, по мнению ИИ и обитателей StackOverflow.

Технический ультрахардкор

Коль уж читаете эту статью — скорее всего и так знаете через какое место как именно программы появляются на свет и какова роль компилятора в этом сложном процессе.

Для простых обывателей поясняю:

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

Сотрудник компании Valve вместо работы над Half-Life 3 запускает компилятор, который собирает из набора файлов с исходниками «финальный билд», который затем упаковывается в инсталлятор и выкладывается на официальный сайт Steam.

Откуда его потом скачивают ушастые простые пользователи.

Теперь представьте:

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

C концами.

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

Спустя пару сотен лет, вы — представитель жалких остатков человечества, выживших на небольшой колонии с обратной стороны Луны, вновь ступаете на опустевшую Землю в поисках артефактов погибшей цивилизации.

И находите на развалинах бывшего офиса Valve ту самую флешку с исходниками альфа-версии Half-Life 3.

Конечно прогресс в разработке программ к тому времени успел уйти далеко вперед, у вас в ходу на лунной базе теперь какие-нибудь C++-157 и clang-777, с встроенным Rust, тремя слоями виртуализации и сборщиком мусора, работающим через промпты LLM. А про язык C вы узнали лишь из лекции по истории, про исторический период между египетскими пирамидами и вторжением инопланетян.

Встает очевидный вопрос:

как же все-таки насладиться шедевром далеких предков, так и не увидевшим свет в свое время?

Многое можно отдать за запуск этой красоты, даже спустя пару сотен лет после зомби-апокалипсиса:

Несмотря на весь этот «апокалиптический треш», ситуация сама по себе — более чем реальная:

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

В первую очередь это мейнфреймы, которые до сих пор живее всех живых, вроде такого красавца от Unisys:

Если немного снизить накал технического фетишизма экстрима и обратить взор к современной коммерческой разработке — можно внезапно обнаружить, что фактически вся ее продуктовая часть (там где создается приложение, устанавливаемое у конечного пользователя) работает с обязательной поддержкой устаревшего окружения:

поддержка Windows 7/10, поддержка старых версий Android и iOS, обязательная работа на JRE 1.8+ и так далее и тому подобное.

Разумеется на машинах разработчиков используется современный софт, но собирает он так чтобы конечное приложение без проблем запускалось и работало в устаревшем окружении.

Обратное портирование

Процесс, с помощью которого в окружении 21го века создается нечто работающее на оборудовании из века 20го называется обратным портированием (backporting). И мы уже неоднократно о нем рассказывали, например тут или тут.

Обычно бекпорт создается для окружения с не очень большим устареванием — лет на 5-10 с момента релиза, поскольку на таком промежутке и проходят все основные обновления пользовательского окружения.

В редких случаях (и за отдельную плату) разработчик ПО может согласиться покопаться в чем-то еще более древнем, но уже без гарантий.

Однако то что покажу в этой статье — однозначно выходит за любую границу разумности, проходя даже среди коллег по категории отбитой дичи научной фантастики:

приложение на современном C++, с современными фичами, созданное в современной ОС, которое работает в окружении из 1986 года!

Операционной системой, которую выпустили 40 лет назад выступит известная MS-DOS 3.20. Именно эта версия была выбрана ввиду одной интересной исторической особенности:

Version 3.20 – First retail release (non-OEM); Release date: July 1986

Это первая версия MS-DOS, продаваемая конечным пользователям напрямую от самой Microsoft, с полок магазинов.

До нее Microsoft продавала свою операционную систему только производителям компьютеров, которые включали ее в поставку своих продуктов и под своим собственным брендом:

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

Комната жениха

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

• Компилятор C++ DigitalMars, который до сих пор официально поддерживает сборку под DOS;

• Эмулятор 86Box для запуска DOS из 1986 года;

• Утилиты GNU Mtools для работы с образами старых дискет.

И все это под FreeBSD 14, в качестве своеобразного гаранта качества:

если что-то работает на FreeBSD, оно однозначно будет работать и на Windows и в MacOS и в Linux и на Луне.

Цифровой Марс

Главный герой сегодняшнего праздника жизни — набор компиляторов от Digital Mars:

Digital Mars is an American computer software company founded by Walter Bright and based in Vienna, Virginia. It makes C, C++, and D compilers, and associated utilities such as an integrated development environment (IDE) for Windows and MS-DOS, which Digital Mars calls an integrated development and debugging environment (IDDE)

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

Во-первых Вена это не только столица Австрии, но еще и небольшой городок на севере США, на 15к жителей, где (внезапно) находится штаб-квартира серьезной софтверной компании, выпускающей эпические компиляторы аж с 1988 года:

In 1988, Zortech was the first C++ compiler to ship for Windows. PC Magazine ran a graphics benchmark and reported that most executables produced by Zortech ran faster than executables produced by Microsoft C 5.1 and by Watcom C 6.5.[3]

Вот так, парни переплюнули официальный компилятор от самого Microsoft, несмотря на весь инсайд и поддержку. Кстати «Zortech» — старое название компилятора (если вдруг будете искать в архивах), продукт по какой-то причине несколько раз переименовывался.

Есть еще один удивительный факт, связанный с этой компанией:

The company gained notice in the software development community for creating the D programming language. D resulted from Bright's frustration with the direction of the C++ language and from his experience implementing it.

Ребята до такой степени угорели по С++, что создали свой собственный язык, «по мотивам»:

resulted from Bright's frustration with the direction of the C++ language

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

• Includes C++ templates, exception handling and rtti.

• Most other compilers for 16 bit code were abandoned nearly a decade ago. Digital Mars has a modern compiler for 16 bits.

Все перечисленные выше радости — для официально поддерживаемой сборки под DOS и 16-битных приложений.

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

Это предельные размеры создаваемого приложения, в случае MS-DOS 3.20 мы будем использовать «s» модель памяти, поэтому размер финальной сборки не должен превышать 64Кб.

Сборка и запуск

Компиляторы C и C++ от DigitalMars изначально были коммерческим продуктом и до сих пор существует коммерческая версия, включающая помимо компиляторов еще и собственную среду разработки (IDDE). Однако не так давно компиляторы стали бесплатным и открытым проектом, с исходниками на Github.

К сожалению проект пока не портируемый — собирается и работает исключительно под Windows.

Тем не менее, поскольку создавали его очень опытные люди — все отлично работает в Wine, что мы и будем использовать для его запуска на FreeBSD. Чтобы снова не раздувать статью — не стал заморачиваться сборкой компилятора из исходников (хотя это не очень сложный процесс), использовав готовую сборку версии 8.5.7.

Инсталлятора тут нет, в архиве сразу готовые бинарники, поэтому распаковываем и запускаем:

Так выглядит отображаемая версия компилятора:

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

Внутри будут дополнительные бинарники, главный из которых это довольно известный EXE2BIN.COM, используемый для генерации COM-файлов из EXE.

С EXE2BIN есть один важный нюанс — он не запустится с помощью Wine, поскольку является DOS-приложением.

Чтобы использовать эту утилиту для создания COM-файлов — необходимо запускать ее с помощью DOSbox:

Теперь переходим к основному эмулятору.

86Box

Достаточно новый проект (разрабатывается с 2016 года), который сейчас активно развивается и позволяет эмулировать огромное множество x86-совместимых систем:

86Box is an IBM PC system emulator that specializes in running old operating systems and software designed for IBM PC systems and compatibles from 1981 through fairly recent system designs based on the PCI bus.

Готовой сборки для FreeBSD пока нет (как и присутствия в портах) и еще год назад были проблемы, требующие ручных правок исходников:

Initially exclusive to Windows, it was ported to Linux in version 3.2 and macOS in version 3.4.

Но на момент написания статьи все поправлено и эмулятор отлично собирается из исходников без каких-либо проблем, а в инструкции по сборке появился раздел про FreeBSD.

Сборка

Забираем исходники:

Репозиторий довольно большой, поэтому стоит использовать ограничение на историю выгружаемых коммитов (ключ --depth 1).

Я использовал master-ветку с текущей версией эмулятора, если будут проблемы — можно использовать срез исходников конкретной версии.

Сборка построена на cmake, но также использует ninja (для модулей).

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

Запуск вполне классический для cmake-проектов:

Готовое для запуска приложение эмулятора будет в build/src/86Box.

Но это еще не конец.

Для работы нужен еще и набор ROM-файлов (да, опять), который для текущей версии (из master-ветки) необходимо загружать из отдельного репозитория:

Для релизных версий эмулятора — ROM-файлы надо брать в другом месте, со страницы releases. Запускается эмулятор с указанием путей к каталогу с ROM-файлами следующим образом:

После запуска эмулятора (по прямой аналогии с каким-нибудь VirtualBox) необходимо создать новую виртуальную машину, задав ей вот такие настройки:

Это не единственный возможный сетап эмулируемого оборудования, но максимально приближенный к реалиям 1986 года.

MS-DOS

Образы самого MS-DOS достать в сети очень легко, например отсюда. Все они уже давно находятся в публичном пользовании (public domain), поэтому за их использование Microsoft вас не съест засудит.

Более того, даже исходный код некоторых версий MS-DOS был выложен в публичный доступ:

The original sources of MS-DOS 1.25, 2.0, and 4.0 for reference purposes

Коробочная версия поставлялась на 5-дюймовых дискетах, размером в 360Кб, собственно их образы и выложены в сети.

Нам нужен лишь первый:

Этот файл нужно выбрать в меню после запуска эмулятора:

После чего перезагрузить эмулируемую систему.

При запуске пойдет проверка памяти, затем MS-DOS будет просить ввести ей дату и время, достаточно нажать пару раз <Enter> для пропуска:

Mtools

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

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

Тот самый, с которого мы выше загружали образ MS-DOS.

Для генерации образов флоппи я использовал известный пакет GNU Mtools,

In addition to file access, it supports many FAT-specific features: volume labels, FAT-specific file attributes (hidden, system, ...), "bad block" map maintenance, access to remote floppy drives, Iomega ZIP disk protection, "secure" erase, display of file's on-disk layout, etc.

Пакет довольно известный, поэтому присутствует практически везде, для FreeBSD установить его можно так:

Работа с образом дискеты

Создаем пустой образ дискеты на 360кб:

Копируем файл с хоста внутрь этого образа:

Запускаем эмулятор 86box и указываем созданный образ в качестве второго в эмулируемой системе:

Переходим на диск B:

Тесты

А теперь будут танцы:

показываю функционал 21 века, работающий под MS-DOS из 20 века.

Напоминаю, что система в эмулятора была выпущена 40 лет тому назад — возможно старше вашего папы.

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

#include <iostream.h>

class Base {
public:
virtual void test() {
cout << "this is base" << endl;
}
};

class Derived : public Base {
public:
void test() {
Base::test();
cout << "this is derived" << endl;
}
};

int main()
{

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);
if (d != NULL) {
// Successful cast
cout << "works" << endl;;
d -> test();
} else {
// Cast failed
cout << "cannot cast B* to D*" << endl;;
}
return 0;
}

Напоминаю, что сборка осуществляется с помощью wineconsole:

Дальше копируем полученный EXE-файл в образ дискеты:

Ну и запускаем эмулятор.

Как видите все отлично работает в операционной системе 40-летней давности:

Следующим шагом проверил обработку ошибок:

#include <iostream.h>
#include <exception>

int main() {
try {
int age = 15;
if (age >= 18) {
cout << "Access granted - you are old enough.";
} else {
throw 505;
}
} catch (int myNum) {
cout << "Access denied - You must be at least 18 years old.\n";
cout << "Error number: " << myNum;
}
return 0;
}

Тут стоит уточнить, что поддержку обработки ошибок надо включать отдельно, ключом -Ae:

Не поверите, но оно тоже работает:

Вот такие дела, конструкция try-catch на языке высокого уровня спокойно работает в MS-DOS образца 1986 года.

Еще больше балета

Разумеется я показал лишь малую часть возможностей компилятора, в первую очередь потому что уже декабрь а статья опять превратилась в простыню не успел закончить историю с STL:

STLport 4.5.3 ported to Digital Mars C++ (requires Digital Mars C++ 8.32 or later)

Это отдельная, весьма своеобразная версия STL, совместимая с DigitalMars, доступная для скачивания в собранном виде (плюс исходники). Но собрана она для целевой платформы Win32, поэтому для сборки под DOS ее готовую версию использовать не получится, надо пересобирать самостоятельно.

Сама возможность такой пересборки под DOS существует, но необходима либо платная версия DigitalMars, которая содержит собственную систему сборки (smake), либо очередной «кровавый патчинг», чтобы собрать STLport вручную.

Не поверите, но еще существует Boost (хоть и очень старый) с поддержкой компилятора DigitalMars:

Boost 1.30.0 for Digital Mars C++

Вот уж где раздолье и настоящий угар: писать под DOS c помощью самой жирной библиотеки для C++ на свете!

Чтобы окончательно добить вашу психику и чувство прекрасного, показываю несколько проектов «обратного портирования» STL — как раз для особых случаев, вроде истории с DigitalMars.

Первый проект:

A recreation of much of the modern C++ standard library in ISO C++98

https://github.com/DryPerspective/Cpp98_Library

Что именно из STL реализовано и примеры использования есть в Wiki проекта. Собирать с помощью dmc попробовать не успел, но выглядит многообещающе.

Второй проект:

A backport of C++11/14/17 features to earlier versions

https://github.com/chaossky/cppbackport

Тут основная цель это C++11, который DigitalMars поддерживает очень слабо, плюс будут проблемы с Windows-платформой:

Does it work on Windows? Sorry, POSIX mostly. Would love for some Windows devs to help.

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

Возвращение на Землю

Несмотря на описанное в статье, дела с компиляторами C/C++ от DigitalMars обстоят несколько печальней чем кажется. Во-первых этот компилятор очень сильно устарел и совместимость со стандартом языка осталась на уровне C++98.

Для более новых версий стандарта есть поддержка лишь отдельных фич и планов по улучшению ситуации я не видел.

Фактически активная разработка остановилась в 2004м году, с тех пор выпускаются лишь мелкие патчи и обновления, поскольку фокус авторов сместился на поддержку языка D.

Во-вторых этот компилятор по прежнему имеет серьезные проблемы с лицензированием:

несмотря на открытие исходного кода, для полноценной сборки требуется закрытый инструментарий.

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

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

Но для целей кросс‑компиляции под DOS (если вас жизнь заставит) — инструмент более чем интересный.

P.S.

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