คำอธิบายโดยละเอียดเกี่ยวกับหลายวิธีในการฉีดถั่วในฤดูใบไม้ผลิ

ก่อนอื่นเพื่อเรียนรู้วิธีการฉีดถั่วในฤดูใบไม้ผลิคุณต้องเข้าใจก่อนว่าการฉีดพึ่งพาคืออะไร การฉีดพึ่งพาหมายถึง: ให้คลาสการโทรฉีดการพึ่งพาของคลาสการใช้งานของคลาสการใช้งานของอินเทอร์เฟซบางอย่างโดยบุคคลที่สามจึงกำจัดการพึ่งพาของคลาสการโทรในคลาสการใช้งานของอินเทอร์เฟซที่แน่นอน

วิธีการฉีดขึ้นอยู่กับการพึ่งพาในภาชนะสปริงส่วนใหญ่รวมถึงการฉีดสมบัติการฉีดคอนสตรัคเตอร์และการฉีดวิธีการจากโรงงาน ต่อไปเราจะแนะนำวิธีการฉีดพึ่งพาทั้งสามนี้และวิธีการกำหนดค่าเฉพาะของพวกเขาในรายละเอียด

1. การฉีดแอตทริบิวต์

การฉีดแอตทริบิวต์หมายถึงการฉีดค่าแอตทริบิวต์หรือวัตถุขึ้นอยู่กับของถั่วผ่านวิธี setxxx () เนื่องจากวิธีการฉีดแอตทริบิวต์นั้นเลือกและยืดหยุ่นจึงเป็นวิธีการฉีดที่ใช้กันมากที่สุดในการพัฒนาจริง

สปริงจะเรียกตัวสร้างเริ่มต้นของถั่วก่อนเพื่อสร้างอินสแตนซ์วัตถุถั่วจากนั้นเรียกใช้วิธีการที่กำหนดผ่านวิธีที่สะท้อนเพื่อฉีดค่าคุณสมบัติ

การฉีดสมบัติต้องการถั่วเพื่อให้ตัวสร้างเริ่มต้นและต้องจัดเตรียมวิธีการที่กำหนดไว้สำหรับคุณสมบัติที่ต้องฉีด

เคล็ดลับ: ตัวสร้างเริ่มต้นที่เรียกว่านั่นคือตัวสร้างที่ไม่มีพารามิเตอร์ หากไม่มีตัวสร้างที่กำหนดเองในชั้นเรียนระบบ (JVM) จะสร้างตัวสร้างเริ่มต้นโดยอัตโนมัติโดยไม่มีพารามิเตอร์ หากตัวสร้างที่มีพารามิเตอร์ได้รับการปรับแต่งอย่างชัดเจนในชั้นเรียนระบบจะไม่สร้างตัวสร้างเริ่มต้นโดยอัตโนมัติและคุณต้องเพิ่มตัวสร้างด้วยตนเองโดยไม่มีพารามิเตอร์

ต่อไปนี้เป็นตัวอย่างในการแสดงวิธีการฉีดสมบัติของถั่วในฤดูใบไม้ผลิ:

เขียนคลาสผู้ใช้:

 แพ็คเกจ com.kevin.bean;/** * สร้างวิธีการฉีดสมบัติการทดสอบคลาสถั่ว * @author Kevin * */ผู้ใช้คลาสสาธารณะ {ชื่อผู้ใช้สตริงส่วนตัว; สตริงสาธารณะ getUserName () {ส่งคืนชื่อผู้ใช้; } โมฆะสาธารณะ setUserName (ชื่อผู้ใช้สตริง) {this.userName = ชื่อผู้ใช้; -

ไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-คำจำกัดความของถั่ว-> <! </property> </ebeans>

ในหมู่พวกเขาค่าคุณสมบัติแต่ละค่าสอดคล้องกับแท็กคุณสมบัติและค่าคุณสมบัติชื่อคือชื่อของคุณสมบัติในคลาส ในคลาสการใช้งานถั่วมีวิธีการใช้งานที่สอดคล้องกัน setUserName ()

เคล็ดลับ: ฤดูใบไม้ผลิจะตรวจสอบว่าถั่วมีวิธีการตั้งค่าและไม่ได้ทำข้อกำหนดเฉพาะว่ามีตัวแปรแอตทริบิวต์ที่สอดคล้องกันหรือไม่ อย่างไรก็ตามตามกฎทั่วไปเราควรตั้งค่าตัวแปรแอตทริบิวต์ที่เกี่ยวข้องสำหรับมัน

ข้อมูลจำเพาะการตั้งชื่อสำหรับ <property> แท็กในฤดูใบไม้ผลิ:

1. ชื่อคุณสมบัติที่ระบุโดยแท็ก <property> ของสปริงและวิธีการตั้งค่าของคลาสการใช้งานถั่วตรงตามข้อกำหนดการตั้งชื่อคุณสมบัติของ Sun Javabean นั่นคือวิธีการของแอตทริบิวต์ของ XXX ที่สอดคล้องกับ setxxx ()

โดยทั่วไปแล้วชื่อตัวแปรแอตทริบิวต์ Java เริ่มต้นด้วยตัวอักษรตัวพิมพ์เล็ก แต่เมื่อพิจารณาถึงตัวย่อภาษาอังกฤษที่มีความหมายพิเศษถั่วชวายังอนุญาตให้ชื่อตัวแปรเริ่มต้นด้วยตัวอักษรตัวพิมพ์ใหญ่ แต่จะต้องพบสองจุดต่อไปนี้:

1. ตัวอักษรสองตัวแรกของตัวแปรเป็นตัวพิมพ์ใหญ่ทั้งหมดหรือตัวพิมพ์เล็กทั้งหมด
2. อย่างไรก็ตามตามนิสัยการเขียนโปรแกรมทั่วไปควรใช้ตัวอักษรตัวพิมพ์เล็กทั้งหมดเพื่อการเขียนโปรแกรมและการอ่านที่ง่าย

สำหรับวิธีการฉีดแอตทริบิวต์การค้ำประกันสามารถให้ได้ในไฟล์การกำหนดค่าเทียม แต่ไม่สามารถรับประกันได้ในระดับไวยากรณ์ ในเวลานี้คุณต้องใช้การฉีดคอนสตรัคเตอร์เพื่อตอบสนองความต้องการที่ดีขึ้น

2. การฉีดคอนสตรัคเตอร์

การฉีดคอนสตรัคเตอร์เป็นอีกวิธีการฉีดที่ใช้กันทั่วไปนอกเหนือจากการฉีดแอตทริบิวต์ สามารถมั่นใจได้ว่ามีการตั้งค่าคุณสมบัติที่จำเป็นบางอย่างเมื่อถั่วมีการสร้างอินสแตนซ์และสามารถใช้งานได้หลังจากการสร้างอินสแตนซ์

ข้อกำหนดเบื้องต้นสำหรับการใช้การฉีดคอนสตรัคเตอร์คือถั่วจะต้องจัดให้มีข้อโต้แย้ง

สำหรับการฉีดคอนสตรัคเตอร์ไฟล์การกำหนดค่าสามารถใช้ในวิธีต่อไปนี้:

1. การจับคู่พารามิเตอร์ตามประเภท
2. การจับคู่พารามิเตอร์โดยดัชนี
3. การใช้พารามิเตอร์การจับคู่ประเภทและดัชนีรวมกัน
4. จับคู่พารามิเตอร์ผ่านการสะท้อนประเภทตนเอง

【วิธีการจับคู่พารามิเตอร์โดยประเภท】

เขียนรหัสถั่ว:

 แพ็คเกจ com.kevin.bean;/** * เขียนการทดสอบถั่วเพื่อจับคู่พารามิเตอร์ตามประเภท * @author kevin * */บุคคลระดับสาธารณะ {ชื่อสตริงส่วนตัว; อายุจำนวนเต็มส่วนตัว สตริงสาธารณะ getName () {ชื่อคืน; } โมฆะสาธารณะ setName (ชื่อสตริง) {this.name = name; } Public Integer Getage () {return Age; } การตั้งค่าโมฆะสาธารณะ (อายุจำนวนเต็ม) {this.age = อายุ; -

เขียนไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! <value> kevin </alue> </scrovtor-Arg> <constructor-Arg type = "Integer"> <value> 20 </value> </constructor-Arg>

ไฟล์การกำหนดค่าของสปริงใช้กลยุทธ์การกำหนดค่าที่เป็นอิสระจากลำดับของฉลากองค์ประกอบดังนั้นความมั่นใจของข้อมูลการกำหนดค่าสามารถรับประกันได้ในระดับหนึ่ง

จากนั้นเมื่อพารามิเตอร์หลายประเภทของตัวสร้างในถั่วเหมือนกันมันเป็นเรื่องง่ายที่จะทำให้เกิดความสับสนโดยพารามิเตอร์การจับคู่ตามประเภท ในเวลานี้จำเป็นต้องใช้วิธีอื่น: การจับคู่พารามิเตอร์ตามดัชนี

【พารามิเตอร์จับคู่ตามดัชนี】

เขียนรหัสถั่ว:

 แพ็คเกจ com.kevin.bean;/** * เขียนการทดสอบถั่วและพารามิเตอร์ในวิธีการดัชนี * @author kevin * */นักเรียนชั้นเรียนสาธารณะ {ชื่อสตริงส่วนตัว; เพศสตริงส่วนตัว คะแนนสองเท่าส่วนตัว; นักเรียนสาธารณะ (ชื่อสตริง, เพศสตริง, คะแนนสองเท่า) {super (); this.name = ชื่อ; this.gender = เพศ; this.score = คะแนน; -

ไฟล์กำหนดค่าถูกเขียนดังนี้:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-คำจำกัดความของถั่ว-> <! value = "kevin"> </constructor-Arg> <constructor-Arg index = "1" value = "male"> </constructor-Arg> <constructor-Arg index = "2" value = "66">

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

【พารามิเตอร์ประเภทการใช้งานแบบรวมและดัชนีการจับคู่】】

ในไฟล์การกำหนดค่าที่ซับซ้อนบางประเภทและดัชนีจะต้องใช้พร้อมกันเพื่อให้การฉีดพารามิเตอร์ของตัวสร้างเสร็จสมบูรณ์ นี่คือตัวอย่างที่จะสาธิต

เขียนถั่ว:

 แพ็คเกจ com.kevin.bean;/** * เขียนการทดสอบถั่วเพื่อใช้พารามิเตอร์ประเภทและดัชนีการจับคู่ * @author kevin * */ครูชั้นเรียนสาธารณะ {ชื่อสตริงส่วนตัว; ที่อยู่สตริงส่วนตัว เงินเดือนสองเท่าส่วนตัว อายุ int ส่วนตัว; ครูสาธารณะ (ชื่อสตริง, ที่อยู่สตริง, เงินเดือนสองเท่า) {super (); this.name = ชื่อ; this.address = ที่อยู่; this.salary = เงินเดือน; } ครูสาธารณะ (ชื่อสตริงที่อยู่สตริงอายุ int) {super (); this.name = ชื่อ; this.address = ที่อยู่; this.age = อายุ; -

ในชั้นเรียนนี้มีตัวสร้างเกินพิกัดสองตัวและพวกเขาทั้งหมดมีพารามิเตอร์สามตัว ในกรณีนี้การใช้วิธีการประเภทและดัชนีไม่สามารถทำตามข้อกำหนดได้ ในเวลานี้คุณสมบัติทั้งสองของพวกเขาจะต้องใช้ในเวลาเดียวกัน

ไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-คำจำกัดความของถั่ว-> <! <value> kevin </alue> </castructor-Arg> <constructor-Arg index = "1" type = "string"> <value> จีน </value> </constructor-Arg> <constructor-Arg index = "2" type = "int">

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

เคล็ดลับ: เพิ่มไปยังไฟล์การกำหนดค่าของเรามีปัญหาความกำกวม คอนเทนเนอร์สปริงสามารถเริ่มต้นได้ตามปกติและจะไม่รายงานข้อผิดพลาด มันจะใช้ตัวสร้างการจับคู่แบบสุ่มเพื่อยกตัวอย่างถั่ว ผู้ใช้อาจไม่ต้องการตัวสร้างแบบสุ่มที่เลือกดังนั้นเราควรระมัดระวังในการหลีกเลี่ยงความกำกวมนี้เมื่อการเขียนโปรแกรม

【พารามิเตอร์จับคู่ผ่านการสะท้อนประเภทของตัวเอง】

หากชนิดของพารามิเตอร์ตัวสร้างถั่วมองไม่เห็นเนื่องจากกลไกการสะท้อน Java สามารถรับประเภทของพารามิเตอร์ตัวสร้างแม้ว่าการฉีดของตัวสร้างไม่ได้ให้ข้อมูลประเภทและดัชนีสปริงยังคงสามารถฉีดข้อมูลตัวสร้างได้ ตัวอย่างเช่นในตัวอย่างต่อไปนี้ประเภทพารามิเตอร์ของตัวสร้างของคลาสผู้จัดการสามารถแยกแยะได้

เขียนคลาสผู้จัดการ:

 แพ็คเกจ com.kevin.bean;/** * เขียนการทดสอบถั่วเพื่อจับคู่อาร์กิวเมนต์ผ่านการสะท้อนประเภทของตัวเอง * @author kevin * */ผู้จัดการชั้นเรียนสาธารณะ {ชื่อสตริงส่วนตัว; เงินเดือนสองเท่าส่วนตัว บุคคลส่วนตัว ผู้จัดการสาธารณะ (ชื่อสตริง, เงินเดือนคู่, บุคคลบุคคล) {super (); this.name = ชื่อ; this.salary = เงินเดือน; this.person = บุคคล; -

เขียนไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <! </constructor-arg> <cantructor-Arg> <ref bean = "ผู้ใช้"/> </constructor-Arg> <constructor-Arg> <ref bean = "บุคคล"/> </constructor-Arg>

วิธีการข้างต้นสามารถใช้การฉีดพารามิเตอร์ตัวสร้าง แต่เพื่อหลีกเลี่ยงการเกิดปัญหาขอแนะนำให้ใช้ดัชนีที่ชัดเจนและพิมพ์เพื่อกำหนดค่าข้อมูลการป้อนพารามิเตอร์ของตัวสร้าง

3. การฉีดวิธีการจากโรงงาน

วิธีการจากโรงงานเป็นรูปแบบการออกแบบที่มักใช้ในแอปพลิเคชันและยังเป็นวิธีหลักในการใช้แนวคิดของการผกผันควบคุมและการออกแบบอินสแตนซ์เดี่ยว คลาสโรงงานมีหน้าที่สร้างอินสแตนซ์คลาสโรงงานอย่างน้อยหนึ่งรายการ วิธีการคลาสโรงงานโดยทั่วไปจะส่งคืนอินสแตนซ์คลาสเป้าหมายในรูปแบบของอินเตอร์เฟสหรือตัวแปรคลาสนามธรรม

คลาสโรงงานบล็อกขั้นตอนการสร้างอินสแตนซ์ของคลาสเป้าหมายภายนอกและผู้โทรไม่จำเป็นต้องระบุว่าคลาสเป้าหมายเฉพาะคืออะไร เนื่องจากคอนเทนเนอร์ฤดูใบไม้ผลิให้ฟังก์ชั่นของวิธีการโรงงานในวิธีการทำงานและเปิดให้นักพัฒนาซอฟต์แวร์อย่างโปร่งใส ดังนั้นจึงไม่จำเป็นต้องเขียนวิธีการทางวิศวกรรมด้วยตนเอง อย่างไรก็ตามวิธีการทางวิศวกรรมจะยังคงพบได้ในระบบดั้งเดิมหรือห้องสมุดบุคคลที่สาม ในเวลานี้วิธีการฉีดสปริงจากโรงงานสามารถใช้ในการฉีดสปริง

วิธีการฉีดสปริงจากโรงงานสามารถแบ่งออกเป็นแบบคงที่และไม่คงที่

【วิธีโรงงานที่ไม่คงที่】

วิธีการของโรงงานบางวิธีไม่คงที่และจะต้องมีการสร้างอินสแตนซ์ก่อนที่จะเรียกใช้วิธีการจากโรงงาน ต่อไปนี้เป็นตัวอย่างที่จะแสดง

เขียนคลาสโรงงาน:

 แพ็คเกจ com.kevin.factoryBean;/** * เขียนการทดสอบชั้นเรียนจากโรงงานวิธีการฉีดยาที่ไม่คงที่ * @author Kevin * */ชั้นเรียนสาธารณะ BookFactory {หนังสือสาธารณะหนังสือสาธารณะ () {หนังสือหนังสือ = หนังสือเล่มใหม่ (); Book.setName ("Think in Java"); หนังสือคืน; -

การเขียนไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-คำจำกัดความของถั่ว-> <! Factory-bean = "BookFactory" โรงงาน-วิธี = "Buybook"> </ebean> </epeans>

เนื่องจากวิธีการโรงงานของ BookFactory นั้นไม่คงที่คุณต้องกำหนดถั่วของชั้นเรียนจากโรงงานก่อนจากนั้นอ้างถึงอินสแตนซ์ของโรงงานผ่านทรัพย์สินจากโรงงาน จากนั้นวิธีการใช้โรงงานที่สอดคล้องกันจะใช้เพื่อระบุวิธีโรงงานที่เกี่ยวข้อง

【วิธีโรงงานคงที่】

วิธีการคลาสจากโรงงานจำนวนมากเป็นแบบคงที่ซึ่งหมายความว่าวิธีการคลาสจากโรงงานสามารถเรียกได้โดยไม่ต้องสร้างอินสแตนซ์คลาสจากโรงงาน ดังนั้นวิธีการทางวิศวกรรมแบบคงที่จึงสะดวกและกระชับกว่าวิธีการที่ไม่คงที่จากโรงงาน ต่อไปนี้เป็นตัวอย่างในการแสดงวิธีการคงที่จากโรงงาน

เขียนคลาสโรงงาน:

 แพ็คเกจ com.kevin.factoryBean;/** * เขียนการทดสอบคลาสโรงงานวิธีการฉีดยาแบบคงที่ * @author kevin * */คลาสสาธารณะ carfactory {รถสาธารณะคงที่ createCar () {Car Car = ใหม่ Car (); car.setbrand ("Lamborghini"); รถกลับ; -

เขียนไฟล์กำหนดค่า:

 <? xml version = "1.0" การเข้ารหัส = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://ww.w3.org/2001/xml xmlns: context = "http://www.springframework.org/schema/context" XSI: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-คำจำกัดความของถั่ว-> <!

สรุป

ฤดูใบไม้ผลิมีวิธีการฉีดแบบเสริมสามวิธี แต่ในการใช้งานจริงไม่มีมาตรฐานแบบครบวงจรสำหรับวิธีการฉีดที่เราควรเลือก นี่คือเหตุผลบางประการที่อ้างถึง:

เหตุผลในการฉีดคอนสตรัคเตอร์:

1. ตัวสร้างทำให้มั่นใจได้ว่าคุณลักษณะที่สำคัญนั้นตั้งไว้ล่วงหน้า
2. ไม่จำเป็นต้องให้วิธีการตั้งค่าสำหรับแต่ละแอตทริบิวต์และลดจำนวนวิธีการของคลาส
3. มันสามารถห่อหุ้มตัวแปรคลาสและหลีกเลี่ยงการเรียกเกิดข้อผิดพลาดภายนอกได้ดีขึ้น

คุณสมบัติการฉีดเหตุผล:

1. เมื่อมีคุณลักษณะมากเกินไปตัวสร้างจะป่อง;
2. การฉีดคอนสตรัคเตอร์นั้นไม่ยืดหยุ่นมากและบางครั้งก็จำเป็นต้องฉีดค่าว่างลงในแอตทริบิวต์
3. เมื่อมีการใช้ตัวสร้างหลายตัวการกำหนดค่าจะมีความคลุมเครือและความซับซ้อนจะเพิ่มขึ้น
4. ตัวสร้างไม่เอื้อต่อการสืบทอดและการขยายของชั้นเรียน
5. การฉีดคอนสตรัคเตอร์ทำให้เกิดการพึ่งพาเป็นวงกลม

ในความเป็นจริงฤดูใบไม้ผลิให้เรามีวิธีการมากมายสำหรับการฉีดพารามิเตอร์ดังนั้นวิธีการเหล่านี้จะต้องมีเหตุผลของตนเอง แต่ละวิธีมีข้อได้เปรียบที่ไม่ซ้ำกันในบางประเด็น เราจำเป็นต้องเลือกวิธีการที่เหมาะสมตามความต้องการการใช้งานเฉพาะของเรา แต่ไม่แนะนำให้ใช้วิธีการจากโรงงานโดยทั่วไป

ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้ ฉันหวังว่ามันจะเป็นประโยชน์ต่อการเรียนรู้ของทุกคนและฉันหวังว่าทุกคนจะสนับสนุน wulin.com มากขึ้น