Рассказываю что можно сделать на одном только голом JDK. Это старое и ныне почти забытое искусство разработки без внешних библиотек и фреймворков. Работать будем «как в былинные времена» — киркой и лопатой голыми руками и немного мозгом.
Disclaimer:
В нынешние интересные времена, когда один только boilerplate (шаблон проекта) может занимать на диске гигабайт, а количество библиотек в самом обычном проекте приближается к паре сотен — данная статья может нанести психическую травму неподготовленному читателю и заставить задуматься о правильности выбора профессии.
Обязательно посоветуйтесь с вашим психотерапевтом если родились после 2000х прежде чем читать дальше.
Disclaimer №2:
Конечно же я не призываю полностью отказываться от фреймворков и библиотек в рабочих проектах, данная статья — лишь демонстрация, что подобная разработка все еще вообще возможна.
Поскольку современные Java-разработчики почему-то считают, что без пары десятков библиотек Apache Commons, Spring и JPA с Hibernate разработки быть не может, а сразу за порогом любимого фреймворка начинается «страшный C++» и ходят люди с песьими головами.
Disclamier №3:
Эта объемная работа предназначена в первую очередь для профессионалов разработки на Java, которые уже имеют практический опыт с большими фреймворками, так популярными в этом болоте среде и смогут в полной мере оценить всю сложность работы «без всего».
Что будем делать
Вот такое:
Это самая обычная на первый взгляд гостевая книга — древний аналог «стены» из ВКонтакта.
Еще это веб‑приложение на Java (и немного на JavaScript), сильно упрощенный аналог самой популярной связки из Spring Boot + Thymeleaf, которые используются для современной разработки каждый день.
Но только:
без фреймворков и библиотек.
Готовый проект был по традиции выложен на GitHub.
Фичи
Хранилище данных на диске
Локализация
Авторизация, роли и разграничение доступа
Добавление, просмотр и удаление записей гостевой
И все это сделано и работает на одном только JDK, без каких-либо внешних библиотек:
Без сервлетов, сервлет-контейнеров, серверов приложений и так далее.
Одна голая Java и все.
Технические фичи
Парсер и генератор JSON
Шаблонизатор страниц
Парсер выражений (Expression Language «а‑ля рюс»)
IoC-Контейнер
Напоминаю что все это реализовано с нуля в рамках проекта, без каких-либо внешних библиотек.
Наверное прикинув сейчас размеры каких-нибудь Wildfly, Spring, Thymeleaf или еще каких монстров вы подумали что слегка устанете это все читать?
Немного успокою:
~800 строк кода, ~1200 с комментариями
70кб итоговый «бинарник»
Технически наш проект будет представлять собой встроенный HTTP‑сервер с упакованными внутрь ресурсами — как в Spring Boot. В качестве движка веб‑сервера будет использоваться «тайный» класс специального назначения com.sun.net.httpserver, который «тайно» присутствует в JRE и JDK начиная аж с версии 1.8, а ныне вообще является официально поддерживаемым для внешнего использования.
Если вам очень сильно надо использовать устаревший или нестандартный JRE — можете взять один из форков этого сервера, который был вытащен из исходного кода JDK и очищен от всех зависимостей.
Я не стал так поступать чтобы не увеличивать размер кодовой базы демонстрационного проекта в два раза — все же обработка HTTP на голых сокетах достаточно объемна.
Упрощенная логика использования выглядит так:
import com.sun.net.httpserver.*;
import java.net.*;
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception {
// создаем объект http сервера
HttpServer server = HttpServer.create(
new InetSocketAddress(8000), 0);
// добавляем контекст
server.createContext("/test", new MyHandler());
// запускаем
server.start();
}
/**
Пример обработчика.
Все настолько просто что поймут даже зумеры и дети.
*/
static class MyHandler implements HttpHandler {
/**
Вызов обработчика при совпадении контекста,
к которому он привязан.
*/
@Override
public void handle(HttpExchange t) throws IOException {
// тестовая строка
final String response = "Это тест";
// устанавливаем код 200 = ОК и размер отправляемых данных
t.sendResponseHeaders(200, response.length());
// пишем в поток вывода данные, которые отправятся пользователю.
try (OutputStream os = t.getResponseBody();) {
os.write(response.getBytes("UTF-8")); os.flush();
}
}
}
}Можете легко собрать руками:
javac -cp . Test.javaи запустить:
java -cp . TestНо конечно у нас в проекте все будет сложнее, поскольку есть и статичные ресурсы и специальная обработка шаблонов и еще всякие непотребства. Еще у нас будет почти настоящий REST API и некое подобие SPA:
аж целый отдельный класс на Javascript ECMA6, на котором сделан весь интерактив.
И еще один, отвечающий за авторизацию. Плюс немного CSS — для стильности и целая одна иконка. Куда же без иконки-то?
Сборка
Разумеется для нормальной разработки стоит использовать какую-то внешнюю систему сборки, но поскольку мы идем путем бусидо лишений и страданий — будем использовать исключительно средства JDK и ничего больше:
javac, jar и.. все.
Я использовал достаточно свежие фичи в проекте, поэтому необходимо собирать с помощью современных версий JDK — 17 и выше.
Вот так выглядит «тру» компиляция без всего:
javac -cp ./src/main/java -d target/classes src/main/java/com/Ox08/noframeworks/FeelsLikeAServer.javaДля упрощения жизни, был написан простой shell-скрипт, повторяющий шаги сборки из обычного Apache Maven:
#!/bin/sh
# очищаем каталог сборки
rm -rf target/
# компилируем
javac -cp ./src/main/java -d target/classes src/main/java/com/Ox08/noframeworks/FeelsLikeAServer.java
# копируем ресурсы
cp -R ./src/main/resources/* target/classes/
# формируем манифест для создания исполнимого JAR-файла
echo 'Manifest-Version: 1.0' > target/manifest.mf
echo 'Main-Class: com.Ox08.noframeworks.FeelsLikeAServer' >> target/manifest.mf
# упаковываем результат сборки в JAR-файл
jar cfm target/likeAServer.jar target/manifest.mf -C target/classes .В результате сборки появится файл likeAServer.jar в каталоге target.
Запустить собранное приложение можно следующим образом:
java -jar target/likeAServer.jarВот так выглядит запущенное приложение в работе:
Теперь рассказываю как оно все работает.
Общая логика
Все реализовано в виде одного класса с некоторой вложенностью, точкой запуска является стандартная функция:
public static void main(String[] args) {}Только без всей этой черной магии с загрузкой классов, характерной для Spring и всех больших серверов приложений.
Вот так выглядит общая структура класса и функция запуска (без учета вложенных классов):
/**
Да, это все - один класс.
*/
public class FeelsLikeAServer {
// JUL логгер, один и общий.
private final static Logger LOG = Logger.getLogger("NOFRAMEWORKS");
// признак включения отладки
private static boolean debugMessages;
/**
Вот она - та самая дырка: точка входа в приложение. Отсюда оно запускается.
*/
public static void main(String[] args) throws IOException {
// Получить номер порта из входящих параметров, если не указан - будет 8500
// Если кто вдруг не знает, параметры указываются как -DappPort=9000
final int port = Integer.parseInt(System.getProperty("appPort", "8500"));
// проверка на включение отладочных сообщений.
debugMessages = Boolean.parseBoolean(
System.getProperty("appDebug", "false"));
// если включена отладка - делаем доп. настройку JUL логгера
// для показа FINE уровня
if (debugMessages) {
LOG.setUseParentHandlers(false);
final Handler systemOut = new ConsoleHandler();
systemOut.setLevel(Level.FINE);
LOG.addHandler(systemOut);
LOG.setLevel(Level.FINE);}
}
// создание DI контейнера
final TinyDI notDI = new TinyDI();
// инициализация - указываем все классы являющиеся зависимостями
notDI.setup(List.of(Users.class,Sessions.class,LocaleStorage.class,
BookRecordStorage.class,RestAPI.class,Expression.class,
Json.class,PageHandler.class,ResourceHandler.class));
// получение уже созданного контейнером инстанса сервиса Users
// он отвечает за работу с пользователями
final Users users = notDI.getInstance(Users.class);
// загрузка списка пользователей
users.load();
// получение инстанса сервиса с записями в гостевой
final BookRecordStorage storage = notDI.getInstance(BookRecordStorage.class);
// загрузка их с диска
storage.load();
// загрузка локализованных строк
final LocaleStorage localeStorage = notDI.getInstance(LocaleStorage.class);
localeStorage.load();
// инициализация встроенного HTTP-сервера
final HttpServer server = HttpServer.create(new InetSocketAddress(port), 50);
// подключение обработчика страниц
server.createContext("/").setHandler(notDI.getInstance(PageHandler.class));
// .. обработчика статичных ресурсов
final ResourceHandler rs = notDI.getInstance(ResourceHandler.class);
server.createContext("/static").setHandler(rs);
server.createContext("/favicon.ico").setHandler(rs);
// .. обработчика REST API
server.createContext("/api").setHandler(notDI.getInstance(RestAPI.class));
LOG.info("FeelsLikeAServer started: http://%s:%d . Press CTRL-C to stop"
.formatted(server.getAddress().getHostString(), port));
// запуск сервера
server.start();
}
..А пока кратко разберем что тут происходит и зачем:
// создание DI контейнера
final TinyDI notDI = new TinyDI();
// инициализация - указываем все классы являющиеся зависимостями
notDI.setup(List.of(Users.class,Sessions.class,LocaleStorage.class,
BookRecordStorage.class,RestAPI.class,Expression.class,
Json.class,PageHandler.class,ResourceHandler.class));TinyDI это отдельный вложенный класс менеджера зависимостей, в этом месте происходит его инстанциация. Затем ему передается список зависимостей — классов, которые используют друг-друга и которые необходимо связать между собой.
Дальше мы получаем уже готовые экземпляры обслуживаемых классов и делаем их дальнейшую настройку:
// получение уже созданного контейнером инстанса сервиса Users
// он отвечает за работу с пользователями
final Users users = notDI.getInstance(Users.class);
// загрузка списка пользователей
users.load();
// получение инстанса сервиса с записями в гостевой
final BookRecordStorage storage = notDI.getInstance(BookRecordStorage.class);
// загрузка их с диска
storage.load();
// загрузка локализованных текстов
final LocaleStorage localeStorage = notDI.getInstance(LocaleStorage.class);
localeStorage.load();Метод load() в данном случае — сильно упрощенный аналог @PostConstruct аннотации, который вызывается вручную согласно логике работы приложения.
Дальше происходит инстанциация и настройка движка HTTP-сервера:
final HttpServer server = HttpServer.create(new InetSocketAddress(port), 50);
server.createContext("/").setHandler(notDI.getInstance(PageHandler.class));
final ResourceHandler rs = notDI.getInstance(ResourceHandler.class);
server.createContext("/static").setHandler(rs);
server.createContext("/favicon.ico").setHandler(rs);
server.createContext("/api").setHandler(notDI.getInstance(RestAPI.class));
LOG.info("FeelsLikeAServer started: http://%s:%d . Press CTRL-C to stop"
.formatted(server.getAddress().getHostString(), port));
server.start();Выставляются обработчики контента а в последней строке происходит непосредственно запуск HTTP-сервера. Вызов метода start() является блокирующим, поэтому на этом месте произойдет блокировка ввода.
Завершить приложение можно будет только по нажатию Ctrl-C. Или kill -9
По-умолчанию сервер запускается на порту 8500, откройте в браузере адрес:
и сможете узреть нашу гостевую:
Управление зависимостями
Да, когда-то давно так начинался знаменитый Spring Framework — как контейнер для автоматического управления зависимостями:
Внедрение зависимости (англ. Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (англ. Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму[1].
Расскажу в кратце как это работает с точки зрения «пользователя» — обычного разработчика, который использует DI и IoC в своем проекте. Допустим есть классы:
class Moo {
public Moo(Zoo z, Foo f) {}
}
class Foo {
}
class Zoo {
public Zoo(Foo f) {}
}Для того чтобы инициализировать класс Moo, содержащий зависимости от двух других классов без DI-контейнера, придется последовательно инициализировать все зависимые классы, подставляя параметры в конструкторы:
Foo f = new Foo();
Zoo z = new Zoo(f);
Moo m = new Moo(z,f);Теперь представьте объем подобного кода для типового проекта, где каждая вставка @Autowired или @Inject является признаком зависимости от другого бина.
Вот для примера небольшой кусочек из примера для JHipster:
public UserService(
UserRepository userRepository,
PasswordEncoder passwordEncoder,
AuthorityRepository authorityRepository,
CacheManager cacheManager
) {
this.userRepository = userRepository;
this.passwordEncoder = passwordEncoder;
this.authorityRepository = authorityRepository;
this.cacheManager = cacheManager;
}
...Чтобы не утонуть во всех этих массах однотипного говнокода и были придуманы DI-контейнеры, которые сами выстраивают цепочки зависимостей и согласно ним инициализируют классы.
Для максимальной простоты, я реализовал внедрение зависимостей исключительно через конструктор (без полей или сеттеров-геттеров), причем конструктор должен быть единственным.
Инициализация контейнера, построение дерева зависимостей и инстанциация зависимых классов — все происходит в один шаг вызовом метода:
public synchronized void setup(List<Class<?>> inputCl) {}После этого или пан или пропан либо все зависимости инициализируются либо выбрасывается ошибка. Если загрузка прошла успешно, можно получить инстанс бина вызовом метода:
public <T> T getInstance(Class<T> clazz) {}Да, это прямой аналог метода getBean() из ApplicationContext в Spring:
@Autowired
private ApplicationContext context;
..
SomeClass sc = (SomeClass)context.getBean(SomeClass.class);Вот так выглядит метод инициализации целиком:
public synchronized void setup(List<Class<?>> inputCl) {
if (this.totalDeps > 0)
throw new IllegalStateException("Already initialized!");
if (inputCl == null || inputCl.isEmpty())
throw new IllegalStateException("There should be dependencies!");
// we use 0 as marker for 'no dependencies'
this.totalDeps = inputCl.size() + 1;
// build adjuction array
for (int i = 0; i < totalDeps; i++)
adj.add(new ArrayList<>());
// build classes indexes, set initial class number
this.cl = new Class[totalDeps]; this.cdc = 1;
// build dependencies tree, based on class constructor
for (Class<?> c : inputCl) {
final List<Class<?>> dependsOn = new ArrayList<>();
for (Class<?> p : c.getDeclaredConstructors()
[0].getParameterTypes())
if (Dependency.class.isAssignableFrom(p))
dependsOn.add(p);
// add class number
addClassNum(c, dependsOn);
}
// make topological sort
final int[] ans = topoSort(adj);
final List<Integer> deps = new ArrayList<>();
// put marks for 'zero-dependency',
// when class does not depend on others
for (int node : ans)
if (node > 0)
deps.add(node);
// reverse to get least depend on top
Collections.reverse(deps);
// and instantiate one by one
for (int i : deps) instantiate(cl[i]);
}Тут происходит определение зависимых классов путем поиска аргументов у конструктора по-умолчанию:
for (Class<?> p : c.getDeclaredConstructors()[0].getParameterTypes())
if (Dependency.class.isAssignableFrom(p))
dependsOn.add(p);
..Dependency это специальный интерфейс, который используется как маркер зависимости, все зависимые классы должны обязательно его иметь:
static class Sessions implements Dependency {
..
}Что нужно для отделения «мух от котлет» — для понимания какие из зависимых классов являются управляемыми, а какие — нет.
Для построения дерева зависимостей используется Topological sort:
final int[] ans = topoSort(adj);
final List<Integer> deps = new ArrayList<>();
// put marks for 'zero-dependency', when class does not depend on others
for (int node : ans) if (node > 0) deps.add(node);
// reverse to get least depend on top
Collections.reverse(deps); Вот так выглядит реализация такой сортировки:
static int[] topoSort(ArrayList<ArrayList<Integer>> adj) {
final int[] indegree = new int[adj.size()];
for (ArrayList<Integer> integers : adj)
for (int it : integers) indegree[it]++;
final Queue<Integer> q = new LinkedList<>();
for (int i = 0; i < adj.size(); i++)
if (indegree[i] == 0)
q.add(i);
final int[] topo = new int[adj.size()];
int i = 0;
while (!q.isEmpty()) {
topo[i++] = q.remove();
for (int it : adj.get(topo[i - 1]))
if (--indegree[it] == 0)
q.add(it);
}
return topo;
}Смысл кода выше — в том чтобы отсортировать список от менее зависимых классов к более зависимым, а количество зависимостей используется в качестве весов.
Для примера с тремя зависимыми классами Foo,Zoo и Moo выше это будет выглядеть как-то так:
Foo — 0
Zoo — 1
Moo — 2
В результате всех операций мы получаем список классов, отсортированных по количеству зависимостей и готовых к инициализации:
// and instantiate one by one
for (int i : deps)
instantiate(cl[i]);Инстанциация класса происходит с помощью Reflection API и выглядит следующим образом :
private void instantiate(Class<?> clazz) {
if (clazz == null)
throw new IllegalStateException("Cannot create instance for null!");
LOG.log(Level.FINE, "Creating instance of %s"
.formatted(clazz.getName()));
// we just take first public constructor for simplicity
final java.lang.reflect.Constructor<?> c = clazz
.getDeclaredConstructors()[0];
final List<Object> params = new ArrayList<>();
// lookups constructor params in 'instances storage'
for (Class<?> p : c.getParameterTypes())
if (Dependency.class.isAssignableFrom(p)
&& services.containsKey(p))
params.add(services.get(p));
// try to instantiate
try {
services.put(clazz, c.newInstance(params.toArray()));
} catch (InstantiationException
| java.lang.reflect.InvocationTargetException
| IllegalAccessException e) {
throw new RuntimeException("Cannot instantiate class: %s"
.formatted(clazz.getName()), e);
}
}Предполагается, что на момент создания класса все его зависимости уже загружены в контейнер, поэтому достаточно их вытащить по имени и подставить в вызов конструктора с использованием Reflection API.
Если инициализация прошла успешно, бин добавляется в контейнер и сам становится доступен для подключения в виде зависимости.
Весь код целиком этого мини-контейнера можно посмотреть по ссылке.
Пользователи,сессии и авторизация
Да, все это также реализовано без каких-либо внешних библиотек и фреймворков — голыми руками. Разумеется не стоит так делать в большом коммерческом проекте, если только вы не владеете предметом и четко представляете что делаете.
Начнем с самого простого — с сессий, вот так выглядит класс для управления сессиями пользователей:
static class Sessions implements Dependency {
public static final int MAX_SESSIONS = 5,//max allowed sessions
SESSION_EXPIRE_HOURS = 8; // session expiration, in hours
private final Map<String, Session> sessions = new HashMap<>();
private final Map<String, String> registeredUsers = new HashMap<>();
..
public Session getSession(String sessionId) {
return !isSessionExist(sessionId) ? null :
sessions.get(sessionId);}
..
public boolean isSessionExist(String sessionId) {
// if there is no session registered with such id
// respond false
if (!sessions.containsKey(sessionId))
return false;
// extract session entity
final Session s = sessions.get(sessionId);
// checks for expiration time
// Logic is: [session created]...
// [now,session not expired]....
// [+8 hours]....
// [now,session expired]
if (s.created.plusHours(SESSION_EXPIRE_HOURS)
.isBefore(java.time.LocalDateTime.now())) {
LOG.log(Level.INFO,
"removing expired session: %s for user: %s"
.formatted(s.sessionId, s.user.username));
sessions.remove(sessionId); return false;
}
return true;
}
..
public synchronized String registerSessionFor(Users.User user) {
// disallow creation if max sessions limit is reached
if (registeredUsers.size() > MAX_SESSIONS)
return null;
// disallow creation if there is existing session
if (registeredUsers.containsKey(user.username))
return null;
// create new session id
final String newSessionId = UUID.randomUUID().toString();
sessions.put(newSessionId, new Session(newSessionId,
java.time.LocalDateTime.now(), user));
registeredUsers.put(user.username, newSessionId);
return newSessionId;
}
..
public synchronized boolean unregisterSession(String sessionId) {
if (!sessions.containsKey(sessionId))
return false;
registeredUsers.remove(sessions.remove(sessionId).user.username);
return true;
}
..
public record Session(String sessionId,
java.time.LocalDateTime created, Users.User user) {}
} Как видно из самого начала класса:
public static final int MAX_SESSIONS = 5,//max allowed sessions
SESSION_EXPIRE_HOURS = 8; // session expiration, in hours тут реализованы ограничения на количество сессий и их время жизни:
через 8 часов сессия авторизировавшегося пользователя
превратится в тыквуперестает быть валидной и удаляется.
Для хранения сессий используются два key-value связки:
private final Map<String, Session> sessions = new HashMap<>();
private final Map<String, String> registeredUsers = new HashMap<>(); В первой находятся сами сессии, с ключом в виде уникального ID, во второй находится связка между логином пользователя и ID сессии — для того чтобы вытаскивать сессию по логину пользователя.
Чтобы не реализовывать отдельную логику для проверки устаревания и удаления устаревших сессий, все это происходит непосредственно в методе проверки существования сессии:
public boolean isSessionExist(String sessionId) {
// if there is no session registered with such id
// respond false
if (!sessions.containsKey(sessionId))
return false;
// extract session entity
final Session s = sessions.get(sessionId);
// Checks for expiration time
// Logic is:
// [session created]...
// [now,session not expired]....
// [+8 hours]....[now,session expired]
if (s.created.plusHours(SESSION_EXPIRE_HOURS)
.isBefore(java.time.LocalDateTime.now())) {
LOG.log(Level.INFO,
"removing expired session: %s for user: %s"
.formatted(s.sessionId, s.user.username));
sessions.remove(sessionId);
return false;
}
return true;
}Вот так выглядит регистрация новой сессии для пользователя:
public synchronized String registerSessionFor(Users.User user) {
// disallow creation if max sessions limit is reached
if (registeredUsers.size() > MAX_SESSIONS)
return null;
// disallow creation if there is existing session
if (registeredUsers.containsKey(user.username))
return null;
// create new session id
final String newSessionId = UUID.randomUUID().toString();
sessions.put(newSessionId, new Session(newSessionId,
java.time.LocalDateTime.now(), user));
registeredUsers.put(user.username, newSessionId);
return newSessionId;
}Заодно в этом методе происходит проверка на количество допустимых сессий и если этот лимит превышен — регистрации не произойдет. И проверка на повторную регистрацию — чтобы не было затирания предыдущей сессии.
Для упрощения реализации, возврат null из этой функции означает ошибку, если же регистрация прошла успешно — вернется ID сессии.
Пользователи
Теперь переходим к пользователям, за работу с которыми отвечает другой вложенный класс:
static class Users implements Dependency {
private final Map<String, User> users = new TreeMap<>();
..
public void load() {
addUser(new User("admin", "admin", "Administrator", true));
addUser(new User("alex", "alex", "Alex", false));
}
..
public boolean isUserExists(String username) {
return username != null && !username.isBlank()
&& users.containsKey(username);
}
..
public User getUserByUsername(String username) {
return users.getOrDefault(username, null);
}
..
public void addUser(User user) { users.put(user.username(), user); }
..
public record User(String username,
String password,
String name, boolean isAdmin) {}
} Этот класс — упрощенный аналог UserDetailsService из Spring Security, совмещенный с репозиторием для хранения записей о пользователях. Как видите все пользователи зашиты в код:
public void load() {
addUser(new User("admin", "admin", "Administrator", true));
addUser(new User("alex", "alex", "Alex", false));
}Это было сделано для упрощения реализации, но ничего не мешает вставить в этом месте чтение из JSON/XML/СУБД лишь чуть усложнив логику. Также ради упрощения я реализовал разделение ролей админа и обычного пользователя одним булевым признаком isAdmin:
public record User(String username,
String password, String name, boolean isAdmin) {}
Авторизация
Авторизация работает путем формирования на стороне браузера JSON с полями логина и пароля, c последующей отправкой этого JSON на сервер POST‑запросом с помощью асинхронного API — все как в больших проектах на SPA.
Далее сервер обрабатывает POST-запрос, парсит JSON, вытаскивает введенные пользователем логин с паролем и проверяет.
Если учетные данные совпали — сервер создает сессию, выставляет авторизационный Cookie отдельным заголовком и возвращает url для перехода после авторизации. Если нет — сервер возвращает ошибку, которая отображается в браузере (см. скриншот выше)
Такая реализация близка к современным веб‑системам, построенным по модели SPA и позволяет определенный интерактив: например отображение сообщения об ошибке происходит без перезагрузки страницы.
Самопальный "JSON"
Очень надеюсь на адекватность читающих — что вы не воспримете описанное как руководство к действию и никогда не опуститесь до подобной самопальной реализации парсера JSON в боевом проекте.
Не надо так делать. Никогда.
Чтобы вам там ни казалось, формат JSON — сложный, не стоит браться за реализацию своего парсера с нуля если у вас недостаточно опыта или времени. Все описанное — лишь демонстрация что подобное вообще возможно, причем оставаясь в рамках минимально возможного объема кода.
Опишу все ограничения, чтобы вы «не раскатывали губу» заранее:
Нет поддержки вложенности
Ручная сериализация, без рефлексии — по заранее определенным полям
Нет типов - все поля обрабатываются как строка
Нет обработки массивов при парсинге
Фактически вся обработка сводится к разбору вот таких примитивов:
{
"id":"98e64df2-d2b5-4997-bedb-75ada485ea62",
"title":"Some title 9",
"author":"alex 9",
"created":"1675173817790",
"message":"test message 9"
}и превращению полученных данных в Map с полями «ключ-значение».
Код полной реализации, как парсера так и сериализации в строку:
static class Json implements Dependency {
final static Pattern PATTERN_JSON = Pattern
.compile("\"([^\"]+)\":\"*([^,^}\"]+)", Pattern.CASE_INSENSITIVE);
/**
* That's how we do it: parse JSON as grandpa!
* No nested objects allowed.
*
* @param json json string
* @return key-value map parsed from json string
*/
public static Map<String, String> parseJson(String json) {
// yep, we just parse JSON with pattern and
// extract keys and values
final java.util.regex.Matcher matcher = PATTERN_JSON.matcher(json);
// output map
final Map<String, String> params = new HashMap<>();
// loop over all matches
while (matcher.find()) {
String key = null, value = null;
// skip first match group (0 index) ,
// because it responds whole text
for (int i = 1; i <= matcher.groupCount(); i++) {
// First match will be key, second - value
// So we need to read them one by one
final String g = matcher.group(i);
if (key != null)
value = g;
else
key = g;
LOG.log(Level.FINE, "key=%s value=%s g=%s"
.formatted(key, value, g));
if (key != null && value != null) {
params.put(key, value);
key = null;
value = null;
}
}
}
return params;
}
public static void toJson(StringBuilder out,
Collection<BookRecord> records) {
// yep, we build json manually
out.append("[");
boolean first = true;
// build list of objects
for (BookRecord r : records) {
if (first)
first = false;
else
out.append(",");
Json.toJson(out, r);
}
out.append("]");
}
/**
* Build JSON string from BookRecord object
*/
public static void toJson(StringBuilder out, BookRecord r) {
out.append("{\n");
toJson(out, "id", r.id, true);
toJson(out, "title", r.title, true);
toJson(out, "author", r.author, true);
toJson(out, "created", r.created.getTime(), true);
toJson(out, "message", r.message, false);
out.append("}");
}
/**
* Build JSON string with key-value pair
*/
public static void toJson(StringBuilder sb,
String key, Object value, boolean next) {
sb.append("\"")
.append(key)
.append("\":\"")
.append(value)
.append("\"");
if (next)
sb.append(",");
sb.append("\n");
}
}Теперь разберем особенности реализации.
Парсинг JSON
Начнем с функции разбора JSON:
public static Map<String, String> parseJson(String json) { .. }Для простоты реализации, весь JSON разбирается одним регулярным выражением:
final static Pattern PATTERN_JSON = Pattern
.compile("\"([^\"]+)\":\"*([^,^}\"]+)", Pattern.CASE_INSENSITIVE); Вызывается парсер регулярных выражений:
final java.util.regex.Matcher matcher = PATTERN_JSON.matcher(json); и запускается цикл по найденным блокам:
while (matcher.find()) { .. }Внутри находится еще один цикл, в котором происходит перебор найденных пар ключ-значение:
String key = null, value = null;
// skip first match group (0 index) ,
// because it responds whole text
for (int i = 1; i <= matcher.groupCount(); i++) {
// First match will be key, second - value
// So we need to read them one by one
final String g = matcher.group(i);
if (key != null)
value = g;
else
key = g;
LOG.log(Level.FINE, "key=%s value=%s g=%s"
.formatted(key, value, g));
if (key != null && value != null) {
params.put(key, value);
key = null;
value = null;
}
}Замечу что ключи должны быть уникальными, поскольку такая реализация парсера дубли просто затрет. Но для нашей упрощенной реализации это допустимо.
Сериализация JSON
Теперь разберем процесс сериализации в строку, он состоит из нескольких уровней, на самом низком это выглядит вот так:
public static void toJson(StringBuilder sb,
String key, Object value, boolean next) {
sb.append("\"")
.append(key)
.append("\":\"")
.append(value)
.append("\"");
if (next)
sb.append(",");
sb.append("\n");
}В результате работы этой функции будет сформирована одна пара ключ-значение в формате JSON:
"message":"Дооо дооо дооооо дооооо"Следующий уровень это последовательные вызовы данного метода для всех полей объекта:
public static void toJson(StringBuilder out, BookRecord r) {
out.append("{\n");
toJson(out, "id", r.id, true);
toJson(out, "title", r.title, true);
toJson(out, "author", r.author, true);
toJson(out, "created", r.created.getTime(), true);
toJson(out, "message", r.message, false);
out.append("}");
}В результате вызова получится вот такой JSON:
{
"id":"0f2fbde8-c51d-4a39-bef2-3f5d33e64fe4",
"title":"Some title 3",
"author":"alex 3",
"created":"1675173817789",
"message":"test message 3"
}Что соответствует полям объекта BookRecord. Наконец на самом верхнем уровне находится обработка массивов объектов:
public static void toJson(StringBuilder out,
Collection<BookRecord> records) {
// yep, we build json manually
out.append("[");
boolean first = true;
// build list of objects
for (BookRecord r : records) {
if (first)
first = false;
else
out.append(",");
Json.toJson(out, r);
}
out.append("]");
}В результате вызова получается строка в формате JSON, соответствующая массиву объектов. Вот так выглядит результат для массива объектов типа BookRecord:
[{
"id":"81081891-0282-40e2-abc8-c84a40823677",
"title":"тест",
"author":"тест",
"created":"1676379108664",
"message":"тест"
},{
"id":"77e4f673-da34-465b-867c-febe4035bee4",
"title":"Some title 5",
"author":"alex 5",
"created":"1675173817789",
"message":"test message 5"
},{
"id":"d4f7be9c-a290-407d-a642-e3030a2b9300",
"title":"лдлдл",
"author":"еее",
"created":"1676381010026",
"message":"лдлдл"
},{
"id":"60697959-ed1f-4cb0-94aa-a63109b4c710",
"title":"Еще один унылый тест",
"author":"Тестов",
"created":"1717661222006",
"message":"Дооо дооо дооооо дооооо"
}]Но едем дальше, на очереди следущая интересная тема.
Шаблонизатор
«Чад кутежа во славу самопала» был бы неполным без своей реализации шаблонизатора — упрощенного аналога Thymeleaf, разумеется с крайне ограниченным функционалом.
В качестве шаблонов используются HTML-файлы со специальными управляющими блоками внутри — по прямой аналогии с Thymeleaf.
Расскажу сначала как это выглядит со стороны самих шаблонов.
Главный шаблон и страницы
Классика шаблонизации страниц — разделение на один или несколько общих шаблонов, с последующей подстановкой внутрь именованных частей, заданных на каждой отдельной странице. Именно такой подход мы и будем использовать.
Вот так выглядит общий шаблон:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
..
</head>
<body class="c">
<div class="row" >
<b class="col">
<!-- inject section 'header' below -->
${inject(header)}
</b>
</div>
...
</body>
</html>Cо стороны страницы использование родительского шаблона активируется специальным тегом:
<!-- instruct to use main template -->
${template(template/main.html)}А так задаются данные для подстановки в именованную секцию:
<!-- the 'header' section -->
${section(header)
<h4>${msg(gb.text.login.title)}</h4>
}В результате при формировании страницы login.html будет взят шаблон template/main.html, в котором вместо ${inject(header)} будет подстановка текстового блока из login.html:
<h4>${msg(gb.text.login.title)}</h4>Но перед этим еще произойдет препроцессинг — блок ${msg (gb.text.login.title)} будет заменен на строку из локализованного бандла:
gb.text.login.title=Please authenticateИтог работы выглядит следующим образом:
<h4>Please authenticate</h4>Ну разве не чудо?
Локализованные сообщения
Наш самостийный и краснознаменный шаблонизатор поддерживает подстановку локализованных текстовых сообщений из бандлов:
<div class="6 col">
<label for="titleInput">${msg(gb.text.newmessage.title)}</label>
<input type="text" class="card w-100"
id="titleInput"
placeholder="${msg(gb.text.newmessage.title.placeholder)}"/>
</div>Тег ${msg(gb.text.newmessage.title)} является указанием на использование подстановки локализованного текстового значения из бандла.
Глобальные переменные
Разумеется шаблонизатор ограниченно поддерживает глобальные переменные:
<span style="padding-right:0.5em;">${msg(user.name)}</span>В данном случае будет подставлено имя текущего пользователя, если он был авторизован.
Условия
Наконец наверное самое веселое — поддержка выражений, разумеется также сильно ограниченная:
${if(url eq /login.html)
<a class="btn"
href="/">${msg(gb.text.login.btn.back)}</a>
}Для этого был реализован аж целый мини-движок для разбора логики сложных булевых выражений:
true && ( false || ( false && true ) )Но вместо true/false будет подстановка вычисленных значений, типа такого:
${if(!gb.isAuthenticated)
<a class="btn" href="/login.html">${msg(gb.text.login)}</a>
}Реализация шаблонизатора
Начну с самого начала, тут происходит установка обработчика, отвечающего за выдачу страниц:
final HttpServer server = HttpServer.create(new InetSocketAddress(port), 50);
// setup page handler and bind it to /
server.createContext("/").setHandler(notDI.getInstance(PageHandler.class));Поскольку мы имеем дело с встроенным и максимально упрощенным HTTP-сервером (это вам не Jetty), всю логику — аналог сервлетов необходимо помещать в специальные обработчики, реализующие интерфейс HttpHandler:
class MyHandler implements HttpHandler {
public void handle(HttpExchange t) throws IOException {
InputStream is = t.getRequestBody();
read(is); // .. read the request body
String response = "This is the response";
t.sendResponseHeaders(200, response.length());
OutputStream os = t.getResponseBody();
os.write(response.getBytes());
os.close();
}
}Полный код обработчика для отдачи страниц с шаблонизатором можно посмотреть по ссылке. Ниже я по шагам разберу как он работает.
Во-первых сам обработчик имеет зависимости, поэтому его жизненный цикл управляется IoC-контейнером:
PageHandler(Sessions sessions, Expression expr) {}Бины Sessions (отвечает за сессии пользователей) и Expression (за вычисляемые выражения) инициируются до нашего обработчика и затем подставляются в конструктор.
Дальше происходит чтение главного шаблона из ресурсов приложения:
templates.put("template/main.html",
new String(
getResource("/static/html/template/main.html")));Данные шаблона добавляются в key-value хранилище, в качестве ключа используется путь, который указывается в теге $template:
<!-- instruct to use main template -->
${template(template/main.html)}Затем загружаются сами страницы:
resources.put("/index.html",
new StaticResource(
getResource("/static/html/index.html"), "text/html"));
resources.put("/login.html",
new StaticResource(
getResource("/static/html/login.html"), "text/html"));и помещаются в другое хранилище, где ключем является URL страницы, по которому она доступна пользователям, например: /login.html
На этом процесс инициализации обработчика страниц заканчивается, остальная логика находится уже в методе обработки, вызываемом на каждый входящий HTTP-запрос:
@Override
public void handle(HttpExchange exchange) throws IOException { .. }Первым делом выполняется проверка и очистка URL, взятая из HTTP-запроса:
String url = getUrl(exchange.getRequestURI());Метод getUrl() находится в классе AbstractHandler, и отвечает за проверку на пустоту и начальную очистку строки запроса:
protected String getUrl(URI u) {
return (u != null ? u.getPath() : "").toLowerCase().trim();
}Перевод в нижний регистр нужно для последующего сравнения с доступными страницами, регистрация которых выполняется в нижнем регистре.
Дальше происходит получение «сырых» данных шаблона по URL:
final StaticResource resource = resources.get(url);Поскольку одинаковый механизм используется как для статичных файлов так и для шаблонов - необходима проверка на тип MIME, чтобы отсеять файлы не являющиеся шаблонами или страницами:
if (!"text/html".equals(resource.mime)) {
respondData(exchange, resource.data);
return;
}Следующим шагом создается «рантайм» для шаблонизатора — HashMap, в который помещаются все ресурсы, доступные из шаблона:
// build rendering runtime
final TypedHashMap<String, Object> runtime = new TypedHashMap<>();Добавляются ссылки на все доступные шаблоны:
// put all available templates to let expression parser found them
runtime.put(Expression.ALL_TEMPLATES_KEY,templates);Добавляется выбранный язык или язык по-умолчанию, а также текущий URL страницы:
// put current language and current page url
runtime.put("lang", lang == null || lang.isBlank() ? "en" : lang);
runtime.put("url",url);Добавляется признак авторизации пользователя:
// check if user session exist
final boolean sessionExist = sessions.isSessionExist(sessionId);
LOG.info("got session: %s exist? %s".formatted(sessionId, sessionExist));
runtime.put("gb.isAuthenticated", sessionExist);Напомню как выглядит его использование из шаблона:
${if(gb.isAuthenticated)
<a href="#" id="deleteBtn"
class="btn primary"
confirm="${msg(gb.text.btn.delete.confirm)}">
${msg(gb.text.btn.delete)}
</a>
}Далее в окружение шаблонизатора добавляется информация о текущем пользователе:
// put current user's name to been displayed in top of page
if (sessionExist)
runtime.put("user.name", sessions.getSession(sessionId).user.name);Наконец мы подходим к самой генерации страницы, поскольку она сложная и могут быть ошибки в шаблонах — вся логика обернута в блок try-catch:
try {
final String source = new String(resource.data);
expr.parseTemplate(source, runtime,
(line)-> expr.buildTemplate(line.expr,line.runtime));
final String merged = runtime.containsKey(Expression.PAGE_TEMPLATE_KEY) ?
expr.mergeTemplate(runtime.getTyped(Expression.PAGE_TEMPLATE_KEY,null),
runtime) : source;
respondData(exchange, expr.parseTemplate(merged, runtime,
(line)-> expr.parseExpr(line.expr,line.runtime))
.getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
LOG.log(Level.WARNING,
"Cannot parse template: %s".formatted(e.getMessage()), e);
respondBadRequest(exchange);
}Теперь рассмотрим каждый шаг генерации шаблона, первый важный шаг это связывание всех частей шаблона в единый HTML:
expr.parseTemplate(source, runtime,
(line)-> expr.buildTemplate(line.expr,line.runtime));Причем третий аргумент это на самом деле замыкание, внутри которого вызывается метод подстановки в строке:
(line)-> expr.buildTemplate(line.expr,line.runtime)Следующим шагом запускаем обработку всех выражений:
respondData(exchange, expr.parseTemplate(merged, runtime,
(line)-> expr.parseExpr(line.expr,line.runtime))
.getBytes(StandardCharsets.UTF_8));Метод parseTemplate() в котором происходит связывание частей в единый HTML оказался слишком объемным для цитирования, поэтому целиком его можно посмотреть по ссылке.
В нем происходит последовательное и посимвольное чтение шаблона, где внутри цикла происходит поиск и выборка всех подстановок вида
${..}
В момент определения выражения — когда последовательно считались символы '$', '{', внутренний блок и завершающий символ '}', происходит вызов функции обработки, переданной в качестве аргумента:
out.append(onReadExpr.apply(new Line(expr.toString(), runtime)));Внутри происходит вызов функции buildTemplate():
(line)-> expr.buildTemplate(line.expr,line.runtime)В результате работы этой функции, происходит вычленение секций и заполнение рантайма данными из каждой секции.
На следующем шаге эти данные подставляются в готовый шаблон.
REST API
Скажу сразу — на самом деле это лишь очень простое подобие RESTful.
Все отличие данного обработчика от отвечающего за шаблонизатор лишь в том что для входящих и исходящих данных используется JSON.
Нет подстановки именованных параметров из url (вроде «/api/records/get/<id>»), нет обработки HEAD, PUT и DELETE запросов — ничего не мешает все это добавить разумеется, но увеличит объем кода.
Поэтому я ограничился самым минимумом функцонала.
Которого как ни странно вполне хватает для управляющего ПО вашего роутера, например.
Вот так выглядит сокращенный исходный код обработчика (убрана только логика обработки методов внутри case — она описана отдельно по каждому логическому блоку):
static class RestAPI
extends AbstractHandler implements HttpHandler, Dependency {
private final BookRecordStorage storage;
private final Users users;
private final Sessions sessions;
private final LocaleStorage localeStorage;
RestAPI(BookRecordStorage storage,
Users users,
Sessions sessions, LocaleStorage localeStorage) {
this.storage = storage;
this.localeStorage = localeStorage;
this.users = users;
this.sessions = sessions;
}
@Override
public void handle(HttpExchange exchange) throws IOException {
// extract url
final String url = getUrl(exchange.getRequestURI()),
query = exchange.getRequestURI().getQuery();
// extract url params
final Map<String, String> params = query != null
&& !query.trim().isBlank() ?
parseParams(exchange.getRequestURI().getQuery()) :
Collections.emptyMap();
// for output json
final StringBuilder out = new StringBuilder();
// we use simple case-switch with end urls
switch (url) {
// respond list of records
case "/api/records" -> {
..
..
}
}
respondData(exchange, out.toString()
.getBytes(StandardCharsets.UTF_8));
}Помимо уже описанного выше метода getUrl(), который нужен для очистки входяшего урла, тут есть еще парсинг и заполнение «key-value» хранилища параметрами HTTP-запроса:
// extract url params
final Map<String, String> params = query != null
&& !query.trim().isBlank() ?
parseParams(exchange.getRequestURI().getQuery()) :
Collections.emptyMap();Вот как происходит разбор параметров, указанных в урле HTTP-запроса:
static Map<String, String> parseParams(String query) {
return Arrays.stream(query.split("&"))
.map(pair -> pair.split("=", 2))
.collect(java.util.stream.Collectors
.toMap(pair ->
URLDecoder.decode(pair[0], StandardCharsets.UTF_8),
pair -> pair.length > 1 ?
URLDecoder.decode(pair[1], StandardCharsets.UTF_8) :
"")
);
}Теперь вы тоже знаете откуда сервлет достает для вас параметры HTTP-запроса.
Подход очень даже рабочий.
Локализация
Разве можно делать современный веб-проект только на одном языке? Ведь в современном динамичном мире любое веб-приложение для широких масс должно иметь поддержку минимум двух языков:
английского и «местного», в нашем случае — русского.
Поэтому я тоже реализовал поддержку локализации — без фреймворков и библиотек.
Рассказываю как оно работает.
Выражения в шаблоне страницы
Для начала вернемся к шаблону страницы:
<div class="row">
<label for="messageInput">${msg(gb.text.newmessage.message)}</label>
<textarea class="card w-100" id="messageInput"
rows="3"
placeholder="${msg(gb.text.newmessage.message.placeholder)}">
</textarea>
</div>Это блок (div) отвечающий за отрисовку формы ввода сообщения:
Как видите вместо слова «Сообщение» и строки «Однажды в студеную зимнюю пору.» в шаблоне указаны только специальные теги с выражениями внутри:
${msg(gb.text.newmessage.message)} и:
${msg(gb.text.newmessage.message.placeholder)}Эти выражения обрабатываются парсером при работе шаблонизатора и происходит подстановка — вместо выражения вставляется текстовое значение из .properties-файла, взятое по ключу:
gb.text.newmessage.message=Сообщение
gb.text.newmessage.message.placeholder=Однажды в студеную зимнюю пору..Файлов .properties несколько, с постфиксами, соответствующими локали:
Выбираются они в зависимости от выбранной пользователем локали.
Интерфейс
Выбор локали осуществляется кнопками интерфейса:
По нажатию на которые происходит вызов обработчика:
document.querySelector('#selectEn')
.addEventListener('click', (e) => {
e.preventDefault();
gb.changeLang('en');
});Который выполняет POST-запрос с выбранной локалью на сервер:
changeLang(lang) {
console.log("change lang to: ", lang);
fetch('/api/locale?' + new URLSearchParams({ lang: lang }),
{ method: 'POST', headers: {} }).then((response) => {
// support for redirection
if (response.redirected) {
location.href = response.url;
}
}).catch(error => {
console.log("error on lang select: ", error);
});
}В ответе сервера в случае успешного вызова будет редирект — он нужен для того чтобы перезагрузить страницу с уже другой локализацией.
API бекэнда
Вот так выглядит обработка запроса на смену локали со стороны сервера:
..
case "/api/locale" -> {
if (!params.containsKey("lang")) {
LOG.log(Level.FINE,
"bad request: no 'lang' parameter");
respondBadRequest(exchange);
return;
}
String lang = params.get("lang");
if (lang == null || lang.isBlank()) {
LOG.log(Level.FINE,
"bad request: 'lang' parameter is empty");
respondBadRequest(exchange);
return;
}
lang = lang.toLowerCase().trim();
if (!localeStorage.getSupportedLocales()
.contains(lang)) {
LOG.log(Level.FINE,
"bad request: unsupported locale: %s"
.formatted(lang));
respondBadRequest(exchange);
return;
}
exchange.getResponseHeaders()
.add("Set-Cookie", "%s=%s; Path=/; Secure; HttpOnly"
.formatted(LANG_KEY, lang));
respondRedirect(exchange, "/index.html");
LOG.log(Level.FINE, "changed lang to: %s"
.formatted(lang));
return;
}
..Обратите внимание на установку заголовка Set-Cookie — с его помощью сохраняется выбранный пользователем язык, который при следущих запросах передается на сервер.
На стороне сервера в методе обработчика страниц PageHandler.handle() происходит получение выбранного пользователем языка из заголовка Cookie:
lang = getCookieValue(exchange, LANG_KEY);Если он пуст или не был задан — выбирается английская локаль в качестве значения по-умолчанию:
// put current language and current page url
runtime.put("lang", lang == null || lang.isBlank() ? "en" : lang); Дальше она устанавливается в рантайм шаблонизатора — т. е. значение локали становится доступно как из самого шаблона так и из логики его обработки, в которой происходит чтение значений из бандла:
...
if (expr.startsWith("msg(")) {
// extract variable name from expression block
String data = expr.substring("msg(".length());
data = data.substring(0, data.indexOf(")"));
LOG.log(Level.FINE, "key: '%s'".formatted(data));
/*
* We support 2 cases:
* 1) direct substitution from provided key-value map
* 2) attempt to get value from i18n bundle
*/
return runtime.containsKey(data) ?
runtime.get(data).toString() :
localeStorage.resolveKey(data, (String) runtime.get("lang"));
}Как видите вызов метода resolveKey(), который отвечает за получение текстовых сообщений из бандлов происходит с указанием выбранной локали.
Парсер булевых выражений
Наконец последняя, но крайне интересная тема данного проекта — свой собственный парсер булевых выражений.
Нужен он для того чтобы превратить сложные выражения записанные в виде строки вроде:
String s = "true && ( false || ( false && true ) )";В одно булевое значение true или false. Это и есть очень простой аналог Expression Language, вернее одной из его ключевых частей. Идея реализации была взята отсюда, затем переработана.
Вот так выглядит лексическое выражение:
expression = factor { "||" factor }
factor = term { "&&" term }
term = [ "!" ] element
element = "T" | "F" | "(" expression ")"Вот так парсер запускается:
ConditionalParser c =new ConditionalParser(s);
boolean result = c.evaluate();Как видите на каждое выражение порождается свой экземпляр парсера — это нужно из-за использования рекурсии в реализации:
private static class ConditionalParser {
private final String s;
int index = 0;
ConditionalParser(String src) {
this.s = src;
}
private boolean match(String expect) {
while (index < s.length()
&& Character.isWhitespace(s.charAt(index)))
++index;
if (index >= s.length())
return false;
if (s.startsWith(expect, index)) {
index += expect.length();
return true;
}
return false;
}
private boolean element() {
if (match(Boolean.TRUE.toString()))
return true;
if (match(Boolean.FALSE.toString()))
return false;
if (match("(")) {
boolean result = expression();
if (!match(")"))
throw new RuntimeException("')' expected");
return result;
} else
throw new RuntimeException("unknown token found: %s"
.formatted(s));
}
private boolean term() {
return match("!") != element();
}
private boolean factor() {
boolean result = term();
while (match("&&"))
result &= term();
return result;
}
private boolean expression() {
boolean result = factor();
while (match("||"))
result |= factor();
return result;
}
public boolean evaluate() {
final boolean result = expression();
if (index < s.length())
throw new RuntimeException(
"extra string '%s'"
.formatted(s.substring(index)));
else
return result;
}
}
}Кстати таких проектов достаточно много на Github, поскольку задача реализации подобного парсера является одним из домашних заданий в ВУЗах, где серьезно учат компьютерным наукам.
Эпилог
Как видите есть веские причины по которым на свете существуют готовые библиотеки и сложные фреймворки — если вы не готовы угореть по хардкору к сложностям полностью кастомной разработки, то лучше все же использовать что-то готовое.
Сложность и объем разработки «полностью с нуля» думаю теперь стал для многих читателей вполне очевиден — это ни разу не накидывание готовых компонентов в уютном фреймворке.
Помните об этом прежде чем садиться за разработку чего-то «с нуля» и с желанием всех переиграть.
P.S.
К сожалению редактор статьей Хабра не выдерживает таких объемов текста и подвисает даже на урезанной версии, поэтому полную версию статьи (в два раза больше) с описанием всего реализованного функционала вы можете найти в нашем блоге.
0x08 Software
Мы небольшая команда ветеранов ИТ‑индустрии, создаем и дорабатываем самое разнообразное программное обеспечение, наш софт автоматизирует бизнес‑процессы на трех континентах, в самых разных отраслях и условиях.
Оживляем давно умершее, чиним никогда не работавшее и создаем невозможное — затем рассказываем об этом в своих статьях.
