คำอธิบายโดยละเอียดของไลบรารีแท็กตรรกะ Struts

1.ตรรกะ:ว่างเปล่า
แท็ก logic:empty ใช้เพื่อระบุว่าว่างเปล่าหรือไม่ หากว่างเปล่า เนื้อหาที่ฝังอยู่ในเนื้อหาของแท็กจะได้รับการประมวลผล แท็กนี้ใช้ในสถานการณ์ต่อไปนี้:
เมื่อวัตถุ Java เป็นโมฆะ เมื่อวัตถุ String เป็น "" เมื่อ isEmpty() ในวัตถุ java.util.Collection ส่งกลับค่าจริง เมื่อ isEmpty() ในวัตถุ java.util.Map ส่งกลับค่าจริง ตัวอย่างโค้ดต่อไปนี้แสดงให้เห็นถึงตรรกะ: แท็กว่างเปล่าจะกำหนดว่าบุคคลในคอลเลกชันว่างเปล่าหรือไม่:
<logic:empty name="listForm" property = "บุคคล">
<div>ผู้รวบรวมว่างเปล่า!</div>
</ตรรกะ:ว่างเปล่า>

2.logic:notEmpty
การใช้แท็กนี้ตรงกันข้ามกับตรรกะ:แท็กว่างทุกประการ

3.ตรรกะ:เท่ากัน
แท็กนี้คือตัวดำเนินการเปรียบเทียบที่เท่ากัน
เช่น 1. เปรียบเทียบแอตทริบิวต์สถานะของผู้ใช้เพื่อดูว่าเป็น 1 หรือไม่ หากเป็น 1 เอาต์พุตจะ "เปิดใช้งาน";
เช่น 2 หากได้รับค่าในตัวอย่างข้างต้นแบบไดนามิก จำเป็นต้องส่งออกผ่าน bean:write เนื่องจากสตรัทไม่รองรับการซ้อนป้ายกำกับ จึงสามารถใช้ EL เพื่อแก้ไขปัญหานี้ได้
ตรรกะ:เท่ากัน
สิ่งที่เราต้องการแนะนำที่นี่ไม่ใช่แค่แท็ก logic:equal(=) แต่เป็นแท็กประเภทหนึ่งที่ดำเนินการเปรียบเทียบให้เสร็จสิ้น ซึ่งได้แก่:
ตรรกะ:เท่ากับ(=)
ตรรกะ:ไม่เท่ากับ(!=)
ตรรกะ: เท่าเทียมกันมากขึ้น (>=)
ตรรกะ: น้อยกว่า (<=)
ตรรกะ:graterThan(>)
ตรรกะ:น้อยกว่า(<)
การใช้แท็กประเภทนี้จะคล้ายกัน เราจะแนะนำเฉพาะแท็ก logic:equal เท่านั้น และปล่อยให้ส่วนที่เหลือเป็นหน้าที่ของคุณ
ตรรกะ:เท่ากับ ใช้เพื่อพิจารณาว่าเท่ากันหรือไม่ หากเท่ากัน เนื้อหาที่ฝังอยู่ในเนื้อหาของแท็กจะได้รับการประมวลผล แท็กนี้ใช้ในสถานการณ์ต่อไปนี้:
เปรียบเทียบว่าค่าของคุกกี้ที่ระบุโดยแอตทริบิวต์คุกกี้ของแท็กนี้เท่ากับค่าของแอตทริบิวต์ค่าของแท็กนี้หรือไม่
เปรียบเทียบว่าค่าของส่วนหัวที่ระบุโดยแอตทริบิวต์ส่วนหัวของแท็กจะเท่ากับค่าของแอตทริบิวต์ค่าของแท็กหรือไม่
เปรียบเทียบว่า JSP Bean ที่ระบุโดยแอตทริบิวต์ชื่อของแท็กจะเท่ากับแอตทริบิวต์ค่าของแท็กหรือไม่ (แอตทริบิวต์คุณสมบัติของแท็กไม่ปรากฏ) หรือเปรียบเทียบว่าค่าแอตทริบิวต์คุณสมบัติของ JSP Bean ที่ระบุโดยแอตทริบิวต์ชื่อของแท็กนั้น เท่ากับค่าแอตทริบิวต์ของแท็ก ค่าจะเท่ากัน
เปรียบเทียบว่าค่าพารามิเตอร์ที่ระบุโดยแอตทริบิวต์พารามิเตอร์ของแท็ก (ในคำขอ) เท่ากับค่าแอตทริบิวต์ของแท็กหรือไม่

4. ตรรกะ:ไม่เท่ากัน
ความหมายของแท็กนี้ตรงกันข้ามกับตรรกะ:เท่ากับ และการใช้งานก็คล้ายกัน ซึ่งละเว้นไว้

5. ตรรกะ: ไปข้างหน้า
แท็กนี้ใช้เพื่อใช้คำแนะนำหน้าและค้นหาการส่งต่อไฟล์การกำหนดค่าทั่วโลก การเปลี่ยนเส้นทางโกลบอลในไฟล์ struts-config.xml
เช่น <logic:forward name="redirect"/>

6. ตรรกะ: เท่าเทียมกันมากขึ้น
คือตัวดำเนินการเปรียบเทียบที่มากกว่าหรือเท่ากัน
เช่น เมื่อคะแนนของนักเรียนมากกว่าหรือเท่ากับ 60 เอาต์พุต "ผ่าน":
<logic:greaterEqual name="student" property="scores" value="60">
ผ่าน
</logic:greaterEqual>

7. ตรรกะ:มากกว่า
นี่คือค่ามากกว่าตัวดำเนินการเปรียบเทียบ และการใช้งานจะเหมือนกับตรรกะ:greaterEqual;

8. ตรรกะ:น้อยกว่าเท่ากัน
นี่คือตัวดำเนินการเปรียบเทียบที่น้อยกว่าหรือเท่ากัน และการใช้งานจะเหมือนกับตรรกะ:greaterEqual;

9. ตรรกะ:lessThan
นี่เป็นค่าน้อยกว่าตัวดำเนินการเปรียบเทียบ และการใช้งานเหมือนกับ logic:greaterEqual;

10. ตรรกะ:ตรงกัน
แท็กนี้เปรียบเทียบออบเจ็กต์เพื่อความเท่าเทียมกัน
แท็ก logic:match ใช้เพื่อจัดการปัญหาการจับคู่สตริงย่อย
หากค่าที่ระบุตรงกับแท็ก เนื้อหาของแท็กจะถูกสร้างขึ้น แท็กนี้ใช้ในสถานการณ์ต่อไปนี้:
ตรวจสอบว่าคุกกี้ที่มีชื่อที่ระบุตรงกับค่าของแท็กนี้หรือไม่
ตรวจสอบว่าส่วนหัวที่มีชื่อที่ระบุตรงกับค่าของแท็กนี้หรือไม่
ตรวจสอบว่า JSP Bean ที่มีชื่อที่ระบุตรงกับค่าของแท็ก หรือตรวจสอบว่าค่าแอ็ตทริบิวต์คุณสมบัติใน JSP Bean ที่มีชื่อที่ระบุตรงกับค่าของแท็กหรือไม่
ตรวจสอบว่าค่าพารามิเตอร์ของชื่อที่ระบุในคำขอตรงกับค่าของแท็กหรือไม่
รหัสต่อไปนี้แสดงการใช้งานทั่วไปของแท็ก logic:match:
เช่น0.

เช่น ตรวจสอบว่าแอตทริบิวต์ name ในขอบเขตคำขอมีสตริง "hello" หรือไม่:

เช่น ตรวจสอบว่าแอตทริบิวต์ name ในขอบเขตคำขอมี "hello" เป็นสตริงเริ่มต้นหรือไม่:

เช่น3.

11. ตรรกะ:ไม่ตรงกัน
การใช้แท็ก logic:notMatch นั้นตรงกันข้ามกับแท็ก logic:match ทุกประการ
แท็กนี้ใช้เพื่อเปรียบเทียบว่าวัตถุต่างกันหรือไม่ โดยมีความหมายตรงกันข้ามกับตรรกะ:การจับคู่ และการใช้งานก็คล้ายกัน

12. ตรรกะ:ข้อความปัจจุบัน
แท็กนี้ใช้เพื่อกำหนดว่ามีอ็อบเจ็กต์ ActionMessages/ActionErrors อยู่หรือไม่
แท็ก logic:messagesPresent ใช้ในสถานการณ์ต่อไปนี้:
มีวัตถุ ActionMessages ในขอบเขตคำขอ และแอตทริบิวต์คุณสมบัติของป้ายกำกับสอดคล้องกับคุณสมบัติใน ActionMessages
มีวัตถุ ActionErrors ในขอบเขตคำขอ และแอตทริบิวต์คุณสมบัติของป้ายกำกับสอดคล้องกับคุณสมบัติใน ActionErrors
มีวัตถุ String แปลง (สร้าง) ให้เป็น ActionMessage แล้วเพิ่มลงใน ActionMessages
มีวัตถุ String Array ให้แปลงแต่ละ String ในอาร์เรย์เป็น ActionMessage แล้วเพิ่มลงใน ActionMessages
เมื่อค่าของแอตทริบิวต์ข้อความของแท็กเป็นจริง Globals.MESSAGE_KEY จะถูกใช้เป็นคีย์ในการค้นหาข้อความในขอบเขตคำขอ ในกรณีอื่น ๆ ค่าของชื่อจะถูกใช้เป็นคีย์ในการค้นหา ไม่ปรากฏ ค่าเริ่มต้นคือ Globals.ERROR_KEY
รหัสต่อไปนี้แสดงให้เห็นถึงการใช้งานทั่วไปของแท็ก logic:messagesPresent:
เช่น1.

เช่น2.
หากมีข้อมูลข้อผิดพลาด ให้ส่งออกข้อมูลทั้งหมด:

13. ตรรกะ: ข้อความไม่ปัจจุบัน
การใช้ตรรกะของป้ายกำกับ:messagesNotPresent นั้นตรงกันข้ามกับการใช้ตรรกะ:messagesPresent ทุกประการ
แท็กนี้ใช้เพื่อตรวจสอบว่าไม่มีออบเจ็กต์ ActionMessages/ActionErrors หรือไม่ วิธีการใช้งานคล้ายกับ logic:messagePresent

14. ตรรกะ: ปัจจุบัน
แท็กนี้ใช้เพื่อกำหนดว่ามีพารามิเตอร์ที่ส่งผ่านโดยออบเจ็กต์คำขออยู่หรือไม่
หากค่าที่ระบุปรากฏขึ้น แท็กจะสร้างเนื้อหาในส่วนเนื้อหาของแท็ก แท็กนี้ใช้ในสถานการณ์ต่อไปนี้:
ตรวจสอบว่ามีคุกกี้ตามชื่อที่ระบุอยู่หรือไม่
ตรวจสอบว่าส่วนหัวที่มีชื่อที่ระบุปรากฏขึ้นหรือไม่
ตรวจสอบว่า JSP Bean ที่มีชื่อที่ระบุปรากฏขึ้น หรือตรวจสอบว่าแอ็ตทริบิวต์คุณสมบัติใน JSP Bean ที่มีชื่อที่ระบุปรากฏขึ้นหรือไม่
ตรวจสอบว่าพารามิเตอร์ที่มีชื่อที่ระบุในคำขอปรากฏขึ้นหรือไม่
ตรวจสอบว่าผู้ใช้ที่ได้รับการรับรองความถูกต้องในปัจจุบันเชื่อมโยงกับบทบาทความปลอดภัยที่ระบุหรือไม่
ตรวจสอบว่าหัวเรื่องที่ได้รับการรับรองความถูกต้องในปัจจุบันมีชื่อที่ระบุหรือไม่
เช่น 1. เมื่อทั้งวัตถุผู้ใช้และแอตทริบิวต์ชื่อมีอยู่ในการร้องขอ สตริงที่เกี่ยวข้องจะถูกส่งออก:

เช่น 2 หากมี JavaBean ชื่อ "hello" ให้ส่งออกสตริงที่เกี่ยวข้อง:
<logic:present name="สวัสดี" >
มี JavaBean ชื่อ "สวัสดี"
</ตรรกะ:ปัจจุบัน>
เช่น3.
<logic:present header="user-agent">
เราได้รับส่วนหัวของตัวแทนผู้ใช้
</ตรรกะ:ปัจจุบัน>
เช่น4.
ตัวอย่างโค้ดต่อไปนี้แสดงแท็ก logic:present ตรวจสอบว่ามีส่วนหัวที่มีชื่อ User-Agent ที่ระบุอยู่หรือไม่:
<logic:present header="ผู้ใช้-ตัวแทน">
เบราว์เซอร์ของคุณคือ <bean:header id="userAgent" name="User-Agent"/>
<bean:write name="userAgent"/>. <br/>
</ตรรกะ:ปัจจุบัน>
15. ตรรกะ:ไม่ปัจจุบัน
แท็กนี้ใช้เพื่อกำหนดว่าไม่มีพารามิเตอร์ที่ส่งโดยออบเจ็กต์คำขอ ความหมายตรงกันข้ามกับตรรกะ:ปัจจุบัน และวิธีการใช้งานก็คล้ายกัน
การใช้แท็ก logic:notPresent ตรงกันข้ามกับแท็ก logic:present ทุกประการ
16. ตรรกะ: ตัววนซ้ำ
ใช้เพื่อแสดงค่ารายการเป็นคอลเลกชัน (List, ArrayList, HashMap ฯลฯ)
แท็ก logic:iterate ใช้เพื่อวนซ้ำคอลเลกชัน คุณสามารถใช้วิธีต่อไปนี้เพื่อระบุคอลเลกชันที่จะวนซ้ำสำหรับแท็กนี้:
ใช้นิพจน์รันไทม์ที่มีค่าเป็นชุด
ใช้แอ็ตทริบิวต์ name เพื่ออ้างอิง JSP Bean ซึ่งตัวมันเองเป็นคอลเล็กชัน
ใช้แอ็ตทริบิวต์ name เพื่ออ้างอิงถึง JSP Bean หนึ่งในแอ็ตทริบิวต์ของ JSP Bean นี้คือคอลเล็กชัน ในกรณีนี้ คุณสามารถใช้คุณสมบัติร่วมกันเพื่อระบุคอลเล็กชัน
คอลเลกชันที่กล่าวถึงข้างต้นอาจเป็น:
อาร์เรย์ของประเภทวัตถุหรือประเภทอะตอม
การใช้งาน java.util.Collection รวมถึง ArrayList, Vector
การใช้งาน java.util.Enumeration
การใช้งาน java.util.Iterator
การใช้งาน java.util.Map รวมถึง HashMap, Hashtable และ TreeMap
หากคอลเลกชันที่คุณวนซ้ำมีค่าว่าง คุณจะต้องใช้มาตรการบางอย่าง เนื่องจากตรรกะ:วนซ้ำจะไม่สร้างออบเจ็กต์ในขอบเขตของหน้า โดยทั่วไป ให้ใช้แท็ก <logic:present> หรือแท็ก <logic:notPresent> เพื่อตัดสิน
ต่อไปนี้คือความสัมพันธ์ในการอ้างอิงวัตถุและส่วนหนึ่งของโค้ดสำหรับตัวอย่างของตรรกะ: วนซ้ำ ArrayList:
รูปที่ 3 การอ้างอิงถึงออบเจ็กต์ในตรรกะ: วนซ้ำ รายชื่อบุคคลในไดอะแกรมถูกกรอกลงใน ListAction ในที่นี้ มีการเพิ่มออบเจ็กต์บุคคลสามรายการในแอปพลิเคชันจริง ข้อมูลเหล่านี้ควรนำมาจากฐานข้อมูล รหัสเฉพาะมีดังนี้:

ผลลัพธ์ของเอาต์พุตฉลากคือ:
00001-->จ้าวเฉิน
00002-->หลี่ เว่ยฟาง
00003-->วังเหว่ย
เช่น 1. ส่งออกชื่อของผู้ใช้ในรายการผู้ใช้ (empList) ทีละรายการ:
<logic:iterate id="emp" name="empList">
<bean:write name="emp" property="name"/><br>
</ตรรกะ:วนซ้ำ>
เช่น 2. ส่งออกชื่อของผู้ใช้สองคนโดยเริ่มจาก 1 จากรายชื่อผู้ใช้
<logic:iterate id="emp" name="empList" indexId="index" offset="1" length="2">
<bean:write name="index"/>.<bean:write name="emp" property="name"/><br>
</ตรรกะ:วนซ้ำ>
เช่น 3. ตัวอย่างที่ซ้อนกันของแท็ก logic:iterator
<logic:iterate id="emp" indexId="index" name="empList">
<bean:write name="index"/>. <bean:write name="emp" property="name"/><br>
<logic:iterate id="ที่อยู่" name="emp" property="addressList" length="3" offset="1">
<bean:write name="ที่อยู่"/><br>
</ตรรกะ:วนซ้ำ>
</ตรรกะ:วนซ้ำ>
17. ตรรกะ:เปลี่ยนเส้นทาง
แท็กนี้ใช้เพื่อใช้การเปลี่ยนเส้นทางหน้าและสามารถส่งผ่านพารามิเตอร์ได้
เช่น <logic:redirect href="http://www.javaeye.com"/>
18. การเปรียบเทียบตรรกะ:ไปข้างหน้า และตรรกะ:เปลี่ยนเส้นทาง
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------
การนำทั้งสองการกระทำไปข้างหน้าและการเปลี่ยนเส้นทางร่วมกันจะช่วยให้เข้าใจได้มากขึ้น ด้วยเหตุนี้ จึงมีการใช้แท็กทั้งสองอย่าง logic:forward และ logic:redirect ที่นี่

มาดูความแตกต่างระหว่างการกระทำทั้งสองนี้:
การส่งต่อจะดำเนินการภายในเซิร์ฟเล็ต เบราว์เซอร์จะไม่ทราบถึงการกระทำนี้เลย และ URL ดั้งเดิมจะไม่เปลี่ยนแปลง หากเบราว์เซอร์ถูกโหลดซ้ำ เบราว์เซอร์ก็จะทำซ้ำคำขอเดิม
การเปลี่ยนเส้นทางแบ่งออกเป็นสองขั้นตอน ขั้นตอนแรกคือเว็บแอปพลิเคชันจะบอกเบราว์เซอร์ถึง URL ที่สอง จากนั้นเบราว์เซอร์จะส่งคำขอไปยัง URL ที่สอง
การเปลี่ยนเส้นทางช้ากว่าการส่งต่อเนื่องจากเบราว์เซอร์ต้องส่งคำขอครั้งที่สอง โปรดทราบว่า bean ในขอบเขตคำขอแรก (ขอบเขตคำขอ) จะไม่สามารถมองเห็นได้ในคำขอที่สอง
หลังจากทำความเข้าใจความแตกต่างที่อธิบายไว้ข้างต้นแล้ว คุณจะรู้ว่าเมื่อใดควรใช้แท็ก logic:forward และเมื่อใดควรใช้แท็ก logic:redirect
แท็ก logic:forward ทำให้ PageContext.forward() หรือ HttpServletResponse.sendRedirect() สมบูรณ์ ตัวเลือกจะถูกกำหนดโดยตัวควบคุม แท็กตรรกะ:เปลี่ยนเส้นทางทำให้ HttpServletResponse.sendRedirect() เสร็จสมบูรณ์
เมื่อใช้แท็ก logic:redirect เราสามารถสร้างพารามิเตอร์ baseurl และแบบสอบถามได้เหมือนกับการใช้ html:link หากคุณสนใจ คุณสามารถดูแท็ก html:link ได้