วิธีแก้ปัญหาภาษาจีน jsp (เวอร์ชันเต็ม)

-
เป็นเรื่องปกติมากที่อักขระที่อ่านไม่ออกจะปรากฏขึ้นเมื่อพัฒนาแอปพลิเคชัน Java ท้ายที่สุดแล้ว Unicode ไม่ได้ถูกใช้อย่างแพร่หลายในขณะนี้ ในระบบที่ใช้ gb2312 (รวมถึง gbk แบบง่ายและ big5 แบบดั้งเดิม)

มันเป็นข้อกำหนดพื้นฐานที่สุดในการปรับใช้การแสดงผลภาษาจีนอย่างถูกต้องและ การจัดเก็บฐานข้อมูล

-
1. ขั้นแรก นักพัฒนาจะต้องเข้าใจว่าเหตุใดเขาจึงพบรหัสที่อ่านไม่ออก และเขาพบรหัสที่อ่านไม่ออกประเภทใด (สัญลักษณ์ที่ไม่มีความหมาย ชุดเครื่องหมายคำถาม หรืออย่างอื่น)
มือใหม่มักจะสูญเสียเมื่อพบกับตัวละครยุ่งๆ มากมาย ปฏิกิริยาที่ตรงไปตรงมาที่สุดคือเปิด Google และค้นหา "java Chinese" (สตริงนี้มักถูกค้นหาในเครื่องมือค้นหา)

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

-
2. โดยเฉพาะอย่างยิ่ง ข้อมูลใดที่จำเป็นในการกำหนดแหล่งที่มาของรหัสที่อ่านไม่ออกในโครงการ
ก. ระบบปฏิบัติการที่นักพัฒนาใช้
b ชื่อและเวอร์ชันของคอนเทนเนอร์ j2ee
c, ชื่อฐานข้อมูล, เวอร์ชัน (เวอร์ชันที่แน่นอน) และเวอร์ชันไดรเวอร์ jdbc
d. มีซอร์สโค้ดที่อ่านไม่ออก (เช่น มาจากระบบหรืออยู่ในหน้า jsp หากอยู่ใน jsp การประกาศส่วนหัวก็มีความสำคัญเช่นกัน)

========== === ==============================================
3. วิธีวิเคราะห์สาเหตุของอักขระที่อ่านไม่ออกเบื้องต้น
ด้วยข้อมูลข้างต้น คุณสามารถโพสต์ขอความช่วยเหลือได้ ฉันเชื่อว่าหากคุณใส่ไว้ในฟอรัมเช่น Javaworld ผู้เชี่ยวชาญจะพบวิธีแก้ปัญหาที่มีประสิทธิภาพสำหรับคุณในไม่ช้า
แน่นอนว่าคุณไม่สามารถพึ่งพาการโพสต์เพื่อขอความช่วยเหลือได้เสมอไป แต่คุณควรพยายามแก้ไขปัญหาด้วยตัวเองด้วย จะเริ่มต้นอย่างไร?
ก. วิเคราะห์ว่าการเข้ารหัส "รหัสที่อ่านไม่ออก" ของคุณคืออะไร จริงๆ แล้วนี่ไม่ใช่เรื่องยากเลย เป็นต้น
System.out.println(testString);
มีรหัสที่อ่านไม่ออกในย่อหน้านี้ ดังนั้นคุณอาจใช้วิธีที่ละเอียดถี่ถ้วนเพื่อเดารูปแบบการเข้ารหัสจริงของรหัสนั้น
System.out.println(สตริงใหม่(testString.getBytes(”ISO-8859-1″),”gb2312″));
System.out.println(สตริงใหม่(testString.getBytes(”UTF8″),,”gb2312″));
System.out.println(สตริงใหม่(testString.getBytes(”GB2312″),”gb2312″));
System.out.println(สตริงใหม่(testString.getBytes("GBK"),"gb2312"));
System.out.println(สตริงใหม่(testString.getBytes("BIG5"),"gb2312"));
เดี๋ยว โค้ดด้านบนหมายถึงการใช้รูปแบบการเข้ารหัสที่ระบุเพื่ออ่าน "โค้ดที่อ่านไม่ออก" ของ testString และแปลงเป็น gb2312 (ใช้เฉพาะภาษาจีนเป็นตัวอย่างที่นี่)
จากนั้นคุณจะเห็นว่าผลลัพธ์ที่แปลงแล้วแบบใดก็โอเค - -

ข. หากคุณสามารถอ่านภาษาจีนที่ถูกต้องได้โดยใช้ขั้นตอนข้างต้น แสดงว่าข้อมูลของคุณอยู่ที่นั่นแน่นอน แต่เพียงแสดงไม่ถูกต้องในอินเทอร์เฟซ ขั้นตอนที่สองคือการแก้ไข view part ของคุณ

สิ่งที่มักจะต้องตรวจสอบคือเลือกการเข้ารหัสหน้าที่ถูกต้องใน jsp หรือไม่

ฉันอยากจะชี้ให้เห็นบางสิ่งที่หลายคนเข้าใจผิด นั่นก็คือคำสั่ง <%@ page contentType="text/html; charset=GB2312″ %> และ <META http-equiv=Content-Type

content="text /html; charset= gb2312″>ความแตกต่างระหว่างทั้งสอง โดยปกติแล้วเมื่อบทความจำนวนมากบนอินเทอร์เน็ตกล่าวถึงปัญหาของจีน พวกเขากล่าวว่าการเลือกหน่วยเก็บข้อมูลยูนิโค้ดหรือ gb2312 ในฐานข้อมูลสามารถแก้ไขได้

โดยใช้

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

คือการจัดเตรียมวิธีการเข้ารหัสสำหรับ Java เพื่อ "อ่าน" สตริงในนิพจน์ระหว่างกระบวนการของ JSP ที่ถูกคอมไพล์เป็น HTML (ค่อนข้างคล้ายกับบทบาทของคำสั่งที่สามด้านบน) และบทบาท

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

ซึ่งส่งผลให้ข้อมูลที่เดิมคือ iso-8859 ถูกอ่านเป็น gb2312 โดยคำสั่งเพจ ดังนั้นจึงอ่านไม่ออก ดังนั้นฉันจึงเพิ่มโค้ด ฟังก์ชั่นการแปลงข้อมูลสตริงทั้งหมดเปลี่ยนจาก iso8859 เป็น gb2312 (

ทำไม

================================================== =============
4. การเข้ารหัสใดดีกว่าสำหรับฐานข้อมูล?
ฐานข้อมูลที่ได้รับความนิยมในปัจจุบันส่วนใหญ่ประกอบด้วยเซิร์ฟเวอร์ sql, mysql, oracle, DB2 และอื่น ๆ ในหมู่พวกเขา mysql เป็นผู้นำในฐานข้อมูลฟรี ประสิทธิภาพและฟังก์ชั่นของมันได้รับการยอมรับค่อนข้างสะดวกในการติดตั้งและกำหนดค่าและไดรเวอร์

ที่เกี่ยวข้อง

ใช้ได้ ดังนั้นใช้ mysql เป็นตัวอย่าง

โดยส่วนตัวแล้วฉันแนะนำให้ใช้การเข้ารหัสเริ่มต้นของ mysql สำหรับการจัดเก็บซึ่งก็คือ iso-8859-1 (ตรงกับ latin-1 ในตัวเลือก mysql) มีเหตุผลหลักหลายประการ ประการแรก iso-8859-1 รองรับ

ภาษาจีน

ความเสถียรก็ดีขึ้นเช่นกัน เนื่องจาก

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

ตัวอย่างเช่น ในผลิตภัณฑ์ก่อน mysql 4.0 โซลูชันภาษาจีนจำนวนมากใช้ฟิลด์ characterEncoding ในการเชื่อมต่อเพื่อตั้งค่าการเข้ารหัส เช่น gb2312 หรือบางอย่าง ซึ่งเป็นเรื่องปกติ

เนื่องจากข้อมูลต้นฉบับได้รับการเข้ารหัส ISO8859_1 และไดรเวอร์ jdbc จะใช้ข้อมูลที่ระบุ ใน url ชุดอักขระใช้สำหรับการเข้ารหัส และ resultSet.getString(*) จะนำ

สตริง

ด้วยวิธีนี้ คุณสามารถรับข้อมูลของ gb2312 ได้โดยตรง

อย่างไรก็ตาม การเปิดตัว mysql 4.1 ได้สร้างปัญหาให้กับ dbadmin จำนวนมาก เนื่องจาก mysql 4.1 รองรับชุดอักขระระดับคอลัมน์ แต่ละตารางและคอลัมน์สามารถระบุการเข้ารหัสได้

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

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

ข้อผิดพลาด

ใช้ภายในเท่านั้น
คำถามใด ๆ โปรดอ้างอิงถึง [email protected]
================================================== ==============

ในที่สุดก็พบวิธีแก้ปัญหาของจีนที่สมบูรณ์แบบที่สุด - - ขอขอบคุณผู้เขียนบทความออนไลน์นี้ - -
บทความต้นฉบับของฉันอิงจากประสบการณ์ของตัวเอง แม้ว่าจะไม่มีอะไรผิดปกติ แต่ก็ไม่เคยพบสาเหตุที่แท้จริงของปัญหา อ่านบทความนี้แล้วจู่ๆก็นึกขึ้นได้ว่า 555
—————————————————————————————————————————————— ———— ——————-

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

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

1. แหล่งที่มาของปัญหาภาษาจีน

การเข้ารหัสที่ระบบปฏิบัติการดั้งเดิมรองรับคือการเข้ารหัสอักขระแบบไบต์เดียว ดังนั้น โปรแกรมประมวลผลทั้งหมดในคอมพิวเตอร์จึงเริ่มประมวลผลเป็นภาษาอังกฤษด้วยการเข้ารหัสไบต์เดียว

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

นี่เป็นกรณีของ JDK และ JVM ของ Java JDK ที่ฉันกำลังพูดถึงในที่นี้หมายถึง JDK เวอร์ชันสากล โปรแกรมเมอร์ของเราส่วนใหญ่ใช้ JDK เวอร์ชันสากลต่อไปนี้ อักขระภาษาจีนของเราเป็นภาษาเข้ารหัสแบบไบต์คู่ เพื่อให้คอมพิวเตอร์สามารถประมวลผลภาษาจีนได้ เราได้พัฒนามาตรฐานของเราเอง เช่น gb2312, GBK และ GBK2K เพื่อตอบสนองความต้องการในการประมวลผลด้วยคอมพิวเตอร์

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

เนื่องจากภาษา Java ใช้การเข้ารหัส UNICODE ภายใน เมื่อโปรแกรม Java กำลังทำงาน มีปัญหาในการแปลงอินพุตและเอาต์พุตจากการเข้ารหัส UNICODE และรูปแบบการเข้ารหัสที่เกี่ยวข้องซึ่งระบบปฏิบัติการและเบราว์เซอร์สนับสนุน กระบวนการแปลงนี้มีชุดขั้นตอน หากมีข้อผิดพลาดในขั้นตอนใด ๆ อักขระภาษาจีนที่แสดงจะอ่านไม่ออก นี่คือปัญหาภาษาจีนชวาทั่วไปของเรา

ในเวลาเดียวกัน Java เป็นภาษาโปรแกรมข้ามแพลตฟอร์ม ซึ่งหมายความว่าโปรแกรมที่เราเขียนไม่เพียงแต่สามารถทำงานบน windows ภาษาจีนเท่านั้น แต่ยังทำงานบน Linux ของจีนและระบบอื่น ๆ อีกด้วย นอกจากนี้ยังจำเป็นต้องทำงานบนภาษาอังกฤษและระบบอื่น ๆ ( เรามักจะเห็นมีคนย้ายโปรแกรม Java ที่เขียนบน Windows 2000 ของจีนมาทำงานบน Linux ภาษาอังกฤษ) การผ่าตัดปลูกถ่ายครั้งนี้ยังจะนำมาซึ่งปัญหาของจีนอีกด้วย

นอกจากนี้ บางคนใช้ระบบปฏิบัติการภาษาอังกฤษและเบราว์เซอร์ภาษาอังกฤษ เช่น IE เพื่อรันโปรแกรมที่มีตัวอักษรจีนและเรียกดูหน้าเว็บภาษาจีน พวกเขาไม่รองรับภาษาจีนเองและยังทำให้เกิดปัญหากับภาษาจีนด้วย

เบราว์เซอร์เกือบทั้งหมดส่งผ่านพารามิเตอร์ในรูปแบบการเข้ารหัส UTF-8 เป็นค่าเริ่มต้น แทนที่จะเป็นการเข้ารหัสภาษาจีน ดังนั้น จะเกิดปัญหาเมื่อส่งพารามิเตอร์ภาษาจีนด้วย ส่งผลให้อักขระอ่านไม่ออก

กล่าวโดยสรุป ประเด็นข้างต้นเป็นสาเหตุหลักของปัญหาภาษาจีนใน Java เราเรียกปัญหาที่เกิดจากโปรแกรมทำงานไม่ถูกต้องเนื่องจากสาเหตุข้างต้น: ปัญหาภาษาจีน Java

2. กระบวนการโดยละเอียดของการแปลงการเข้ารหัส Java

โปรแกรม Java ทั่วไปของเราประกอบด้วยหมวดหมู่ต่อไปนี้:

*คลาสที่ทำงานบนคอนโซลโดยตรง (รวมถึงคลาสอินเทอร์เฟซแบบมองเห็น)

*คลาสโค้ด JSP (หมายเหตุ: JSP เป็นตัวแปรของคลาส Servlets)

*Servelets class

* EJB class

* คลาสสนับสนุนอื่นๆ ที่ไม่สามารถรันได้โดยตรง

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

*โปรแกรมเมอร์เลือกซอฟต์แวร์แก้ไขที่เหมาะสมบนระบบปฏิบัติการบางตัวเพื่อใช้ซอร์สโค้ดโปรแกรมและบันทึกลงในระบบปฏิบัติการที่มีนามสกุล .Java . ตัวอย่างเช่น เราใช้ Notepad เพื่อแก้ไขซอร์สโปรแกรม Java ใน Windows 2000 ของจีน

*โปรแกรมเมอร์ใช้ Javac.exe ใน JDK เพื่อคอมไพล์ซอร์สโค้ดเหล่านี้เพื่อสร้างคลาส .class (ไฟล์ JSP ถูกคอมไพล์โดยคอนเทนเนอร์ที่เรียก JDK)

*รันคลาสเหล่านี้โดยตรงหรือปรับใช้คลาสเหล่านี้กับคอนเทนเนอร์เว็บเพื่อรันและส่งออกผลลัพธ์

ดังนั้นในระหว่างกระบวนการเหล่านี้ JDK และ JVM จะเข้ารหัส ถอดรหัส และรันไฟล์เหล่านี้ได้อย่างไร

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

ขั้นตอนแรกคือการใช้ซอฟต์แวร์แก้ไข เช่น Notepad เพื่อเขียนไฟล์โปรแกรมต้นฉบับ Java (รวมถึงโปรแกรม Java ห้าประเภทข้างต้น) ใน Windows ภาษาจีน 2000 เมื่อบันทึกไฟล์โปรแกรม ไฟล์โปรแกรมจะใช้รูปแบบการเข้ารหัส GBK ที่สนับสนุนโดย ระบบปฏิบัติการตามค่าเริ่มต้น (รองรับโดยระบบปฏิบัติการตามค่าเริ่มต้น) รูปแบบคือรูปแบบ file.encoding) ที่สร้างไฟล์ .Java นั่นคือก่อนที่โปรแกรม Java จะถูกคอมไพล์ ไฟล์โปรแกรมต้นฉบับ Java ของเราจะถูกบันทึกใน file.encoding รูปแบบการเข้ารหัสที่ระบบปฏิบัติการรองรับตามค่าเริ่มต้น ในโปรแกรมต้นฉบับ Java ประกอบด้วยอักขระข้อมูลภาษาจีนและรหัสโปรแกรมภาษาอังกฤษ หากต้องการดูพารามิเตอร์ file.encoding ของระบบ คุณสามารถใช้รหัสต่อไปนี้:

คลาสสาธารณะ ShowSystemDefaultEncoding
-
โมฆะสาธารณะคง main (String [] args)
-
การเข้ารหัสสตริง =
System.getProperty("file.encoding");
System.out.println (เข้ารหัส);
-
}

ในขั้นตอนที่สอง เราใช้ไฟล์ Javac.exe ของ JDK เพื่อคอมไพล์โปรแกรมซอร์ส Java ของเรา เนื่องจาก JDK เป็นเวอร์ชันสากล เมื่อทำการคอมไพล์ หากเราไม่ใช้พารามิเตอร์ -encoding เพื่อระบุรูปแบบการเข้ารหัสของซอร์ส Java ของเรา จากนั้น Javac.exe จะได้รับรูปแบบการเข้ารหัสที่ใช้โดยระบบปฏิบัติการของเราเป็นค่าเริ่มต้น นั่นคือเมื่อทำการคอมไพล์โปรแกรม Java หากเราไม่ได้ระบุรูปแบบการเข้ารหัสของไฟล์โปรแกรมต้นฉบับ JDK จะได้รับพารามิเตอร์ file.encoding ก่อน ของระบบปฏิบัติการ (ซึ่งบันทึกรูปแบบการเข้ารหัสเริ่มต้น เช่น Windows2000 ค่าของมันคือ GBK) จากนั้น JDK จะแปลงซอร์สโปรแกรม Java ของเราจากรูปแบบการเข้ารหัส file.encoding เป็นรูปแบบ UNICODE เริ่มต้นภายในของ Java และใส่ไว้ในหน่วยความจำ

จากนั้น Javac จะรวบรวมไฟล์รูปแบบ Unicode ที่แปลงแล้วเป็นไฟล์คลาส .class ในขณะนี้ ไฟล์ .class จะถูกเข้ารหัส UNICODE และจะถูกวางไว้ในหน่วยความจำชั่วคราว จากนั้น JDK จะคอมไพล์คลาสที่คอมไพล์แล้วในการเข้ารหัสไฟล์ ถูกบันทึกลงในระบบปฏิบัติการของเราเพื่อสร้างไฟล์ .class ที่เราเห็น

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

ในขั้นตอนนี้ ไฟล์โปรแกรมต้นฉบับ JSP จะแตกต่างออกไป สำหรับ JSP กระบวนการจะเป็นดังนี้ นั่นคือ คอนเทนเนอร์เว็บจะเรียกคอมไพเลอร์ JSP ก่อนตรวจสอบว่ารูปแบบการเข้ารหัสไฟล์ถูกตั้งค่าไว้ในไฟล์ JSP หรือไม่ ไม่มีรูปแบบการเข้ารหัสไฟล์ในไฟล์ JSP ในการตั้งค่ารูปแบบการเข้ารหัสของไฟล์ JSP คอมไพเลอร์ JSP เรียก JDK เพื่อแปลงไฟล์ JSP เป็นคลาส Servlet ชั่วคราวโดยใช้รูปแบบการเข้ารหัสอักขระเริ่มต้นของ JVM (นั่นคือค่าเริ่มต้น file.encoding ของระบบปฏิบัติการที่มีคอนเทนเนอร์เว็บอยู่) จากนั้นจะถูกคอมไพล์เป็นคลาสรูปแบบ UNICODE และบันทึกในโฟลเดอร์ชั่วคราว

ตัวอย่างเช่น: บน Windows ภาษาจีน 2000 คอนเทนเนอร์ WEB จะแปลงไฟล์ JSP จากรูปแบบการเข้ารหัส GBK ไปเป็นรูปแบบ UNICODE จากนั้นคอมไพล์เป็นคลาส Servlet ที่บันทึกไว้ชั่วคราวเพื่อตอบสนองคำขอของผู้ใช้

ขั้นตอนที่สามคือการรันคลาสที่คอมไพล์ในขั้นตอนที่สอง ซึ่งแบ่งออกเป็นสามสถานการณ์:
A. คลาสที่ทำงานโดยตรงบนคอนโซล

B. คลาส EJB และคลาสสนับสนุนที่ไม่สามารถรันได้โดยตรง (เช่น คลาส JavaBean)

C. โค้ด JSP และคลาส Servlet

D. ระหว่างโปรแกรม Java และฐานข้อมูล

ลองดูที่สี่สถานการณ์ด้านล่างนี้

ตอบ ในกรณีของคลาสที่รันโดยตรงบนคอนโซล

การรันคลาสนี้ก่อนต้องใช้การสนับสนุน JVM นั่นคือ JRE จะต้องได้รับการติดตั้งในระบบปฏิบัติการ กระบวนการรันเป็นดังนี้ ขั้นแรก Java เริ่มต้น JVM ในเวลานี้ JVM อ่านไฟล์คลาสที่บันทึกไว้ในระบบปฏิบัติการและอ่านเนื้อหาลงในหน่วยความจำ ในขณะนี้ หน่วยความจำเป็นคลาสรูปแบบ UNICODE จากนั้น JVM จะรัน หากในเวลานี้หากคลาสนี้จำเป็นต้องรับอินพุตของผู้ใช้ คลาสจะใช้รูปแบบการเข้ารหัส file.encoding ตามค่าเริ่มต้นเพื่อเข้ารหัสอินพุตสตริงโดยผู้ใช้และแปลงเป็น Unicode และบันทึกลงในหน่วยความจำ (ผู้ใช้สามารถกำหนดรูปแบบการเข้ารหัสของสตรีมอินพุตได้)

หลังจากที่โปรแกรมรัน สตริงที่สร้างขึ้น (เข้ารหัส UNICODE) จะถูกส่งกลับไปยัง JVM ในที่สุด JRE จะแปลงสตริงเป็นรูปแบบ file.encoding (ผู้ใช้สามารถตั้งค่ารูปแบบการเข้ารหัสของสตรีมเอาต์พุต) และส่งผ่านไปยังระบบปฏิบัติการ แสดงผลอินเทอร์เฟซและส่งออกไปยังอินเทอร์เฟซ ขั้นตอนการแปลงแต่ละขั้นตอนข้างต้นจำเป็นต้องมีการแปลงรูปแบบการเข้ารหัสที่ถูกต้อง เพื่อไม่ให้อักขระที่อ่านไม่ออกปรากฏขึ้นในตอนท้าย B. คลาส EJB และคลาสสนับสนุนที่ไม่สามารถรันได้โดยตรง (เช่น คลาส JavaBean)

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

C.

หลังจากขั้นตอนที่สองของโค้ด JSP และคลาส Servlet ไฟล์ JSP จะถูกแปลงเป็นไฟล์คลาส Servlets ด้วย แต่ไม่มีอยู่ในไดเร็กทอรีคลาสเหมือนกับ Servlets มาตรฐาน และมีอยู่ในไดเร็กทอรีชั่วคราวของคอนเทนเนอร์ WEB ดังนั้นในขั้นตอนนี้เราจะมองว่าเป็น Servlets ด้วย

สำหรับ Servlet เมื่อไคลเอนต์ร้องขอ WEB คอนเทนเนอร์จะเรียก JVM เพื่อรัน Servlet ขั้นแรก JVM จะอ่านคลาส Servlet จากระบบและโหลดลงในหน่วยความจำ ในหน่วยความจำคือรหัสของคลาส Servlet ที่เข้ารหัส UNICODE จากนั้น JVM จะรันคลาส Servlet ในหน่วยความจำ หาก Servlet ทำงานอยู่ จะต้องยอมรับอักขระจากไคลเอนต์ เช่น ค่าที่ป้อนในแบบฟอร์มและค่าที่ส่งผ่านใน URL นี้ เวลาหากโปรแกรมไม่ได้ตั้งค่าให้ยอมรับ หากใช้รูปแบบการเข้ารหัสเป็นพารามิเตอร์ WEB คอนเทนเนอร์จะใช้รูปแบบการเข้ารหัส ISO-8859-1 เป็นค่าเริ่มต้นเพื่อยอมรับค่าที่เข้ามาและแปลงเป็นรูปแบบ UNICODE ใน JVM และ บันทึกไว้ในหน่วยความจำของคอนเทนเนอร์เว็บ

หลังจากเรียกใช้ Servlet แล้ว จะสร้างเอาต์พุต และสตริงเอาต์พุตอยู่ในรูปแบบ UNICODE จากนั้น คอนเทนเนอร์จะส่งสตริงรูปแบบ UNICODE โดยตรง (เช่น ไวยากรณ์ HTML สตริงเอาต์พุตของผู้ใช้ ฯลฯ) ที่สร้างโดย Servlet ที่รันไปยังไคลเอนต์ เบราเซอร์และส่งออกไปที่หากผู้ใช้ระบุรูปแบบการเข้ารหัสสำหรับเอาต์พุตเมื่อส่งในเวลานี้จะถูกส่งออกไปยังเบราว์เซอร์ในรูปแบบการเข้ารหัสที่ระบุหากไม่ได้ระบุก็จะถูกส่งไปยังเบราว์เซอร์ของลูกค้าในรูปแบบ ISO-8859- 1 การเข้ารหัสโดยค่าเริ่มต้น

D. ระหว่างโปรแกรม Java และฐานข้อมูล

สำหรับไดรเวอร์ JDBC ฐานข้อมูลเกือบทั้งหมด รูปแบบการเข้ารหัสเริ่มต้นสำหรับการถ่ายโอนข้อมูลระหว่างโปรแกรม Java และฐานข้อมูลคือ ISO-8859-1 ดังนั้น โปรแกรมของเราจะส่งข้อมูลไปยังฐานข้อมูล เมื่อจัดเก็บข้อมูลที่มีภาษาจีน โปรแกรม JDBC จะแปลงข้อมูลในรูปแบบการเข้ารหัส UNICODE ภายในโปรแกรมเป็นรูปแบบ ISO-8859-1 ก่อนแล้วจึงส่งต่อไปยังฐานข้อมูล เมื่อฐานข้อมูลบันทึกข้อมูล จะมีค่าเริ่มต้นเป็นการบันทึก ISO-8859-1 นี่คือเหตุผลว่าทำไมข้อมูลภาษาจีนที่เรามักอ่านในฐานข้อมูลจึงอ่านไม่ออก

3. หลักการหลายประการที่ต้องเข้าใจเมื่อวิเคราะห์ปัญหา Java Chinese ทั่วไป

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

ประการที่สอง เราต้องเข้าใจว่ารูปแบบการเข้ารหัสที่ใช้กันทั่วไปต่อไปนี้ที่ Java รองรับในเวลาคอมไพล์คือ:

*ISO-8859-1, 8-บิต เช่นเดียวกับ 8859_1, ISO-8859-1, ISO_8859_1 และการเข้ารหัสอื่น ๆ

*Cp1252, American การเข้ารหัสภาษาอังกฤษ เช่นเดียวกับการเข้ารหัสมาตรฐาน ANSI

* UTF-8 เช่นเดียวกับการเข้ารหัส Unicode

* GB2312 เช่นเดียวกับ gb2312-80, gb2312-1980 และการเข้ารหัสอื่นๆ

* GBK เหมือนกับ MS936 มันเป็นส่วนขยายของ gb2312 และ การเข้ารหัสอื่นๆ เช่น เกาหลี ญี่ปุ่น จีนดั้งเดิม เป็นต้น ในเวลาเดียวกัน เราควรใส่ใจกับความสัมพันธ์ที่เข้ากันได้ระหว่างการเข้ารหัสเหล่านี้ดังนี้

การเข้ารหัส Unicode และ UTF-8 มีการโต้ตอบแบบหนึ่งต่อหนึ่ง GB2312 ถือได้ว่าเป็นชุดย่อยของ GBK นั่นคือการเข้ารหัส GBK จะขยายใน gb2312 ในเวลาเดียวกัน การเข้ารหัส GBK ประกอบด้วยอักขระจีน 2,0902 ตัว และช่วงการเข้ารหัสคือ 0×8140-0xfefe อักขระทั้งหมดสามารถแมปกับ UNICODE2.0 แบบตัวต่อตัวได้

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

ใช้ -encoding เพื่อระบุวิธีการเข้ารหัสของไฟล์ต้นฉบับเป็น GBK หรือ gb2312 ไม่ว่าเราจะคอมไพล์โปรแกรมต้นฉบับ Java ที่มีอักขระภาษาจีนอยู่ในระบบใดก็ตาม ก็จะไม่มีปัญหาในการแปลงภาษาจีนเป็น UNICODE และจัดเก็บไว้ใน ไฟล์คลาส

จากนั้น เราต้องชัดเจนว่ารูปแบบการเข้ารหัสอักขระเริ่มต้นของคอนเทนเนอร์เว็บเกือบทั้งหมดใช้ ISO-8859-1 เป็นค่าเริ่มต้น ในเวลาเดียวกัน เบราว์เซอร์เกือบทั้งหมดใช้ UTF-8 เป็นค่าเริ่มต้นเมื่อส่งผ่านพารามิเตอร์ .

ดังนั้น แม้ว่าซอร์สไฟล์ Java ของเราจะระบุวิธีการเข้ารหัสที่ถูกต้องที่ทางเข้าและออก แต่จะยังคงประมวลผลเป็น ISO-8859-1 เมื่อทำงานภายในคอนเทนเนอร์

4. การจำแนกประเภทของปัญหาภาษาจีนและแนวทางแก้ไขที่เหมาะสมที่สุดที่แนะนำ

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

วิธีแก้ปัญหาเฉพาะมีดังนี้:

1. สำหรับคลาสที่ทำงานบนคอนโซลโดยตรง

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

สำหรับไฟล์: FileReader, FileWrieter

ประเภทสตรีมโหนดที่มุ่งเน้นไบต์คือ: FileInputStream, FileOutputStream

สำหรับหน่วยความจำ (อาร์เรย์ ): CharArrayReader,

CharArrayWriter ประเภทสตรีมของโหนดคือ: ByteArrayInputStream, ByteArrayOutputStream

หน่วย

ความ

จำ (สตริง): StringReader,

StringWriter

ควรใช้สตรีมการประมวลผลเชิง:

BufferedWriter, BufferedReader,

สตรีมการประมวลผลประเภทไบต์คือ: BufferedInputeStream, BufferedOutputStream

InputStreamReader, OutputStreamWriter,

สตรี

มการประมวลผลประเภทไบต์คือ: DataInputStream, DataOutputStream

สตรีมไบต์ตามชุดการเข้ารหัสอักขระที่ระบุ เช่น:

InputStreamReader in = new InputStreamReader(System.in, "GB2312"); OutputStreamWriter out = new OutputStreamWriter (System.out, "GB2312"); ตัวอย่าง: ตัวอย่างการเข้ารหัส Java ต่อไปนี้สามารถตอบสนองความต้องการ:

//Read.Java
นำเข้า Java.io.*;
ชั้นเรียนสาธารณะอ่าน
-
โมฆะสาธารณะคง main (String [] args)
พ่นIOException
-
สตริง str =
"nการทดสอบภาษาจีน นี่คือสตริงฮาร์ดโค้ดภายใน "+"nทดสอบอักขระภาษาอังกฤษ";
สตริง สตริง = "";
BufferedReader stdin =
ใหม่ BufferedReader (new
InputStreamReader(System.in,”gb2312″));
//ตั้งค่าอินเทอร์เฟซอินพุตให้เข้ารหัสเป็นภาษาจีน
BufferedWriter stdout =
ใหม่ BufferedWriter (new
OutputStreamWriter(System.out,”gb2312″));
//ตั้งค่าอินเทอร์เฟซเอาต์พุตให้เข้ารหัสเป็นภาษาจีน
stdout.write("กรุณาระบุ:");
stdout.flush();
strin = stdin.readLine();
stdout.write("นี่คืออินพุตสตริงจากผู้ใช้:"+strin);
stdout.write(str);
stdout.flush();
}}

ในเวลาเดียวกัน เมื่อคอมไพล์โปรแกรม เราใช้วิธีต่อไปนี้:

Javac -encoding gb2312 Read.Java

2 สำหรับคลาส EJB และคลาสสนับสนุนที่ไม่สามารถรันได้โดยตรง (เช่น คลาส JavaBean)

เนื่องจากคลาสเหล่านี้เอง ถูกใช้โดยคลาสอื่น การเรียกไม่ได้โต้ตอบกับผู้ใช้โดยตรง ดังนั้น สำหรับประเภทนี้ วิธีการประมวลผลที่เราแนะนำคือโปรแกรมภายในควรใช้สตรีมอักขระเพื่อประมวลผลสตริงภาษาจีนภายในโปรแกรม (โดยเฉพาะตามหัวข้อด้านบน) และในเวลาเดียวกันในเมื่อคอมไพล์คลาส ให้ใช้พารามิเตอร์ -encoding gb2312 เพื่อระบุว่าไฟล์ต้นฉบับถูกเข้ารหัสในรูปแบบภาษาจีน

3. สำหรับคลาส Servlet

เราขอแนะนำวิธีการต่อไปนี้:

เมื่อรวบรวมโปรแกรมต้นฉบับของคลาส Servlet ให้ใช้ -encoding เพื่อระบุการเข้ารหัสเป็น GBK หรือ GB2312 และใช้ setContentType("text" ของอ็อบเจ็กต์การตอบสนองในการเข้ารหัส ส่วนเมื่อส่งออกไปยังผู้ใช้ /html;charset=GBK”); หรือ gb2312 เพื่อตั้งค่ารูปแบบการเข้ารหัสเอาต์พุต เช่นเดียวกันเมื่อรับอินพุตจากผู้ใช้ เราใช้ request.setCharacterEncoding(”GB2312″); คลาสเซิร์ฟเล็ตของเราถูกย้ายไปยังไคลเอนต์เท่านั้น หากเบราว์เซอร์ของคุณรองรับการแสดงผลภาษาจีน จะแสดงอย่างถูกต้อง นี่คือตัวอย่างที่ถูกต้อง:

//HelloWorld.Java
แพ็คเกจสวัสดี;
นำเข้า Java.io.*;
นำเข้า Javax.servlet.*;
นำเข้า Javax.servlet.http.*;
HelloWorld คลาสสาธารณะ
ขยาย HttpServlet
-
โมฆะสาธารณะ init()
พ่น ServletException
-
-
โมฆะสาธารณะ doGet
(คำขอ HttpServletRequest
การตอบสนอง HttpServletResponse)
พ่น IOException, ServletException
-
request.setCharacterEncoding("GB2312");
//กำหนดรูปแบบการเข้ารหัสอินพุต
response.setContentType
("ข้อความ/html;charset=GB2312");
//กำหนดรูปแบบการเข้ารหัสเอาต์พุต
PrintWriter ออก = response.getWriter();
// ขอแนะนำให้ใช้เอาต์พุต PrintWriter
out.println(”<ชม>”);
out.println("สวัสดีชาวโลก!
สิ่งนี้สร้างโดย Servlet!Test Chinese!");
out.println(”<ชม>”);
-
โมฆะสาธารณะ doPost (คำขอ HttpServletRequest,
การตอบสนอง HttpServletResponse)
พ่น IOException, ServletException
-
request.setCharacterEncoding("GB2312");
//กำหนดรูปแบบการเข้ารหัสอินพุต
response.setContentType
("ข้อความ/html;charset=GB2312");
//กำหนดรูปแบบการเข้ารหัสเอาต์พุต
ชื่อสตริง = request.getParameter("name");
String id = request.getParameter("id");
ถ้า(ชื่อ==null) ชื่อ = "";
ถ้า(id==null) id="";
PrintWriter ออก = response.getWriter();
// ขอแนะนำให้ใช้เอาต์พุต PrintWriter
out.println(”<ชม>”);
out.println("สตริงภาษาจีนที่คุณส่งคือ: " + name);
out.println("<hr>รหัสที่คุณป้อนคือ: " + id);
out.println(”<ชม>”);
-
โมฆะสาธารณะทำลาย ()
-
-
-

กรุณาใช้ Javac -encoding gb2312 HelloWorld.Java เพื่อคอมไพล์โปรแกรมนี้

โปรแกรมที่จะทดสอบ Servlet นี้มีดังนี้:

< %@page contentType="text/html;
ชุดอักขระ=gb2312″%>
<%request.setCharacterEncoding("GB2312");%>
<html><head><title></title>
<ภาษาสคริปต์ = "จาวาสคริปต์">
ฟังก์ชั่นส่ง ()
-
//ส่งค่าสตริงภาษาจีนไปยัง Servlet ผ่าน URL
document.base.action =
"./HelloWorld?name=中文";
document.base.method = “โพสต์”;
document.base.submit();
-
</สคริปต์>
</head>

<body bgcolor=”#FFFFFF”
ข้อความ=”#000000″ ขอบด้านบน=”5″>
<ชื่อแบบฟอร์ม = "ฐาน" วิธีการ =
“โพสต์” เป้าหมาย =”_self”>
<ชื่ออินพุต = "id" ประเภท = "ข้อความ"
ค่า=”” ขนาด=”30″>
<a href = “JavaScript:ส่ง()">
ส่งต่อไปยังเซิร์ฟเล็ต</a>
</รูปแบบ></ร่างกาย></html>

4.

เพื่อหลีกเลี่ยงข้อมูลที่อ่านไม่ออกในการถ่ายโอนข้อมูลระหว่างโปรแกรม Java และฐานข้อมูล เราขอแนะนำวิธีการที่เหมาะสมที่สุดต่อไปนี้ในการจัดการ:

1. โปรแกรม Java ควรได้รับการประมวลผลตามวิธีการที่เราระบุ

2. เปลี่ยนรูปแบบการเข้ารหัสที่ฐานข้อมูลรองรับตามค่าเริ่มต้นเป็น GBK หรือ GB2312

ตัวอย่างเช่น: ใน mysql เราสามารถเพิ่มคำสั่งต่อไปนี้ลงในไฟล์การกำหนดค่า my.ini เพื่อให้บรรลุสิ่งนี้:

default-Character-set=gbk

ในพื้นที่ [mysqld]

และเพิ่ม:

[client]
default-Character-set=gbk

ใน SQL Server2K เราสามารถตั้งค่าภาษาเริ่มต้นของฐานข้อมูลเป็นภาษาจีนตัวย่อเพื่อให้บรรลุวัตถุประสงค์

5. สำหรับโค้ด JSP

เนื่องจาก JSP ได้รับการคอมไพล์แบบไดนามิกโดยคอนเทนเนอร์เว็บในขณะรันไทม์ หากเราไม่ได้ระบุรูปแบบการเข้ารหัสของไฟล์ต้นฉบับ JSP คอมไพเลอร์ JSP จะได้รับค่า file.encoding ของระบบปฏิบัติการเซิร์ฟเวอร์เพื่อคอมไพล์ ใช่ มักจะทำให้เกิดปัญหาเมื่อทำการย้าย ตัวอย่างเช่น ไฟล์ jsp ที่สามารถทำงานได้ดีใน Windows 2000 ของจีนจะไม่ทำงานใน English Linux แม้ว่าไคลเอนต์จะเหมือนกันก็ตาม JSP เมื่อทำการคอมไพล์ เกิดจากการเข้ารหัสระบบปฏิบัติการที่แตกต่างกัน (file.encoding ในภาษาจีนจะแตกต่างจาก file.encoding ใน English Linux และ file.encoding ใน English Linux ไม่รองรับภาษาจีน ดังนั้น จะเกิดปัญหากับ คลาส JSP ที่คอมไพล์แล้ว)

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

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

< %@page contentType =” ข้อความ/html;
charset=gb2312″%>

2. เพื่อให้ JSP รับพารามิเตอร์ขาเข้าได้อย่างถูกต้อง เราจะเพิ่มประโยคต่อไปนี้ในส่วนหัวของไฟล์ต้นฉบับ JSP:

<%request.setCharacterEncoding(”GB2312″);
%>

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

หัว

ไฟล์ JSP

หรือ < %@page pageencoding = "gbk" %>

นี่คือคำสั่งที่เพิ่มขึ้นใหม่ในสเปค JSP 2.0

ใน

ไฟล์ JSP

< %@page pageencoding =” GB2312″ %>
< %@page contentType = "ข้อความ/html;
charset = gb2312″%>
<%request.Setcharacterencoding ("GB2312");
-
-
String action = request.getParameter ("การกระทำ");
ชื่อสตริง = "";
string str = "";
if (action! = null && action.equals ("ส่ง"))))
-
name = request.getParameter ("ชื่อ");
str = request.getParameter ("str");
-
-
<html>
<หัว>
<title></title>
<ภาษาสคริปต์ = "JavaScript">
ฟังก์ชั่นส่ง ()
-
document.base.action =
"? action = ส่ง & str = ภาษาจีนเข้ามา";
document.base.method =“ โพสต์”;
document.base.submit ();
-
</สคริปต์>
</หัว>
<body bgcolor =”#ffffff”
text =”#000000″ topmargin =” 5″>
<form name = "base" method =
“ โพสต์” target =” _ ตัวเอง”>
<input type =” text” name =” ชื่อ”
value =”” size =” 30″>
<a href =“ JavaScript: ส่ง ()”> ส่ง </a>
</แบบฟอร์ม>
-
if (action! = null && action.equals ("ส่ง"))))
-
out.println ("<br> อักขระที่คุณป้อนคือ:"+ชื่อ);
out.println ("<br> ตัวละครที่คุณผ่านผ่าน URL คือ:"+str);
-
-
</ร่างกาย>
</html>