Coffee break #89. 10 Pinakamahusay na IntelliJ IDEA Plugin para Palakasin ang Iyong Produktibo. Pangangasiwa sa mga exception sa Java Streams gamit ang functional na interface

10 Pinakamahusay na IntelliJ IDEA Plugin na Magpapalakas sa Iyong Produktibo

Pinagmulan: Hackernoon Tinanong ko kamakailan ang mga developer na gumagamit ng IntelliJ IDEA kung anong mga plugin ang pinakagusto nila para sa IDE na ito? Batay sa mga nakolektang tugon, nakuha ang isang listahan ng 10 pinakasikat na extension.

1. WakaTime

Pinapayagan ka ng WakaTime na makita ang mga sukatan, analytics, at subaybayan ang oras na ginugol sa programming. Sa pamamagitan nito, malalaman mo nang eksakto kung gaano karaming oras ang ginugugol mo sa pag-coding habang awtomatikong sinusubaybayan ng plugin kapag nagsimula ka at huminto sa pag-type, na may mga detalyadong sukatan para sa mga proyekto, file, branch, commit/PR, feature, at higit pa.

2.Stepsize

Tumutulong ang plugin na ito sa paglutas ng mga isyu na may kaugnayan sa teknikal na utang, pagpapanatili, at refactoring ng code. Nagbibigay-daan sa iyo ang stepsize na:

• gumawa ng mga bookmark sa code;
• subaybayan ang teknikal na utang nang direkta mula sa editor;
• lumikha ng TODO;
• unahin ang mga teknikal na isyu sa panahon ng pagpaplano ng sprint;
• Makipagtulungan sa mga kasamahan sa koponan sa panahon ng pagpapanatili ng code at refactoring.

3. Key Promoter X

Tinutulungan ka ng Key Promoter X na matutunan ang kahulugan ng mga shortcut at button sa IntelliJ IDEA. Kapag nag-hover ka ng iyong mouse sa isang button sa loob ng IDE, ipinapakita sa iyo ng Key Promoter X ang isang keyboard shortcut na magagamit mo sa halip na i-click ang mouse.

4. ZIO para sa IntelliJ

Bibigyan ka ng ZIO ng mga mungkahi, refactoring at iba pang mga pagpapahusay para sa ecosystem ng Scala ZIO. Pinapalawak ng plugin ang ZIO library na may mga function tulad ng:

• refactorings at mungkahi;
• suporta para sa zio macros (halimbawa, @accessible);
• built-in na test run.

5.Protobuf

Ang plugin ng Protobuf Language para sa mga IntelliJ-based na IDE ay nagbibigay ng suporta para sa wikang Protobuf. Tumutulong ang Protobuf sa pag-highlight ng syntax, pag-import ng mga file mula sa library at SDK, pag-navigate, pag-fold ng code, pagsusuri ng semantiko, at mabilis na dokumentasyon.

6.SonarLint

Binibigyang-daan ka ng SonarLint na ayusin ang mga problema sa code bago mangyari ang mga ito. Bilang isang spell checker, itinatampok ng SonarLint ang mga error at kahinaan sa seguridad habang nagsusulat ka ng code, na may malinaw na tagubilin kung paano ayusin ang mga ito, para maayos mo ang mga ito bago gawin ang code. Sinusuportahan ng SonarLint sa VS Code ang pagsusuri ng code sa Java, JavaScript, TypeScript, Python, HTML at PHP.

7. ESLint

Sinusuportahan ng ESLint ang pagpapakita ng mga babala sa eslint bilang mga inspeksyon ng IntelliJ, tumutulong na magsagawa ng mabilis na pag-aayos para sa maraming panuntunan, sinusuportahan ang mga custom na panuntunan ng eslint, at annotation at pagkumpleto ng configuration ng eslint.

8. Mas maganda

Ang Prettier extension ay tumutulong sa iyong code na magmukhang mas mahusay at maging mas pare-pareho. Tinitiyak nito ang pare-parehong istilo sa pamamagitan ng pagsusuri sa iyong code at muling pagsulat nito ayon sa mga panuntunan nito at maximum na haba ng linya.

9.Quokka

Ang Quokka.js ay isang tool sa produktibidad ng developer para sa mabilis na prototyping ng JavaScript/TypeScript. Sa IDE, ina-update nito ang sukatan ng oras ng pagpapatupad sa tabi ng code habang nagta-type ka. Ito ay lubos na nagpapabilis ng prototyping, pagsasanay, at pagsubok ng JavaScript/TypeScript.

10. AceJump

Pinapayagan ka ng AceJump na mabilis na ilipat ang cursor sa anumang posisyon na makikita sa editor. Pindutin lang ang “CRTL+;”, maglagay ng character, pagkatapos ay ilagay ang kaukulang karakter para sa Ace Jump. Kung walang makikitang tugma sa screen, magpapatuloy ang AceJump sa susunod na tugma na mahahanap nito.

Pangangasiwa sa mga exception sa Java Streams gamit ang functional na interface

Pinagmulan: Dev.to Kamakailan ay tumitingin ako sa ilang code at may nakita akong ganito:

subject.getIdentities().forEach(i -> {
  try {
    caseService.updateDocument(i.getCase());
  } catch (Exception e) {
    log.error(e);
  }
});

Dahil ako ay isang malaking fan ng lambda expression at love brevity, ang code sa itaas ay tila medyo maigsi at medyo nakakalito sa akin. Upang i-clear ito, dapat kang gumamit ng mga functional na interface. Ano ang kailangan natin para dito? Alam namin na inaasahan ng forEach ang input ng Consumer. Kung maaari naming ibalot ang aming exception sa paghawak ng logic sa isang Consumer, pagkatapos ay maaari naming gamitin ang logic sa forEach. Ang pangunahing lohika sa loob ng forEach ay ang sumusunod na linya:

//try catch removed
// i is an Identity and updateDocument returns a UpdateResponse
i -> caseService.updateDocument(i.getCase());

Alam namin ang uri ng pag-input at pagbabalik, at maaari kaming lumikha ng isang functional na interface na ang pamamaraan ay nagbibigay ng isang pagbubukod.

@FunctionalInterface
public interface ThrowingFunction<Identity, UpdateResponse> {
  UpdateResponse apply(Identity i) throws Exception;
}

Maaari naming gawing mas maginhawa ang code gamit ang mga generics.

@FunctionalInterface
public interface ThrowingFunction<T, R> {
  R apply(T t) throws Exception;
}

Kapag nalikha na ang interface, maaaring ma-type ang orihinal na logic:

ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase());

Ngayon na mayroon na kaming functional na interface para sa aming logic, maaari naming ipasa ito bilang isang parameter sa isang paraan na humahawak sa exception at nagbabalik ng Consumer na magagamit namin sa forEach.

private static <T, R> Consumer<T> wrap(ThrowingFunction<T, R> f) {
  return t -> {
    try  {
      f.apply(t);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  };
}

Mukhang medyo kakaiba, ngunit mahalagang ang paraan ng pag-wrap ay tumatagal ng ThrowingFunction bilang input at pinangangasiwaan ang pagpapatupad ng function o nakakakuha at naghagis ng mga exception sa Consumer. Ngayon ay maaari na nating balutin ang anumang ginamit na lohika sa forEach na maaaring magtapon ng exception. Mukhang ganito:

// target type the original logic
ThrowingFunction<Identity, UpdateResponse> tf = i -> caseService.updateDocument(i.getCase()):

// pass logic to the wrapmethod
// which will execute the function or throw a RunTimeException.
Consumer<Identity> p = wrap(tf);

// use Consumer in foreach
subject.getIdentities().forEach(p);

O kung mas gusto mo ang isang linya:

subject.getIdentities().forEach(wrap(i -> caseService.updateDocument(i.getCase())));

Sumang-ayon na ito ay mas mahusay! Maaari mong ipatupad ang isang bagay na tulad nito upang mahawakan ang iba't ibang uri ng mga functional na interface. Halimbawa, ang pagpapatakbo ng Map ay tumatagal lamang ng isang Function bilang input . Sa halip na isang paraan ng wrapper na nagbabalik ng isang Consumer, maaari kang magkaroon ng isang paraan ng pagbabalik ng isang function. Isa lang itong paraan para pangasiwaan ang mga exception sa mga thread. Dapat kong banggitin na may mga aklatan na gumagawa nito para sa iyo. Maaari ka ring gumamit ng monad upang mahawakan ang mga tagumpay o kabiguan, ngunit iyon ay lampas sa saklaw ng post na ito.