byte buddy

บัดดี้ไบต์

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

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

Byte Buddy เขียนใน Java 5 แต่สนับสนุนการสร้างชั้นเรียนสำหรับเวอร์ชัน Java ใด ๆ Byte Buddy เป็นห้องสมุดน้ำหนักเบาและขึ้นอยู่กับ API ผู้เข้าชมของ Java Byte Code Parser Parser Library ASM ซึ่งไม่จำเป็นต้องมีการพึ่งพาเพิ่มเติมใด ๆ

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

---

ในเดือนตุลาคม 2558 Byte Buddy โดดเด่นด้วย รางวัล Duke's Choice Award โดย Oracle รางวัลดังกล่าวชื่นชม Byte Buddy สำหรับ " นวัตกรรมจำนวนมหาศาลใน Java Technology " เรารู้สึกเป็นเกียรติอย่างยิ่งที่ได้รับรางวัลนี้และต้องการขอบคุณผู้ใช้ทุกคนและทุกคนที่ช่วยสร้าง Byte Buddy ความสำเร็จที่ได้กลายเป็น เราซาบซึ้งจริงๆ!

---

Byte Buddy นำเสนอประสิทธิภาพที่ยอดเยี่ยมในด้านคุณภาพการผลิต มันมีความเสถียรและใช้งานโดยกรอบและเครื่องมือที่โดดเด่นเช่น Mockito, Hibernate, Jackson, ระบบ Bazel Build ของ Google และอื่น ๆ อีกมากมาย Byte Buddy ยังถูกใช้โดยผลิตภัณฑ์เชิงพาณิชย์จำนวนมากเพื่อผลลัพธ์ที่ยอดเยี่ยม ปัจจุบันมีการดาวน์โหลดมากกว่า 75 ล้านครั้งต่อปี

สวัสดีโลก

การพูด สวัสดีโลก กับ Byte Buddy นั้นง่ายอย่างที่จะทำได้ การสร้างคลาส Java ใด ๆ เริ่มต้นด้วยอินสแตนซ์ของคลาส ByteBuddy ซึ่งแสดงถึงการกำหนดค่าสำหรับการสร้างประเภทใหม่:

 Class <?> dynamicType = new ByteBuddy ()
  . subclass ( Object . class )
  . method ( ElementMatchers . named ( "toString" ))
  . intercept ( FixedValue . value ( "Hello World!" ))
  . make ()
  . load ( getClass (). getClassLoader ())
  . getLoaded ();
assertThat ( dynamicType . newInstance (). toString (), is ( "Hello World!" ));

การกำหนดค่า ByteBuddy เริ่มต้นซึ่งใช้ในตัวอย่างด้านบนสร้างคลาส Java ในรูปแบบไฟล์คลาสใหม่ล่าสุดที่เข้าใจโดยเครื่องเสมือน Java Processing ตามที่หวังไว้อย่างชัดเจนจากรหัสตัวอย่างประเภทที่สร้างขึ้นจะขยายคลาส Object และแทนที่วิธี toString ซึ่งควรส่งคืนค่าคงที่ของ Hello World! - วิธีการที่จะถูกแทนที่ถูกระบุโดย ElementMatcher ที่เรียกว่า ในตัวอย่างข้างต้นมีการใช้ตัวจับคู่องค์ประกอบที่กำหนดไว้ล่วงหน้า named(String) ซึ่งระบุวิธีการด้วยชื่อที่แน่นอน Byte Buddy มาพร้อมกับผู้จับคู่ที่กำหนดไว้ล่วงหน้าและผ่านการทดสอบมาอย่างดีจำนวนมากซึ่งรวบรวมไว้ในคลาส ElementMatchers และสามารถประกอบได้อย่างง่ายดาย การสร้างตัวจับคู่แบบกำหนดเองนั้นง่ายพอ ๆ กับการใช้งานอินเตอร์เฟส (ฟังก์ชัน) ElementMatcher

สำหรับการใช้วิธี toString คลาส FixedValue จะกำหนดค่าการส่งคืนคงที่สำหรับวิธีการแทนที่ การกำหนดค่าคงที่เป็นเพียงตัวอย่างเดียวของการสกัดกั้นวิธีการหลายอย่างที่จัดส่งกับ Byte Buddy ด้วยการใช้อินเทอร์เฟซ Implementation งานวิธีการสามารถกำหนดได้ด้วยรหัสไบต์แบบกำหนดเอง

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

ตัวอย่างที่ซับซ้อนมากขึ้น

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

Byte Buddy แสดงการใช้วิธีการที่กำหนดแบบไดนามิกโดยอินสแตนซ์ของอินเทอร์เฟซ Implementation ในตัวอย่างก่อนหน้านี้ FixedValue ที่ที่ใช้อินเทอร์เฟซนี้ได้แสดงให้เห็นแล้ว โดยการใช้อินเทอร์เฟซนี้ผู้ใช้ของ Byte Buddy สามารถไปที่ความยาวของการกำหนดรหัสไบต์ที่กำหนดเองสำหรับวิธีการ โดยปกติแล้วจะใช้งานได้ง่ายกว่าการใช้งานที่กำหนดไว้ล่วงหน้าของ Byte Buddy เช่น MethodDelegation ซึ่งช่วยให้สามารถใช้วิธีการใด ๆ ในจาวาธรรมดา การใช้การใช้งานนี้ตรงไปตรงมาเนื่องจากมันทำงานโดยมอบหมายกระแสควบคุมไปยัง POJO ใด ๆ เป็นตัวอย่างของ pojo ดังกล่าว Byte Buddy สามารถเปลี่ยนเส้นทางการโทรไปยังวิธีเดียวของคลาสต่อไปนี้:

 public class GreetingInterceptor {
  public Object greet ( Object argument ) {
    return "Hello from " + argument ;
  }
}

โปรดทราบว่า GreetingInterceptor ข้างต้นไม่ได้ขึ้นอยู่กับประเภท Byte Buddy ใด ๆ นี่เป็นข่าวดีเพราะไม่มีชั้นเรียนใดที่ Byte Buddy สร้างขึ้นต้องการ Byte Buddy บนเส้นทางชั้นเรียน! ด้วย GreetingInterceptor ด้านบนเราสามารถใช้ Byte Buddy เพื่อใช้ Java 8 java.util.function.Function Interface และวิธี apply บทคัดย่อ:

 Class <? extends java . util . function . Function > dynamicType = new ByteBuddy ()
  . subclass ( java . util . function . Function . class )
  . method ( ElementMatchers . named ( "apply" ))
  . intercept ( MethodDelegation . to ( new GreetingInterceptor ()))
  . make ()
  . load ( getClass (). getClassLoader ())
  . getLoaded ();
assertThat (( String ) dynamicType . newInstance (). apply ( "Byte Buddy" ), is ( "Hello from Byte Buddy" ));

การดำเนินการรหัสด้านบน Byte Buddy ใช้อินเทอร์เฟซฟังก์ Function ของ Java และใช้วิธี apply เป็นตัวแทนของอินสแตนซ์ของ Pojo GreetingInterceptor ที่เรากำหนดไว้ก่อนหน้านี้ ตอนนี้ทุกครั้งที่มีการเรียกใช้วิธี Function::apply กระแสการควบคุมจะถูกส่งไปยัง GreetingInterceptor::greet และค่าการส่งคืนของวิธีหลังจะถูกส่งกลับจากวิธีการของอินเตอร์เฟส

Interceptors สามารถกำหนดให้ใช้กับอินพุตและเอาต์พุตทั่วไปมากขึ้นโดยการใส่คำอธิบายประกอบพารามิเตอร์ของ Interceptor เมื่อ Byte Buddy ค้นพบคำอธิบายประกอบไลบรารีจะฉีดการพึ่งพาที่พารามิเตอร์ interceptor ต้องการ ตัวอย่างสำหรับการดักจับทั่วไปมากขึ้นคือคลาสต่อไปนี้:

 public class GeneralInterceptor {
  @ RuntimeType
  public Object intercept ( @ AllArguments Object [] allArguments ,
                          @ Origin Method method ) {
    // intercept any method of any signature
  }
}

ด้วยการสกัดกั้นข้างต้นวิธีการที่สกัดกั้นสามารถจับคู่และประมวลผลได้ ตัวอย่างเช่นเมื่อ Function::apply อาร์กิวเมนต์ของวิธีการจะถูกส่งผ่านเป็นองค์ประกอบเดียวของอาร์เรย์ นอกจากนี้ Method การอ้างอิงถึง Fuction::apply จะถูกส่งผ่านเป็นอาร์กิวเมนต์ที่สองของ Interceptor เนื่องจากคำอธิบายประกอบ @Origin โดยการประกาศคำอธิบายประกอบ @RuntimeType บนวิธีนี้ Byte Buddy ในที่สุดก็ใช้ค่าที่ส่งคืนไปยังค่าส่งคืนของวิธีการสกัดกั้นหากจำเป็น ในการทำเช่นนั้น Byte Buddy ยังใช้การชกมวยอัตโนมัติและ Unboxing

นอกจากคำอธิบายประกอบที่กล่าวถึงแล้วยังมีคำอธิบายประกอบที่กำหนดไว้ล่วงหน้าอีกมากมาย ตัวอย่างเช่นเมื่อใช้คำอธิบายประกอบ @SuperCall บนประเภท Runnable หรือ Callable Byte Buddy ฉีดพร็อกซีอินสแตนซ์ที่อนุญาตให้มีการเรียกใช้วิธี Super ที่ไม่ได้รับการรับรองหากมีวิธีการดังกล่าว และแม้ว่า Byte Buddy จะไม่ครอบคลุมกรณีการใช้งาน Byte Buddy เสนอกลไกการขยายสำหรับการกำหนดคำอธิบายประกอบที่กำหนดเอง

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

การเปลี่ยนคลาสที่มีอยู่

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

 public class TimingInterceptor {
  @ RuntimeType
  public static Object intercept ( @ Origin Method method , 
                                 @ SuperCall Callable <?> callable ) {
    long start = System . currentTimeMillis ();
    try {
      return callable . call ();
    } finally {
      System . out . println ( method + " took " + ( System . currentTimeMillis () - start ));
    }
  }
}

การใช้ตัวแทน Java ตอนนี้เราสามารถใช้ interceptor นี้กับทุกประเภทที่ตรงกับ ElementMatcher สำหรับ TypeDescription ตัวอย่างเช่นเราเลือกที่จะเพิ่มตัวดักจับข้างต้นให้กับทุกประเภทที่มีชื่อที่สิ้นสุดใน Timed สิ่งนี้ทำเพื่อความเรียบง่ายในขณะที่คำอธิบายประกอบอาจเป็นทางเลือกที่เหมาะสมกว่าในการทำเครื่องหมายคลาสดังกล่าวสำหรับตัวแทนการผลิต การใช้ AgentBuilder API ของ Byte Buddy การสร้างตัวแทน Java นั้นง่ายพอ ๆ กับการกำหนดคลาสตัวแทนต่อไปนี้:

 public class TimerAgent {
  public static void premain ( String arguments , 
                             Instrumentation instrumentation ) {
    new AgentBuilder . Default ()
      . type ( ElementMatchers . nameEndsWith ( "Timed" ))
      . transform (( builder , type , classLoader , module , protectionDomain ) -> 
          builder . method ( ElementMatchers . any ())
                 . intercept ( MethodDelegation . to ( TimingInterceptor . class ))
      ). installOn ( instrumentation );
  }
}

เช่นเดียวกับวิธี main ของ Java วิธี premain คือจุดเริ่มต้นของตัวแทน Java ใด ๆ ที่เราใช้นิยามใหม่ ในฐานะที่เป็นอาร์กิวเมนต์หนึ่งตัวแทน Java ได้รับอินสแตนซ์ของ Instrumentation ซเครื่องมือวัดซึ่งอนุญาตให้ Byte Buddy เชื่อมต่อกับ API มาตรฐานของ JVM สำหรับการนิยามใหม่ของคลาสรันไทม์

โปรแกรมนี้บรรจุพร้อมกับไฟล์รายการพร้อมแอตทริบิวต์ Premain-Class ที่ชี้ไปที่ TimerAgent ตอนนี้ไฟล์ JAR ที่ได้สามารถเพิ่มลงในแอปพลิเคชัน Java ใด ๆ โดยการตั้งค่า -javaagent:timingagent.jar คล้ายกับการเพิ่มขวดไปยังเส้นทางคลาส ด้วยเอเจนต์ที่ใช้งานอยู่คลาสทั้งหมดที่ลงท้ายด้วย Timed จะพิมพ์เวลาดำเนินการไปยังคอนโซล

Byte Buddy ยังสามารถใช้สิ่งที่แนบมารันไทม์ที่เรียกว่าการปิดใช้งานรูปแบบไฟล์คลาสการเปลี่ยนแปลงและการใช้เครื่องมือ Advice โปรดดู Javadoc ของ Advice และคลาส AgentBuilder สำหรับข้อมูลเพิ่มเติม Byte Buddy ยังเสนอการเปลี่ยนแปลงอย่างชัดเจนของคลาส Java ผ่านอินสแตนซ์ ByteBuddy หรือโดยใช้ปลั๊กอิน Byte Buddy Maven และ Gradle

ไปจากที่นี่ที่ไหน?

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

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

รับการสนับสนุน

ทางการค้า

การใช้ Byte Buddy นั้นฟรีและไม่จำเป็นต้องซื้อใบอนุญาต เพื่อให้ได้ประโยชน์สูงสุดจากห้องสมุดหรือเพื่อความปลอดภัยการเริ่มต้นที่ง่ายอาจเป็นไปได้ที่จะซื้อการฝึกอบรมชั่วโมงการพัฒนาหรือแผนการสนับสนุน อัตราขึ้นอยู่กับขอบเขตและระยะเวลาของการมีส่วนร่วม กรุณาติดต่อกับ [email protected] สำหรับข้อมูลเพิ่มเติม

tideLift

Byte Buddy อยู่ใน TideLift หากคุณไม่ได้ใช้ Byte Buddy ในระดับที่คุณต้องการซื้อการสนับสนุนที่ชัดเจนและต้องการสนับสนุนชุมชนโอเพ่นซอร์สโดยทั่วไปโปรดพิจารณาการสมัครสมาชิก

ผู้สนับสนุน GitHub

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

ฟรี

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

การพึ่งพาและวิวัฒนาการ API

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

ASM ได้เปลี่ยน API สาธารณะก่อนหน้านี้ แต่เพิ่มกลไกสำหรับความเข้ากันได้ของ API เริ่มต้นด้วยไลบรารีเวอร์ชัน 4 เพื่อหลีกเลี่ยงความขัดแย้งในเวอร์ชันกับเวอร์ชันเก่าเช่นนี้ Byte Buddy จะทำการพึ่งพา ASM ลงในเนมสเปซของตัวเอง หากคุณต้องการใช้ ASM โดยตรงสิ่งประดิษฐ์ byte-buddy-dep เสนอ Byte Buddy เวอร์ชันที่มีการพึ่งพา ASM อย่างชัดเจน เมื่อทำเช่นนั้นคุณ ต้อง จัดทำใหม่ ทั้ง Byte Buddy และ ASM ลงในเนมสเปซของคุณเพื่อหลีกเลี่ยงความขัดแย้งในเวอร์ชัน

โปรดทราบนโยบายความปลอดภัยของโครงการนี้

Byte Buddy รองรับการดำเนินการกับ JVM ทั้งหมดจากเวอร์ชันห้าและต่อไปในโถเดียว สิ่งนี้ทำเพื่อลดการพัฒนาตัวแทน Java ซึ่งมักจะต้องสนับสนุนแอพพลิเคชั่นที่เก่ากว่าหรือไม่ทราบซึ่งไม่ได้รับการปรับปรุงอย่างแข็งขัน เพื่อให้ได้เช่นนี้ในขณะที่ยังรองรับ Java ที่ทันสมัยและคุณสมบัติเช่นการตรวจสอบซีดีหรือคลาสด้วยเฟรมแผนที่สแต็กขวดหลักสำหรับเรือบัดดี้บัดดี้เป็นเหยือกหลายตัวที่มีไฟล์คลาสในรุ่นที่ห้าและแปด เป็นผลให้ขนาดขวดของ Byte Buddy สูงกว่าที่คาดไว้ ขนาดไฟล์ JAR ไม่ใช่ปัญหาโดยปกติเนื่องจากคลาสส่วนใหญ่ของ Byte Buddy จะไม่ถูกโหลด แต่ขนาดไฟล์อาจเป็นปัญหาเมื่อแจกจ่ายตัวแทน Java เนื่องจากตัวแทนจำเป็นต้องได้รับการรวมเป็นขวดเดียวดังนั้นจึงแนะนำให้ลบเวอร์ชัน Java Five พื้นฐานหรือรุ่น Java Eight รุ่นที่มีอยู่หลายรุ่นเพื่อลดปัญหานี้ สิ่งนี้ได้รับการสนับสนุนโดยปลั๊กอิน Build ส่วนใหญ่เพื่อจุดประสงค์นี้เช่นปลั๊กอิน Maven Shade

ใบอนุญาตและการพัฒนา

Byte Buddy ได้รับใบอนุญาตภายใต้ ใบอนุญาต Apache ที่เป็นมิตรและเป็นมิตรกับธุรกิจเวอร์ชัน 2.0 และพร้อมใช้งานได้อย่างอิสระบน GitHub นอกจากนี้การแจกจ่าย BYTE-BUDDY BUNDLES ASM ซึ่งเปิดตัวภายใต้ใบอนุญาต BSD 3 ข้อ

ไบนารี Byte Buddy ได้รับการเผยแพร่ไปยังที่เก็บของ Maven Central และ JCenter ลายเซ็นสิ่งประดิษฐ์สามารถตรวจสอบกับคีย์สาธารณะ PGP นี้เริ่มต้นด้วย BYTE BUDDY 1.10.3 รุ่นเก่าสามารถตรวจสอบได้กับใบรับรองที่เก่ากว่าและอ่อนแอกว่านี้

โครงการสร้างขึ้นโดยใช้ Maven จากเปลือกของคุณการโคลนนิ่งและการสร้างโครงการจะเป็นเช่นนี้:

git clone https://github.com/raphw/byte-buddy.git
cd byte-buddy
mvn package

ในคำสั่งเหล่านี้ Byte Buddy ถูกโคลนจาก GitHub และสร้างขึ้นบนเครื่องของคุณ ตัวเลือกการสร้างเพิ่มเติมแสดงอยู่ในไฟล์รูท POM Byte Buddy สามารถสร้างได้ด้วย JDK ใด ๆ อย่างน้อยรุ่น 6 อย่างไรก็ตามขอแนะนำให้ใช้ JDK อย่างน้อยเวอร์ชัน 8 เป็น Builds สำหรับเวอร์ชัน 6 และ 7 ต้องการการใช้งาน HTTP ที่ไม่ได้เข้ารหัส การสนับสนุนของมันมีไว้สำหรับการทดสอบกับเวอร์ชัน JDK นี้เท่านั้นและสามารถเปิดเผยให้คุณเห็นการโจมตีที่อยู่ในระดับกลาง ดังนั้นควรหลีกเลี่ยงการสร้างเหล่านี้ ปัจจุบัน Byte Buddy ได้รับการทดสอบสำหรับรุ่นที่ 6 และสูงกว่าของ JDK บนเซิร์ฟเวอร์ CI

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

ผู้สนับสนุน

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