Java. Երեսուն տարի, երեք դաս
Java-ին 30 տարեկան է։ Ի պատիվ այն լեզվի, որի վրա հիմնված է ժամանակակից տեխնոլոգիաների մեծ մասը, չորս ավագ ինժեներներ կարևոր դասեր են փոխանցում մշակողների հաջորդ սերնդին։ Իմացեք, թե ինչն է այն դարձնում անկանգնելի։
Երեք տասնամյակ առաջ փոքրիկ Duke-ը հայտնվեց տեխնոլոգիական ասպարեզում, և Java-ն տվեց իր համարձակ խոստումը՝ «գրիր մեկ անգամ, աշխատեցրու ամենուր»։ Այսօր՝ 2025-ին, Java-ն մնում է ձեռնարկությունների ծրագրային ապահովման ողնաշարը՝ սնելով ամեն ինչ՝ insurtech հարթակներից մինչև կրիպտոդրամապանակներ, որոնք արագորեն դառնում են ժամանակակից բանկային հավելվածների ստանդարտ մասը։
Իմ աշխատանքային ժամանակի մեծ մասը գնում է ինժեներական գերազանցությունը բիզնես արժեքի վերածելու վրա։ Այնուամենայնիվ, ամեն մեծ պատմություն սկսվում է այն մարդկանցից, ովքեր իրականում ապրում են այն։ Ես հարցրի մեր չորս ավագ ինժեներներին, թե ինչ դասեր կփոխանցեին Java մշակողների հաջորդ սերնդին։
Ահա երեք տասնամյակ և երեք(ի չափ) դաս՝ պատմված այն մարդկանց կողմից, ովքեր ամեն օր գրում են արտադրական կոդ։ Ծնունդդ շնորհավոր, Java։ 🎂
Շարահյուսությունը միայն մակերեսն է
Առաջին լեզուն սովորելը կախարդանք սովորելու պես էր։ Մի քանի տող կոդ էի գրում, և էկրանին ինչ-որ բան հայտնվում էր։ Զարմանալի էր։
Սկզբում ամեն ինչ պարզ ու հասկանալի էր թվում։ Սովորեցի շարահյուսությունը և փորձեցի տարածված հնարավորությունները։ Ծանոթացա collection-ներին, ցիկլերին և բացառություններին, և նույնիսկ պատահաբար հանդիպեցի multithreading-ի։ Իմ մտածողությունը հետևյալն էր. «Երբ լեզվին բավականաչափ լավ տիրապետեմ, չկա մի բան, որ չկարողանամ կառուցել»։
Բայց երբ գաղափարներս մեծացան, բախվեցի «իրականության ստուգման» պատին։
Պարզվեց՝ լեզուն իմանալը բավարար չէ իրական ծրագրակազմ կառուցելու համար։ Հանկարծ պիտի սովորեի Spring Boot, տվյալների բազաներ, Rest API և «deployment», ինչ էլ որ դա այն ժամանակ նշանակեր։
Որպես ծրագրավորող՝ հասկացա, որ սա սառցալեռան ընդամենը գագաթն է։
Լավ արտադրանք ստեղծելը պահանջում է ավելին, քան պարզապես կոդ գրելը։ Մեր նպատակն այլևս պարզապես ինչ-որ բան ստեղծելը չէ։ Մենք ուզում ենք, որ արտադրանքը երկար դիմանա։ Պետք է ստուգենք, որ բիզնես պահանջները բավարարված են, և համոզվենք, որ մեր փոփոխությունները ամեն ինչ չեն փչացնում։ Մենք ուզում ենք, որ հավելվածը լինի անվտանգ, դիտարկելի (observable) և սպասարկելի։
Դա ինձ բերեց կարևոր գիտակցման. Java գրելը նշանակում է աշխատել մի ամբողջ էկոհամակարգի հետ։ Ես պիտի ծանոթանայի գործիքներին, ֆրեյմվորքներին և գրադարաններին։
Սրանից շատը սովորել եմ տեղական meetup-ներում և տարբեր կոնֆերանսներում հանդիպած մշակողներից։ Զվարճալի է, որ նրանցից շատերը Java մշակողներ չէին, բայց մենք, այնուամենայնիվ, կարողանում էինք փորձ և գիտելիք փոխանակել։ Դա այն պատճառով է, որ սրանք այն խնդիրներն են, որոնց բախվում ենք բոլորս՝ անկախ օգտագործվող լեզվից։
Այնպես որ, եթե դուք էլ այս ճանապարհին եք, հիշեք. լեզուն միայն մուտքն է։ Իսկական վարպետությունը նրա շուրջ եղած ամեն ինչի մեջ է։
Java-ն այլևս դանդաղ չէ
Տարիներ շարունակ Java-ն դանդաղ լինելու համբավ է ունեցել։ Ես դա շատ եմ լսել՝ նույնիսկ երբ ծրագրավորումը ինձ համար դեռ միայն հոբբի էր։
Եվ մակերեսային հայացքով դա խելամիտ էր թվում։ Java-ն աշխատում է վիրտուալ մեքենայի վրա, օգտագործում է աղբահավաք (garbage collector) և ավելացնում է աբստրակցիայի շերտեր։ Այդ ամենը ծանր էր զգացվում։
Դեռևս 2011-ին Ռոբերտ Հունդտը հրապարակեց «Loop Recognition in C++/Java/Go/Scala» հոդվածը, որտեղ վերլուծեց և համեմատեց այս 4 լեզուները։ C++-ի կողքին Java-ն դանդաղ էր։ Բնականաբար, չէ՞։ C++-ն աշխատում է ավելի մոտ երկաթին։ Ինչպե՞ս կարող էր որևէ մեկը դրա հետ մրցել։
Բայց Java-ի ամեն նոր տարբերակ այն ավելի արագ է դարձնում, և ամեն տարբերակ ինչ-որ նոր բան է բերում սեղանին։
Վերցնենք, օրինակ, Just In Time կոմպիլյատորը (JIT)՝ Java հավելվածների իսկական փրկարարը։ Այն հայտնաբերում է թեժ կետերը (կոդի ուղիներ, որոնք հաճախ են կատարվում) և կոմպիլյացնում դրանք բնիկ մեքենայական կոդի։
Ունե՞ք մեռյալ կոդ, որը երբեք չի կատարվի։ JIT-ը ազատվում է դրանից։ Եթե մեթոդը հաճախ է կանչվում, JIT-ը կինլայնի այն՝ պատճենելով մեթոդի մարմինը կանչող մեթոդի մեջ։ Եթե օբյեկտի փոփոխականն ապրում է միայն մեկ մեթոդի scope-ում, JIT-ը կարող է այն տեղադրել stack-ում։
Այդ դեպքում օբյեկտը heap-ում ընդհանրապես չի հատկացվում, ուստի աղբահավաքը երբեք չի ստիպված լինում կառավարել այն։
Եվ դեռ շատ բան կա….
Java 19-ը բերեց վիրտուալ թելեր (virtual threads)՝ արգելափակող կանչերի, օրինակ՝ տվյալների բազայից կարդալու հետ գործ ունենալու հարմար եղանակ։
Այս փոփոխությունների շնորհիվ Java-ն շատ ավելի լավը դարձավ։ Օրինակ՝ 2024-ին պարոն Գունար Մորլինգը մեկնարկեց «The One Billion Row Challenge» մարտահրավերը։
Խնդիրը բավական պարզ էր. գրել Java ծրագիր, որը * .txt ֆայլից կարդում է ջերմաստիճանի չափումները, յուրաքանչյուր օդերևութաբանական կայանի համար հաշվում է առավելագույն, միջին և նվազագույն ջերմաստիճանը և կայաններն արտածում այբբենական կարգով։
Թվում է՝ հեշտ է, բացի այն, որ ֆայլը պարունակում էր 1 000 000 000 տող։
Հիանալի մարտահրավեր, և արդյունքները նույնիսկ ավելի տպավորիչ են։ Դրանք տարբերվում են ռեսուրսներից կախված, բայց որոշ արդյունքներ տևում են կես վայրկյանից պակաս։
Եվ Java-ի բարելավումները դրանով չեն ավարտվում։ Java 24-ը (թողարկվել է 2025 թվականի մարտի 18-ին) ներառում է մի քանի JEP, որոնք նպատակ ունեն Java-ն ավելի արագ դարձնել։ Օրինակ՝ Ahead-of-Time Class Loading & Linking-ով (JEP 483) կարող եք ստանալ հավելվածի աշխատանքի ժամանակի 42% բարելավում՝ և՛ սովորական, և՛ Spring հավելվածների համար։ Իհարկե, այդ թիվը հենց JEP-ից է, բայց խոստումնալից է հնչում, չէ՞։
Եթե ձեզ պետք է, որ հավելվածը գործարկվի շլացուցիչ արագությամբ, կարող եք դիմել GraalVM-ին և կառուցել ձեր հավելվածի native image, որպեսզի այն արագ աշխատի ամպային serverless ֆունկցիաներում։
Ձեր Java-ն արագացնելու բազմաթիվ եղանակներ կան։
Հիշեք. Java-ն այլևս դանդաղ չէ և շարունակում է լավանալ։
Որքան Java-ն աճում է, այնքան ավելի ընթեռնելի է դառնում
Նախորդ դասը ցույց տվեց, որ Java-ի ամեն տարբերակ նախորդից արագ է։ Բայց արագությունը միակ պատճառը չէ, թե ինչու արժե թարմացնել արտադրությունում աշխատող Java-ն։ Java-ի նոր տարբերակները նաև տալիս են ձեր կոդը գրելու ավելի մաքուր եղանակներ։
Ենթադրենք՝ դուք մնացել եք Java 11-ի վրա. կարող եք բաց թողնել նոր Java-ի բազմաթիվ հիանալի հնարավորություններ։ Ահա մի քանի օրինակ.
Switch արտահայտություններ
Java 14-ից առաջ. շատ break-երով ծանրաբեռնված switch հրահանգ
switch (day) {
case MONDAY:
case FRIDAY:
case SUNDAY:
System.out.println(6);
break;
case TUESDAY:
System.out.println(7);
break;
case THURSDAY:
case SATURDAY:
System.out.println(8);
break;
case WEDNESDAY:
System.out.println(9);
break;
}
Java 14+. switch արտահայտություն ‘->’ case-երով և առանց break-ների անհրաժեշտության
switch (day) {
case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
case TUESDAY -> System.out.println(7);
case THURSDAY, SATURDAY -> System.out.println(8);
case WEDNESDAY -> System.out.println(9);
}
Switch՝ instanceof-ի փոխարեն
Java 21-ից առաջ. instanceof ստուգումների շղթա
if (animal instanceof Cat c) {
giveFoodToCat(c);
} else if (animal instanceof Dog d) {
giveFoodToDog(d);
} else {
throw new IllegalStateException("Unexpected animat type: " + emp);
}
Java 21+. pattern matching switch-ի ներսում
switch (animal) {
case Cat c -> giveFoodToCat(c);
case Dog d -> giveFoodToDog(d);
default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}
Guard-երը թույլ են տալիս մշակել նաև կոնկրետ դեպքեր
switch (animal) {
case Cat c when c.hasName("Garfield") -> giveLasagneTo(c);
case Cat c -> giveFoodToCat(c);
case Dog d -> giveFoodToDog(d);
default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}
Record-ներ
Record դասերը՝ դասի հատուկ տեսակ, հնարավորություն են տալիս մոդելավորել պարզ տվյալների ագրեգատներ սովորական դասերից ավելի քիչ ծիսակարգով։
record Rectangle(double length, double width) { }
Միայն սա փոխարինում է հետևյալին.
public final class Rectangle {
private final double length;
private final double width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
double length() { return this.length; }
double width() { return this.width; }
public boolean equals...
public int hashCode...
public String toString() {...}
}
Switch pattern-ներ Record-ների հետ
switch (animal) {
case Cat(String name, Color _) when "Garfield".equals(name)-> giveLasagneTo(name);
...
}
Այս մեկ տողը համատեղում է պաշտպանված pattern (when), Java 21-ի record-ի քակտումը (deconstruction) և Java 22-ի անանուն փոփոխականը։
Հին Java-ի համեմատ կան բազմաթիվ այլ բարելավումներ, և ես խրախուսում եմ ձեզ բացահայտել դրանք և փորձարկել։ Հաջողություն և հաճելի աշխատանք։
Կոդը գրվում է մեկ անգամ, բայց կարդացվում է շատ անգամ
Իմ ծրագրավորման արկածը սկսվեց C++-ով դպրոցի ավագ դասարաններում։ Դեռ հիշում եմ առաջին հուզմունքը՝ մի քանի տեքստ գրել և հետո արդյունքը տեսնել էկրանին. դա զուտ կախարդանք էր թվում։
Այդ փորձը ինձ մղեց ուսումնասիրել համակարգչային գիտություն։ Տարիների ընթացքում ավելի ու ավելի շատ բան իմացա ծրագրավորման, տվյալների կառուցվածքների, ալգորիթմների և օպերացիոն համակարգերի մասին։ Մինչ այդ ես արդեն գրել էի շատ փոքր ծրագրեր տարբեր լեզուներով, հիմնականում դասընթացներն անցնելու համար։
Java-ին հանդիպելն անխուսափելի էր, և դա առաջին հայացքից սեր էր։ Java-ն ինձ թվաց հեշտ, հզոր և ընթեռնելի։ Իմ առաջին ավելի մեծ նախագիծը multithreaded Desktop հավելված էր, որը ձևացնում էր բորսա (Stock market)՝ իսկական արկած։
Այնուամենայնիվ, ես սայթաքեցի բազմաթիվ խնդիրների վրա. ինչպե՞ս անվանել դասերն ու ֆունկցիաները։ Ինչպե՞ս հասկանալ, թե երբ պիտի ինչ-որ բան դառնա դաս։ Ինչպե՞ս չմոլորվել կոդում։ Սկսեցի ուսումնասիրել Design Patterns, ինչը օգնեց ինձ ավարտել նախագիծը, և դրանից հետո հավատացի, որ ամեն ինչ տեսել եմ։
Հետո եկավ իմ առաջին աշխատանքը. պրակտիկա, որտեղ հանդիպեցի ավելի փորձառու ծրագրավորողների և շատ ավելի բարդ համակարգի։ Ես ապշած էի, որ կոդային բազան կարող է այդքան հսկայական լինել։ (Իրականում այդքան հսկայական չէր։)
Այնտեղ կարելի էր տեսնել «դասական 3-շերտ ճարտարապետություն» (ներկայացում, հավելված, տվյալներ)՝ բիզնես տրամաբանությամբ լի սերվիսներով և տարբեր հատուկ դեպքերի համար ներդրված if-երով։ Դժվար էր կարդալ և դժվար էր ասել, թե երբ ինչ կաշխատի և երբ՝ ոչ։ Թեստերը նույնպես շատ չէին օգնում. դրանք բարդ էին՝ անընթեռնելի նախապատրաստմամբ և երբեմն նույնիսկ ավելի դժվար հասկացվող assert-ներով։ Բարեբախտաբար, իմ գործընկերներն էլ դա խնդիր էին համարում, այնպես որ միայն ես չէի, որ չգիտեի ոլորտը, պահանջներն ու խնդիրները. նրանք նույնպես դժվարանում էին։
Մենք սկսեցինք ավելի շատ սովորել Domain Driven Design-ի (DDD) մասին, մասնակցեցինք աշխատարանների և ներդրեցինք ավելի խիստ code review գործընթաց։ Ի վերջո դա արդարացրեց իրեն. նոր հնարավորություններն ավելի հեշտ էին կարդացվում, թեստերն ավելի հեշտ էին հասկացվում, և կոդն ավելի բաց էր փոփոխությունների համար։
Խոսքը միայն DDD-ի մասին չէր, այլ այն մտածելակերպի, որով գրում ես կոդ. ինչպես ես անվանում մեթոդները և ինչպես բաժանում պատասխանատվությունները դասերի ու մոդուլների միջև։ Մի ուսանողի համար, որն արել էր միայն անհատական նախագծեր, հիանալի փորձ էր բացահայտել, որ կարևոր է, թե ինչպես ես գրում կոդը, և որ այն բավական երկար կմնա այլ մարդկանց հետ։
Ամեն ինչ այնքան հեշտ չէ, որքան թվում է
Ձախողումը կարող է լավագույն ուսուցիչը լինել, բայց գուցե ոչ այն ժամանակ, երբ արտադրությունը կանգնել է, և պետք է հետ գլորել փոփոխությունները։
Իմ թիմին հանձնարարվեց կառուցել նոր հնարավորություն, որը սերվերից հաճախորդին թարմ տեղեկություն էր հրելու։ Մենք երկու տարբերակ ունեինք կշռադատելու՝ Server-Sent Events (SSE) և WebSockets, և ընտրեցինք SSE-ն, քանի որ այն ավելի պարզ էր թվում և մեզ ավելի էր համապատասխանում։
Ահա SSE-ի նմուշային կոդը.
@GetMapping("/stream")
public SseEmitter streamEvents() {
SseEmitter emitter = new SseEmitter();
executor.submit(() -> {
try {
int i = 0;
while (true) {
emitter.send("SSE message " + i++);
Thread.sleep(1000);
}
} catch (IOException | InterruptedException e) {
emitter.completeWithError(e);
}
});
return emitter;
}
Վերը բերված կոդը յուրաքանչյուր emitter-ի համար ստեղծում է առանձին runnable, և ExecutorService-ն այնուհետև զբաղվում է դրանով։
Երբ կանչում եք այս endpoint-ը, ամեն վայրկյան հաղորդագրություն եք ստանում, մինչև փակեք կապը։ Թե քանի զուգահեռ հարցում կարող է սպասարկել այս endpoint-ը, կախված է ExecutorService-ի իրականացումից։
Բարեբախտաբար, այս կոդում emitter-ը փակվում է հենց Exception նետվելուն պես, ինչը տեղի է ունենում, երբ կապը խզվում է։
Պարզ է թվում, չէ՞։
Մենք էլ նույնը մտածեցինք, և մշակողներից մեկը վստահեցրեց, որ լավ կաշխատի։ Մեր դեպքը այս օրինակից փոքր-ինչ ավելի բարդ էր, քանի որ պետք է ստուգեինք, թե հենց ով է emitter-ը պահանջում, և նրան ուղարկեինք միայն այն տվյալները, որոնք նա իրավունք ուներ տեսնելու։ Նախագծի ողջ ընթացքում մենք չնկատեցինք, որ Tomcat-ը սահմանափակել էր մեր thread pool-ը, և որ emitter-ներ աշխատեցնող թելերը կապի խզվելիս չէին ազատվում։
Ցավոք, խնդիրը նկատեցինք միայն արտադրությունում, երբ սերվերը դադարեց արձագանքել։ Ինչպե՞ս էինք այն ավելի վաղ բաց թողել։ Կարող ենք մատնանշել բազմաթիվ պատճառներ. մեր թեստային միջավայրերը կարճատև էին, գրեթե երթևեկություն չկար, և ընդհանրապես չունեինք բեռնվածքային կամ սթրես թեստեր։
Բարեբախտաբար, այս սխալը մեզ սովորեցրեց.
- Ուսումնասիրել ձեզ անծանոթ լուծումները՝ ուշադրություն դարձնելով թերություններին և այն բանին, թե կարո՞ղ եք դրանց հետ ապրել
- Ստուգել ձեր բացահայտումները թիմակիցների հետ
- Քննադատական մնալ և՛ սեփական, և՛ ուրիշների արդյունքների նկատմամբ
- Միշտ թեստավորել ընտրած լուծումը, հատկապես երբ վստահ չեք, թե ինչպես այն կվարվի բեռի տակ
Streams API-ի մի փոքր հնար
Stream API-ը շատ հզոր է և collection-ների մշակումը դարձնում է ավելի ընթեռնելի։ Այն սովորելուց հետո ես ուզում էի այն օգտագործել ամենուր։ API-ն, իհարկե, կատարյալ չէ և չունի որոշ հնարավորություններ, որոնք այժմ հնարավոր են դարձնում Gatherer-ները։
Մի խնդիր, որին բախվեցի, տրված property-ի հիման վրա տարբեր տարրեր ընտրելն էր, այլ ոչ թե equals() մեթոդով։ Բարեբախտաբար, գործընկերներից մեկը ցույց տվեց այս սիրուն հնարը.
record Book(String title, String author) {}
public static void main(String[] args) {
List<Book> books = List.of(
new Book("Title", "Author1"),
new Book("Title - next part", "Author1"),
new Book("Some adventure", "Author2"),
new Book("Other adventure", "Author2")
);
books.stream()
.filter(uniqueAuthor())
.forEach(System.out::println);
}
private static Predicate<Book> uniqueAuthor() {
Set<String> state = new HashSet<>();
return book -> state.add(book.author());
}
Հնարը հիմնված է այն բանի վրա, որ uniqueAuthor մեթոդը վերադարձնում է Predicate։ Predicate-ը կիրառվում է Stream-ում, ուստի յուրաքանչյուր տարր անցնում է դրա միջով, բայց վիճակը պահող Set-ը ստեղծվում է միայն մեկ անգամ՝ երբ uniqueAuthor մեթոդը կանչվում է։
Հենց դա է թույլ տալիս նրան Predicate կանչերի միջև հիշել authorName-ները։
Համեմատության համար՝ ահա թե ինչպես կարելի է նույն խնդիրը լուծել Gatherer-ներով.
public static void main(String[] args) {
List<Book> books = List.of(
new Book("Title", "Author1"),
new Book("Title - next part", "Author1"),
new Book("Some adventure", "Author2"),
new Book("Other adventure", "Author2")
);
books.stream()
.gather(new UniqueAuthorGatherer())
.forEach(System.out::println);
}
static class UniqueAuthorGatherer implements Gatherer<Book, Set<String>, Book> {
@Override
public Supplier<Set<String>> initializer() {
return HashSet::new;
}
@Override
public Integrator<Set<String>, Book, Book> integrator() {
return Integrator.ofGreedy((state, item, downstream) -> {
String author = item.author();
if(state.add(author)) {
downstream.push(item);
}
return true;
});
}
}
Gatherer API-ն ավելի հզոր է, և նաև ավելի բարդ։ UniqueAuthorGatherer-ը իրականացնում է initializer մեթոդը, որը տալիս է նոր HashSet, և integrator մեթոդը, որը մշակում է յուրաքանչյուր տարր և այն հետագա է փոխանցում միայն եթե նրա հեղինակը դեռ վիճակում չկա։
Ամեն դեպքում, մեթոդները կարելի է ընդհանրացնել (generic) և այլուր վերօգտագործել որպես Util։
Ո՞րն եք նախընտրում։
«Իմ մեքենայի վրա աշխատում է»-ից մինչև DevOps. ինչպես են զարգացել Java մշակման պրակտիկաները
Դժվար է հավատալ, թե որքան է փոխվել Java-ի մշակումը ընդամենը մի քանի տասնամյակում։
Վաղ օրերին տիպիկ Java նախագիծը սկսվում էր որպես խառնաշփոթ դասերի փունջ՝ իրար կպցրած քիչ թեստավորմամբ և էլ ավելի քիչ ավտոմատացմամբ։ Կոդը մատակարարելը նշանակում էր կառուցել WAR կամ EAR ֆայլ և հրել այն, հաճախ ձեռքով, Tomcat կամ WebLogic սերվերի վրա՝ հույս ունենալով, որ արտադրությունում այն «պարզապես կաշխատի», ինչպես ձեր նոթբուքի վրա։
Թեստավորում՞։ Սովորաբար երկրորդական հարց։
Փաստաթղթավորում՞։ Հաճախ պահվում էր ինչ-որ մեկի գլխում։
Ավտոմատացում՞։ Shell սկրիպտ գրելը (հնարավոր է)։
Քանի որ բարդությունը մեծանում էր, մեծանում էր նաև կարգապահության կարիքը։ Այսօրվա ժամանակակից Java նախագիծը լրիվ այլ տեսք ունի.
- Սկզբնական կոդը պահվում է Git պահոցում, ավտոմատ build-երով, թեստերով և linter-ներով, որոնք գործարկվում են յուրաքանչյուր push-ի ժամանակ։
- Unit, integration և նույնիսկ contract թեստերը ինքնին հասկանալի են։
- Continuous Integration/Continuous Deployment pipeline-ները (CI/CD) artifact-ները րոպեների ընթացքում հասցնում են ամպային միջավայրեր։
- Ենթակառուցվածքը նկարագրվում է որպես կոդ, իսկ կոնտեյներացումը (Docker) և օրկեստրացիան (Kubernetes) նորմ են։
- Մոնիտորինգը, ահազանգերը և արագ հետգլորումը ստանդարտ պրակտիկա են։
Այսպիսով, ո՞րն է դասը։
Իրական էվոլյուցիան դուրս է նոր գործիքներից։ Դա մշակութային փոփոխություն է։ Այսօրվա Java թիմերը կոդի որակի, ավտոմատացման և համագործակցության մասին հոգ են տանում նույնքան, որքան լեզվի հնարավորությունների մասին։
Էկոհամակարգը առաջարկում է արագ մատակարարման և բարձր որակի գործիքների հարստություն, բայց նաև բերում է զգալի բարդություն և լրացուցիչ ծանրաբեռնվածություն։ Սա գիտակցելը վճռորոշ է։
Բարեբախտաբար, շատ կազմակերպություններ այժմ ունեն հատուկ ենթակառուցվածքային և հարթակային թիմեր, որոնք վարում են տեղակայման pipeline-ը, այնպես որ մշակողները կարող են կենտրոնանալ իրապես կարևորի վրա՝ հուսալի ծրագրակազմ կառուցելու և իրական բիզնես խնդիրներ լուծելու, այլ ոչ թե տեղակայման գլխացավանքների դեմ պայքարելու վրա։
Հիանալի հնարավորություններ. Boilerplate-ից մինչև գեղեցկություն
Եթե 2000-ականներին Java եք գրել, հիշում եք անվերջ boilerplate-ի տանջանքը։ Պարզ data դասը պահանջում էր գրել դաշտեր, կոնստրուկտորներ, getter-ներ, setter-ներ, equals, hashCode և toString՝ նորից ու նորից։ Java-ն հզոր էր, բայց հազվադեպ էր նրբագեղ։
Նայեք այս դասական մոտեցմանը.
// Java 7 and earlier
public class User {
private final String name;
private final int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public int getAge() { return age; }
@Override
public String toString() { return "User{name='" + name + "', age=" + age + '}'; }
@Override
public boolean equals(Object o) { /* lots of code */ }
@Override
public int hashCode() { /* lots of code */ }
}
Java 16-ից սկսած՝ կարող եք պարզապես օգտագործել record.
public record User(String name, int age) {}
Եվ սա միայն սկիզբն է։
- Lambda-ները և Stream-ները (Java 8) փոխեցին collection-ների մշակման ձևը.
List<String> names = users.stream()
.filter(u -> u.age() > 18)
.map(User::name)
.collect(Collectors.toList());
- Pattern matching-ը և sealed դասերը կոդը դարձնում են և՛ ավելի անվտանգ, և՛ ավելի արտահայտիչ։
sealed interface User permits Admin, RegularUser {}
record Admin(String name, int age, int level) implements User {}
record RegularUser(String name, int age) implements User {}
String accessLevel(User user) {
return switch (user) {
case Admin a -> "Admin Level " + a.level();
case RegularUser r -> r.age() > 18 ? "Full Access" : "Restricted Access";
};
}
Եվ հիմա՝ Virtual Threads (Java 21+)
Տարիներ շարունակ Java-ում բազմաթիվ միաժամանակյա հարցումներ սպասարկելը դժվար էր. հազարավոր OS թելեր ստեղծելը թանկ էր, ուստի ֆրեյմվորքները հենվում էին thread pool-ների և callback-ների վրա, ինչը կոդն ավելի բարդ էր դարձնում։
Ավանդական Java concurrency.
// Handling tasks with traditional threads
for (int i = 0; i < 1000; i++) {
new Thread(() -> {
// Handle some request
handleRequest();
}).start();
}
// This approach doesn’t scale well—creating thousands of real threads is costly!
Virtual Threads-ի օգտագործմամբ.
// Java 21+ - Virtual Threads make massive concurrency simple and efficient
for (int i = 0; i < 1000; i++) {
Thread.startVirtualThread(() -> {
handleRequest();
});
}
// Now you can easily have thousands or even millions of lightweight threads!
Կամ ժամանակակից ExecutorService-ով.
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 1000; i++) {
executor.submit(() -> handleRequest());
}
}
Spring Boot-ը դա էլ ավելի է պարզեցնում։
Spring Boot 3.2+-ով (և Java 21+-ով) վիրտուալ թելերին անցնելը համարյա ջանք չի պահանջում։
Պետք է ընդամենը այս property-ն ձեր application.properties-ում.
spring.threads.virtual.enabled=true
Այսքանը. կոդի փոփոխություն պետք չէ։ Spring-ը կսկսի մուտքային հարցումները մշակել վիրտուալ թելերով՝ ձեր հավելվածն անմիջապես դարձնելով ավելի մասշտաբավորելի և պատրաստ ժամանակակից ծանրաբեռնվածություններին։
Ուրեմն ի՞նչն է տարբեր։
Վիրտուալ թելերը կառավարվում են JVM-ի, այլ ոչ թե OS-ի կողմից։ Դրանք էժան է ստեղծել և պլանավորել, ուստի կարող եք գրել միաժամանակյա կոդ, որը մասշտաբավորելի է, պարզ և ընթեռնելի. էլ ոչ մի բարդ thread pool, ոչ մի ասինխրոն ակրոբատիկա։
Այս նոր հնարավորությունները շարահյուսական շաքարից ավելին են. դրանք հնարավոր են դարձնում ավելի լավ նախագծում, ավելի քիչ վրիպակներ և իրական արդյունավետություն։
Դաս.
Եթե դեռ չեք փորձել ժամանակակից Java-ն, բաց եք թողնում շատ բան։ Ողջունեք էվոլյուցիան. ավելի քիչ boilerplate, ավելի շատ բիզնես տրամաբանություն և լեզու, որը վերջապես հասնում է իր ավելի երիտասարդ ազգականներին։
Արդյո՞ք ֆրեյմվորքն իսկապես անհրաժեշտ է. Java-ի անվերջ երկընտրանքը
Խոստովանենք. համարյա յուրաքանչյուր Java մշակող ինչ-որ պահի փորձում է գրել սեփական ֆրեյմվորքը։
Գուցե Spring-ը չափազանց շատ է թվում ձեր պարզ REST API-ի համար։ Գուցե ուզում եք հասկանալ, թե իրականում ինչպես են աշխատում dependency injection-ը կամ routing-ը։ Կամ գուցե պարզապես ուզում եք, որ ամեն ինչ մնա «մաքուր և մինիմալ»։
Այնպես որ, սկսում եք մի բուռ դասերից, գուցե փաթաթում եք որոշ կոնֆիգուրացիա և ավելացնում հիմնական HTTP սերվեր։ Հիանալի է զգացվում… մինչև հանկարծ սկսում եք իրականացնել authentication, սխալների մշակում, logging, validation, թեստավորման աջակցություն… և այն սկսում է կասկածելիորեն նման լինել Spring-ի կամ Quarkus-ի, միայն թե առանց փորձված լինելու և համայնքի աջակցության։
Ահա մի փոքր օրինակ.
// Minimal HTTP server in Java, no framework
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
server.createContext("/hello", exchange -> {
String response = "Hello, World!";
exchange.sendResponseHeaders(200, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}
});
server.start();
Սա լավ է աշխատում սովորելու, հնարների կամ իսկապես փոքրիկ սերվիսների համար։ Բայց երբ պահանջները կուտակվում են, կուտակվում է նաև անվտանգության, թեստավորման, փաստաթղթավորման, ինտեգրացիաների կարիքը… և միանգամից ֆրեյմվորքն այնքան էլ վատ չի թվում։
Հետաքրքրվո՞ւմ եք Java ֆրեյմվորքների նոր սերնդով։
Մինի դաս.
Spring-ի կամ Micronaut-ի նման ֆրեյմվորքները գոյություն ունեն լավ պատճառով. դրանք լուծում են դժվար, հաճախ անտեսանելի խնդիրներ՝ dependency injection, կոնֆիգուրացիա, կյանքի ցիկլի կառավարում և այլն։ Դրանք մեզ փրկում են անիվը նորից հորինելուց։
Բայց խնդիրն այն է, որ այս ֆրեյմվորքները հակված են հսկայական լինել, և մակերեսի տակ աբստրակցիաների, proxy-ների և ներքին մեխանիզմների լաբիրինթոս կա, որը հազվադեպ ենք ամբողջությամբ հասկանում։ Annotation ավելացնելը հեշտ է. իմանալ, թե ինչ է այն գործի դնում, ավելի դժվար է։
Ուրեմն արդյո՞ք միշտ պետք է ծանրակշիռ ֆրեյմվորք։ Թե՞ պարզ պահելը դեռ արդարացնում է իրեն, հատկապես փոքր սերվիսների կամ greenfield նախագծերի համար։ Երբեմն սովորական Java-ն մեզ տալիս է ավելի շատ հստակություն, ավելի արագ գործարկում և ավելի քիչ անակնկալ։
Ֆունկցիոնալ domain մոդելավորում
Երբ Scala-ն առաջին անգամ հայտնվեց 2004-ին՝ որպես ֆունկցիոնալ և օբյեկտ-կողմնորոշված պարադիգմները միավորող լեզու, այն սկսեց տարածել ֆունկցիոնալ ծրագրավորման հասկացությունները։
Scala-ն սկզբում դիտվում էր որպես «ավելի լավ Java», բայց այսօր դա ճիշտ է միայն մասամբ. Java-ն տարիների ընթացքում չի հետ մնացել և ավելացրել է մի քանի լեզվական հնարավորություն, որոնք որոշ ոլորտներում ֆունկցիոնալ ծրագրավորումը դարձնում են համարյա նույնքան հեշտ, որքան Scala-ում։
Այդպիսի ոլորտներից մեկը ֆունկցիոնալ domain մոդելավորումն է, որը, ինչպես ընդհանրապես ֆունկցիոնալ ծրագրավորումը, հիմնված է domain-ը անփոփոխելի արժեքներով և մաքուր ֆունկցիաներով մոդելավորելու վրա։ Այստեղ կենտրոնական հասկացությունը Algebraic Data Types-ն (ADT) են։
ADT-ներ
ADT-ները երկու տեսակի են.
- Product տիպեր – սրանք ներկայացնում են հատկությունների համակցություն (օրինակ՝ օգտատերը ունի անուն և email), որտեղ յուրաքանչյուր օրինակ ունի բոլոր հատկությունները (այսինքն՝ դրանց դեկարտյան արտադրյալ, որտեղից էլ անունը)։ Java-ում դրանք արտահայտվում են որպես record-ներ.
record User(String name, String email)
- Sum/union տիպեր – սրանք ներկայացնում են մի քանի անհատական թույլատրելի արժեքներից մեկի ընտրությունը (օրինակ՝ վիճակը կա՛մ միացված է, կա՛մ անջատված)։ Java-ում դրանք արտահայտվում են որպես sealed հիերարխիաներ.
sealed interface State {
record On() implements State {}
record Off() implements State {}
}
sealed հիմնաբառը նշանակում է, որ State-ի յուրաքանչյուր հնարավոր տարբերակ հայտնի է compile ժամանակ, ուստի կոմպիլյատորը կարող է ստուգել, որ բոլոր արժեքները մշակված են, օրինակ՝ pattern matching-ում։
ADT-ների մեծ առավելությունն այն է, որ անթույլատրելի վիճակները պարզապես չեն կարող ներկայացվել. այդպիսի կոդը պարզապես չի կոմպիլյացվում։
Սխալները որպես արժեքներ
Domain մոդելավորման ֆունկցիոնալ մոտեցումը ամեն ինչ դիտարկում է որպես արժեք՝ սխալները ներառյալ։ Այնպես որ, բացառություններ նետելու փոխարեն ավելի լավ է սխալները ներկայացնել որպես արժեքներ՝ բնականաբար ADT-ներով։ Ահա օրինակ.
sealed interface DomainError {
record SomeError(String message) implements DomainError {}
record OtherError(int code) implements DomainError {}
}
sealed interface Try<A> {
record Success<A>(A value) implements Attempt<A> {}
record Failure<A>(DomainError e) implements Attempt<A> {}
}
Այնուհետև Try-ը կդարձնենք սխալ կարող արտադրող յուրաքանչյուր ֆունկցիայի վերադարձվող տիպը։ Սա մեզ տալիս է մեկ մեխանիզմ՝ և՛ հաջող, և՛ անհաջող արդյունքները ներկայացնելու համար։ Ավելին, domain սխալները (որոնք մենք կանխատեսում ենք) սահմանափակվում են SomeError-ով և OtherError-ով։
Pattern matching (նմուշների համապատասխանեցում)
Pattern matching-ի հետ համակցված՝ սա թույլ է տալիս compile ժամանակ երաշխավորել, որ Try վերադարձնող ֆունկցիայի յուրաքանչյուր հնարավոր արդյունք մշակված է.
Try<String> result = foo();
switch (result) {
case Try.Success(var value) -> // use value as a String
case Try.Failure(SomeError(var message)) -> // use message as a String
case Try.Failure(OtherError(var code)) -> // use code as an int
}
Մի քանի նշանակալի կետեր.
- Pattern matching-ը թույլ է տալիս քակել ներդրված record-ները (օրինակ՝ հասնել code-ին ուղղակիորեն, այլ ոչ թե e.code-ի միջոցով)։
- Կոմպիլյատորը կարող է եզրակացնել ներդրված record-ների ներսի տիպերը։
- Եթե վերը նշված case-երից որևէ մեկը բացակայեր, կոմպիլյատորը կբողոքեր (DomainError հիերարխիայի sealed հիմնաբառի պատճառով)։
Ֆունկցիոնալ domain մոդելավորումը սկզբում կարող է հակասեզական թվալ, բայց ես հորդորում եմ փորձել այն և տեսնել, թե որքան հզոր է։
Բառացիություն՝ կախարդանքի փոխարեն
Դիտարկենք տիպիկ Spring Boot հավելվածի (պարզեցված) կառուցվածքը.
@Service
public class Service {
@Autowired
private Repository repository;
}
@Controller
public class Controller {
@Autowired
private Service service;
// request mappings
}
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Այն աշխատելու է անմիջապես տուփից դուրս. կասկած չկա։ Կոդը պարզ է թվում և հեշտ է դրա մասին դատել, բայց արդյո՞ք իսկապես այդպես է։ Spring Boot-ի նման ֆրեյմվորքների հետ խնդիրն այն է, որ նրանք բերում են շատ կախարդանք՝ շատ բան անելով ձեր փոխարեն։
Նրանք հստակորեն հետևում են convention-over-configuration մոտեցմանը։ Բայց գիտե՞ք բոլոր կոնվենցիաները։ Օրինակ՝ կարո՞ղ եք ասել.
- Ի՞նչ է իրականում տեղի ունենում կուլիսներում, երբ դասի վրա դնում եք @SpringBootApplication annotation-ը։
- Ինչպիսի՞ն է repository-ների, սերվիսների և այլնի կյանքի ցիկլը, օրինակ՝ երբ են դրանք ստեղծվում։
- Ի՞նչ կախվածություններ ունի յուրաքանչյուր բաղադրիչ, օրինակ՝ տեսնո՞ւմ եք, որ Repository-ին տվյալների բազայի կապ է պետք։
- Որտեղի՞ց է բեռնվում կոնֆիգուրացիան։
- Ինչպե՞ս են կառավարվում Repository-ի տվյալների բազայի կապերը։
Այս մոտեցումը հիանալի է աշխատում, քանի դեռ ձեր հավելվածը իրեն պատշաճ է պահում։ Բայց երբ ինչ-որ բան փչանում է, թաքնված կոնվենցիաները դադարում են օգտակար լինել։ Խնդիրները վրիպազերծելուց առաջ պետք է հասկանալ կախարդանքի գոնե մի մասը։
Եթե all-in-one ֆրեյմվորքը փոխարինեք գրադարանների համախմբով, որոնցից յուրաքանչյուրն ունի մեկ պատասխանատվություն, շատ ավելի շատ վերահսկողություն կստանաք այն բանի վրա, ինչ կատարվում է ձեր հավելվածում։ Կոդը դառնում է ավելի շատախոս, բայց դա ժամանակի ընթացքում կարող է արդարանալ, քանի որ կախարդանք և թաքնված կոնվենցիաներ այլևս չեն մնում։
Ահա մեր վերանայված հավելվածը.
public class Service(Repository repository) {
}
public class Controller(Service service) {
// request mappings
}
public class Application {
public static void main(String[] args) {
final var config = Config.load();
final var repository = new Repository(config);
final var service = new Service(repository);
final var controller = new Controller(service)
new HttpServer(config, controller).start();
}
}
Վերը բերված կոդը պարզ ցույց է տալիս, թե ինչ է պետք հավելվածը կարգավորելու համար։
Կա մեկ մուտքի կետ, որը պետք է քննել կոդային բազան վերլուծելիս։ Դուք նաև ավելի շատ ազատություն եք ստանում այն հարցում, թե ինչպես կառուցվածքավորել ձեր կոդը և ինչ գործիքներ օգտագործել տարբեր խնդիրներ լուծելու համար։ Զարմանալի չէ, սակայն, որ դա միշտ փոխզիջումների հարց է. այս մոտեցումը կարող է կատարյալ չմասշտաբավորվել շատ մեծ կոդային բազաների համար, ուստի օգտագործեք այն զգուշությամբ։
Spring-ի նման ֆրեյմվորքները հարմար են արագ նախատիպավորման համար, բայց ես կասեի, որ երբ անցել եք նախատիպավորման փուլը, կարող է արժեր ավելի շատ վերահսկողություն վերցնել այն բանի վրա, ինչ ձեր հավելվածն անում է ձեր թիկունքում։ Սա կարող է հատկապես օգտակար լինել արտադրական խնդիրները վրիպազերծելիս։
@SpringBootApplication-ից և Hibernate-ից դուրս էլ կյանք կա (լսե՞լ եք jOOQ-ի մասին)։
RPC. EJB-ից մինչև REST և gRPC
Ահա պարզ պահելու մասին մեկ այլ տեսանկյուն։ Remote Procedure Call-ը (RPC) յուրաքանչյուր բաշխված համակարգի անհրաժեշտ մասն է, և Java-ն այս ոլորտում տարիների ընթացքում երկար ճանապարհ է անցել։
EJB
Ամեն ինչ սկսվեց Enterprise Java Beans-ից (EJB). Java-ին հատուկ ստանդարտ՝ կոդը հեռակա կանչելու համար, որը հիմքում հենվում էր սեփական RMI (Remote Method Invocation)-ի վրա։
EJB-ն կարգավորելը բնավ հեշտ չէր. պետք էր գրել մի քանի XML տեղակայման նկարագրիչներ, օրինակ՝ այսպես կոչված local և remote ինտերֆեյսների համար։ Սերվիսների հայտնաբերումը (այսինքն՝ մյուս կողմին գտնելը) արվում էր JNDI-ի միջոցով՝ ևս մեկ Java-ին հատուկ տեխնոլոգիա։
Վերջապես, հավելվածը գործարկելու համար պետք էր լիարժեք J2EE կոնտեյներ (օրինակ՝ JBoss կամ Weblogic)։
WebServices
Հետո եկան SOAP-ը և WebServices-ը. կոդը հեռակա կատարելու առաջին փորձը արդեն հայտնի արձանագրությամբ՝ HTTP-ով։
Java-ն դրանք աջակցում էր JAX-WS սպեցիֆիկացիայի միջոցով։ WebServices-ը կախված չէր որևէ կոնկրետ լեզվից, ուստի, ի տարբերություն EJB-ի, Java հավելվածի հետ հեռակա խոսելու համար Java հաճախորդ պետք չէր։
WebServices-ը հենվում էր XML-ով կոդավորված տեքստային payload-ների վրա, սխեման ապահովվում էր XSL-ով։ Տեքստային payload-ը սովորաբար մարդկանց համար վրիպազերծումը հեշտացնում է, բայց XML-ը իդեալական ձևաչափ չէր, քանի որ ավելացնում էր շատ boilerplate (payload, որը իրական տվյալ չէր կրում), ինչը հարցումները դարձնում էր հսկայական և ոչ այնքան հեշտ վրիպազերծվող։
REST
HTTP վրա հիմնված RPC-ի հաջորդ քայլը XML-ի փոխարեն HTTP-ով JSON ուղարկելն էր։
REST-ը (Representational State Transfer-ի կրճատումը) կառուցված է URI-ներով նույնականացվող ռեսուրսների կառավարման շուրջ, որոնք կարելի է ստանալ կամ փոխել։ Թեև մոտեցումը հատուկ նախագծված չէ կամայական կոդը հեռակա աշխատեցնելու համար, այն լայնորեն օգտագործվել է այդ նպատակով՝ դուրս գալով զուտ ռեսուրսների կառավարումից։
Քանի որ JSON-ը շատ ավելի քիչ boilerplate է կրում, քան XML-ը, payload-ները դարձան շատ ավելի փոքր և իսկապես մարդու համար ընթեռնելի, հետևաբար՝ իսկապես հեշտ վրիպազերծվող։
REST սերվիսներն աջակցվում էին ոչ միայն հենց Java լեզվի կողմից (JAX-RS-ի միջոցով)։ Մոտեցումը լայնորեն ընդունվեց, և այդ ժամանակահատվածում հայտնվեցին բազմաթիվ ֆրեյմվորքներ (օրինակ՝ Spring) և գրադարաններ (JSON-ի հետ աշխատելու կամ սերվիսները թեստավորելու համար)։
HTTP-ի և տեքստային payload-ների ճկունությունը հաշվի առնելով՝ API նախագծման լավ պրակտիկաների ներդրումը արագորեն կարևոր դարձավ։
gRPC
gRPC-ն դեռ հենվում է հայտնի արձանագրության (HTTP/2) վրա, բայց տեքստային payload-ները փոխարինում է երկուականով և օգտագործում է առանձին IDL (Interface Definition Language)՝ Protocol Buffers, կամ protobuf, հաղորդագրության կառուցվածքը և հեռակա endpoint-ների ստորագրությունները նկարագրելու համար։
Այսպիսով, այս անգամ շեշտը ռեսուրսների կառավարման վրա չէ, այլ կամայական կոդը իսկապես հեռակա աշխատեցնելու։ Երկուական payload-ները դժվար է վրիպազերծել, բայց դրանք թույլ են տալիս տվյալների սեղմում, ինչը զգալիորեն նվազեցնում է ցանցային երթևեկությունը։
Ներկա վիճակը
Այսօր REST-ը և gRPC-ն երկու ամենատարածված տարբերակներն են, և որն ընտրել՝ կախված է կիրառման դեպքից։ Որն էլ ընտրեք, ես կասեի, այն շատ ավելի պարզ կլինի, քան EJB-ի (ծանրակշիռ և կապված Java-ին) կամ WebServices-ի (հսկայական, հազիվ ընթեռնելի payload-ներով) հետ գործ ունենալը։ Պարզությունը հաղթում է։
Ամփոփում
Երեք տասնամյակների ընթացքում Java-ն ցույց է տվել, որ իրական նորարարությունը հավասար չափով գալիս է մարդկանցից, գործընթացից և հարթակից.
- Լեզուն շարունակում է թեթևանալ։ Record-ները, lambda-ները, sealed դասերը և վիրտուալ թելերը ապացուցում են, որ արտահայտչականությունն ու արտադրողականությունը կարող են բարելավվել ձեռք ձեռքի տված։
- Ընտրեք ձեր աբստրակցիաները զգուշորեն։ Spring-ի, Micronaut-ի կամ Quarkus-ի նման ֆրեյմվորքները լուծում են դժվար խնդիրներ, բայց իմանալը, թե ինչ է կատարվում թաքնված մասում, մնում է վրիպազերծման լավագույն տեխնիկան։
- Մշակույթն ու գործիքակազմը նույնքան կարևոր են։ Մերկ սերվերային հավելվածների սերվերներից մինչև DevOps և Platform Engineering՝ հաջողակ թիմերը համագործակցության և ավտոմատացման մեջ նույնքան են ներդնում, որքան IDE-ների և գրադարանների։
- Ընթեռնելիությունը հնարավորություն է։ Մտածված, բացահայտ նախագծման վրա ժամանակ ծախսելը արդարանում է՝ հարթակները դարձնելով ավելի հեշտ սպասարկելի և օգնելով ձեզ հաղթել յուրաքանչյուր code review-ում։
Եթե դուք ձեր սեփական Java ճանապարհորդության մեջ եք, լինի դա արդիականացում թե greenfield ամպային-բնիկ կառուցումներ, կապ հաստատեք մեզ հետ։
Կենացը ևս 30 տարվա, որի ընթացքում միասին կմատակարարենք հուսալի, նրբագեղ ծրագրային ապահովում։