Rocker เป็น Java 8+ ที่ได้รับการปรับให้เหมาะสมใกล้กับการเรนเดอร์เป็นศูนย์เครื่องยนต์เทมเพลตที่รวดเร็วซึ่งสร้างเทมเพลตวัตถุจาวาธรรมดาที่พิมพ์แบบคงที่ซึ่งรวบรวมพร้อมกับส่วนที่เหลือของโครงการของคุณ ไม่มีเวลา "วอร์มอัพ" ในการผลิตอีกต่อไปตรรกะการสะท้อนช้าหรือความประหลาดใจที่น่ารังเกียจที่ควรได้รับในระหว่างการพัฒนา
เขียนเทมเพลตของคุณโดยใช้ไวยากรณ์ที่ใช้งานง่ายและ ไม่มีแท็ก พร้อมนิพจน์ Java มาตรฐานสำหรับตรรกะการทำซ้ำและค่า ใช้ Rocker เป็นพิเศษ ? ตัวดำเนินการ Presence สำหรับการประเมินผลที่ปลอดภัยเป็นโมฆะ การยกหนักทั้งหมดทำโดยตัวแยกวิเคราะห์โยกในระหว่างการพัฒนา - ซึ่งช่วยให้การพึ่งพารันไทม์ลงไปเพียงไม่กี่ชั้นเรียน Rocker จะแยกวิเคราะห์เทมเพลตของคุณและสร้างไฟล์ต้นฉบับ Java ที่มีการบันทึกไว้อย่างดี (เพื่อให้คุณสามารถตรวจสอบและเข้าใจวิธีการทำงานได้อย่างง่ายดาย)
รวมคุณสมบัติต่อไปนี้:
? ตัวดำเนินการสถานะขยายไวยากรณ์สำหรับการจัดการค่า NULL ที่ง่ายขึ้นโครงการโดย Fizzed, Inc. (ติดตามบน Twitter: @fizzed_inc)
การพัฒนาและบำรุงรักษาโครงการ OpenSource ต้องใช้เวลาอย่างมาก หากคุณพบว่าโครงการนี้มีประโยชน์หรือต้องการการสนับสนุนเชิงพาณิชย์เราชอบที่จะแชท ส่งอีเมลถึงเราที่ [email protected]
ผู้สนับสนุนโครงการอาจรวมถึงประโยชน์ดังต่อไปนี้:
ขึ้นอยู่กับเกณฑ์มาตรฐานเทมเพลตต่อไปนี้ Rocker เป็นผู้ชนะที่ชัดเจน ~ 250% เร็วกว่า freemarker ในขณะที่ยังต้องการคำสั่งของหน่วยความจำน้อยกว่า
เทมเพลตส่วนใหญ่ใช้สำหรับเว็บไซต์ดังนั้นนี่คือตัวอย่างที่รวดเร็วซึ่งแสดงให้เห็นว่าเทมเพลตโยกทำงานอย่างไรและสามารถโทรหากันระหว่างกระบวนการเรนเดอร์ สร้างเทมเพลตที่มีส่วนหัวและส่วนท้ายทั่วไปรวมถึงตัวยึดสำหรับเนื้อหาของร่างกาย สร้างเทมเพลต src/main/java/views/main.rocker.html
@args (String title, RockerBody content)
< html >
< head >
< title > @title </ title >
</ head >
< body >
@content
</ body >
</ html > เทมเพลตที่เราวางแผนจะแสดงให้ผู้ใช้จะแสดงเนื้อหาภายในบริบทของส่วนท้ายของส่วนประกอบ/ส่วนหัว ในเงื่อนไข Java มันผ่านบล็อกของรหัสการเรนเดอร์ที่จะดำเนินการภายในเทมเพลตอื่น สร้างเทมเพลต src/main/java/views/index.rocker.html
@args (String message)
@views.main.template("Home") - > {
< h1 > Hello @message! </ h1 >
} เฮ้อาร์กิวเมนต์ RockerBody content ล่ะ? เราครอบคลุมรายละเอียดเพิ่มเติมในไวยากรณ์ readme แต่ตอนนี้เพิ่งเข้าใจว่ามันเป็นข้อโต้แย้งประเภทพิเศษเพียงอย่างเดียวและสั่งให้โยกว่าเทมเพลตคาดว่า "ร่างกาย" จะถูกส่งผ่านไป
ตัวแยกวิเคราะห์โยกจะสร้างไฟล์แหล่ง Java สำหรับแต่ละเทมเพลต พวกเขาจะเป็น target/generated-sources/rocker/views/main.java และ target/generated-sources/rocker/views/index.java ในแอปพลิเคชันของคุณคุณสามารถแสดงเทมเพลตดัชนีได้เช่นนั้น
static public void main ( String [] args ) {
String output = views . index . template ( "World" )
. render ()
. toString ();
}เอาต์พุตจะเท่ากับ:
< html >
< head >
< title > Home </ title >
</ head >
< body >
< h1 > Hello World! </ h1 >
</ body >
</ html > เมื่อคุณสร้างแหล่ง Java และมองเข้าไปในรหัสแล้วมันง่ายที่จะดูว่ามันทำงานอย่างไร Views.index Class สร้างมุมมองอินสแตนซ์เทมเพลตเมนและส่งการแสดงผลให้กับมัน - ในขณะที่ผ่านบล็อกของตัวเองว่ามันจะแสดงผลเมื่อมุมมอง main เรียกตัวแปร @content ไวยากรณ์เหมือนกับวิธีที่แลมบ์ดาถูกกำหนดใน Java 8 (นำไปใช้กับแลมบ์ดาสำหรับ Java 8 และชั้นเรียนภายในที่ไม่ระบุชื่อสำหรับ Java 6/7) Rocker ทำหลายสิ่งที่อยู่เบื้องหลังเพื่อให้แน่ใจว่าเทมเพลตที่สร้างเทมเพลตอื่น ๆ แบ่งปันบริบทการแสดงผลเดียวกัน (บัฟเฟอร์เอาท์พุทบริบทเฉพาะแอปพลิเคชัน/สถานะโดยปริยาย)
เช็คเอาต์ไฟล์ Syntax.md สำหรับการดำน้ำลึกที่ครอบคลุมบนไวยากรณ์โยก
Rocker มีรายการเฟรมเวิร์กที่เพิ่มขึ้นซึ่งได้รับการรวมเข้าด้วยกันอย่างราบรื่น หากคุณต้องการเชื่อมโยงไปยังเฟรมเวิร์กใหม่โปรดยื่นปัญหาหรือส่ง PR:
แบบคงที่ (ข้อความธรรมดา) สำหรับเทมเพลตโยกแต่ละตัว (โดยค่าเริ่มต้น) เก็บไว้ภายในเป็นอาร์เรย์ไบต์คงที่แล้วแปลงเป็น charset เป้าหมายของคุณแล้ว (เช่น UTF-8) เมื่อเทมเพลตมีการแสดงผล - อาร์เรย์ไบต์แบบคงที่จะถูกนำกลับมาใช้ใหม่ในคำขอทั้งหมด ROCKER แสดงผลไปยังสตรีมเอาต์พุตที่ได้รับการปรับปรุงซึ่งเก็บมุมมองคอมโพสิต (รายการที่เชื่อมโยง) ของอาร์เรย์ไบต์ที่นำกลับมาใช้ใหม่รวมถึงเนื้อหาแบบไดนามิกของคุณ เนื่องจากเทมเพลตส่วนใหญ่ประกอบด้วยเนื้อหาคงที่ที่แสดงในชุดเดียวกันซ้ำแล้วซ้ำอีกแทนที่จะจัดสรรหน่วยความจำใหม่คัดลอกเนื้อหานั้นแล้วแปลงเป็นชุดเป้าหมายของคุณสำหรับแต่ละคำขอ - Rocker ใช้ตัวชี้ไปซ้ำแล้วซ้ำอีก อีกครั้ง. เทคนิคนี้สร้างการแสดงผลที่รวดเร็วและมีประสิทธิภาพ
สมมติว่าคุณมีเทมเพลตประกอบด้วยข้อความคงที่ 9000 ไบต์และเนื้อหาแบบไดนามิก 1,000 ไบต์ หากไม่มีการปรับให้เหมาะสมนี้จะต้องใช้หน่วยความจำ ~ 100MB ในการให้บริการ 10,000 คำขอ (คำขอ 10,000 ไบต์ x 10,000) ด้วยการเพิ่มประสิทธิภาพนี้จะต้องใช้หน่วยความจำ ~ 10MB ในการร้องขอ 10,000 คำขอ (1,000 ไบต์ x 10,000 คำขอ) นอกจากหน่วยความจำที่ต่ำกว่าคุณยังตัดสำเนาหน่วยความจำ 90MB และ 90MB ของการแปลงสตริง UTF-8-> ไบต์ การเพิ่มประสิทธิภาพที่มีประโยชน์ค่อนข้างมาก
ทุกอย่างรวบรวมโดยคอมไพเลอร์โครงการของคุณพร้อมกับซอร์สโค้ด Java อื่น ๆ ของคุณ รหัสไดนามิกใด ๆ ในเทมเพลตของคุณจะถูกแปลงเป็น Java มาตรฐานและรวบรวม ไม่มีการใช้งานสะท้อน
เวอร์ชัน 0.10.0 แนะนำการสนับสนุนสำหรับเทมเพลตการโหลดซ้ำในระหว่างการพัฒนา การโหลดซ้ำ HOT ช่วยให้คุณสามารถปรับเปลี่ยนซอร์สโค้ดเทมเพลตบันทึกและให้การเปลี่ยนแปลงที่ใช้งานอยู่ในคำขอถัดไป - โดยไม่ต้องรีสตาร์ท JVM ของคุณ Rocker นำเสนอการโหลดซ้ำสองรสชาติที่แตกต่างกันเพื่อความยืดหยุ่น
คุณสมบัติที่สำคัญของเทมเพลตโยกคือเทมเพลตของคุณมีการตรวจสอบเวลารวบรวมการใช้งานอาร์กิวเมนต์ตรรกะ ฯลฯ โดยคอมไพเลอร์ Java
ในเวอร์ชัน 0.10.0 โครงสร้างพื้นฐานของเทมเพลตได้รับการแก้ไขโดยที่แม่แบบสร้างคลาสพื้นฐานสองคลาส แต่ละเทมเพลตสร้างคลาสโมเดล (อินเทอร์เฟซ) และคลาสการใช้งาน (Renderer) แอปพลิเคชันของคุณจะโต้ตอบโดยตรงกับโมเดลเท่านั้นดังนั้นการอนุญาตให้โยกกลับมาคอมไพล์อีกครั้งและโหลดคลาสการใช้งานใหม่
ประโยชน์ที่สำคัญของรสชาติหนึ่งคือรหัสแอปพลิเคชันของคุณยังคงเหมือนเดิมและมีการรวบรวมเวลาที่ตรวจสอบโดยคอมไพเลอร์ Java ในขณะที่เนื้อหาเทมเพลตสามารถแก้ไขและโหลดซ้ำโดยอัตโนมัติเมื่อรันไทม์ เฉพาะในกรณีที่คุณเปลี่ยนอาร์กิวเมนต์เทมเพลตจริง ๆ แล้วคุณจะต้องรีสตาร์ทแอปพลิเคชันของคุณหรือไม่
หากคุณต้องการความสะดวกสบายของเทมเพลตแบบไดนามิกอย่างเต็มที่รสชาติสองรองรับการโหลดซ้ำของทั้งคลาสเทมเพลต (อินเทอร์เฟซ) รวมถึงคลาสการใช้งาน (Renderer) แอปพลิเคชันของคุณจะสูญเสียการตรวจสอบเวลาคอมไพล์บางส่วนและประสิทธิภาพการทำงานเพียงเล็กน้อย แต่ได้รับความสะดวกสบายของทุกสิ่งที่สามารถโหลดซ้ำได้ วิธีที่แอปพลิเคชันของคุณจะใช้เทมเพลตแตกต่างกันเช่นกัน
import com . fizzed . rocker . Rocker
...
// dynamic interfaces, dynamic implementation
String rendered = Rocker . template ( "views/index.rocker.html" )
. bind ( "val" , "ValueA" )
. render ()
. toString ();เส้นทางเทมเพลตและอาร์กิวเมนต์จะถูกตรวจสอบรันไทม์ โปรดทราบว่าแต่ละค่าที่มีประโยชน์จะต้องตรงกับชื่อและพิมพ์ที่ประกาศไว้ในเทมเพลตของคุณ
ในกรณีที่แผนที่ที่มีประโยชน์ของคุณอาจมีค่ามากกว่าที่ต้องการจะมีการผูกที่ผ่อนคลาย ทางเลือกที่ผ่อนคลายจะไม่ล้มเหลวหากแอตทริบิวต์เป็นพิเศษในรายการที่ต้องการ ตัวอย่างเช่น:
@args (String name)
Hello ${name}!
จะแสดงในโหมดผ่อนคลายเป็น:
Map map = new HashMap ();
map . put ( "name" , "Joe" );
map . put ( "age" , 42 );
Rocker . template ( "views/hello.rocker.html" )
. relaxedBind ( map )
. render ();
// -> Hello Joe! การสนับสนุนสำหรับการโหลดซ้ำร้อนจะถูกเพิ่มลงในเทมเพลตที่สร้างขึ้นของคุณโดยค่าเริ่มต้นในเวอร์ชัน 0.10.0 หากคุณต้องการปิดใช้งานการสนับสนุนให้ตั้งค่าการกำหนดค่า/คุณสมบัติของระบบ rocker.optimize เป็นจริงในระหว่างการสร้างของคุณ เนื่องจากรหัสมีอยู่ในเทมเพลตของคุณโดยค่าเริ่มต้นคุณเพียงแค่ต้องเปิดใช้งานที่รันไทม์
ต้องมีการเพิ่มการพึ่งพา rocker-compiler ลงในงานสร้างของคุณ การพึ่งพานี้จะต้องมีอยู่ในระหว่างการพัฒนาและสามารถลบออกในการผลิต ใน Maven นี่หมายความว่าคุณจะต้องเพิ่มการพึ่งพาในขอบเขต provided
< dependency >
< groupId >com.fizzed</ groupId >
< artifactId >rocker-compiler</ artifactId >
< version >2.1.0</ version >
< scope >provided</ scope >
</ dependency >เปิดใช้งานการโหลดซ้ำที่รันไทม์ คุณสามารถเปิดใช้งานการโหลดซ้ำร้อนด้วยคุณสมบัติของระบบหรือทางโปรแกรม สำหรับการเปิดใช้งานการโหลดซ้ำด้วยคุณสมบัติระบบใน Maven
mvn -Drocker.reloading=true ...rest of args...
หรือคุณสามารถเปิดใช้งานการโหลดซ้ำแบบร้อน
import com . fizzed . rocker . runtime . RockerRuntime
...
RockerRuntime . getInstance (). setReloading ( true );มีตัวอย่างง่ายๆที่แสดงให้เห็นถึงการโหลดใหม่ที่ร้อนแรง โครงการนี้ใช้ Blaze เพื่อช่วยงานสคริปต์ เรียกใช้สิ่งต่อไปนี้
java -jar blaze.jar hot_reload
ชี้เบราว์เซอร์ของคุณไปที่ http: // localhost: 8080
จากนั้นแก้ไขและบันทึก rocker-test-reload/src/test/java/views/index.rocker.html และรีเฟรชเบราว์เซอร์ของคุณ
Rocker ประกอบด้วยสององค์ประกอบคือตัวแยกวิเคราะห์/เครื่องกำเนิดไฟฟ้าและรันไทม์ หากต้องการใช้ Rocker ในโครงการของคุณให้เพิ่มการพึ่งพารันไทม์ลงในแอปพลิเคชันของคุณจากนั้นเปิดใช้งานตัวแยกวิเคราะห์ในเครื่องมือสร้างของคุณตามด้วยการสร้างเทมเพลตแรกของคุณ
Rocker เผยแพร่ไปยัง Maven Central เพื่อเพิ่มการพึ่งพาใน Maven:
< dependency >
< groupId >com.fizzed</ groupId >
< artifactId >rocker-runtime</ artifactId >
< version >2.1.0</ version >
</ dependency >
<!-- for hot-reloading support only during development -->
< dependency >
< groupId >com.fizzed</ groupId >
< artifactId >rocker-compiler</ artifactId >
< version >2.1.0</ version >
< scope >provided</ scope >
</ dependency >เพื่อเพิ่มการพึ่งพาใน Gradle:
repositories {
mavenCentral()
}
dependencies {
compile group : ' com.fizzed ' , name : ' rocker-runtime ' , version : ' 2.1.0 '
// add rocker-compiler dependency as needed
}Rocker รองรับ Maven และ Gradle นอกกรอบ
เพิ่มสิ่งต่อไปนี้ใน POM ของคุณ
< build >
< plugins >
< plugin >
< groupId >com.fizzed</ groupId >
< artifactId >rocker-maven-plugin</ artifactId >
< version >2.1.0</ version >
< executions >
< execution >
< id >generate-rocker-templates</ id >
< phase >generate-sources</ phase >
< goals >
< goal >generate</ goal >
</ goals >
</ execution >
</ executions >
</ plugin >
</ plugins >
</ build > โดยค่าเริ่มต้น Rocker จะประมวลผลไฟล์เทมเพลตใด ๆ ที่ลงท้ายด้วย .rocker.html ใน src/main/java ไดเรกทอรีที่บันทึกไว้จะกลายเป็นแพ็คเกจ Java มาตรฐานคลาส Java ที่สร้างขึ้นจะถูกวางไว้ ไฟล์ต้นฉบับ Java ที่สร้างขึ้นจะถูกบันทึกไว้ใน target/generated-sources/rocker ปลั๊กอินจะดูแลการเพิ่มไดเรกทอรีที่สร้างขึ้นนี้ลงในรูทแหล่งที่มาของคุณ
รองรับคุณสมบัติต่อไปนี้:
templateDirectory เป็นไดเรกทอรีพื้นฐานเพื่อเริ่มต้นซ้ำเมื่อค้นหาและแยกวิเคราะห์ไฟล์เทมเพลต package Java เทมเพลตจะถูกสร้างขึ้นเพื่อใช้ไดเรกทอรีนี้เป็นฐาน ดังนั้นหากคุณมี ${templateDirectory}/views/mytemplate.rocker.html แล้ว Rocker จะสร้าง ${outputDirectory}/views/mytemplate.java ค่าเริ่มต้นเป็น ${project.build.sourceDirectory}
outputDirectory เป็นไดเรกทอรีตัวแยกวิเคราะห์จะสร้างแหล่งที่มาสำหรับแม่แบบ ค่าเริ่มต้นเป็น ${project.build.directory}/generated-sources/rocker
classDirectory เป็นไดเรกทอรีที่คุณลักษณะการโหลดใหม่จะ (RE) คอมไพล์คลาสคอมไพล์ไปที่รันไทม์ ค่าเริ่มต้นเป็น ${project.build.outputDirectory}
failOnError กำหนดว่าการแยกวิเคราะห์/การสร้างข้อผิดพลาดใด ๆ ทำให้ Maven ล้มเหลวหรือไม่ ค่าเริ่มต้นเป็นจริง
skip กำหนดว่าควรข้ามการดำเนินการของปลั๊กอินหรือไม่ ค่าเริ่มต้นเป็นเท็จ
touchFile เป็นไฟล์ที่จะ "สัมผัส" หลังจากสร้างแหล่ง Java ได้สำเร็จ มีประโยชน์สำหรับการเรียกเวิร์กโฟลว์อื่น ๆ IDEs จำนวนมากจะไม่โหลดแหล่งข้อมูลที่สร้างขึ้นโดยอัตโนมัติเพื่อให้รหัสเสร็จสมบูรณ์เว้นแต่จะได้รับคำสั่งอย่างชัดเจนว่าจะโหลดซ้ำหรือหากไฟล์ maven pom.xml เปลี่ยนไป ดังนั้นค่านี้จึงตั้งค่าเป็นค่าเริ่มต้นเป็น ${basedir}/pom.xml มักจะไม่เป็นอันตรายที่จะเปิดใช้งานนี้
skipTouch ปิดการใช้งาน TouchFile ค่าเริ่มต้นเป็นเท็จ
addAsSources จะเพิ่ม outputDirectory ให้กับ Maven เป็นแหล่งที่จะรวบรวม ค่าเริ่มต้นเป็นจริง
addAsTestSources จะเพิ่ม outputDirectory ให้กับ Maven เป็นแหล่งทดสอบที่จะรวบรวม ค่าเริ่มต้นเป็นเท็จ หากเป็นจริงสิ่งนี้จะได้รับการประเมินก่อนที่จะมีการเก็บข้อมูลและบอกให้ Maven รวบรวมเทมเพลตของคุณเป็นรหัสทดสอบได้อย่างมีประสิทธิภาพ
นอกจากนี้ยังมีการสนับสนุนคุณสมบัติต่อไปนี้ แต่สิ่งสำคัญคือต้องเข้าใจสิ่งเหล่านี้เป็นการแทนที่เป็นหลักไปยังตัวแยกวิเคราะห์และพวกเขาทั้งหมดเริ่มต้นกับค่าเริ่มต้นของ Rocker
javaVersion เป็นเวอร์ชัน Java ที่คุณต้องการให้ Templates Compile & Runtime เข้ากันได้กับ ค่าเริ่มต้นเป็นเวอร์ชัน Java ของ JVM ที่ดำเนินการ Maven (เช่น "1.8")
optimize กำหนดว่าการสนับสนุนการโหลดซ้ำจะถูกลบออกจากเทมเพลตที่สร้างขึ้นหรือไม่ เท็จโดยค่าเริ่มต้น
extendsClass เป็นคลาสที่การใช้งานเทมเพลตทั้งหมดควรขยาย มีประโยชน์สำหรับคลาสกลางเฉพาะแอปพลิเคชันที่คุณต้องการให้เทมเพลตทั้งหมดขยาย ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
extendsModelClass เป็นคลาสที่รุ่นเทมเพลตทั้งหมดควรขยาย มีประโยชน์สำหรับคลาสกลางเฉพาะแอปพลิเคชันที่คุณต้องการให้แบบจำลองเทมเพลตทั้งหมดขยาย ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
plainTextStrategy เป็นกลยุทธ์ที่ใช้ในการฝังข้อความธรรมดาเป็นส่วนหนึ่งของเทมเพลต ค่าเริ่มต้นคือ static_byte_arrays_via_unloaded_class แต่ถ้าคุณต้องการความเข้ากันได้ของ Graalvm คุณจะลอง static_byte_arrays
discardLogicWhitespace กำหนดว่าช่องว่างในเทมเพลตที่พิจารณาว่าเป็นเพียงส่วนหนึ่งของบล็อกตรรกะ/ควบคุมควรถูกยกเลิกหรือไม่ ช่วยให้เนื้อหาที่แสดงผลดูเป็นมืออาชีพมากขึ้นในขณะที่ยังคงรักษารูปแบบของคุณไว้มาก ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
targetCharset เป็น Charset เป้าหมายสำหรับเอาต์พุตเทมเพลต ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
suffixRegex เป็นนิพจน์ทั่วไปที่ใช้เพื่อค้นหาเทมเพลตเพื่อแยกวิเคราะห์ ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
markAsGenerated เพิ่มคำอธิบายประกอบ @Generated ให้กับคลาสที่สร้างขึ้น การเก็บรักษาเป็นคลาสเพื่อให้คำอธิบายประกอบสามารถใช้งานได้โดยเครื่องมือที่พึ่งพาไฟล์คลาสเท่านั้นและไม่ได้อยู่ในซอร์สโค้ด ค่าเริ่มต้นเป็นค่าเริ่มต้นของ Rocker
ขอบคุณ @victory และ @mnlipp สำหรับการบริจาคปลั๊กอิน Gradle @etiennestuder ยังมีปลั๊กอิน Gradle ทางเลือกที่คุณอาจต้องการพิจารณาเช่นกัน ปลั๊กอิน Gradle ของ Rocker เผยแพร่ไปยัง gradle.org เพียงเพิ่มสิ่งต่อไปนี้ลงในสคริปต์บิลด์ของคุณ:
plugins {
id " com.fizzed.rocker " version " 2.1.0 "
}
sourceSets {
main {
rocker {
srcDir( ' src/main/java ' )
}
}
}
rocker {
// (All settings are shown with their defaults)
//
// Skips building templates all together
skip false
// Base directory for generated java sources, actual target is sub directory
// with the name of the source set. The value is passed through project.file().
outputBaseDirectory = " $b uildDir /generated-src/rocker "
// Base directory for the directory where the hot reload feature
// will (re)compile classes to at runtime (and where `rocker-compiler.conf`
// is generated, which is used by RockerRuntime.getInstance().setReloading(true)).
// The actual target is a sub directory with the name of the source set.
// The value is passed through project.file().
classBaseDirectory = " $b uildDir /classes "
failOnError true
skipTouch true
// must not be empty when skipTouch is equal to false
touchFile " "
javaVersion ' 1.8 '
extendsClass null
extendsModelClass null
optimize null
discardLogicWhitespace null
targetCharset null
suffixRegex null
postProcessing null
markAsGenerated null
}
ไวยากรณ์เทมเพลตอธิบายไว้ในรายละเอียดด้านล่าง แต่ตอนนี้สร้างไฟล์ใหม่ใน ${templateDirectory}/views/HelloWorld.rocker.html
@*
Example of hello world
*@
@args (String message)
Hello @message!
ถึงเวลารวบรวมโครงการของคุณและเริ่มใช้เทมเพลต คุณสามารถเรียกมันได้จาก Java เช่นนั้น:
static public void main ( String [] args ) {
String output = views . HelloWorld
. template ( "World" )
. render ()
. toString ();
} Rocker ได้รับการปรับให้เหมาะสมอย่างมาก (โดยค่าเริ่มต้น) ไปยังเทมเพลตเอาต์พุตเป็นอาร์เรย์ไบต์ RockerOutput เริ่มต้นเทมเพลตจะแสดงผลเป็นประเภท com.fizzed.rocker.runtime.ArrayOfByteArraysOutput นี่เป็นตัวเลือกที่ยอดเยี่ยมสำหรับอาร์เรย์ไบต์หรืออะซิงโครนัส IO อย่างไรก็ตามเฟรมเวิร์กมีความสามารถในการแสดงผลที่เหมาะสมกับสตริง (หรือเอาต์พุตที่กำหนดเองอื่น ๆ )
เพื่อแสดงผลเป็นสตริงได้อย่างมีประสิทธิภาพ:
import com . fizzed . rocker . runtime . StringBuilderOutput ;
static public void main ( String [] args ) {
StringBuilderOutput output = views . HelloWorld
. template ( "World" )
. render ( StringBuilderOutput . FACTORY );
String text = output . toString ();
}เพื่อแสดงผลอย่างมีประสิทธิภาพไปยัง outputstream:
import com . fizzed . rocker . runtime . OutputStreamOutput ;
static public void main ( String [] args ) throws Exception {
final OutputStream os = new FileOutputStream ( new File ( "test" ));
OutputStreamOutput output = views . HelloWorld
. template ( "World" )
. render (( contentType , charsetName ) -> new OutputStreamOutput ( contentType , os , charsetName ));
} โปรดทราบว่าหากมีข้อยกเว้นในระหว่างการแสดงผล OutputStream จะมีเทมเพลตบางส่วนที่แสดงผล (จนถึงจุดของข้อยกเว้น) ในกรณีส่วนใหญ่จะเป็นการดีกว่าที่จะแสดงผลเป็น com.fizzed.rocker.runtime.ArrayOfByteArraysOutput และเขียนบัฟเฟอร์ของอาร์เรย์ไบต์ออกไปยังเอาท์พุทสตรีมของคุณโดยตรง
มีการสาธิตของโยกจำนวนมากในการดำเนินการ จากการแยกวิเคราะห์เทมเพลตลงในโมเดลไปจนถึงการส่งผลลัพธ์แบบอะซิงโครนัสในเซิร์ฟเวอร์ HTTP โครงการนี้ใช้ Blaze เพื่อช่วยงานสคริปต์ เรียกใช้รายการต่อไปนี้สำหรับรายการที่สมบูรณ์:
java -jar blaze.jar -l
ลิขสิทธิ์ (C) 2015+ Fizzed, Inc.
งานนี้ได้รับใบอนุญาตภายใต้ใบอนุญาต Apache เวอร์ชัน 2.0 ดูใบอนุญาตสำหรับรายละเอียด
