מגף אביב כיבוש

יום טוב, קורא יקר! ונעים להכיר, גם אם השם הפומפוזי היה הסיבה העיקרית לבחון את הנושא הצנוע על ההיכרות הראשונה עם פיתוח Spring Boot. ברצוני לחלוק את הניסיון שלי בביצוע משימת ההיכרות להתמחות בפורטל JavaRush, תוך הצגת סקירה מהצד של סטודנט רגיל באוניברסיטה טכנית לחלוטין שרוצה לבחון את חוזק הידע המצטבר שלו. אני בשום אופן לא מתכחש לנוכחות אפשרית של גסות רוח בקוד או בשיטת החשיבה המצורפת, ואני מברך על ביקורת בונה, כי בזכות "מהמורות וחבורות" אפשר להתפתח לכיוון מקצועי. יתר על כן, אני בכלל לא מתיימר להיות "תרופת פלא" בפתרון התנאים הנתונים ומשמיט בכוונה קטעים בודדים של התוכנית, מה שמותיר את חשיבות המפתח של כניסה לנושא מורכב יחסית ללא השלכות קטנטנות על מערכת העצבים. זה נכון, זה פזיז להכחיש את המובן מאליו: זה היה לי קשה ושום דבר לא היה ברור עד רגע מסוים. ואם אתה חווה רגשות דומים מהפגישה הראשונה עם המשימה, אז "ברוך הבא!" בואו נכתוב יישום אינטרנט ב-Spring Boot באמצעות אנלוגיה פשוטה של ​​מבחן כניסה להתמחות באמצעות מנוע תבנית Thymeleafושאילתות queryלשרת MySQL מקומי כדי לסנן את מערך המידע הנכנס. אז בואו נתחיל!

מגף אביב. איזו חיה זו וכיצד לבשל אותה?

בקצרה ובתמציתיות, זהו כלי מצוין מבית Pivotel לחיסכון בזמן יקר בתהליך יצירת האפליקציה, ביטול הצורך בחיבור ישיר של ספריות צד שלישי, כתיבת בד מיפוי וסרבלטים מרשימים. די להשתמש בבונה Spring Initializr , המשולב ב- IntelliJ IDEA Ultimate Edition (קובץ - חדש - פרויקט... - Spring Initializr) או ממוקם בשירות האינטרנט start.spring.io , תוך ציון חבילות לכלול ממגוון רחב של הצעות. בהתאם למפרטים הטכניים שהועלו, נשתמש בסט האדון, הסטנדרטי ליצירת יישום אינטרנט פשוט באמצעות מסד הנתונים של MySQL :

• WEB הוא הרכיב העיקרי לפיתוח אפליקציית אינטרנט, כולל שרת Apache Tomcat מקומי בכתובת הסטנדרטית localhost:8080 ומסגרת Spring MVC האוניברסלית.


• DevTools - משמשים להפעלה מחדש מהירה של יישום ב-JVM חם כאשר מתגלים שינויים בקוד או בתבניות הקומפילציה; יתר על כן, זה משחרר את Thymeleaf מניקוי מטמון אם המנוע שנבחר כלול בפרויקט.


• JPA היא טכנולוגיה הנדרשת לעבודה עם מסדי נתונים ומספקת מיפוי אובייקטיבי של אובייקטי Java, מספקת API ( Hibernate במקרה שלנו) לניהול, שמירה ואחזור של ישויות.


• Thymeleaf (שפם, AngularJS, Vaadin ועוד) - מנוע תבנית להדמיית אפליקציות; בזכות ההיכרות היחסית שלי עם עקרונות ה-html, בחרתי ב-Thymeleaf, שדחף את השפה לאבן הפינה של העולם.


• MySQL - מחבר מנהלי התקנים של Java Database Connectivity לביצוע שאילתות SQL מול מסד הנתונים.

לאחר הבחירה הסופית של הרכיבים והיצירה, אנו מקבלים ארכיטקטורת אפליקציות אינטרנט רגילה עם ספריות מוכנות למילוי נוסף. פרגמנטים לאינטראקציה עם החלק הוויזואלי, בין אם זה סגנונות גרפיים של CSS, דפי HTML סטנדרטיים או פונקציונליות JavaScript, צריכים להיות ממוקמים ב"משאבים", ובהתאם לכך, רכיב הקצה האחורי אמור להיות ממוקם ב-"Java". כדאי לשים לב גם לקובץ pom.xml בטווח השורש, המאחסן את מבנה הפרויקט והתלות בין הרכיבים. אם אתה רוצה להרחיב עוד יותר את הפונקציונליות עם חבילות נוספות או להסיר דברים מיותרים, עליך לבצע מניפולציות בין תגיות <dependencies></dependencies>לפי שיטה דומה.

צעדים ראשונים לעתיד גדול

לאחר מכן, עולה שאלה די מעניינת ודי הגיונית: "מה לעשות עכשיו? איך זה יעבוד? התוכנית בנויה על העקרונות של Model-View-Controller: היא מארגנת את קריאת הישויות ממסד הנתונים המחוברים (Model) ומוצגת בממשק המשתמש עם פקדים (View); תקשורת בין רכיבים וביצוע פעולות על פי בקשות מועברות מתבצעת בזכות הבקר. יצירת מרכיבי מפתח היא המשמשת כנקודת התייחסות להמשך הפיתוח. על מנת למנוע מדרון חלקלק ולשמור על כבוד חבריך לתחום העבודה, יש למקם את הרכיבים בספריות המתאימות (למשל, למקם את קובץ ה-Controller בתיקיית הבקרים בסניף "java") ולשמור בקפידה סדר במקום העבודה.

מהות היא חלק קטן במנגנון גדול

או במילים אחרות, המודל שלנו לפי התנאים שנקבעו בבעיה. אם יוצאים מנושא הדיון וחוזרים לפרויקט המבוא, אנו יכולים לקבוע בביטחון שיש הבדלים מינימליים בין המשימות ולהיצמד לקונספט הממוצע בסקירה נוספת. נניח, הערות במחברת, כולל:

• מספר זיהוי לקביעת מיקום בזרימה הכללית;
• הודעת טקסט של מספר מסוים של תווים;
• התאריך שבו המשתמש הוסיף אותו לרשימה הכללית;
• משתנה בוליאני לקביעת "בוצע או לא נעשה" ("קרא או לא קרא").

לכן, בואו ניצור מחלקה Note בספרייה בשם "entity" ונוסיף את השדות המתאימים:

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

סטייה נוספת מנושא הדיון להבנה רבה יותר של המתרחש מתוך עמדה תיאורטית. הקשר בין רכיבים באביב מוגדר על ידי הערות - מצביעים מיוחדים מול אובייקטים, שכל אחד מהם ממלא תפקיד מסוים במנגנון ומתחיל בסמל "@". ההערה @Entity מציינת ל-Spring Boot שנתוני המחלקה הבאים שייכים ל-"Entity", ו-@Id ו-@GeneratedValue מציינים את השדה הנבחר כמזהה עם יצירה אוטומטית של איטרטור בעת עיבוד מערך מידע. אני משמיט בכוונה את הוספת Getter ו-Setter סטנדרטיים כדי להגביר את הקומפקטיות של הפורמט הוויזואלי. לאחר מכן, תוך התחשבות בשימוש במסד נתונים לאחסון רשומות, אנו עוברים לשלב הבא בפיתוח אפליקציות: ניצור את ממשק NoteRepository בספריית "repository", אלמנט מקשר בשרשרת החליפין, ונניח את המירב מאגר מתאים לעבודה נוספת, המציין את הישות המאוחסנת ואת איטרטור המספרים השלמים שיש לגשת אליהם.

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

בעצם, זה הכל. קצר ותמציתי. כעת Spring Boot ישתמש ברכיב שנוצר כדי לארגן אינטראקציות עם מסד הנתונים. ישנם סוגים רבים יחסית של מאגרים מדור קודם עם פוטנציאל פעולה משתנה. JpaRepository נמצא בראש הסולם ויש לו את הפוטנציאל הרב ביותר, כולל CrudRepository ו-PageAndSortingRepository שמתחתיו. לא נרחיק יותר ונסטה מהנושא, כי חלק מהדקויות ניתן למצוא באתר Pivotel בתיעוד הטכני. כעת, לאחר הטמעת תמונת הנתונים וציון שיטות תקשורת בצד האפליקציה, עליך לשים לב ליצירת מסד נתונים MySQL בסביבה החיצונית המתאימה "MySQL Workbench", המותקנת מראש על פלטפורמת שולחן העבודה בהרכבה מהמפתח הרשמי עם חבילות נוספות ליצירת שרת מקומי: לאחר מכן, בעקבות הוראות הסביבה לאחר לחיצה על האייקון עם השרת המקומי הנוכחי בחלון הראשי, אנו יוצרים דיאגרמת טבלה לפי שדות הישות שלנו (הערה) וממלאים אותה בנתונים המתאימים. יש צורך להבהיר בנפרד את הדקויות של ניב MySQL, הדורשים תשומת לב בדחיפות כדי להשיג את התוצאה הרצויה בהצלחה:

• אין סוג בוליאני נפרד ככזה. כל פעולות עיבוד בקשות ימירו "true" או "false" לערך הסיביות "1" או "0", בהתאמה;
• התאריך מאוחסן כולו בסוג חותמת זמן. אם אתה משתמש ב-Date, המוכר עד היסוד, תצטרך להגביל את עצמך רק למיקום בלוח השנה.

לאחר ההשלמה הסופית של שלבי ההכנה, אנו מציינים "MySQL Workbench" כדי לשלוח נתונים לשרת המקומי על ידי לחיצה על סמל ה"ברק" בסרגל הכלים. כעת, אם הוספת המידע הושלמה כהלכה, נוכל לחזור בביטחון ל-IDE המקורי שלנו כדי להמשיך בפיתוח על ידי הוספת תצורת מסד הנתונים הנוכחית ל- application.properties (בדרך כלל ממוקמת בספריית "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

ולבסוף מחייב את הישות Note ל-MySQL באמצעות הערות. @Table מציין את השימוש בטבלה עם השם והסכימה שנבחרו, ו-@Column מציין שהמשתנים שייכים לשדה ספציפי.

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

הצג או ממשק משתמש

למרבה הצער, אנו יכולים לומר בבטחה את הדברים הבאים: "ויזואליזציה של האפליקציה תהפוך לאבן הנגף העיקרית ללא שמץ של ידע תיאורטי או מעשי." למען האמת, הרכיב הקדמי תפס כמות מדהימה מכמות העבודה הכוללת וריסק את העצבים שלי בביטחון לאורך תקופה ארוכה. אבל בזכות הפשטות המדהימה של Thymeleaf, אפשר היה למצוא פשרה מתאימה לאחר סדרה של תבוסות קסומות. דיון נוסף יהיה על המורכבויות של השימוש במנוע הנבחר, אם כי הרעיון הכללי דבק בעמדה דומה. הטכניקה העיקרית היא היכולת להשתמש ב-HTML הטהור ביותר ולהרכיב את התצוגה הסופית מפרגמנטים בודדים כדי למנוע חזרות מרובות של קטעים זהים. נניח שארכיטקטורת ממשק המשתמש מורכבת מעמוד ראשי המורכב מסרגל ניווט עם פקדים (הוספת ערך חדש, חזרה לעמוד הראשי) וטבלה דינמית להצגת ישויות ממוינות לפי זמן הוספת ההערה ברשימה עולה (ASC). או הקטנה (DESC) כיוון.משמעויות. הבה ניקח כמיקום הסטנדרטי את התצוגה של כל הרשומות בסדר עולה. על פי המדיניות ההיררכית של מנוע התבניות שנבחר, רכיבי ההדמיה של הרכיב צריכים להיות ממוקמים בענף "תבניות" בספריית "משאבים". כתוצאה מכך, מניפולציות נוספות עם רכיבים לוקחות בחשבון את התנאים שהוצעו. בואו ניצור עמוד ראשי עם השם "אינדקס" (או כל שם אחר לפי העדפה אישית) בתבנית html5. לדוגמה:

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

וכך, בואו נפרק את מרכיבי המפתח של היישום הסופי. Thymeleaf משתמש בתחביר נפרד כדי לציין את השימוש בפרוצדורות ומתחיל במילת המפתח "th:", הקישור לספרייה שאיתו נכלל בהכרח בתג הפתיחה <html>.

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

פעולת "אם" אינה שונה לחלוטין מהדרך הרגילה לעשות דברים ובודקת את תכונת "הערות" הנכנסות עבור נוכחותם של אובייקטים לתצוגה נוספת. ראוי להזכיר בנפרד את החפיפה של הנושא עם השימוש בבקר, תוך התחשבות בשימוש בו לארגון האינטראקציה של המודל והדמיה. רגעים מעורפלים רבים מתגבשים בעתיד, פשוט חזור אחורה אם תרצה.

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

פעולת "החלפה" מציינת החלפה של "סטב" או בלוק פעיל עם קטע נבחר מהדף הנוכחי או הנפרד - המקרה האחרון נצפה בבירור בדוגמה. אנו מעתיקים את הפרגמנט שנקרא "מחברת" מ-"list.html" של ספריית "פעולות" אל <div></div> של קובץ ה"אינדקס", ומחליף לחלוטין את התוכן ביעד הסופי. ליוצא יש את התוכן הבא:

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

נחזור לסקירה הקונסטרוקטיבית ונעבור על פונקציות Thymeleaf המשמשות לפי הסדר, תוך השמטת תחביר HTML או סגנונות גרפיים סטנדרטיים בשימוש, ונתמקד במיוחד בהבנת מנגנון מנוע התבנית.

<div th:fragment="notebook">

פעולת "fragment" מציינת את שם הפרגמנט ומאפשרת להשתמש בתוכן הבלוק עבור הפקודה "replace". יתר על כך! שימושים מרובים בתוך עמוד בודד אינם נכללים בשום אופן, דבר המביא שוב את האנלוגיה עם נהלים או פונקציות בשפות תכנות.

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

קריאה לביאור @PostMapping משמשת בבקר עם המיפוי "/sort/{sortDate}", כאשר {sortDate} היא תכונת כיוון המיון היוצא. משהו דומה ניתן לראות בבלוק הבא, שמוסיף שינוי דינמי בהתאם למיקום האלמנט שנבחר על ידי המשתמש בלולאת האיטרציה:

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

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

ספירת ערכים דומה מאוד לשימוש המוכר של בלוק for בתחביר Java: המשתנה "note" לוקח את האלמנט הנוכחי ממערך תכונת הקלט ${notes} - מערך של ישויות - ומשמש לשינוי הערכים מאוחר יותר. למען האמת, נוכל להקדיש מאמר נפרד לרשימת המגוון הרחב של יכולות Thymeleaf עם דוגמאות ליישום מעשי - מנוע התבניות פשוט ביותר ואינו דורש למידה כלל מטען מרשים של תחביר נוסף. הפונקציות המתוארות לעיל מתוארות בתיעוד הטכני באתר הרשמי של המפתחים והן בעלות חשיבות מרכזית בארגון התקשורת עם הקצה האחורי. לכן, אתה יכול לעבור בביטחון לחלק הבא והאחרון. כמובן, על ידי צירוף שאר מרכיבי ההדמיה בקישור לאפליקציה המוגמרת בסוף המאמר.

בקר, מנהל בחברה קטנה

"אבן היסוד בארכיטקטורה של אפליקציית אינטרנט" - אולי אין דרך למצוא תיאור מדויק יותר של חשיבות רכיב ה-Controller בארגון עבודת התוכנית: רוב הפעולות מתבצעות בדיוק על ידי האלמנט המקשר בין הדגם והנוף. הודות למכניקת הפעולה של Spring Boot, אתה יכול להשתמש בביטחון בשיטות מיפוי ובקשות GET/POST ללא כל בעיה, ולחבר אוטומטית את מאגר הנתונים. בואו ניצור את המחלקה NoteController בקובץ נפרד בספריית "בקרים", שוב בהתייחסות לשימוש בהערה המתאימה:

@Controller
public class NoteController {

   private NoteService service;

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

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

עין קפדנית עשויה להבחין בשינוי חשוב בעיצוב ארכיטקטורת האפליקציה הקשורה להוספת שירות כדי לבודד את ההיגיון העסקי מעבודה עם שירות ניהול מסדי הנתונים. הפעולות שהושלמו נדרשות כדי להגביר את הרבגוניות של המוצר המוגמר ולספק מרחב רחב לשינוי הפונקציונליות של ממשק המשתמש ללא צורך בשינויים בשיטות התקשורת עם מסד הנתונים. הייצוג הסטנדרטי בשום אופן לא בולט מהמון הדומים: הממשק ממוקם בספריה נפרדת ומיושם על ידי מחלקה עם הערת @Service לזיהוי 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();
   }
}

בואו נחזור לסקור את הבקר ונבחן את המורכבויות של ארגון העבודה בשיטות Spring Boot. ההערה @Autowired מציינת את הצורך לאגד שירות אוטומטית למשתנה מוגדר מהסוג המתאים וליצור חיבור עם מסד הנתונים. יש להקדיש תשומת לב רבה יותר לדרך שבה התצוגה מתקשרת, המצוינת על ידי ההערה @GetMapping ("/"), המחזירה דף בשם "אינדקס" בעת קבלת קריאה ל-localhost:8080. אתה יכול להשתמש בגישה אחרת, לציין את התיאור המורחב @RequestMapping(value = "/", method = RequestMethod.GET) או להחליף את סוג ההחזרה ב-ModelAndView מוכן. עם זאת, על פי מצב הניסיון הנוכחי ביישום מעשי, אני לא שם לב להבדלים מהותיים בתוצאה הסופית ומשתמש באפשרות הרגילה. בואו נרחיב את הבקר על ידי הוספת אלמנטים חדשים באמצעות כרטיסייה נוספת. לאחר שהמשתמש לוחץ על אלמנט בסרגל הניווט, @GetMapping("/new") נקרא ומופנה לדף "חדש" מספריית "פעולות", ומחזיר פרמטר בשם "הודעה" בעת אישור הנתונים שהוזנו באמצעות הכפתור והפניה מחדש לבלוק הראשי. הצורך בהתאמה מלאה של שם המשתנה בחלון הקלט עם שם הערך המועבר דורש אזכור מיוחד.

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

טכניקה דומה משמשת לעדכון רשומה. לאחר לחיצה על הפקד, מיפוי @GetMapping("/edit/{id}") נקרא והמזהה ממחרוזת כתובת האתר מועבר, התכונה "הערה" מתווספת עם ערך לעריכה נוספת. @RequestParam(value = "done", required = false) boolean done) ציון ערך ספציפי ממלא תפקיד מפתח בשימוש בתיבת הסימון בעת ​​שימוש במנוע התבנית Thymeleaf ומוגדר כ"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:/";
}

הסרת פריטים ממסד הנתונים היא פשוטה ביותר ואינה דורשת כל מניפולציה משמעותית על ידי קריאה לפונקציית השירות המתאימה באמצעות הערך שעבר:

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

כעת בואו נעשה התאמות קטנות לפרגמנטים המוגמרים ונעבור לתקשורת מרגשת עם MySQL באמצעות שאילתות שאילתות ב-Spring Data JPA, הוספת בנפרד פונקציה לניהול סינון פשוט לפני סגירת הבקר.

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

כל כך קטן, אבל כל כך חשוב שאילתה.

זה מביך להודות, סינון ערכים, בניגוד לציפיות, התברר כאבן נגף נוספת במילוי המשימה הטכנית, תוך התגברות בביטחון על סף המורכבות שנקבע על ידי עימוד - פירוק מערך הנתונים לדפים נפרדים בגודל מסוים לתצוגה נוספת. סביר להניח שהעייפות המצטברת עשתה את שלה, אבל... ההשראה הגיעה לאחר מפגש מקרי לחלוטין עם שאילתות שאילתות.

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

Spring Data JPA מספקת את היכולת ליצור שאילתות מסד נתונים מפורטות ביותר המבטלות את הצורך למיין מידע ברגע שהוא מתקבל ויש להם מגוון רחב של פוטנציאל יישום. לדוגמה:

List<Note> findAllByOrderByDateAsc();

השיטה תומר לשאילתת SQL ותציג את כל הרשומות (findAll) ממוינות (byOrder) לפי תאריך (byDate) בסדר עולה (Asc). יתר על כן, אתה יכול ליצור שילובים מורכבים ולדגום על פני שדות רבים עם דרישה אחת. נניח, בחר את כל הרשומות (findAll) שהושלמו (byDoneTrue) לפי סדר (לפי הזמנה) בירידה (Decs) לפי ערך התאריך (byDate):

Page<Note> findAllByDoneTrueOrderByDateDesc(Pageable pageable);

מסקנה או וידוי אחר של מתכנת מתחיל

את כל! אתה יכול להפעיל את יישום האינטרנט בבטחה באמצעות השילוב Shift+F10 או על ידי לחיצה על הסמל המתאים. Spring Boot יבנה את התוכנית על Apache Maven ותתקין שרת Apache Tomcat מקומי ב-localhost:8080. עכשיו אתה רק צריך לעקוב אחר הקישור בכל דפדפן. וכמובן, לפתח מתודולוגיה למילוי דרישות עסקיות אחרות. הפוטנציאל של האפליקציה מוגבל על ידי המאמץ, התושייה והדמיון של המפתח. בהיותי כנה ושם לב לדרך שעברתי, אני שוב ושוב משוכנע בנכונות הכיוון הנבחר ומבין את היתרונות של לימוד בפורטל החינוכי JavaRush. הודות למגוון משימות מעשיות, ניתן היה להחזיר את העניין המפתה בלימוד תכנות, שנדחק לחלוטין בתכנית המיושנת והמשעממת להפתיע של מוסד להשכלה גבוהה בכיוון דומה. ארבעה חודשים של לימוד פעיל של חומר בערימת הטכנולוגיה האחורית השקיעו הרבה יותר ידע בהשוואה לשנים שלמות של השתתפות בהרצאות ושיעורי מעבדה. תאמין לזה או לא. אני מאחל לך לא להיכנע לקשיים בכניסה לחומרים מורכבים, כי דרך התגברות על מכשולים אנחנו משתפרים ומתפתחים מקצועית ואישית. אני מקווה שהסיפור הקטן הזה עזר לי לגלות כמה רעיונות חדשים לשימוש בכלי המדהים שנקרא SpringBoot. נ.ב Github .