Coffee break #109. Ang pinaka-in-demand na mga kasanayan sa Java development ngayon. 7 Mga Opsyonal na Tip sa Java para Maalis ang Code Clutter

Ang pinaka-in-demand na mga kasanayan sa Java development ngayon

Pinagmulan: Ang Medium Java ay nananatiling isa sa pinakasikat at in-demand na mga programming language, sa kabila ng katotohanan na ito ay halos isang-kapat ng isang siglo ang edad. Samakatuwid, makatuwirang ipagpalagay na ang katanyagan ng Java ay patuloy na lalago at ang mga developer ng Java ay makakakita ng mas malaking demand mula sa mga employer sa hinaharap. Upang lumikha ng mga de-kalidad na produkto, kailangan ng mga developer na makasabay sa pinakabagong mga tool sa Java at pagbutihin ang kanilang mga teknikal na kasanayan at kaalaman. Sa ibaba ay nagpapakita kami ng anim na mahahalagang kasanayan na kinakailangan para sa mga developer ng Java.

1. Napakahusay na kaalaman sa Java 8

Kahit na ang mga mas bagong bersyon ng Java ay malawakang ginagamit, lahat ng naghahangad na Java developer ay nangangailangan ng malalim na kaalaman at karanasan sa Java 8. Ang ilan sa mga pinakakapaki-pakinabang na feature ng Java 8 ay kinabibilangan ng:

• Mga karaniwang at static na pamamaraan para sa paglikha ng mga interface na may mga pagpapatupad ng pamamaraan.
• Isang functional na interface na mayroon lamang isang abstract na paraan at tumutulong sa mga developer na maiwasan ang pagdaragdag ng iba pang abstract na pamamaraan.
• Mga expression ng Lambda na tumutulong sa paggawa ng mga functional na interface.
• Java Stream API upang paganahin ang parallel at sequential execution.
• Mga bagong paraan sa Collection API.

Ang lahat ng mga tampok na ito ay gumagawa ng Java 8 na kailangang-kailangan para sa functional programming. Ang functional programming ay nagbibigay ng concurrency at code brevity, at tumutulong sa paggawa ng mga high-load na application na may naka-optimize na code. Naging batayan din ang Java 8 para sa pag-optimize ng katutubong code, na nagbibigay-daan para sa pag-optimize ng pag-unlad sa ibang mga wika tulad ng Scala, Kotlin, at Grails.

2. Karanasan sa pagsubok

Ang pagsubok sa unit sa Java ay medyo kontrobersyal na paksa. Ang ilang mga developer ay nangangatuwiran na ang pagsusulat ng mga pagsubok sa yunit ay isang pag-aaksaya ng oras, ngunit lubos kaming naniniwala na ang mga kasanayan sa pagsubok ng yunit ay kinakailangan para sa sinumang propesyonal na developer ng Java. Binibigyang-daan ka ng pagsubok ng unit na subukan ang mga indibidwal na bloke ng code at tinitiyak na gumagana ang panghuling produkto nang walang mga error. Samakatuwid, kung nais ng isang developer na pagbutihin ang kanyang mga kasanayan at kaalaman, kailangan niyang matutunan kung paano gamitin ang pinakasikat at epektibong mga tool sa pagsubok. Ang pangunahing balangkas ng pagsubok na kailangan mong maging pamilyar ay ang library ng JUnit 5. Kasama sa iba pang mga tool ang:

• Robot Framework
• Mockito
• PowerMock

Bukod sa pagsubok sa yunit, hindi dapat kalimutan ng isang developer ng Java ang tungkol sa iba pang mga pamamaraan ng pagsubok (pagsusuri ng system, pagsubok sa pagtanggap at pagsubok sa pagsasama). Binibigyang-daan ka nitong magsagawa ng komprehensibong pagsubok ng software at tiyaking walang mga error, bug o kritikal na pagkabigo. Ang pangunahing bagay na dapat tandaan tungkol sa pagsubok ay ang maliliit na pagbabago ay humahantong sa malalaking resulta. Kung hindi ka mag-atubiling maglaan ng oras at pagsisikap sa pagsubok sa yunit, ikaw ay mamamangha sa pagpapabuti ng kalidad ng iyong trabaho.

3. DevOps

Bagama't hindi kinakailangan, ang pag-aaral tungkol sa DevOps at ang mga prinsipyo nito ay maaaring maging kapaki-pakinabang para sa iyo bilang isang developer at para sa kumpanya kung saan ka nagtatrabaho. Ang flexibility at organisasyon ng mga proseso ng DevOps ay nagbibigay-daan sa mga kumpanya na i-optimize ang kalidad ng kanilang produkto at i-streamline ang mga operasyon. at dagdagan din ang transparency ng mga proseso. Ang DevOps sa Java ay mahalagang aplikasyon ng DevOps sa pagbuo ng Java. Kabilang dito ang:

• Patuloy na paghahatid at pagsasama.
• Paggawa gamit ang mga microservice sa halip na mga monolith.
• Imprastraktura bilang code.
• Awtomatikong pagsubok.

Ang DevOps ay isang malawak na larangan at nangangailangan ng malaking halaga ng oras at mapagkukunan upang pag-aralan ito. Ngunit kung ikaw ay isang developer ng Java, ang pag-aaral ng DevOps ay magiging kapaki-pakinabang dahil ito ay magbibigay-daan sa iyong maging isang DevOps engineer sa hinaharap. Kung ayaw mong maging isang DevOps engineer o hindi interesado ang iyong kumpanya dito, okay lang din. Tandaan lamang na ang DevOps ay nagiging mas at mas sikat sa komunidad ng Java.

4. Kaalaman sa mga library at API ng Java.

Dahil ang Java ay isa sa mga nangungunang programming language sa mundo, hindi nakakagulat na mayroon itong malaking bilang ng magagamit na mga API at library na magagamit. Ang mga tool na ito ay lubos na nagpapasimple sa proseso ng pag-develop at nagbibigay-daan sa mga developer na mabilis na lumikha ng maaasahang software. Sa ibaba ay naglista kami ng isang pangunahing hanay ng mga tool na alam ng sinumang mahusay na developer ng Java at may kumpiyansang magagamit. Tinutulungan ka ng mga tool na ito na mabilis na bumuo ng isang application at epektibong pamahalaan ang data at ang storage nito:

• Gradle (isang tool para sa pagbuo ng mga application);
• Maven (medyo lipas na ngunit sikat pa rin, ginagamit din sa pagbuo ng mga application);
• Java 8 Standard Packages;
• Spring Frameworks;
• JPA ORM (Hibernate, TopLink);
• Mga database ng NoSQL (MongoDB, Cassandra).

Tulad ng para sa API, upang gumana sa pangunahing Java API, ang isang developer ay kailangang magkaroon ng isang mahusay na kaalaman sa OpenJDK, Android, Oracle at IS2T. Ang malaking bentahe ng mga tool na ito ay ang lahat ng ito ay may kasamang detalyado at nagbibigay-kaalaman na dokumentasyon. Bukod dito, ang mga developer ay palaging makakakuha ng suporta sa komunidad, na isa ring malaking kalamangan.

5. Tiwala na kaalaman sa Spring at Spring Boot

Ang Spring Framework ay ang pinakakaraniwang ginagamit na framework para sa pagbuo ng Java-based na mga application, kaya mahalagang malaman ng developer kung paano ito gagawin. Ang isa sa mga pangunahing benepisyo ng Spring ay dependency injection, na nagbibigay-daan sa iyong lumikha ng mga loosely coupled na application at nagbibigay sa mga developer ng higit na flexibility. Napakagaan din ng Spring, na sumusuporta sa mga XML configuration, anotasyon, at declarative programming. Kaya kung gusto mong makabisado ang mga kasanayan sa pagpapaunlad ng Java, dapat mo ring makabisado ang pag-deploy ng Spring. Ang Spring Boot ay isang pag-ulit ng Spring na nagbibigay ng maginhawang tool para sa mabilis na pag-deploy ng mga application. Ligtas na sabihin na ang Spring Boot ay gumagamit ng Spring bilang base at bumubuo ng sarili nitong mga feature sa ibabaw nito. Habang nakatutok ang Spring sa flexibility, nakakatulong ang Spring Boot na bawasan ang code at pasimplehin ang proseso ng pagbuo. Nag-aalok ito sa mga developer ng mga out-of-the-box na feature, tumutulong sa pagbuo ng mga standalone na app, at sa pangkalahatan ay mas madaling ilunsad at pamahalaan. Ang Spring Boot ay mahusay para sa mga microservice at application na kailangang mabilis na mabuo, dahil ginagawa nitong mabilis at madaling mag-set up at magpatakbo ng mga application para sa iba't ibang kapaligiran (produksyon, pagsubok, kalidad, CI/CD). Parehong lumawak ang Spring at Spring Boot gamit ang mga kakayahan sa programming ng React, na isa pang mainit na trend sa komunidad ng developer. Ang Spring 5, halimbawa, ay mayroon na ngayong WebFlux upang ipatupad ang isang reaktibong diskarte sa programming at paglutas ng mga kumplikadong distributed system.

6. Karanasan sa Big Data

Ang Big Data ay isang lumalagong trend na dapat sundin at gamitin ng mga developer upang matugunan ang mga pangangailangan sa merkado. Ang mga pangunahing tool na maaaring maging pamilyar sa mga propesyonal na developer ng Java ay:

• Apache Spark
• Apache Kafka
• Hadoop (para sa pagproseso ng batch)

Ang Apache Spark ay isang distributed na Big Data processing platform na nagbibigay ng mga native na binding para sa Java. Ang balangkas na ito ay naging napakapopular dahil sa mga tampok at pagganap nito at sa kasalukuyan ay ang pinakagustong tool ng malaking data sa komunidad ng Java. Ang Apache Spark ay maaaring tumakbo sa cluster standalone mode at para dito kailangan mo lamang ng isang Apache Spark na kapaligiran at isang JVM (para sa bawat makina sa cluster). Ang Spark ay napakabilis din at may napaka-user-friendly na Spark API. Ang Hadoop ay isang data storage platform na kilala rin sa mga developer ng Java. Kahit na ang Hadoop ay hindi kasing bilis ng Spark, nananatili itong isa sa mga pinakasikat na tool para sa pagtatrabaho sa malaking data. Ito ay dahil din sa katotohanan na ang Hadoop (at mga katulad na solusyon) ay may malaking bilang ng mga plugin na nagbibigay-daan sa iyong mahusay na lutasin ang mga problema sa pagproseso ng Big Data at sa pangkalahatan ay i-optimize ang pagganap ng Hadoop (kabilang ang suporta para sa real-time na pagpoproseso ng stream).

7 Mga Opsyonal na Tip sa Java para Maalis ang Code Clutter

Source: Medium "Mayroon akong mga kasamahan na hindi alam ang tungkol sa pagkakaroon ng Opsyonal," isinulat ng isang developer ng Java sa Reddit. Maaari ba nating isaalang-alang na ang Opsyonal ay nagpapabuti sa "kakayahang mabasa" ng code? Ito ba ay nagkakahalaga ng paggamit nito sa lahat ng oras? Nasaan ang paggamit ng Opsyonal na ganap na hindi kailangan? Dahil hindi pa rin alam ng maraming developer kung paano gamitin ang Opsyonal nang tama, magbibigay ako ng 7 halimbawa ng Opsyonal na mga pang-aabuso at kung ano ang gagawin sa mga ito.

1. Huwag gumamit ng Opsyonal para sa null check

Ang paggamit ng Opsyonal sa halip na null check ay nagdaragdag lamang ng kalat. Walang pakinabang dito. Ito rin ay isang pagkakamali na gumamit ng Opsyonal at ang isPresent at makakuha ng mga pamamaraan . Naniniwala ang mga developer na dapat gumana ang get gaya ng inaasahan. Pagkatapos ay idinagdag nila ang isPresent at bumalik sa null check. Tandaan na hindi inaayos ng Opsyonal ang iyong mga null check. Sa susunod na makita mo ang isPresent at makuha (o ElseThrow ) baguhin ang piraso ng code na ito. Gumamit ng pagmamapa at orElse upang alisin ang mga karaniwang null check, at gamitin ang Opsyonal nang mas pili. Narito ang isang magandang halimbawa:

var user = userService.getCurrentUser();
if(user == null) {
    return "(unknown)";
}
var username = user.getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

var user = userService.getCurrentUser();
if(user.isEmpty()) {
    return "(unknown)";
}
var username = user.orElseThrow().getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

return userService.getCurrentUser()
                  .map(User::getUsername)
                  .orElse("(unknown)");

Maaari kang magsimula sa Opsyonal na target. Ang layunin ng Opsyonal ay kumatawan sa opsyonal, nawawalang mga halaga. Pagkatapos ay bumalik sa iyong problema at tingnan kung ito ay gumagana para sa iyo. Ang isa pang paraan upang harapin ang null check ay ang paggamit ng mga anotasyon. Dapat gumana nang maayos ang Nullable o NotNull . Totoo, maaari nilang dumumi ang iyong code, at nagpoprotekta lamang sila sa oras ng pag-compile. Upang suriin ang runtime gamitin ang Objects.requireNonNull .

2. Gawin ang wastong paghawak ng error

Minsan ang null ay kumakatawan sa mga pagbubukod. At ito ang maling paraan upang magsenyas ng mga error at exception. "May nangyaring mali, at narito ito ay null" ay isang anti-pattern na dapat iwasan. Gayundin, hindi mo dapat gamitin ang Opsyonal upang masakop ang mga pagbubukod. Narito ang isang halimbawa.

public Optional<MyObject> getMyObject(final String jql) {
    try {
        return Optional.ofNullable(get(sql));
    } catch (final JqlParseException e) {
        return Optional.empty();
    }
}

Bakit walang laman ang myObject ? Ito ay alinman sa isang error o isang walang laman na halaga. Kaya makakakuha ka muli ng hindi maliwanag na resulta at burahin ang mga benepisyo ng Opsyonal bilang resulta. Umiiral ang code na ito dahil sinusubukan ng mga tao na gumamit ng Opsyonal para sa kontrol ng daloy. Ang opsyonal ay mag-aalis ng ilang mga zero sa iyong codebase. Ngunit kailangan mo pa ring gumamit ng try-catch construct upang mahawakan ang mga exception. Gamitin ang try-catch upang mahawakan nang tama ang mga exception. Huwag alisin ang Opsyonal kapag humahawak ng mga error, maghintay lamang at ito ay gagana nang perpekto. Ngunit mayroong isang pagbubukod dito - walang laman na catch . Kapag hindi mo alam kung ano ang ibabalik sa isang walang laman na catch, ang isang walang laman na Opsyonal ay dapat gumana nang maayos.

private int readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();
  try {
    return Integer.parseInt(expiration);
  }
  catch(NumberFormatException ignored) {}

  return 0;
}


private OptionalInt readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();

  try {
    return Optional.of(Integer.parseInt(expiration));
  }
  catch(NumberFormatException e) {
    return OptionalInt.empty();
  }
}

3. Huwag ibalik ang null mula sa Opsyonal na pamamaraan

public static Optional<POSType> getPOSType(String posName) {
    if (StringUtils.isNotBlank(posName)) {
        return Arrays.stream(POSType.values())
                .filter(type -> type.toString().equalsIgnoreCase(posName))
                .findFirst();
    }
    return null;
}

Tinatalo nito ang layunin ng Opsyonal. Ito ay isa pang halimbawa ng hindi magandang pagsubok. Dahil walang laman ang input, nangangahulugan ito na kailangan namin ng IllegalArgumentException file . Gayundin, ito ay isang pagkakamali. Walang sinuman ang kailangang suriin ang mga Opsyonal na paraan ng pagtawag. Ibalik ang isang walang laman na Opsyonal na elemento at huwag suriin ang isang Opsyonal na elemento para sa null.

4. Huwag gumamit ng Opsyonal sa mga koleksyon.

Hindi na kailangang balutin ang mga koleksyon sa Opsyonal. Bukod dito, huwag maglagay ng Mga Opsyonal sa mga koleksyon. Ginagawa lamang nitong kumplikado ang mga bagay sa pamamagitan ng pagdaragdag ng walang kabuluhang boksing at dagdag na pag-unwrapping. Huwag magdagdag ng Mga Opsyonal sa mga koleksyon. Walang nakikitang benepisyo mula dito. Panatilihin itong simple at gamitin ang Opsyonal para sa mga nawawalang halaga.

5. Huwag kadena para sa kapakanan ng kadena

Optional.ofNullable(foo).ifPresent(value -> {
  //do something
})

May mga detalyadong pamamaraan ang opsyonal na makakatulong dito. Sa halip na chain, isang simpleng null check ay sapat na. Alam kong ang Opsyonal ay may magagandang pamamaraan at mahusay na suporta sa IDE. Maaari mong gamitin ang mga ito.

6. Gumamit ng primitive value wrapper

Hindi ito isang malaking problema, ngunit maaari mong gamitin ang OptionalInt o OptionalLong . Sa pamamagitan lamang ng pag-alis ng mga hindi kinakailangang generic, mapapabuti mo ang pagganap at magsulat ng mas maigsi na code.

7. Dapat mong malaman ang tungkol sa ofNullable

if (a==null){
  return Optional.empty();
} else {
  return Optional.of(a);
}

Ang ganitong uri ng code ay karaniwang isinulat ng mga developer na walang alam tungkol sa Optional#ofNullable . Karamihan sa mga developer ay hindi naiintindihan ang pagkakaiba sa pagitan ng ofNullable at ng . Hindi nila naiintindihan kung paano maaaring mag-backfire ang Optional#of . Karamihan ay gumagamit ng ofNullable dahil sa takot na maghagis ng NullPointerException sa Opsyonal#of . Muli, tinatalo nito ang layunin ng dalawang pamamaraang ito. Kung ginagamit lang natin ang ofNullable , bakit kailangan natin ang Optional#of sa lahat ? Opsyonal#of throws isang NPE kapag pumasa ka sa null. Nangyayari ito sa isang dahilan. Dapat gamitin ang paraang ito kapag inaasahan mong naroroon ang halaga. Kung wala ito, mabilis itong mabibigo. Ang Opsyonal#ofNullable ay nagko-convert ng null sa isang walang laman na Opsyonal. Ang pamamaraang ito ay tumatagal ng null bilang isang argumento, na tumutugma sa isang walang laman na Opsyonal.