מדריך למיפוי עם דוזר

1. סקירה כללית

דוזר הוא א Java Bean ל- Java Bean Map שמעתיק רקורסיבית נתונים מאובייקט אחד לאחר, תכונה אחר תכונה.

הספרייה לא רק תומכת במיפוי בין שמות תכונות של Java Beans, אלא גם ממיר אוטומטית בין סוגים - אם הם שונים.

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

2. דוגמה פשוטה

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

זהו המיפוי הבסיסי ביותר שאפשר לעשות עם Dozer:

מחלקה ציבורית מקור {שם מחרוזת פרטי; גיל פרטי פרטי; מקור ציבורי () {} מקור ציבורי (שם מחרוזת, גיל גיל) {this.name = שם; this.age = גיל; } // גטרים וקובעים סטנדרטיים}

ואז קובץ היעד שלנו, Dest.java:

מחלקה ציבורית Dest {שם פרטי מחרוזת; גיל פרטי פרטי; public Dest () {} public Dest (שם מחרוזת, int גיל) {this.name = שם; this.age = גיל; } // גטרים וקובעים סטנדרטיים}

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

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

ממפה DozerBeanMapper; @ לפני שמבוטל ברבים לפני () זורק חריג {mapper = DozerBeanMapper חדש (); }

עכשיו, בואו נבצע את הבדיקה הראשונה שלנו כדי לאשר זאת כשאנחנו יוצרים a מָקוֹר אנו יכולים למפות אותו ישירות אל יעד לְהִתְנַגֵד:

@Test ציבורי בטל givenSourceObjectAndDestClass_whenMapsSameNameFieldsCorrectly_ thenCorrect () {מקור מקור = מקור חדש ("Baeldung", 10); Dest dest = mapper.map (מקור, Dest.class); assertEquals (dest.getName (), "Baeldung"); assertEquals (dest.getAge (), 10); }

כפי שאנו רואים, לאחר מיפוי הדוזר, התוצאה תהיה מופע חדש של ה- יעד אובייקט המכיל ערכים לכל השדות שיש להם שם שדה זהה לזה מָקוֹר לְהִתְנַגֵד.

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

@Test ציבורי בטל givenSourceObjectAndDestObject_whenMapsSameNameFieldsCorrectly_ thenCorrect () {מקור מקור = מקור חדש ("Baeldung", 10); Dest dest = חדש Dest (); mapper.map (מקור, יעד); assertEquals (dest.getName (), "Baeldung"); assertEquals (dest.getAge (), 10); }

3. הגדרת Maven

עכשיו שיש לנו הבנה בסיסית של אופן הפעולה של Dozer, בואו נוסיף את התלות הבאה ל- pom.xml:

 net.sf.dozer dozer 5.5.1 

הגרסה האחרונה זמינה כאן.

4. דוגמה להמרת נתונים

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

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

בואו נראה את הרעיון החדש הזה בפעולה:

מחלקה ציבורית מקור 2 {מזהה מחרוזת פרטי; נקודות כפולות פרטיות; Source2 ציבורית () {} Source2 ציבורית (מזהה מחרוזת, נקודות כפולות) {this.id = id; this.points = נקודות; } // גטרים וקובעים סטנדרטיים}

ומחלקת היעד:

מחלקה ציבורית Dest2 {מזהה פרטי פרטי; נקודות אינטימיות פרטיות; ציבורי Dest2 () {} ציבורי Dest2 (מזהה int, int נקודות) {super (); this.id = id; this.points = נקודות; } // גטרים וקובעים סטנדרטיים}

שימו לב ששמות התכונות זהים אבל סוגי הנתונים שלהם שונים.

בכיתת המקור, תְעוּדַת זֶהוּת הוא חוּט ו נקודות הוא לְהַכפִּילואילו במחלקת היעד, תְעוּדַת זֶהוּת ו נקודות שניהם מספר שלםס.

בואו נראה כעת כיצד Dozer מטפל נכון בהמרה:

@Test ציבורי בטל givenSourceAndDestWithDifferentFieldTypes_ whenMapsAndAutoConverts_thenCorrect () {Source2 source = new Source2 ("320", 15.2); Dest2 dest = mapper.map (מקור, Dest2.class); assertEquals (dest.getId (), 320); assertEquals (dest.getPoints (), 15); }

אנחנו עברנו “320” ו 15.2, א חוּט ו לְהַכפִּיל לאובייקט המקור והתוצאה הייתה 320 ו 15, שניהם מספר שלםs באובייקט היעד.

5. מיפוי מותאם אישית בסיסי באמצעות XML

בכל הדוגמאות הקודמות שראינו, גם לאובייקטים של נתוני המקור וגם ליעד יש אותם שמות שדות, מה שמאפשר מיפוי קל מצדנו.

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

כדי לפתור זאת, Dozer נותן לנו אפשרות ליצור תצורת מיפוי מותאמת אישית ב- XML.

בקובץ XML זה, אנו יכולים להגדיר ערכי מיפוי מחלקות שבהם ישתמש מנוע מיפוי הדוזר כדי להחליט באיזו תכונת מקור למפות לאיזה תכונת יעד.

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

יש לנו אדם התנגד עם שֵׁם, כינוי ו גיל שדות:

אדם בכיתה ציבורית {פרטי שם מחרוזת; כינוי מחרוזת פרטי; גיל פרטי פרטי; אדם ציבורי () {} אדם ציבורי (שם מחרוזת, כינוי מחרוזת, גיל גיל) {סופר (); this.name = שם; this.nickname = כינוי; this.age = גיל; } // גטרים וקובעים סטנדרטיים}

נקרא לאובייקט שאנחנו לא מאחסנים פרסונה ויש לו שדות nom, דרומי ו גיל:

מעמד ציבורי אישי {פרטי מחרוזת מחרוזת; פרטי מחרוזת מחרוזת; גיל פרטי פרטי; Personne public () {} Personne public (Nom String, String surnom, int age) {super (); this.nom = nom; this.surnom = surnom; this.age = גיל; } // גטרים וקובעים סטנדרטיים}

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

עלינו ליצור רק קובץ מיפוי מותאם אישית שיעזור לדוזר לעשות זאת, אנו נקרא לזה dozer_mapping.xml:

   com.baeldung.dozer. פרסון com.baeldung.dozer שֵׁם   דרומי כינוי

זו הדוגמה הפשוטה ביותר לקובץ מיפוי XML מותאם אישית שיכול להיות לנו.

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

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

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

אין צורך לציין מאפיינים בעלי אותו שם בקובץ ה- XML ​​למיפוי. Dozer ממפה אוטומטית את כל השדות עם אותו שם מאפיין מאובייקט המקור לאובייקט היעד.

לאחר מכן נניח את קובץ ה- XML ​​המותאם אישית שלנו בכיתה ישירות מתחת ל- src תיקיה. עם זאת, בכל מקום שנציב אותו על מסלול הכיתה, Dozer יחפש את מסלול הכיתה כולו בכדי לחפש את הקובץ שצוין.

בואו ניצור שיטת עוזר להוספת קבצי מיפוי ל- ממפה:

חלל ציבורי configureMapper (String ... mappingFileUrls) {mapper.setMappingFiles (Arrays.asList (mappingFileUrls)); }

בואו נבדוק את הקוד:

@Test ציבורי בטל givenSrcAndDestWithDifferentFieldNamesWithCustomMapper_ whenMaps_thenCorrect () {configureMapper ("dozer_mapping.xml"); Personne frenchAppPerson = Personne חדש ("סילבסטר סטאלון", "רמבו", 70); אדם אנגליתAppPerson = mapper.map (frenchAppPerson, Person.class); assertEquals (englishAppPerson.getName (), frenchAppPerson.getNom ()); assertEquals (englishAppPerson.getNickname (), frenchAppPerson.getSurnom ()); assertEquals (englishAppPerson.getAge (), frenchAppPerson.getAge ()); }

כפי שמוצג במבחן, DozerBeanMapper מקבל רשימה של קבצי מיפוי XML מותאמים אישית ומחליט מתי להשתמש בכל אחד בזמן הריצה.

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

@Test ציבורי בטל givenSrcAndDestWithDifferentFieldNamesWithCustomMapper_ whenMapsBidirectionally_thenCorrect () {configureMapper ("dozer_mapping.xml"); אדם אנגלית AppPerson = אדם חדש ("דוויין ג'ונסון", "הרוק", 44); Personne frenchAppPerson = mapper.map (אנגליתAppPerson, Personne.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), אנגלית AppPerson.getAge ()); }

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

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

בסביבת Windows (כגון הבדיקה למטה), נשתמש כמובן בתחביר הקבצים הספציפי ל- Windows.

בתיבה של לינוקס, אנו עשויים לאחסן את הקובץ תחת /בית ואז:

configureMapper ("file: /home/dozer_mapping.xml");

וב- Mac OS:

configureMapper ("file: /Users/me/dozer_mapping.xml");

אם אתה מריץ את בדיקות היחידה מפרויקט github (מה שאתה צריך), תוכל להעתיק את קובץ המיפוי למיקום המתאים ולשנות את הקלט עבור configureMapper שיטה.

קובץ המיפוי זמין בתיקיית הבדיקה / משאבים של פרויקט GitHub:

@ מבחן חלל ציבורי givenMappingFileOutsideClasspath_whenMaps_thenCorrect () {configureMapper ("file: E: \ dozer_mapping.xml"); אדם אנגליתAppPerson = אדם חדש ("מרשל ברוס מת'רס השלישי", "אמינם", 43); Personne frenchAppPerson = mapper.map (אנגליתAppPerson, Personne.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), אנגלית AppPerson.getAge ()); }

6. תווים כלליים והתאמה אישית נוספת של XML

בואו ליצור קובץ מיפוי מותאם אישית שני שנקרא dozer_mapping2.xml:

   com.baeldung.dozer. פרסון com.baeldung.dozer שֵׁם   דרומי כינוי

שימו לב שהוספנו תכונה תו כללי אל ה אלמנט שלא היה שם קודם.

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

כשאנחנו מגדירים את זה ל שֶׁקֶר, אנו אומרים לדוזר למפות שדות בלבד שציינו במפורש ב- XML.

אז בתצורה שלעיל, אנו רוצים רק למפות שני שדות שנשארים בחוץ גיל:

@Test ציבורי בטל givenSrcAndDest_whenMapsOnlySpecifiedFields_thenCorrect () {configureMapper ("dozer_mapping2.xml"); אדם אנגליתAppPerson = אדם חדש ("שון קורי קרטר", "ג'יי זי", 46); Personne frenchAppPerson = mapper.map (אנגליתAppPerson, Personne.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), 0); }

כפי שאנו יכולים לראות בקביעה האחרונה, היעד גיל שדה נשאר 0.

7. מיפוי מותאם אישית באמצעות ביאורים

למקרי מיפוי פשוטים ולמקרים בהם יש לנו גם גישת כתיבה לאובייקטים הנתונים שברצוננו למפות, ייתכן שלא נצטרך להשתמש במיפוי XML.

מיפוי שדות בעלי שם שונה באמצעות הערות הוא פשוט מאוד ועלינו לכתוב הרבה פחות קוד מאשר במיפוי XML אך יכול לעזור לנו רק במקרים פשוטים.

בואו נשכפל את אובייקטים הנתונים שלנו לתוך אדם 2. ג'אווה ו Personne2.java בלי לשנות את השדות בכלל.

כדי ליישם זאת, עלינו להוסיף רק @מיפוי ("destinationFieldName") ביאור על גטר שיטות באובייקט המקור. ככה:

@Mapping ("שם") מחרוזת ציבורית getNom () {nom return; } @Mapping ("כינוי") ציבורי מחרוזת getSurnom () {return surnom; }

הפעם אנחנו מטפלים Personne2 כמקור, אבל זה לא משנה בגלל טבע דו-כיווני של מנוע הדוזר.

עכשיו עם כל הקוד שקשור ל- XML ​​מוסר, קוד הבדיקה שלנו קצר יותר:

@Test הציבור בטל givenAnnotatedSrcFields_whenMapsToRightDestField_thenCorrect () {Person2 englishAppPerson = Person2 חדש ("ז'אן קלוד ואן דאם", "JCVD", 55); Personne2 frenchAppPerson = mapper.map (אנגליתAppPerson, Personne2.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), אנגלית AppPerson.getAge ()); }

אנו יכולים גם לבדוק דו כיווניות:

@Test public void givenAnnotatedSrcFields_whenMapsToRightDestFieldBidirectionally_ thenCorrect () {Personne2 frenchAppPerson = Personne2 new ("Jason Statham", "transporter", 49); Person2 englishAppPerson = mapper.map (frenchAppPerson, Person2.class); assertEquals (englishAppPerson.getName (), frenchAppPerson.getNom ()); assertEquals (englishAppPerson.getNickname (), frenchAppPerson.getSurnom ()); assertEquals (englishAppPerson.getAge (), frenchAppPerson.getAge ()); }

8. מיפוי API מותאם אישית

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

חלופה נוספת הקיימת ב- Dozer, בדומה למיפוי ביאורים, היא מיפוי API. הם דומים מכיוון שאנו מבטלים את תצורת ה- XML ​​ומשתמשים בקוד Java בקפידה.

במקרה זה, אנו משתמשים BeanMappingBuilder המוגדר במקרה הפשוט ביותר שלנו כך:

BeanMappingBuilder בונה = חדש BeanMappingBuilder () {@Override מוגן ריק להגדיר () {מיפוי (Person.class, Personne.class) .fields ("שם", "nom") .fields ("כינוי", "surnom"); }};

כפי שאנו רואים, יש לנו שיטה מופשטת, הגדר (), שעלינו לעקוף כדי להגדיר את התצורות שלנו. ואז, בדיוק כמו שלנו תגיות ב- XML, אנו מגדירים כמה שיותר TypeMappingBuilderכפי שאנו דורשים.

בונים אלה מספרים לדוזר איזה מקור לשדות היעד אנו ממפים. לאחר מכן אנו עוברים את BeanMappingBuilder ל DozerBeanMapper כפי שהיינו עושים, קובץ מיפוי ה- XML, רק עם ממשק API אחר:

@Test הציבור בטל givenApiMapper_whenMaps_thenCorrect () {mapper.addMapping (בונה); Personne frenchAppPerson = Personne חדש ("סילבסטר סטאלון", "רמבו", 70); אדם אנגליתAppPerson = mapper.map (frenchAppPerson, Person.class); assertEquals (englishAppPerson.getName (), frenchAppPerson.getNom ()); assertEquals (englishAppPerson.getNickname (), frenchAppPerson.getSurnom ()); assertEquals (englishAppPerson.getAge (), frenchAppPerson.getAge ()); }

ממשק ה- API למיפוי הוא גם דו כיווני:

@Test הציבור בטל givenApiMapper_whenMapsBidirectionally_thenCorrect () {mapper.addMapping (בונה); אדם אנגלית AppPerson = אדם חדש ("סילבסטר סטאלון", "רמבו", 70); Personne frenchAppPerson = mapper.map (אנגליתAppPerson, Personne.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), אנגלית AppPerson.getAge ()); }

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

BeanMappingBuilder builderMinusAge = חדש BeanMappingBuilder () {@Override מוגן ריק () מיפוי (Person.class, Personne.class). שדות ("שם", "nom"). שדות ("כינוי", "Surnom"). כלול ("גיל"); }};

ושלנו גיל == 0 המבחן חזר:

@Test הציבור בטל givenApiMapper_whenMapsOnlySpecifiedFields_thenCorrect () {mapper.addMapping (builderMinusAge); אדם אנגלית AppPerson = אדם חדש ("סילבסטר סטאלון", "רמבו", 70); Personne frenchAppPerson = mapper.map (אנגליתAppPerson, Personne.class); assertEquals (frenchAppPerson.getNom (), אנגלית AppPerson.getName ()); assertEquals (frenchAppPerson.getSurnom (), אנגלית AppPerson.getNickname ()); assertEquals (frenchAppPerson.getAge (), 0); }

9. ממירים בהתאמה אישית

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

בדקנו תרחישים בהם שמות שדות המקור והיעד שונים כמו בצרפתית פרסונה לְהִתְנַגֵד. סעיף זה פותר בעיה אחרת.

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

1182882159000

אך אובייקט הנתונים המקביל שלנו מייצג את אותו שדה ותאריך ושעה וערך בפורמט ISO זה כמו a חוּט:

2007-06-26T21: 22: 39Z

ממיר ברירת המחדל פשוט ימפה את הערך הארוך ל- a חוּט ככה:

"1182882159000"

זה בהחלט יפגע באפליקציה שלנו. אז איך נפתור את זה? אנחנו פותרים את זה על ידי הוספת חסימת תצורה בקובץ ה- XML ​​למיפוי ו- ציון הממיר שלנו.

ראשית, בוא נשכפל את היישומים המרוחקים אדם DTO עם א שֵׁם, ואז תאריך ושעת הלידה, dtob שדה:

מחלקה ציבורית Personne3 {שם מחרוזת פרטי; dtob פרטי פרטי; Personne3 ציבורי (שם מחרוזת, dtob ארוך) {super (); this.name = שם; this.dtob = dtob; } // גטרים וקובעים סטנדרטיים}

והנה משלנו:

מחלקה ציבורית אדם 3 {פרטי מחרוזת; פרטי מחרוזת dtob; אדם ציבורי 3 (שם מחרוזת, מחרוזת dtob) {סופר (); this.name = שם; this.dtob = dtob; } // גטרים וקובעים סטנדרטיים}

שימו לב להבדל בסוג של dtob ב- DTOs המקור והיעד.

בואו גם ניצור משלנו CustomConverter להעביר לדוזר ב- XML ​​המיפוי:

class class MyCustomConvertor מיישם CustomConverter {@Override Object Object convert (Object dest, Object Object, Class arg2, Class arg3) {if (source == null) return null; אם (מקור המקרה של Personne3) {Personne3 person = (Personne3) מקור; תאריך תאריך = תאריך חדש (person.getDtob ()); פורמט DateFormat = SimpleDateFormat חדש ("yyyy-MM-dd'T'HH: mm: ss'Z '"); מחרוזת isoDate = format.format (תאריך); להחזיר Person3 חדש (person.getName (), isoDate); } אחר אם (מקור המקור של אדם 3) מקור {אדם 3 = מקור (אדם 3); פורמט DateFormat = SimpleDateFormat חדש ("yyyy-MM-dd'T'HH: mm: ss'Z '"); תאריך תאריך = format.parse (person.getDtob ()); חותמת זמן ארוכה = date.getTime (); להחזיר Personne3 חדש (person.getName (), חותמת זמן); }}}

עלינו רק לעקוף להמיר() ואז להחזיר את כל מה שאנחנו רוצים להחזיר אליו. אנו זוכים לאובייקטים של מקור ויעד וסוגי הכיתות שלהם.

שימו לב כיצד דאגנו לדו-כיווניות על ידי ההנחה שהמקור יכול להיות אחד משני השיעורים שאנו ממפים.

ניצור קובץ מיפוי חדש לשם הבהרה, dozer_custom_convertor.xml:

     com.baeldung.dozer.Personne3 com.baeldung.dozer.Person3 

זהו קובץ המיפוי הרגיל שראינו בחלקים הקודמים, הוספנו רק a לחסום שבתוכו אנו יכולים להגדיר כמה ממירים מותאמים אישית ככל שנדרש עם מחלקות נתוני המקור והיעד שלהם.

בואו לבדוק את החדש שלנו CustomConverter קוד:

@Test הציבור בטל givenSrcAndDestWithDifferentFieldTypes_whenAbleToCustomConvert_ thenCorrect () {configureMapper ("dozer_custom_convertor.xml"); מחרוזת תאריך זמן = "2006-06-26T21: 22: 39Z"; חותמת זמן ארוכה = חדשה ארוכה ("1182882159000"); אדם 3 = אדם 3 חדש ("עשיר", תאריך זמן); Personne3 person0 = mapper.map (אדם, Personne3.class); assertEquals (חותמת זמן, person0.getDtob ()); }

אנחנו יכולים גם לבדוק כדי להבטיח שהוא דו כיווני:

@Test הציבור בטל givenSrcAndDestWithDifferentFieldTypes_ whenAbleToCustomConvertBidirectionally_thenCorrect () {configureMapper ("dozer_custom_convertor.xml"); מחרוזת תאריך זמן = "2006-06-26T21: 22: 39Z"; חותמת זמן ארוכה = New Long ("1182882159000"); אדם Person3 = Personne3 חדש ("עשיר", חותמת זמן); Person3 person0 = mapper.map (person, Person3.class); assertEquals (dateTime, person0.getDtob ()); }

10. מסקנה

במדריך זה, יש לנו הציג את רוב היסודות של ספריית מיפוי הדוזר וכיצד להשתמש בו ביישומים שלנו.

היישום המלא של כל הדוגמאות וקטעי הקוד ניתן למצוא בפרויקט github של Dozer.


$config[zx-auto] not found$config[zx-overlay] not found