Coffee break #88. Ang kapangyarihan ng metadata: kung paano gamitin ang spaghetti code. Pagkolekta ng basura sa Java - kung paano ito gumagana at ano ang mga pakinabang nito

Ang kapangyarihan ng metadata: kung paano gamitin ang spaghetti code

Pinagmulan: Hackernoon Sinusubukan nating lahat na gumamit ng mga karaniwang diskarte at kilalang pattern upang lumikha ng isang application na may kaunting pagsisikap at maximum na epekto. Mayroon kaming mahuhusay na mga aklatan at makapangyarihang mga framework na nagsasagawa ng mga karaniwang operasyon para sa amin. Ginagamit namin ang lahat ng ito upang tumuon lamang sa lohika ng negosyo. Gayunpaman, ang pagtugis na ito ay madalas na humahantong sa amin sa spaghetti code, lalo na pagdating sa pagpapatupad ng isang function na walang handa na solusyon para dito. Sa artikulong ito, gusto kong ibahagi sa iyo ang isang makapangyarihang tool na, sa aking karanasan, hindi lahat ng developer ay pinahahalagahan. Ang tool na ito ay naroroon sa karamihan ng mga programming language, at ito ay madalas na ginagamit sa maraming mga frameworks - mga anotasyon.

Gusto mo ba ng spaghetti?

Tingnan natin ang isang halimbawa na nakita ko ilang taon na ang nakalilipas. Kailangan kong mag-parse ng Excel spreadsheet para ilagay ang na-parse na data sa isang database. Nais ko ring mangolekta ng ilan sa mga data mula sa database at lumikha ng isang spreadsheet. Para sa pagpapatupad, ginamit ko ang kilalang Java library - Apache POI. Pinapadali ng API ng library ang iyong trabaho dahil pinapayagan ka nitong manual na gumawa ng sheet, row, cell, at iba pang elemento. Ito ay napakahusay, ngunit kapag kinakailangan na bumuo ng iba't ibang mga spreadsheet ng Excel, ang code ay nagiging ganap na hindi nababasa at hindi nasusuportahan. Bilang isang resulta, tulad ng karaniwang nangyayari, ang unang bersyon ng application ay lumabas na kakila-kilabot. Ang pagpapatupad ay binubuo ng isang klase ng data na kumakatawan sa isang string kasama ang lahat ng mga patlang na kailangan para sa pag-parse. Mayroon ding parser kung saan ang mga patlang ng Excel ay na-parse ng cell sa pamamagitan ng cell at inilagay sa isang bagong likhang halimbawa ng klase ng data. Sa una ang programa ay gumana nang mahusay at ginawa kung ano ang kinakailangan dito. Nagsimula ang mga problema nang dumating ang oras na gumawa ng ilang pagbabago; hindi nabasa ang code. Kahit ako, na sumulat ng code na ito, ay hindi makahanap ng angkop na lugar para maglagay ng mga bagong linya para ipatupad ang bagong function na kailangan ko.

Pagsagip sa mga anotasyon

Na-save ang application mula sa annotation na spaghetti code na ito. Upang maalis ang hindi sinusuportahang code, kailangan kong ilipat ang logic para sa pagtukoy kung aling column ang i-parse, anong uri ng data ang nilalaman ng isang cell, at lahat ng iba pa sa ibang lokasyon. Para magawa ito, gumawa ako ng anotasyon kung saan tinukoy ko ang pangalan ng column para sa bawat field ng klase. Sa anotasyon, nagdagdag din ako ng variable na nagbibigay-daan sa iyong piliin ang kulay at font ng cell. Kaya, ang code sa klase ng pag-parse ay makabuluhang nabawasan. Isang processor lang ang dynamic na gumawa ng spreadsheet batay sa mga parameter na kinuha mula sa mga anotasyon. Ito ay isang tagumpay. Pagkatapos, para gumawa ng anumang pagbabago sa application, kailangan ko lang gumawa ng klase na may mga anotasyon. Ang solusyon ay nakapagpapaalaala sa Jackson library, na nag-parse ng JSON gamit ang mga anotasyon, at sa tingin ko ay hindi na kailangang sabihin kung gaano kaginhawa ang Jackson o mga katulad na aklatan.

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnExcel {

    String name() default "";

    int position();

    ExcelColumnDataFormat cellTypePattern() default ExcelColumnDataFormat.NONE;

    IndexedColors cellColor() default IndexedColors.AUTOMATIC;

    ExcelTotalFormula total() default ExcelTotalFormula.NONE;

}

ColumnExcel columnExcel = field.getAnnotation(ColumnExcel.class);

Habang nag-evolve ang application, nakatanggap ito ng bagong anotasyon na magagamit para gumawa ng cell sa isang spreadsheet na may function sa loob. Maaaring i-multiply, ibawas, at anumang karaniwang mga function ng Excel ang iba't ibang field. Nagdagdag din ako ng kabuuang row para ipakita ang kabuuan ayon sa column. At ginawa ko ang lahat ng ito sa pamamagitan lamang ng bahagyang pagbabago sa pangunahing parser at pagdaragdag lamang ng mga anotasyon sa mga klase.

@ColumnExcel(
            name = "Views",
            position = 4,
            total = ExcelTotalFormula.SUM)
    private BigDecimal variableC;

    @ColumnExcelFormula(
            name = "Conversion",
            position = 5,
            cellTypePattern = CellDataTypeFormatPattern.PERCENTAGE
    )
    public String variableD(int rowNumber) {
        return new CellAddress(rowNumber, 4).formatAsString() + "*"
		+ new CellAddress(rowNumber, 2).formatAsString();
    }

    @ColumnExcelTotalFormula(position = 4, cellTypePattern = CellDataTypeFormatPattern.RUR)
    public static String getVariableCTotalFormula(int firstRowNum, int lastRowNum) {
        return "SUM( " + new CellAddress(firstRowNum, 4).formatAsString() + ":"
		+ new CellAddress(lastRowNum, 4).formatAsString() + ")";
    }

Pagkolekta ng basura sa Java - kung paano ito gumagana at ano ang mga pakinabang nito

Source: Dev.to Garbage collection ay nangangahulugan ng pagsira o paglilinis ng mga hindi nagamit na bagay sa memorya. Awtomatikong pinangangasiwaan ng Java ang deallocation ng memory dahil kapag nalikha ang isang bagay, gumagamit ito ng ilang memory sa heap.

Paano ito gumagana?

Bago ang Java, ang pinakasikat na programming language ay C o C++. Kung nagsasalita ka ng mga wikang ito, dapat mong malaman na pinamamahalaan nila ang kanilang sariling memorya nang manu-mano. Halimbawa, ang C ay may mga pamamaraan tulad ng calloc() , malloc() at realloc() na magbibigay-daan sa iyong gumamit ng buffer memory. Dapat mong matukoy kung gaano karaming memory ang kailangan mo para sa iyong programa at tukuyin kung ano ang tinatawag ng API na ito. Pagkatapos ay maaari kang makakuha ng memory buffer upang lumikha ng isang naka-link na node ng listahan o iba pa. Kapag natapos ang iyong programa, sa isang punto, responsable ka rin sa paglilinis ng memorya na iyon. Kaya ang isang malaking application na nakasulat sa C ay patuloy na naglalaan ng buffer memory at kung minsan ay nakakalimutang i-flush ito. Ito sa huli ay nagdudulot ng mga pagtagas ng memorya at maraming problema sa application. Hindi tulad ng C at C++, ang wikang Java ay may awtomatikong pamamahala ng memorya sa pamamagitan ng thread na tinatawag na garbage collector. Ang pangunahing layunin nito ay palayain ang heap memory sa pamamagitan ng pagsira sa mga bagay na hindi naa-access. Palaging tumatakbo sa background ang tagakolekta ng basura.

Ano ang hindi naa-access na mga bagay sa Java?

Kailan nagkakaroon ng pagkakataon ang isang bagay na simulan ang pangongolekta ng basura? Kung may mga hindi naa-access na bagay - ang mga kung saan walang mga aktibong link. Tingnan natin ang isang halimbawa:

public static void main(String[] args)
{
// StringBuffer object sb is not eligible for garbage collection
StringBuffer sb = new StringBuffer("Flower Brackets");
System.out.println(sb);
// StringBuffer object sb is eligible for garbage collection
sb = null;
}

Sa pangunahing pamamaraan lumikha ako ng isang StringBuffer object at isang sanggunian dito. Sa puntong ito, ang StringBuffer object ay hindi karapat-dapat para sa koleksyon ng basura. Ngayon ay itatakda ko ang StringBuffer object sa "null". Kwalipikado na ngayon ang object para sa pangongolekta ng basura at nagiging isang hindi naa-access na object sa heap memory. Iyon ay, ang pagkolekta ng basura ay karaniwang gumagana sa mga kaso kung saan ang mga bagay ay nagiging hindi naa-access. Nangangahulugan ito na ang mga bagay ay karaniwang nilikha sa konteksto ng isang "kung bloke" o pamamaraan. Kaya, ang mga bagay ay lumalabas sa saklaw kapag nakumpleto na ang pagpapatupad ng pamamaraan at maaaring itapon ng tagakolekta ng basura. Dahil ang mga sanggunian mula sa mga lumang bagay hanggang sa mga bago ay umiiral sa limitadong bilang, nangangahulugan ito na ang mga bagay na matagal nang naroroon sa iyong aplikasyon ay karaniwang hindi mga bagong nilikhang bagay. Narito ang ilang termino na dapat nating pamilyar; isa sa mga ito ay isang buhay na bagay. Ito ay isang object sa isang application na nire-reference ng isa pang object sa parehong application. Mayroon ding isang "patay" na bagay. Ang isang patay na bagay ay isang hindi naa-access na bagay na nilikha sa panahon ng isang tawag sa pamamaraan, at sa sandaling makumpleto ang tawag sa pamamaraan, ang bagay ay mawawala sa konteksto at uupo lamang sa heap.

Kailan karapat-dapat ang isang bagay para sa koleksyon ng basura?

Kung ang isang bagay ay walang anumang reference na variable, kung gayon ang bagay ay karapat-dapat para sa koleksyon ng basura.

Paano gawing available ang isang bagay para sa koleksyon ng basura?

Nasa ibaba ang ilang paraan:

1. null reference variable
   Student obj = new Student();
   obj = null;

2. re-assign reference variable
   Student obj1 = new Student();
   Student obj2 = new Student();
   obj1 = obj2;

3. reate anonymous object
   new Student();

   Kapag ang isang bagay ay ginawang magagamit sa kolektor ng basura, hindi ito agad na masisira.

Kapag ang Java Virtual Machine ang nagpapatakbo ng garbage collector, ang bagay lang ang masisira. TANDAAN: Nangongolekta lamang ang tagakolekta ng basura ng mga bagay na ginawa gamit ang "bagong" keyword, para sa mga bagay na walang "bagong" keyword, gamitin ang finalize() na paraan . Mayroong ilang mga paraan upang patakbuhin ang kolektor ng basura sa Java Virtual Machine:

1. System.gc() method

2. finalize() na pamamaraan

3. Runtime.getRuntime().gc() method

Ang static na gc() na pamamaraan ay matatagpuan sa klase ng System . Ang pamamaraang ito ay humihiling sa JVM na tawagan ang kolektor ng basura. Tingnan natin kung paano tinatawag ng Java application ang garbage collector gamit ang gc() method.

public class GarbageCollector
{
public static void main(String[] args)
{
Employee obj1 = new Employee();
Employee obj2 = new Employee();
obj1 = null;
obj2 = null;
System.gc();
}
public void finalize()
{
System.out.println("object garbage collected");
}
}

Resulta: Tinatawag ang finalize() na paraan bago linisin ang bagay. Ang pamamaraang ito ay tinukoy sa klase ng Bagay :

protected void finalize() throws Throwable

1. Ang paraan ng Finalize ay ginagamit upang isara ang koneksyon sa database.

2. Ang pamamaraang ito ay tinatawag ng tagakolekta ng basura, hindi ang JVM.

3. Kailangan nating i-override ang finalize() method . Dahil mayroon itong walang laman na pagpapatupad.

4. Ito ay tinatawag na isang beses lamang sa bawat bagay.

Ang getRuntime().gc() method ay nasa runtime class. Ibinabalik nito ang Runtime object na nauugnay sa kasalukuyang Java application. Tingnan natin ang pamamaraang ito sa isang Java program.

public class Demo
{
public static void main(String[] args)
{
Demo obj1 = new Demo();
Demo obj2 = new Demo();
// nullifying reference variable
obj1 = null;
// nullifying reference variable
obj2 = null;
// running Garbage Collector
Runtime.getRuntime().gc();
}
@Override
protected void finalize() throws Throwable
{
System.out.println("Garbage collector called");
System.out.println("Object garbage collector: " + this);
}
}

Resulta:

Mga benepisyo ng pagkolekta ng basura:

1. Awtomatikong nangyayari ang pangongolekta ng basura sa Java, na nagliligtas sa atin mula sa karagdagang pasanin ng pagpapalaya ng ginamit na memorya. Ginagawa nitong mas mahusay ang memorya ng Java program.
2. Tinitiyak ng koleksyon ng basura ang integridad ng programa.
3. Hindi namin kailangang magsulat ng anumang karagdagang code dahil ang tagakolekta ng basura ay bahagi ng JVM.