Ha junior java programozó szeretnék lenni, akkor milyen technológiákat kell még elsajátítsak?

Hát mondhatnék neked sokmindent. :D A cégek legtöbbsége WEB-re fejleszt és a Java mint szerver alkalmazás lesz jelen.

- Hibernate javaslom, ha RMDBS alapú adatbázissal akarsz foglalkozni. Így JDBC-vel se nagyon fogsz találkozni, mert a Hibernate megoldja.

- JPA fog kelleni, ha NoSQL bejön a pakliba. De ehhez nyilván a Spring nagy segítséget tud nyújtani, ha Cassandra, Redis, MongoDB-vel kellene foglalkozni

- Spring Boot-ban, az lényegében egy kollekció. Spring mely moduljaira gondolsz?

- Bean-ek? Ez most a JavaEE-sre gondolsz? Vagy a Spring DI-s dolgokra? Ha utóbbi, akkor Springben tanultad, így nincs jelentősége a listában.

- HTML, CSS kevés lesz, ha fullstack-ben gondolkozol. Kell Angular vagy NuxtJS/VueJS. Azaz JavaScript!

Nagy vállalatoknál azért valamilyen MQ javaslot ismerni. Én a Kafka-t javaslom, de van olyan még, hogy RabbitMQ vagy ActiveMQ. Ahogy én veszem ki a Kafka és a RabbitMQ a legnépszerűbb. (Igaz, más is a megközelítésük.)

Javaslom még a NoSQL-be is beleásni. a Fent említett 3 adatbázis rendszert megtanulni, mert azért más-másra jó.

Plusz egy kis érdekesség: [link]

Nyilván, ha fentieket ismered az már egy medior szint és interjún is nagyon jó. Az MQ nem kötelező, és a DB-k nem ismerete sem hátrány. De jó pont, ha hallottál már róluk.

#2 vagyok. #3-ra válaszolok.

Hát.. Attól függ, hogy miket kell használni. De igen, ellehet vadítani, ha olyan a környezet. Terhelés elosztás, microservice rendszerek, JWT hitelesítés és sorolhatnám.

Én most egy házi projektet csinálok. Ha érdekel ezek vannak benne. Viszonyítás alapnak:

- Spring Boot (MVC, Security, JPA Cassandra, JPA Redis, Email, AOP)

- Thymeleaf template rendszer, hogy HTML alapúak legyen az emailek.

- Angular 10

- JWT Security authentication (Stateless megoldás, azaz nincs session)

- Kafka (még tervben, hogy bekötöm)

- Nginx a loadbalance miatt.

Adatbázis:

- Cassnadra klaszterizáció

- Redis klaszterizáció

- Elasticsearch (tervben, főleg logok számára és statisztikákra)

Angular cuccok:

- Ngrx (Store, Data)

- Angular material

- ngx-translate

- saját library-k

Deploy:

- Docker környezet

- Ezt Kubernetes vezérel

- Azure felhőben, mint egy SaaS alkalmazás

Kedes 4-es, és mindez amit csinálsz egy junior szint alja?

üdv :)

:D Nem ez már Medior/Senior szint.

Juniornak nem feltétlen kell ismernie:

- Elasticsearch

- Deploy megoldásokat (Ezt általában a DevOps csapat vagy CI csinálja commit után)

- JWT, is csak egy eszköz, nem kötelező használni.

- Nginx, kvázi 1 nap alatt megtanulod ami érdekel. Java-s nem feltétlen Nginxezik, inkább DevOps-osok játék tere, mikor Deployba ér a fázis.

- MQ rendszereket, mert ahhoz már kell lennie egy microservice alapnak, hogy belelássa, hol jöhet jól egy MQ.

- NoSQL sem feltétlen muszály, de jó ha van. SQL-es rendszerek után (MySQL, Oracle, MSSQL, ...) után kicsit életidegen tud lenni a NoSQL féle tér. Azért mondom, jó tudni, mert látóteret növel.

Pl.: Redis memóriában tárol (nem ír diskre) és kulcs-érték alapján tárol, amitől kis adatokra nagyon gyors. Emiatt jó cachere is.

Cassandra egy oriási adathalmazban O(1) művelettel (azaz 1 művelettel) megtalálja az adatot, legyen mármennyi sorod. Persze működéséből fakadóan nincs JOIN, mint egy RMDBS-ben. Egy több-a-többhöz kapcsolatot Cassandrában 4 tábla kell. Két tábla amiben adatot tárolsz és másik kettő amibel ide-oda linkelsz. Nyilván neked kell ezt karbantartani.

Mindegyik DB-nek meg van az előnye-hátránya. Önskálázódó, több adatközpontú infrastruktúrára RMDBS-t nem használnék. Helybenfutó rendszerre, pl. egy gyáron belül, azért meggondolnám, hogy MySQL, PostgreSQL vagy Oracle-t húznék fel.

Ez a eltudod dönteni mi a legideálisabb hova, ha több mindent tudsz előnye. :)

Az nem Java Bean. Az Spring téma. Nézd meg honnan importálod az annotációt. :3

Klasszikus Java Bean az JavaEE-ben van.

Ha már Spring. A @Component, @Service, @Controller, @RestController, @Repository ezek mind DI Singletonok lesznek, mint ha @Bean-el definiáltad volna. Persze egyes általam említett annotációknak is saját feladata is van, mint pl. a @RestController. IntelliJ-ben ctrl és ráklikkelsz, akkor megtudod nézni mit hoz még magával.

@Controller + @ResponseBody => @RestController

pl.:

[link]

[link]

De lényegtelen. Spring projektben használhatóak a JavaEE-sek is, ha ugyanat a célja.

pl.: egy controller nálam

import javax.validation.Valid; // <- ez nem Spring, ami a POST body-ját validálja

import org.springframework.lang.NonNull;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseStatus;

import org.springframework.web.bind.annotation.RestController;

Egy másik. Itt használok Lombok-ot is. pl.: @Data. Szeretem, mert kiváltja a rengeteg getter/setter-t. Ofc.. Kell hozzá plugin IntelliJ alatt, különben tele leszel errorral. :)

[link]

// Jackson-nak ismerősnek kell lennie, ha Spring. (JSON <--> Object)

// Szóval ez csak egy JSON adatmodel felett lévő import pack

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import com.intemse.echef.http.models.commons.CaptchaModel;

import com.intemse.echef.validation.NotBusyAccountEmail;

import com.intemse.echef.validation.NotBusyAccountUsername;

import com.intemse.echef.validation.PasswordPolicy;

import javax.validation.constraints.Email;

import javax.validation.constraints.NotBlank;

import lombok.Data;

import lombok.EqualsAndHashCode;

import lombok.NoArgsConstructor;

import org.springframework.lang.NonNull;

Mindezek mellet te is tudsz annotációkat létrehozni, speciális általad igényelt funkciókkal.

[link]

[link]

A második link esetén azért jó ismerni az Aspect-Orientált programozást is, ami az OOP mellet működik. Lényegében 2-t dolgot kell meghatároznod AOP-ban:

- milyen kontextusban fusson

- mikor fusson (hívás elött, után, vagy körbeöleled a metódust)

pl.:

// com.foo.bar.annotations.MyAnnotation

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface MyAnnotation {

}

// Körbe ölelős

// "within" azaz melyik package alatt éljen

// "execution" melyik metódusra. Ez a bármelyik, de lehet láthatóságot, visszatérés alapnám, paraméterezések alapján is.

// @annotation: és rendelkezik ezen annotációval

// Ha minden teljesül mert &&-el vannak elválasztva, akkor lefut az AOP

// Ez a String-ben a logika ez a Spring-EL expression: [link]

@Around(

_ _ "within(com.foo.bar.*) && " +

_ _ "execution(* *(..)) && " +

_ _ "@annotation(com.foo.bar.annotations.MyAnnotation)"

)

public Object method(@NonNull ProceedingJoinPoint pjp) throws Throwable {

_ _ // code...

_ _ Object[] args = pjp.getArgs(); // tegyük fel legalább 1 eleme van

_ _ args[0] = null;

_ _ // itt hívod meg a az eredetileg is hívott metódust, és az első paramétere

_ _ // NULL lesz mindig, bármit adnál át neki eredetileg, mert az AOP kicseréli a

_ _ //metódus hívás elött.

_ _ pjp.process(args);

_ _ // code...

}