Podbij wiosenne buty

Dzień dobry, drogi czytelniku! I miło Cię poznać, nawet jeśli pompatyczna nazwa była głównym powodem do zgłębienia skromnego tematu o pierwszej znajomości z rozwojem Spring Boot. Chciałbym podzielić się swoim doświadczeniem z realizacji zadania wprowadzającego na staż na portalu JavaRush, przedstawiając spojrzenie z perspektywy zupełnie zwyczajnego studenta uczelni technicznej, który chce sprawdzić siłę swojej zgromadzonej wiedzy. W żadnym wypadku nie przeczę ewentualnej obecności chamstwa w załączonym kodzie czy sposobie myślenia i przyjmę konstruktywną krytykę, bo to właśnie dzięki „guzom i siniakom” możliwy jest rozwój w kierunku zawodowym. Co więcej, wcale nie pretenduję do roli „panaceum” w rozwiązaniu zadanych warunków i celowo pomijam poszczególne fragmenty programu, pozostawiając kluczowe znaczenie wejścia w stosunkowo złożony temat bez najmniejszych konsekwencji dla układu nerwowego. To prawda, zaprzeczanie oczywistościom jest lekkomyślne: było mi ciężko i aż do pewnego momentu nic nie było jasne. A jeśli od pierwszego spotkania z zadaniem odczujesz podobne odczucia, to „Witamy!” Napiszmy aplikację internetową w Spring Boot, korzystając z uproszczonej analogii testu wstępnego na staż z wykorzystaniem silnika szablonów Thymeleafi queryzapytań do lokalnego serwera MySQL w celu filtrowania przychodzącej tablicy informacji. Więc zacznijmy!

Wiosenne buty. Jakie to zwierzę i jak je ugotować?

W skrócie i zwięźle jest to doskonałe narzędzie firmy Pivotel pozwalające zaoszczędzić cenny czas w procesie tworzenia aplikacji, eliminując konieczność bezpośredniego łączenia bibliotek innych firm, pisania efektownego canvasu mapującego i serwletów. Wystarczy skorzystać z konstruktora Spring Individualizr , zintegrowanego z IntelliJ IDEA Ultimate Edition (Plik - Nowość - Projekt... - Spring Individualizr) lub znajdującego się w serwisie start.spring.io , określając pakiety do włączenia z szerokiej gamy oferuje. Kierując się przedstawioną specyfikacją techniczną wykorzystamy zestaw dżentelmeński, standard do tworzenia prostej aplikacji internetowej wykorzystującej bazę danych MySQL :

• WEB to główny komponent do tworzenia aplikacji webowych, obejmujący lokalny serwer Apache Tomcat pod standardowym adresem localhost:8080 oraz uniwersalny framework Spring MVC.


• DevTools - służy do szybkiego restartu aplikacji w gorącej maszynie JVM po wykryciu zmian w skompilowanym kodzie lub szablonach; Co więcej, uwalnia Thymeleaf od czyszczenia pamięci podręcznej, jeśli wybrany silnik jest uwzględniony w projekcie.


• JPA to technologia wymagana do pracy z bazami danych i zapewnia obiektowo-relacyjne mapowanie obiektów Java, zapewnia API ( w naszym przypadku Hibernate ) do zarządzania, zapisywania i odzyskiwania obiektów.


• Thymeleaf (Mustache, AngularJS, Vaadin i nie tylko) - silnik szablonów do wizualizacji aplikacji; Dzięki względnej znajomości zasad HTML wybrałem Thymeleaf, który zepchnął ten język na kamień węgielny świata.


• MySQL - łączy sterowniki Java Database Connectivity w celu wykonywania zapytań SQL względem bazy danych.

Po ostatecznym doborze komponentów i stworzeniu otrzymujemy zwykłą architekturę aplikacji webowej z katalogami gotowymi do dalszego uzupełniania. Fragmenty umożliwiające interakcję z częścią wizualną, czy to style graficzne CSS, standardowe strony HTML czy funkcjonalność JavaScript, powinny być umieszczone w „zasobach”, a komponent back-endowy, odpowiednio, ma być umieszczony w „Java”. Warto zwrócić także uwagę na znajdujący się w katalogu głównym plik pom.xml, w którym przechowywana jest struktura projektu oraz zależności pomiędzy komponentami. Jeśli chcesz jeszcze bardziej rozszerzyć funkcjonalność o dodatkowe pakiety lub usunąć niepotrzebne rzeczy, powinieneś <dependencies></dependencies>w podobny sposób wykonać manipulacje pomiędzy tagami.

Pierwsze kroki w wspaniałą przyszłość

Następnie pojawia się dość interesujące i dość logiczne pytanie: „Co teraz zrobić? Jak to będzie działać? Program zbudowany jest na zasadzie Model-View-Controller: organizuje odczyt jednostek z podłączonej bazy danych (Model) i jest wyświetlany w interfejsie użytkownika z kontrolkami (View); komunikacja pomiędzy komponentami i realizacja działań na podstawie przekazanych żądań odbywa się dzięki Kontrolerowi. To właśnie stworzenie kluczowych elementów stanowi punkt odniesienia dla dalszego rozwoju. Aby uniknąć pochyłości i zachować szacunek towarzyszy w pracy, należy umieścić komponenty w odpowiednich katalogach (np. umieścić plik Controller w folderze Controllers w gałęzi „Java”) i starannie przechowywać porządek w miejscu pracy.

Esencja jest małą częścią wielkiego mechanizmu

Inaczej mówiąc, nasz Model zgodnie z warunkami określonymi w zadaniu. Odchodząc od tematu dyskusji i wracając do projektu wprowadzającego, możemy śmiało stwierdzić, że różnice między zadaniami są minimalne i przy dalszej ocenie trzymać się przeciętnej koncepcji. Powiedzmy, notatki w notatniku, w tym:

• Numer identyfikacyjny umożliwiający określenie lokalizacji w ogólnym przepływie;
• Wiadomość tekstowa o określonej liczbie znaków;
• Data dodania go przez użytkownika do listy ogólnej;
• Zmienna logiczna określająca „Ukończono lub nie wykonano” („Przeczytano lub nie przeczytano”).

Stwórzmy zatem klasę Note w katalogu o nazwie „encja” i dodajmy odpowiednie pola:

@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;
   }
}

Kolejne odejście od tematu dyskusji dla lepszego zrozumienia tego co się dzieje z stanowiska teoretycznego. Powiązanie pomiędzy komponentami w Springu określają adnotacje - specjalne wskaźniki przed obiektami, z których każdy pełni określoną rolę w mechanizmie i zaczyna się od symbolu „@”. Adnotacja @Entity wskazuje Spring Bootowi, że kolejne dane klasy należą do „Entity”, a @Id i @GeneratedValue określają wybrane pole jako identyfikator z automatycznym generowaniem iteratora podczas przetwarzania tablicy informacji. Celowo pomijam dodanie standardowego Gettera i Settera, aby zwiększyć zwartość formatu wizualnego. Następnie biorąc pod uwagę wykorzystanie bazy danych do przechowywania rekordów, przechodzimy do kolejnego kroku w rozwoju aplikacji: utworzymy interfejs NoteRepository w katalogu „repozytorium”, element łączący w łańcuchu wymiany i odziedziczymy najwięcej odpowiednie repozytorium do dalszej pracy, wskazując przechowywaną jednostkę i iterator liczb całkowitych, do których można uzyskać dostęp.

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

Właściwie to wszystko. Krótko i zwięźle. Teraz Spring Boot użyje utworzonego komponentu do zorganizowania interakcji z bazą danych. Istnieje stosunkowo wiele typów starszych repozytoriów o różnym potencjale działania. JpaRepository znajduje się na szczycie drabiny i ma największy potencjał, w tym CrudRepository i PageAndSortingRepository poniżej. Nie będziemy już iść dalej i odbiegać od tematu, bo część niuansów znajdziecie na stronie Pivotela w dokumentacji technicznej. Teraz po zaimplementowaniu obrazu danych i określeniu sposobów komunikacji po stronie aplikacji należy zwrócić uwagę na utworzenie bazy danych MySQL w odpowiednim środowisku zewnętrznym „MySQL Workbench”, preinstalowanym na platformie desktopowej w zestawie od oficjalnego dewelopera z dodatkowymi pakietami do utworzenia serwera lokalnego: Następnie, kierując się instrukcjami otoczenia, po kliknięciu w oknie głównym ikony z aktualnym serwerem lokalnym, tworzymy diagram tabelaryczny według pól naszej jednostki (Notatka) i wypełniamy go odpowiednimi danymi. Konieczne jest osobne wyjaśnienie subtelności dialektu MySQL, które pilnie wymagają uwagi, aby pomyślnie osiągnąć pożądany rezultat:

• Nie ma osobnego typu logicznego jako takiego. Wszelkie działania związane z przetwarzaniem żądania spowodują konwersję „prawda” lub „fałsz” na wartość bitową odpowiednio „1” lub „0”.
• Data jest przechowywana w całości w typie Timestamp. Jeśli użyjesz znanej od podstaw daty, będziesz musiał ograniczyć się tylko do pozycji w kalendarzu.

Po ostatecznym zakończeniu czynności przygotowawczych wskazujemy „MySQL Workbench” do przesłania danych na lokalny serwer, klikając ikonę „błyskawicy” na pasku narzędzi. Teraz, jeśli dodawanie informacji zostało zakończone poprawnie, możemy śmiało wrócić do naszego natywnego IDE, aby kontynuować rozwój, dodając bieżącą konfigurację bazy danych do application.properties (zwykle znajdującego się w katalogu „resources”):

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

I na koniec powiązanie jednostki Note z MySQL za pomocą adnotacji. @Table wskazuje użycie tabeli o wybranej nazwie i schemacie, a @Column wskazuje, że zmienne należą do określonego pola.

@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;
   }
}

Widok lub interfejs użytkownika

Niestety, możemy śmiało powiedzieć, co następuje: „Wizualizacja aplikacji stanie się główną przeszkodą bez najmniejszej wiedzy teoretycznej lub praktycznej”. Szczerze mówiąc, komponent front-end pochłonął niesamowitą ilość pracy i pewnie przez długi czas działał mi na nerwy. Ale dzięki niesamowitej prostocie Thymeleaf udało się znaleźć odpowiedni kompromis po serii czarujących porażek. Dalsza dyskusja będzie dotyczyła zawiłości wykorzystania wybranego silnika, choć ogólna koncepcja opiera się na podobnym stanowisku. Główną techniką jest możliwość wykorzystania najczystszego kodu HTML i złożenia końcowego wyświetlacza z pojedynczych fragmentów, aby uniknąć wielokrotnych powtórzeń identycznych sekcji. Załóżmy, że architektura interfejsu użytkownika składa się ze strony głównej składającej się z paska nawigacji z elementami sterującymi (dodaj nowy wpis, powrót do strony głównej) oraz dynamicznej tabeli wyświetlającej elementy posortowane według czasu dodania notatki w kolejności rosnącej (ASC) lub malejącej ( DESC) kierunek, znaczenia. Za standardową pozycję przyjmijmy wyświetlanie wszystkich rekordów w kolejności rosnącej. Zgodnie z hierarchiczną polityką wybranego silnika szablonów, elementy wizualizacji komponentów powinny znajdować się w gałęzi „szablony” w katalogu „zasoby”. W związku z tym dalsze manipulacje komponentami uwzględniają przedstawione warunki. Stwórzmy stronę główną o nazwie „index” (lub dowolnej innej nazwie według osobistych preferencji) na szablonie HTML5. Na przykład:

<!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>

Rozłóżmy więc kluczowe elementy aplikacji końcowej. Thymeleaf używa osobnej składni do wskazania użycia procedur i zaczyna się od słowa kluczowego „th:”, link do biblioteki, z którym koniecznie jest zawarty w otwierającym tagu <html>.

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

Operacja „jeśli” nie różni się niczym od zwykłego sposobu wykonywania czynności i sprawdza przychodzący atrybut „notatek” pod kątem obecności obiektów do dalszego wyświetlenia. Odrębnie warto wspomnieć o pokrywaniu się tematu z wykorzystaniem Kontrolera, biorąc pod uwagę jego zastosowanie do organizowania interakcji modelu i wizualizacji. Wiele niejasnych chwil nabiera kształtu w przyszłości, po prostu wróć, jeśli chcesz.

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

Operacja „zamień” oznacza zastąpienie „odcinka” lub aktywnego bloku wybranym fragmentem z bieżącej lub osobnej strony - ten drugi przypadek wyraźnie widać w przykładzie. Kopiujemy fragment o nazwie „notebook” z „list.html” katalogu „operacje” do <div></div> pliku „index”, całkowicie zastępując treść w miejscu docelowym. Ten wychodzący ma następującą treść:

<!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>

Wróćmy do konstruktywnego przeglądu i przejrzyjmy funkcje Thymeleaf użyte w odpowiedniej kolejności, pomijając standardową składnię HTML lub użyte style graficzne i skupiając się szczególnie na zrozumieniu mechanizmu silnika szablonów.

<div th:fragment="notebook">

Operacja „fragment” określa nazwę fragmentu i umożliwia wykorzystanie zawartości bloku dla polecenia „zamień”. Ponadto! W żaden sposób nie wyklucza się wielokrotnych zastosowań na jednej stronie, co ponownie nasuwa analogię z procedurami lub funkcjami w językach programowania.

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

W Kontrolerze stosowane jest wywołanie adnotacji @PostMapping z mapowaniem „/sort/{sortDate}”, gdzie {sortDate} jest atrybutem kierunku sortowania wychodzącego. Coś podobnego można zobaczyć w poniższym bloku, który dodaje dynamiczną zmianę w zależności od pozycji wybranego przez użytkownika elementu w pętli iteracyjnej:

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

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

Wyliczanie wartości jest bardzo podobne do znanego użycia bloku for w składni Java: zmienna „note” pobiera bieżący element z wejściowej tablicy atrybutów ${notes} – tablicy jednostek – i służy do zmiany wartości później. Szczerze mówiąc, opisaniu szerokiego zakresu możliwości Thymeleaf wraz z przykładami praktycznego zastosowania moglibyśmy poświęcić osobny artykuł – silnik szablonów jest niezwykle prosty i nie wymaga w ogóle nauki imponującego bagażu dodatkowej składni. Opisane powyżej funkcje są opisane w dokumentacji technicznej na oficjalnej stronie deweloperów i odgrywają kluczową rolę w organizowaniu komunikacji z backendem. Dlatego możesz śmiało przejść do kolejnej i ostatniej części. Oczywiście dołączając pozostałe elementy wizualizacji w linku do gotowej aplikacji na końcu artykułu.

Kontroler, administrator w małej firmie

„Kamień węgielny w architekturze aplikacji internetowej” – chyba nie da się znaleźć dokładniejszego opisu znaczenia komponentu Controller w organizacji pracy programu: większość operacji wykonuje właśnie element łączący pomiędzy model i widok. Dzięki mechanice działania Spring Boot możesz bez najmniejszego problemu korzystać z mapowania i metod żądania GET/POST oraz automatycznie łączyć się z repozytorium danych. Stwórzmy klasę NoteController w osobnym pliku w katalogu „controllers”, ponownie nawiązując do użycia odpowiedniej adnotacji:

@Controller
public class NoteController {

   private NoteService service;

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

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

Uważne oko może zauważyć istotną zmianę w projekcie architektury aplikacji związaną z dodaniem usługi izolowania logiki biznesowej od pracy z usługą zarządzania bazami danych. Zrealizowane działania mają na celu zwiększenie uniwersalności gotowego produktu oraz zapewnienie szerokiego zakresu zmiany funkcjonalności interfejsu użytkownika bez konieczności zmiany sposobów komunikacji z bazą danych. Standardowa reprezentacja niczym nie wyróżnia się na tle podobnych: interfejs znajduje się w osobnym katalogu i jest implementowany przez klasę z adnotacją @Service do wykrywania Spring Boot:

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();
   }
}

Wróćmy do przeglądu kontrolera i przyjrzyjmy się zawiłościom organizacji pracy za pomocą metod Spring Boot. Adnotacja @Autowired wskazuje na konieczność automatycznego powiązania usługi z określoną zmienną odpowiedniego typu i nawiązania połączenia z bazą danych. Większą uwagę należy zwrócić na sposób komunikacji widoku, na co wskazuje adnotacja @GetMapping("/"), która po odebraniu wywołania localhost:8080 zwraca stronę o nazwie „index”. Można zastosować inne podejście, podając rozszerzony opis @RequestMapping(value = "/", metoda = RequestMethod.GET) lub zastępując typ zwracany gotowym ModelAndView. Jednakże, zgodnie z obecnym stanem doświadczeń w praktycznym zastosowaniu, nie zauważam żadnych zasadniczych różnic w efekcie końcowym i korzystam ze zwykłej opcji. Rozbudujmy kontroler o nowe elementy za pomocą dodatkowej zakładki. Po kliknięciu przez użytkownika elementu paska nawigacyjnego zostaje wywołane @GetMapping("/new") i przekierowane na stronę „nowy” z katalogu „operacje”, zwracając parametr o nazwie „wiadomość” przy zatwierdzeniu wprowadzonych danych przyciskiem i przekierowanie do głównego bloku. Na szczególną uwagę zasługuje konieczność pełnego dopasowania nazwy zmiennej w oknie wejściowym do nazwy przesyłanej wartości.

<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:/";
}

Podobną technikę stosuje się do aktualizacji rekordu. Po kliknięciu na kontrolkę wywoływane jest mapowanie @GetMapping("/edit/{id}") i przekazywany jest identyfikator z ciągu URL, dodawany jest atrybut „note” z wpisem do dalszej edycji. @RequestParam(value = "gotowe", wymagane = false) boolean gotowe) określenie konkretnej wartości odgrywa kluczową rolę w korzystaniu z pola wyboru podczas korzystania z silnika szablonów Thymeleaf i jest domyślnie ustawione na "false".

@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:/";
}

Usunięcie pozycji z bazy jest niezwykle proste i nie wymaga większych manipulacji poprzez wywołanie odpowiedniej funkcji serwisowej z wykorzystaniem przekazanej wartości:

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

Teraz dokonajmy drobnych poprawek w gotowych fragmentach i przejdźmy do ekscytującej komunikacji z MySQL za pomocą zapytań w Spring Data JPA, osobno dodając funkcję zarządzania prostym filtrowaniem przed zamknięciem Kontrolera.

@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;
}

Takie małe, a jakże ważne Zapytanie.

Aż wstyd przyznać, że filtrowanie wartości wbrew oczekiwaniom okazało się kolejną przeszkodą w wykonaniu zadania technicznego, pewnie pokonując próg złożoności ustanowiony przez paginację - rozbicie tablicy danych na osobne strony o określonej wielkości w celu dalszego wyświetlania. Najprawdopodobniej nagromadzone zmęczenie dawało o sobie znać, ale… inspiracja przyszła po zupełnie przypadkowym zetknięciu się z zapytaniami Query.

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

Spring Data JPA zapewnia możliwość tworzenia wysoce szczegółowych zapytań do baz danych, które eliminują potrzebę sortowania informacji po ich otrzymaniu i mają szeroki zakres zastosowań. Na przykład:

List<Note> findAllByOrderByDateAsc();

Metoda zostanie przekonwertowana na zapytanie SQL i wyświetli wszystkie rekordy (findAll) posortowane (byOrder) według daty (byDate) w kolejności rosnącej (Asc). Co więcej, możesz tworzyć złożone kombinacje i pobierać próbki z wielu dziedzin w ramach jednego wymagania. Powiedzmy, wybierz wszystkie (findAll) zakończone (byDoneTrue) rekordy w kolejności (byOrder) malejącej (Decs) według wartości daty (byDate):

Page<Note> findAllByDoneTrueOrderByDateDesc(Pageable pageable);

Wniosek, czyli kolejne wyznanie początkującego programisty

Wszystko! Aplikację internetową możesz bezpiecznie uruchomić za pomocą kombinacji Shift+F10 lub klikając odpowiednią ikonę. Spring Boot zbuduje program na Apache Maven i zainstaluje lokalny serwer Apache Tomcat na localhost:8080. Teraz wystarczy kliknąć link w dowolnej przeglądarce. I oczywiście opracuj metodologię spełniającą inne wymagania biznesowe. Potencjał aplikacji ograniczony jest wysiłkiem, zaradnością i wyobraźnią programisty. Będąc szczerym i zwracając uwagę na przebytą drogę, raz po raz utwierdzam się w przekonaniu o słuszności obranego kierunku i zdaję sobie sprawę z korzyści płynących ze studiowania na portalu edukacyjnym JavaRush. Dzięki różnorodnym zadaniom praktycznym udało się przywrócić ponętne zainteresowanie nauką programowania, które zostało całkowicie stłumione w przestarzałym i zaskakująco nudnym programie uczelni wyższej o podobnym kierunku. Cztery miesiące aktywnego studiowania materiału w stosie technologii zaplecza zainwestowały znacznie więcej wiedzy w porównaniu do całych lat uczęszczania na wykłady i zajęcia laboratoryjne. Uwierz lub nie. Życzę Wam, abyście nie poddawali się trudnościom związanym z wchodzeniem w skomplikowany materiał, bo to poprzez pokonywanie przeszkód stajemy się lepsi i rozwijamy się zawodowo i osobiście. Mam nadzieję, że ta krótka historia pomogła mi odkryć kilka nowych pomysłów na wykorzystanie niesamowitego narzędzia o nazwie SpringBoot. PS Githuba .