Conquest Spring Boot

Magandang araw, mahal na mambabasa! At nakakatuwang makilala ka, kahit na ang magarbong pangalan ang pangunahing dahilan upang tingnan ang katamtamang paksa tungkol sa unang kakilala sa pag-unlad ng Spring Boot. Nais kong ibahagi ang aking karanasan sa pagkumpleto ng panimulang takdang-aralin para sa isang internship sa portal ng JavaRush, na nagpapakita ng isang pangkalahatang-ideya mula sa panig ng isang ganap na ordinaryong teknikal na estudyante sa unibersidad na gustong subukan ang lakas ng kanyang naipon na kaalaman. Sa anumang paraan ay hindi ko itinatanggi ang posibleng pagkakaroon ng kabastusan sa nakalakip na code o paraan ng pag-iisip, at malugod kong tinatanggap ang nakabubuo na pagpuna, dahil ito ay salamat sa "mga bumps at bruises" na posible na bumuo sa isang propesyonal na direksyon. Bukod dito, hindi ako nagpapanggap na isang "panacea" sa paglutas ng mga ibinigay na kondisyon at sadyang tinanggal ang mga indibidwal na fragment ng programa, na iniiwan ang pangunahing kahalagahan ng pagpasok sa isang medyo kumplikadong paksa nang walang kaunting kahihinatnan para sa nervous system. Totoo, walang ingat na tanggihan ang halata: mahirap para sa akin at talagang walang malinaw hanggang sa isang tiyak na sandali. At kung nakakaranas ka ng mga katulad na damdamin mula sa unang pagpupulong sa gawain, pagkatapos ay "Maligayang pagdating!" Sumulat tayo ng isang web application sa Spring Boot gamit ang isang pinasimple na pagkakatulad ng isang internship entrance test gamit ang isang template engine Thymeleafat querymga query sa isang lokal na MySQL server upang i-filter ang papasok na hanay ng impormasyon. Kaya simulan na natin!

Boot ng tagsibol. Anong uri ng hayop ito at paano ito lutuin?

Sa maikli at maikli, ito ay isang mahusay na tool mula sa Pivotel para sa pag-save ng mahalagang oras sa proseso ng paglikha ng isang application, inaalis ang pangangailangan upang direktang ikonekta ang mga third-party na aklatan, magsulat ng isang kahanga-hangang mapping canvas at servlets. Sapat na gamitin ang Spring Initializr builder , na isinama sa IntelliJ IDEA Ultimate Edition (File - New - Project... - Spring Initializr) o matatagpuan sa start.spring.io web service , na tumutukoy sa mga package na isasama mula sa malawak na hanay ng mga alok. Kasunod ng mga teknikal na pagtutukoy na iniharap, gagamitin namin ang set ng ginoo, pamantayan para sa paglikha ng isang simpleng web application gamit ang MySQL database :

• Ang WEB ay ang pangunahing bahagi para sa pagbuo ng isang web application, kabilang ang isang lokal na server ng Apache Tomcat sa karaniwang address na localhost:8080 at ang unibersal na balangkas ng Spring MVC.


• DevTools - ginagamit upang mabilis na i-restart ang isang application sa isang mainit na JVM kapag may nakitang mga pagbabago sa pinagsama-samang code o mga template; Bukod dito, pinapalaya nito ang Thymeleaf mula sa pag-clear ng cache kung ang napiling makina ay kasama sa proyekto.


• Ang JPA ay isang teknolohiyang kinakailangan para sa pagtatrabaho sa mga database at nagbibigay ng object-relational na pagmamapa ng mga object ng Java, nagbibigay ng API ( Hibernate sa aming kaso) para sa pamamahala, pag-save at pagkuha ng mga entity.


• Thymeleaf (Mustache, AngularJS, Vaadin at higit pa) - template engine para sa visualization ng application; Salamat sa aking kamag-anak na pamilyar sa mga prinsipyo ng html, pinili ko ang Thymeleaf, na nagtulak sa wika sa pundasyon ng mundo.


• MySQL - nag-uugnay sa mga driver ng Java Database Connectivity upang magsagawa ng mga query sa SQL laban sa database.

Pagkatapos ng huling pagpili ng mga bahagi at paglikha, nakakakuha kami ng isang ordinaryong web application architecture na may mga direktoryo na handa para sa karagdagang pagpuno. Ang mga fragment para sa pakikipag-ugnayan sa visual na bahagi, ito man ay CSS graphic na mga estilo, karaniwang HTML na mga pahina o JavaScript functionality, ay dapat na matatagpuan sa "mga mapagkukunan", at ang back-end na bahagi, nang naaayon, ay nilalayong ilagay sa "java". Dapat din nating bigyang pansin ang pom.xml file sa root range, na nag-iimbak ng istraktura ng proyekto at mga dependency sa pagitan ng mga bahagi. Kung gusto mong palawakin pa ang functionality gamit ang mga karagdagang package o alisin ang mga hindi kinakailangang bagay, dapat kang magsagawa ng mga manipulasyon sa pagitan ng mga tag <dependencies></dependencies>ayon sa katulad na paraan.

Mga unang hakbang tungo sa magandang kinabukasan

Susunod, isang medyo kawili-wili at medyo lohikal na tanong ang lumitaw: "Ano ang gagawin ngayon? Paano ito gagana? Ang programa ay binuo sa mga prinsipyo ng Model-View-Controller: inaayos nito ang pagbabasa ng mga entity mula sa konektadong database (Model) at ipinapakita sa user interface na may mga kontrol (View); Ang komunikasyon sa pagitan ng mga bahagi at pagpapatupad ng mga aksyon ayon sa ipinadala na mga kahilingan ay isinasagawa salamat sa Controller. Ito ay ang paglikha ng mga pangunahing elemento na nagsisilbing reference point para sa patuloy na pag-unlad. Upang maiwasan ang madulas na dalisdis at mapanatili ang paggalang ng iyong mga kasama sa larangan ng trabaho, dapat mong ilagay ang mga bahagi sa naaangkop na mga direktoryo (halimbawa, ilagay ang file ng Controller sa folder ng mga controller sa sangay ng "java") at maingat na panatilihin order sa lugar ng trabaho.

Ang kakanyahan ay isang maliit na bahagi sa isang malaking mekanismo

O sa madaling salita, ang ating Modelo ayon sa mga kondisyong itinakda sa problema. Pag-alis mula sa paksa ng talakayan at pagbabalik sa panimulang proyekto, maaari naming kumpiyansa na igiit na may kaunting pagkakaiba sa pagitan ng mga gawain at sumunod sa karaniwang konsepto sa karagdagang pagsusuri. Sabihin nating, mga tala sa isang kuwaderno, kabilang ang:

• Numero ng pagkakakilanlan upang matukoy ang lokasyon sa pangkalahatang daloy;
• Isang text message ng isang tiyak na bilang ng mga character;
• Ang petsa na idinagdag ito ng user sa pangkalahatang listahan;
• Isang Boolean variable upang matukoy ang "Tapos na o hindi tapos na" ("Basahin o hindi basahin").

Samakatuwid, gumawa tayo ng klase ng Tala sa isang direktoryo na tinatawag na “entity” at idagdag ang naaangkop na mga field:

@Entity
public class Note {

   @Id
   @GeneratedValue
   private int id;
   private String message;
   private Date date;
   private boolean done;

   public Note() {
   }

   public Note(String message) {
       this.message = message;
       this.date = new Date();
       this.done = false;
   }
}

Ang isa pang paglihis mula sa paksa ng talakayan para sa isang higit na pag-unawa sa kung ano ang nangyayari mula sa isang teoretikal na posisyon. Ang koneksyon sa pagitan ng mga bahagi sa Spring ay tinukoy ng mga anotasyon - mga espesyal na pointer sa harap ng mga bagay, na ang bawat isa ay gumaganap ng isang tiyak na papel sa mekanismo at nagsisimula sa simbolo na "@". Ang @Entity annotation ay nagpapahiwatig sa Spring Boot na ang kasunod na data ng klase ay kabilang sa "Entity", at ang @Id at @GeneratedValue ay tumutukoy sa napiling field bilang isang identifier na may awtomatikong pagbuo ng isang iterator kapag nagpoproseso ng array ng impormasyon. Sinadya kong alisin ang pagdaragdag ng karaniwang Getter at Setter upang mapataas ang pagiging compact ng visual na format. Susunod, isinasaalang-alang ang paggamit ng isang database para sa pag-iimbak ng mga rekord, nagpapatuloy kami sa susunod na hakbang sa pagbuo ng application: gagawa kami ng interface ng NoteRepository sa direktoryo ng "imbakan", isang elemento ng pagkonekta sa chain ng palitan, at magmana ng pinakamaraming angkop na imbakan para sa karagdagang trabaho, na nagpapahiwatig ng naka-imbak na entity at integer iterator upang ma-access.

public interface NoteRepository extends JpaRepository<Note, Integer> {
}

Actually, yun lang. Maikli at maigsi. Ngayon, gagamitin ng Spring Boot ang nilikhang bahagi upang ayusin ang mga pakikipag-ugnayan sa database. Mayroong medyo maraming uri ng mga legacy na repository na may iba't ibang potensyal para sa pagkilos. Ang JpaRepository ay nasa tuktok ng hagdan at may pinakamaraming potensyal, kasama ang CrudRepository at PageAndSortingRepository sa ibaba nito. Hindi na kami lalayo pa at lilihis sa paksa, dahil ang ilan sa mga subtlety ay makikita sa website ng Pivotel sa teknikal na dokumentasyon. Ngayon, pagkatapos ipatupad ang imahe ng data at tukuyin ang mga paraan ng komunikasyon sa gilid ng application, kailangan mong bigyang-pansin ang paglikha ng MySQL database sa naaangkop na panlabas na kapaligiran na "MySQL Workbench", na na-pre-install sa desktop platform sa isang pagpupulong mula sa opisyal na developer na may karagdagang mga pakete para sa paglikha ng isang lokal na server: Susunod, pagsunod sa mga tagubilin ng kapaligiran pagkatapos mag-click sa icon na may kasalukuyang lokal na server sa pangunahing window, lumikha kami ng isang diagram ng talahanayan ayon sa mga patlang ng aming entity (Tandaan) at punan ito ng naaangkop na data. Kinakailangan na hiwalay na linawin ang mga subtleties ng MySQL dialect, na agarang nangangailangan ng pansin upang matagumpay na makamit ang nais na resulta:

• Walang hiwalay na uri ng Boolean tulad nito. Ang anumang mga pagkilos sa pagpoproseso ng kahilingan ay magko-convert ng "true" o "false" sa bit value na "1" o "0", ayon sa pagkakabanggit;
• Ang petsa ay ganap na nakaimbak sa uri ng Timestamp. Kung gagamit ka ng Date, na pamilyar sa core, kakailanganin mong limitahan ang iyong sarili sa posisyon lamang sa kalendaryo.

Pagkatapos ng huling pagkumpleto ng mga hakbang sa paghahanda, ipinapahiwatig namin ang "MySQL Workbench" upang magpadala ng data sa lokal na server sa pamamagitan ng pag-click sa icon na "kidlat" sa toolbar. Ngayon, kung ang pagdaragdag ng impormasyon ay nakumpleto nang tama, maaari kaming kumpiyansa na bumalik sa aming katutubong IDE upang ipagpatuloy ang pag-unlad sa pamamagitan ng pagdaragdag ng kasalukuyang configuration ng database sa application.properties (karaniwang matatagpuan sa direktoryo ng "mga mapagkukunan"):

spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

At sa wakas ay nagbubuklod sa Note entity sa MySQL gamit ang mga anotasyon. Ipinapahiwatig ng @Table ang paggamit ng isang talahanayan na may napiling pangalan at schema, at ang @Column ay nagpapahiwatig na ang mga variable ay nabibilang sa isang partikular na field.

@Entity
@Table(name = "test", schema = "test", catalog = "")
public class Note {

   @Id
   @GeneratedValue
   private int id;
   @Column(name = "message")
   private String message;
   @Column(name = "date")
   private Date date;
   @Column(name = "done")
   private boolean done;

   public Note() {
   }

   public Note(String message) {
       this.message = message;
       this.date = new Date();
       this.done = false;
   }
}

Tingnan o user interface

Sa kasamaang palad, ligtas nating masasabi ang sumusunod: "Ang visualization ng application ay magiging pangunahing hadlang nang walang kaunting teoretikal o praktikal na kaalaman." Sa totoo lang, ang front-end na bahagi ay nakakuha ng napakalaking halaga ng kabuuang dami ng trabaho at kumpiyansa na nasira ang aking mga ugat sa loob ng mahabang panahon. Ngunit salamat sa kamangha-manghang pagiging simple ng Thymeleaf, posible na makahanap ng angkop na kompromiso pagkatapos ng isang serye ng mga kaakit-akit na pagkatalo. Ang karagdagang talakayan ay tungkol sa mga intricacies ng paggamit ng napiling makina, bagaman ang pangkalahatang konsepto ay sumusunod sa isang katulad na posisyon. Ang pangunahing pamamaraan ay ang kakayahang gamitin ang pinakadalisay na HTML at i-assemble ang huling pagpapakita mula sa mga indibidwal na fragment upang maiwasan ang maraming pag-uulit ng magkatulad na mga seksyon. Ipagpalagay natin na ang arkitektura ng UI ay binubuo ng isang pangunahing pahina na binubuo ng isang navigation bar na may mga kontrol (magdagdag ng bagong entry, bumalik sa pangunahing pahina) at isang dynamic na talahanayan para sa pagpapakita ng mga entity na pinagsunod-sunod ayon sa oras na idinagdag ang tala sa alinman sa pataas (ASC) o pagbabawas ( DESC) direksyon. kahulugan. Kunin natin bilang karaniwang posisyon ang pagpapakita ng lahat ng mga tala sa pataas na pagkakasunud-sunod. Ayon sa hierarchical na patakaran ng napiling template engine, ang mga elemento ng visualization ng bahagi ay dapat na matatagpuan sa sangay ng "mga template" sa direktoryo ng "mga mapagkukunan". Dahil dito, ang mga karagdagang pagmamanipula sa mga bahagi ay isinasaalang-alang ang mga kondisyon na iniharap. Gumawa tayo ng pangunahing pahina na may pangalang "index" (o anumang iba pang pangalan ayon sa personal na kagustuhan) sa isang template ng html5. Halimbawa:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:th="http://www.thymeleaf.org">
<head th:replace="fragments/head :: head"></head>
<body>
<div class="container">
   <div th:replace="fragments/header :: header"></div>
   <div th:if="${not #lists.isEmpty(notes)}">
       <div th:replace="operations/list :: notebook"></div>
   </div>
   <div th:replace="fragments/footer :: footer"></div>
</div>
</body>
</html>

At kaya, hatiin natin ang mga pangunahing bahagi ng panghuling aplikasyon. Gumagamit ang Thymeleaf ng hiwalay na syntax upang ipahiwatig ang paggamit ng mga pamamaraan at nagsisimula sa keyword na "th:", ang link sa library kung saan kinakailangang kasama sa pambungad na tag na <html>.

<div th:if="${not #lists.isEmpty(notes)}">

Ang operasyong "kung" ay ganap na hindi naiiba sa karaniwang paraan ng paggawa ng mga bagay at sinusuri ang papasok na katangiang "mga tala" para sa pagkakaroon ng mga bagay para sa karagdagang pagpapakita. Nararapat na banggitin nang hiwalay ang overlap ng paksa sa paggamit ng Controller, na isinasaalang-alang ang paggamit nito para sa pag-aayos ng pakikipag-ugnayan ng modelo at visualization. Maraming malabong sandali ang nahuhubog sa hinaharap, balikan mo lang kung gusto mo.

<head th:replace="operations/list :: notebook"></head>

Ang "palitan" na operasyon ay nagpapahiwatig ng pagpapalit ng isang "stub" o isang aktibong bloke na may napiling fragment mula sa kasalukuyan o hiwalay na pahina - ang huling kaso ay malinaw na sinusunod sa halimbawa. Kinokopya namin ang fragment na tinatawag na “notebook” mula sa “list.html” ng “operations” directory papunta sa <div></div> ng “index” file, na ganap na pinapalitan ang content sa huling destinasyon. Ang papalabas ay mayroong sumusunod na nilalaman:

<!DOCTYPE html>
<!--suppress ALL -->
<html xmlns="http://www.w3.org/1999/xhtml"
     xmlns:th="http://www.thymeleaf.org">

<div th:fragment="notebook">
   <table class="table table-bordered table-hover horizontal-align">
       <thead>
       <tr>
           <th style="width: 5%">#</th>
           <th style="width: 60%">Message</th>
           <th class="dropdown" style="width: 20%">Date
               <a th:href="@{'/sort/{sortDate}' (sortDate = 'ASC')}"><i class="fa fa-chevron-circle-up"></i></a>
               <a th:href="@{'/sort/{sortDate}' (sortDate = 'DESC')}"><i class="fa fa-chevron-circle-down"></i></a>
           </th>
           <th style="width: 5%">Done</th>
           <th style="width: 5%">Edit</th>
           <th style="width: 5%">Delete</th>
       </tr>
       </thead>
       <tbody>
       <tr th:each="note : ${notes}">
           <td th:text="${note.id}" style="text-align: center">#</td>
           <td th:text="${note.message}">Message</td>
           <td th:text="${#dates.format(note.date, 'EEE, d MMM yyyy HH:mm')}" style="text-align: center">Date</td>
           <td style="text-align: center">
               <i th:if="${note.done} == true" class="fa fa-plus-square-o" style="font-size:20px;color:#337ab7"></i>
               <i th:if="${note.done} == false" class="fa fa-minus-square-o" style="font-size:20px;color:#337ab7"></i>
           </td>
           <td style="text-align: center"><a th:href="@{'/edit/{id}'(id=${note.id})}"><i class="fa fa-edit" style="font-size:20px"></i></a></td>
           <td style="text-align: center"><a th:href="@{'/delete/{id}'(id=${note.id})}"><i class="fa fa-trash" style="font-size:20px"></i></a></td>
       </tr>
       </tbody>
   </table>
</div>
</html>

Bumalik tayo sa nakabubuo na pangkalahatang-ideya at suriin ang mga function ng Thymeleaf na ginamit sa pagkakasunud-sunod, tinanggal ang karaniwang syntax ng HTML o mga graphic na istilo na ginamit, at partikular na nakatuon sa pag-unawa sa mekanismo ng template engine.

<div th:fragment="notebook">

Ang "fragment" na operasyon ay tumutukoy sa pangalan ng fragment at ginagawang posible na gamitin ang mga nilalaman ng block para sa "palitan" na utos. At saka! Ang maramihang paggamit sa loob ng isang pahina ay hindi ibinubukod, muli na naghahatid ng pagkakatulad sa mga pamamaraan o function sa mga programming language.

<a th:href="@{'/sort/{sortDate}' (sortDate = 'ASC')}">

Ang isang tawag sa @PostMapping annotation ay ginagamit sa Controller na may pagmamapa na "/sort/{sortDate}", kung saan ang {sortDate} ay ang papalabas na attribute ng direksyon ng pag-uuri. May makikitang katulad sa sumusunod na bloke, na nagdaragdag ng dynamic na pagbabago depende sa posisyon ng elementong pinili ng user sa iteration loop:

<a th:href="@{'/edit/{id}'(id=${note.id})}">

<tr th:each="note : ${notes}">

Ang pag-enumerate ng mga halaga ay halos kapareho sa pamilyar na paggamit ng isang para sa block sa Java syntax: ang variable na "tala" ay kumukuha ng kasalukuyang elemento mula sa input attribute array ${notes}—isang hanay ng mga entity—at ginagamit upang baguhin ang mga halaga mamaya. Sa totoo lang, maaari naming italaga ang isang hiwalay na artikulo sa paglilista ng malawak na hanay ng mga kakayahan ng Thymeleaf na may mga halimbawa ng praktikal na aplikasyon - ang template engine ay napakasimple at hindi nangangailangan ng pag-aaral sa lahat ng kahanga-hangang bagahe ng karagdagang syntax. Ang mga function na inilarawan sa itaas ay nakabalangkas sa teknikal na dokumentasyon sa opisyal na website ng mga developer at gumaganap ng isang mahalagang papel sa pag-aayos ng komunikasyon sa back-end. Samakatuwid, maaari kang kumpiyansa na magpatuloy sa susunod at huling bahagi. Siyempre, sa pamamagitan ng paglakip ng mga natitirang bahagi ng visualization sa isang link sa natapos na aplikasyon sa dulo ng artikulo.

Controller, administrator sa isang maliit na kumpanya

"Ang pundasyon sa arkitektura ng isang web application" - marahil ay walang paraan upang makahanap ng isang mas tumpak na paglalarawan ng kahalagahan ng bahagi ng Controller sa pag-aayos ng gawain ng programa: karamihan sa mga operasyon ay isinasagawa nang tumpak sa pamamagitan ng elemento ng pagkonekta sa pagitan ng modelo at ang view. Salamat sa action mechanics ng Spring Boot, kumpiyansa kang makakagamit ng pagmamapa at GET/POST na mga paraan ng paghiling nang walang kaunting problema, at awtomatikong ikonekta ang data repository. Gawin natin ang klase ng NoteController sa isang hiwalay na file sa direktoryo ng "mga controllers", muling tumutukoy sa paggamit ng naaangkop na anotasyon:

@Controller
public class NoteController {

   private NoteService service;

   @Autowired
   public void setNoteService(NoteService service) {
       this.service = service;
   }

   @GetMapping("/")
   public String list(Model model) {
       return "index";
   }
}

Maaaring mapansin ng isang maingat na mata ang isang mahalagang pagbabago sa disenyo ng arkitektura ng application na nauugnay sa pagdaragdag ng isang serbisyo upang ihiwalay ang lohika ng negosyo mula sa pagtatrabaho sa serbisyo ng pamamahala ng database. Ang mga nakumpletong aksyon ay kinakailangan upang mapataas ang versatility ng tapos na produkto at magbigay ng malawak na saklaw para sa pagbabago ng functionality ng user interface nang hindi nangangailangan ng mga pagbabago sa mga paraan ng komunikasyon sa database. Ang karaniwang representasyon sa anumang paraan ay hindi namumukod-tangi sa karamihan ng mga katulad: ang interface ay matatagpuan sa isang hiwalay na direktoryo at ipinatupad ng isang klase na may @Service annotation para sa Spring Boot detection:

public interface NoteService {
   Note getNoteById(Integer id);
   void saveNote(Note note);
   void updateNote(Integer id, String message, boolean done);
   void deleteNote(Integer id);
   List<Note> findAll();
}

@Service
public class NoteServiceImpl implements NoteService{

   private NoteRepository repository;

   @Autowired
   public void setProductRepository(NoteRepository repository) {
       this.repository = repository;
   }

   @Override
   public Note getNoteById(Integer id) {
       return repository.findOne(id);
   }

   @Override
   public void saveNote(Note note) {
       repository.save(note);
   }

   @Override
   public void updateNote(Integer id, String message, boolean done) {
       Note updated = repository.findOne(id);
       updated.setDone(done);
       updated.setMessage(message);
       repository.save(updated);
   }

   @Override
   public void deleteNote(Integer id) {
       repository.delete(id);
   }

   @Override
   public List<Note> findAll() {
       return repository.findAll();
   }
}

Bumalik tayo sa pagsusuri sa controller at tingnan ang mga intricacies ng pag-aayos ng trabaho gamit ang mga pamamaraan ng Spring Boot. Ang @Autowired annotation ay nagpapahiwatig ng pangangailangan na awtomatikong itali ang isang serbisyo sa isang tinukoy na variable ng naaangkop na uri at magtatag ng koneksyon sa database. Dapat bigyan ng higit na pansin ang paraan ng pakikipag-ugnayan ng view, na isinasaad ng @GetMapping("/") annotation, na nagbabalik ng page na pinangalanang “index” kapag nakatanggap ng tawag sa localhost:8080. Maaari kang gumamit ng ibang diskarte, na tumutukoy sa pinalawak na paglalarawan @RequestMapping(value = "/", method = RequestMethod.GET) o palitan ang uri ng pagbabalik ng isang handa na ModelAndView. Gayunpaman, ayon sa kasalukuyang estado ng karanasan sa praktikal na aplikasyon, hindi ko napapansin ang anumang mga pangunahing pagkakaiba sa huling resulta at ginagamit ang karaniwang opsyon. Palawakin natin ang controller sa pamamagitan ng pagdaragdag ng mga bagong elemento gamit ang karagdagang tab. Pagkatapos mag-click ng user sa isang elemento ng navigation bar, ang @GetMapping("/bago") ay tatawagin at ire-redirect sa "bago" na pahina mula sa direktoryo ng "mga operasyon", na nagbabalik ng parameter na pinangalanang "mensahe" kapag kinukumpirma ang inilagay na data gamit ang button at pag-redirect sa pangunahing bloke. Espesyal na pagbanggit ay kinakailangan para sa pangangailangan para sa isang kumpletong tugma ng pangalan ng variable sa input window na may pangalan ng inilipat na halaga.

<input type="text" class="form-control" id="message" th:name="message" placeholder="Enter your note." maxlength="100"/>

@GetMapping("/new")
public String newNote() {
   return "operations/new";
}

@PostMapping("/save")
public String updateNote(@RequestParam String message) {
   service.saveNote(new Note(message));
   return "redirect:/";
}

Ang isang katulad na pamamaraan ay ginagamit upang i-update ang isang talaan. Pagkatapos mag-click sa control, tatawagin ang @GetMapping("/edit/{id}") na pagmamapa at ililipat ang identifier mula sa string ng URL, idaragdag ang attribute na “note” kasama ng entry para sa karagdagang pag-edit. @RequestParam(value = "done", required = false) boolean done) ang pagtukoy ng isang partikular na value ay gumaganap ng mahalagang papel sa paggamit ng checkbox kapag ginagamit ang Thymeleaf template engine at nakatakda sa "false" bilang default.

@GetMapping("/edit/{id}")
public String edit(@PathVariable Integer id, Model model) {
   Note note = service.getNoteById(id);
   model.addAttribute("note", note);
   return "operations/edit";
}

@PostMapping("/update")
public String saveNote(@RequestParam Integer id, @RequestParam String message,
                      @RequestParam(value = "done", required = false) boolean done) {
   service.updateNote(id, message, done);
   return "redirect:/";
}

Ang pag-alis ng mga item mula sa database ay napakasimple at hindi nangangailangan ng anumang makabuluhang pagmamanipula sa pamamagitan ng pagtawag sa naaangkop na function ng serbisyo gamit ang naipasa na halaga:

@GetMapping("/delete/{id}")
public String delete(@PathVariable Integer id) {
   service.deleteNote(id);
   return "redirect:/";
}

Ngayon, gumawa tayo ng maliliit na pagsasaayos sa mga natapos na fragment at magpatuloy sa kapana-panabik na komunikasyon sa MySQL gamit ang mga query na query sa Spring Data JPA, hiwalay na magdagdag ng function para sa pamamahala ng simpleng pag-filter bago isara ang Controller.

@Controller
public class NoteController {

   private String sortDateMethod = "ASC";

   @GetMapping("/")
   public String list(Model model) {
       List<Note> notebook = filterAndSort();
       model.addAttribute("notes", notebook);
       model.addAttribute("sort", sortDateMethod);
       return "index";
   }

private List<Note> filterAndSort() {
   List<Note> notebook = null;
   switch (sortDateMethod) {
       case "ASC":
           notebook = service.findAllByOrderByDateAsc();
           break;
       case "DESC":
           notebook = service.findAllByOrderByDateDesc();
           break;
   }
   return notebook;
}

Napakaliit, ngunit napakahalagang Query.

Nakakahiyang aminin, ang pag-filter ng mga halaga, salungat sa mga inaasahan, ay naging isa pang hadlang sa pagtupad sa teknikal na gawain, na may kumpiyansa na pagtagumpayan ang kumplikadong threshold na itinatag ng pagination - sinira ang hanay ng data sa magkahiwalay na mga pahina ng isang tiyak na laki para sa karagdagang pagpapakita. Malamang, ang naipon na pagkapagod ay namamatay, ngunit... dumating ang inspirasyon pagkatapos ng isang ganap na aksidenteng pakikipagtagpo sa mga query sa Query.

public interface NoteRepository extends JpaRepository<Note, Integer> {
   List<Note> findAllByOrderByDateAsc();
   List<Note> findAllByOrderByDateDesc();
}

Ang Spring Data JPA ay nagbibigay ng kakayahang lumikha ng napakabutil na mga query sa database na nag-aalis ng pangangailangang pagbukud-bukurin ang impormasyon kapag natanggap na ito at may malawak na hanay ng potensyal ng aplikasyon. Halimbawa:

List<Note> findAllByOrderByDateAsc();

Ang pamamaraan ay iko-convert sa isang SQL query at ipapakita ang lahat ng mga talaan (findAll) na pinagsunod-sunod (sa pamamagitan ngOrder) ayon sa petsa (byDate) sa pataas na pagkakasunud-sunod (Asc). Bukod dito, maaari kang lumikha ng mga kumplikadong kumbinasyon at sample sa maraming field na may iisang kinakailangan. Sabihin, piliin ang lahat ng (findAll) na nakumpleto (byDoneTrue) na mga tala sa pagkakasunud-sunod (sa pamamagitan ngOrder) na bumababa (Decs) ayon sa halaga ng petsa (byDate):

Page<Note> findAllByDoneTrueOrderByDateDesc(Pageable pageable);

Konklusyon o isa pang pag-amin ng isang baguhan na programmer

Lahat! Maaari mong ligtas na ilunsad ang web application gamit ang Shift+F10 na kumbinasyon o sa pamamagitan ng pag-click sa kaukulang icon. Ang Spring Boot ay bubuo ng programa sa Apache Maven at mag-i-install ng lokal na server ng Apache Tomcat sa localhost:8080. Ngayon ay kailangan mo lamang sundin ang link sa anumang browser. At, siyempre, bumuo ng isang pamamaraan upang matupad ang iba pang mga kinakailangan sa negosyo. Ang potensyal ng application ay limitado sa pamamagitan ng pagsisikap, pagiging maparaan, at imahinasyon ng developer. Sa pagiging prangka at pagbibigay-pansin sa tinatahak na landas, muli at muli akong kumbinsido sa kawastuhan ng napiling direksyon at napagtanto ang mga benepisyo ng pag-aaral sa JavaRush educational portal. Salamat sa iba't ibang praktikal na gawain, posible na ibalik ang kaakit-akit na interes sa pag-aaral ng programming, na ganap na pinigilan sa lipas na at nakakagulat na nakakainip na programa ng isang mas mataas na institusyong pang-edukasyon na may katulad na direksyon. Apat na buwan ng aktibong pag-aaral ng materyal sa back-end na teknolohiya stack ay namuhunan ng higit na kaalaman kumpara sa buong taon ng pagdalo sa mga lektura at mga klase sa laboratoryo. Maniwala ka man o hindi. Nais kong huwag kang sumuko sa mga kahirapan sa pagpasok ng kumplikadong materyal, dahil sa pamamagitan ng pagtagumpayan ng mga hadlang na tayo ay nagiging mas mahusay at umunlad nang propesyonal at personal. Umaasa ako na ang maliit na kuwentong ito ay nakatulong sa akin na tumuklas ng ilang mga bagong ideya para sa paggamit ng kamangha-manghang tool na tinatawag na SpringBoot. PS Github .