fury下載 - fury原始碼下載

Apache Fury（正在孵化）是一種速度極快的多語言序列化框架，由JIT （即時編譯）和零複製提供支持，可提供高達 170 倍的效能和終極易用性。

https://fury.apache.org

重要的

Apache Fury（孵化中）是在 Apache 軟體基金會 (ASF) 中進行孵化的一項成果，由 Apache 孵化器 PMC 贊助。

請閱讀免責聲明和“孵化”的完整解釋。

特徵

多種語言：Java/Python/C++/Golang/JavaScript/Rust/Scala/Kotlin/TypeScript。
零拷貝：受pickle5和堆外讀/寫啟發的跨語言帶外序列化。
高效能：高度可擴展的 JIT 框架，可在運行時以非同步多執行緒方式產生序列化器程式碼以加速序列化，透過以下方式提供 20-170 倍的加速：
- 透過在生成的程式碼中內聯變數來減少記憶體存取。
- 透過產生程式碼中的內聯呼叫減少虛擬方法呼叫。
- 減少條件分支。
- 減少哈希查找。
多種二進位協定：物件圖、行格式等。

除了跨語言序列化之外，Fury 還具有以下功能：

Drop-in 取代 JDK/Kryo/Hessian 等 Java 序列化框架，但最多快 100 倍，可大幅提高高效能 RPC 呼叫、資料傳輸和物件持久化的效率。
與 JDK 序列化 API 100% 相容，實作速度更快：支援 JDK writeObject / readObject / writeReplace / readResolve / readObjectNoData / Externalizable API。
支援Java 8~21 ，也支援Java 17+ record 。
支援GraalVM 原生鏡像的 AOT 編譯序列化，且不需要反射/序列化 json 配置。
支援 golang 的共享和循環引用物件序列化。
支持scala序列化
支援 Kotlin 序列化
支援 golang 自動物件序列化。

協定

Fury針對不同場景設計並實現了多種二進位協定：

xlang序列化格式：
- 跨語言自動序列化任何對象，無需 IDL 定義、模式編譯以及對象與協定之間的轉換。
- 支援可選的共享引用和循環引用，無重複資料或遞歸錯誤。
- 支援物件多態性。
Java 序列化格式：Java 序列化的高度最佳化與直接取代。
Row format格式：一種快取友好的二進位隨機存取格式，支援跳過序列化和部分序列化，並且可以自動轉換為column格式。

基於Fury現有的緩衝區、編碼、元、程式碼產生等功能，可以輕鬆新增協定。所有這些都共享相同的程式碼庫，並且一種協定的最佳化可以由另一種協定重複使用。

基準測試

不同的序列化框架適合不同的場景，這裡的基準測試結果僅供參考。

如果您需要針對特定場景進行基準測試，請確保所有序列化框架都針對該場景進行了適當配置。

動態序列化框架支援多態性和引用，但與靜態序列化框架相比，它們通常具有更高的成本，除非它們像 Fury 那樣使用 JIT 技術。為了確保準確的基準統計數據，建議在由於 Fury 的運行時程式碼產生而收集數據之前預熱系統。

Java序列化

在下面的這些圖表中，包含「相容」的標題代表模式相容模式：類型向前/向後相容性已啟用；而沒有「相容」的標題表示模式一致模式：序列化和反序列化之間的類別模式必須相同。

其中Struct是一個具有 100 個原始欄位的類， MediaContent是來自 jvm-serializers 的類，而Sample是來自 kryo benchmark 的類別。

有關類型前向/後向相容性、堆外支援、零拷貝序列化的更多基準測試，請參閱基準測試。

安裝

爪哇

夜間快照：

< repositories >
  < repository >
    < id >apache</ id >
    < url >https://repository.apache.org/snapshots/</ url >
    < releases >
      < enabled >false</ enabled >
    </ releases >
    < snapshots >
      < enabled >true</ enabled >
    </ snapshots >
  </ repository >
</ repositories >
< dependency >
  < groupId >org.apache.fury</ groupId >
  < artifactId >fury-core</ artifactId >
  < version >0.10.0-SNAPSHOT</ version >
</ dependency >
<!-- row/arrow format support -->
<!-- <dependency>
  <groupId>org.apache.fury</groupId>
  <artifactId>fury-format</artifactId>
  <version>0.10.0-SNAPSHOT</version>
</dependency> -->

發布版本：

< dependency >
  < groupId >org.apache.fury</ groupId >
  < artifactId >fury-core</ artifactId >
  < version >0.9.0</ version >
</ dependency >
<!-- row/arrow format support -->
<!-- <dependency>
  <groupId>org.apache.fury</groupId>
  <artifactId>fury-format</artifactId>
  <version>0.9.0</version>
</dependency> -->

斯卡拉

斯卡拉2：

libraryDependencies += " org.apache.fury " % " fury-scala_2.13 " % " 0.9.0 "

斯卡拉3：

libraryDependencies += " org.apache.fury " % " fury-scala_3 " % " 0.9.0 "

科特林

< dependency >
  < groupId >org.apache.fury</ groupId >
  < artifactId >fury-kotlin</ artifactId >
  < version >0.9.0</ version >
</ dependency >

Python

pip install pyfury

JavaScript

npm install @furyjs/fury

戈蘭

go get github.com/apache/fury/go/fury

快速入門

這裡我們快速入門如何使用 Fury，有關 java、跨語言和行格式的更多詳細資訊請參閱使用者指南。

Fury java物件圖序列化

如果你沒有跨語言的需求，使用這種模式會帶來更好的效能。

 import org . apache . fury .*;
import org . apache . fury . config .*;
import java . util .*;

public class Example {
  public static void main ( String [] args ) {
    SomeClass object = new SomeClass ();
    // Note that Fury instances should be reused between
    // multiple serializations of different objects.
    {
      Fury fury = Fury . builder (). withLanguage ( Language . JAVA )
        . requireClassRegistration ( true )
        . build ();
      // Registering types can reduce class name serialization overhead, but not mandatory.
      // If class registration enabled, all custom types must be registered.
      fury . register ( SomeClass . class );
      byte [] bytes = fury . serialize ( object );
      System . out . println ( fury . deserialize ( bytes ));
    }
    {
      ThreadSafeFury fury = Fury . builder (). withLanguage ( Language . JAVA )
        . requireClassRegistration ( true )
        . buildThreadSafeFury ();
      // Registering types can reduce class name serialization overhead, but not mandatory.
      // If class registration enabled, all custom types must be registered.
      fury . register ( SomeClass . class );
      byte [] bytes = fury . serialize ( object );
      System . out . println ( fury . deserialize ( bytes ));
    }
    {
      ThreadSafeFury fury = new ThreadLocalFury ( classLoader -> {
        Fury f = Fury . builder (). withLanguage ( Language . JAVA )
          . withClassLoader ( classLoader ). build ();
        f . register ( SomeClass . class );
        return f ;
      });
      byte [] bytes = fury . serialize ( object );
      System . out . println ( fury . deserialize ( bytes ));
    }
  }
}

跨語言物件圖序列化

爪哇

 import org . apache . fury .*;
import org . apache . fury . config .*;
import java . util .*;

public class ReferenceExample {
  public static class SomeClass {
    SomeClass f1 ;
    Map < String , String > f2 ;
    Map < String , String > f3 ;
  }

  public static Object createObject () {
    SomeClass obj = new SomeClass ();
    obj . f1 = obj ;
    obj . f2 = ofHashMap ( "k1" , "v1" , "k2" , "v2" );
    obj . f3 = obj . f2 ;
    return obj ;
  }

  // mvn exec:java -Dexec.mainClass="org.apache.fury.examples.ReferenceExample"
  public static void main ( String [] args ) {
    Fury fury = Fury . builder (). withLanguage ( Language . XLANG )
      . withRefTracking ( true ). build ();
    fury . register ( SomeClass . class , "example.SomeClass" );
    byte [] bytes = fury . serialize ( createObject ());
    // bytes can be data serialized by other languages.
    System . out . println ( fury . deserialize ( bytes ));
  }
}

Python

 from typing import Dict
import pyfury

class SomeClass :
    f1 : "SomeClass"
    f2 : Dict [ str , str ]
    f3 : Dict [ str , str ]

fury = pyfury . Fury ( ref_tracking = True )
fury . register_class ( SomeClass , type_tag = "example.SomeClass" )
obj = SomeClass ()
obj . f2 = { "k1" : "v1" , "k2" : "v2" }
obj . f1 , obj . f3 = obj , obj . f2
data = fury . serialize ( obj )
# bytes can be data serialized by other languages.
print ( fury . deserialize ( data ))

戈蘭

 package main

import furygo "github.com/apache/fury/go/fury"
import "fmt"

func main () {
 type SomeClass struct {
  F1 * SomeClass
  F2 map [ string ] string
  F3 map [ string ] string
 }
 fury := furygo . NewFury ( true )
 if err := fury . RegisterTagType ( "example.SomeClass" , SomeClass {}); err != nil {
  panic ( err )
 }
 value := & SomeClass { F2 : map [ string ] string { "k1" : "v1" , "k2" : "v2" }}
 value . F3 = value . F2
 value . F1 = value
 bytes , err := fury . Marshal ( value )
 if err != nil {
 }
 var newValue interface {}
 // bytes can be data serialized by other languages.
 if err := fury . Unmarshal ( bytes , & newValue ); err != nil {
  panic ( err )
 }
 fmt . Println ( newValue )
}

行格式

爪哇

 public class Bar {
  String f1 ;
  List < Long > f2 ;
}

public class Foo {
  int f1 ;
  List < Integer > f2 ;
  Map < String , Integer > f3 ;
  List < Bar > f4 ;
}

RowEncoder < Foo > encoder = Encoders . bean ( Foo . class );
Foo foo = new Foo ();
foo . f1 = 10 ;
foo . f2 = IntStream . range ( 0 , 1000000 ). boxed (). collect ( Collectors . toList ());
foo . f3 = IntStream . range ( 0 , 1000000 ). boxed (). collect ( Collectors . toMap ( i -> "k" + i , i -> i ));
List < Bar > bars = new ArrayList <>( 1000000 );
for ( int i = 0 ; i < 1000000 ; i ++) {
  Bar bar = new Bar ();
  bar . f1 = "s" + i ;
  bar . f2 = LongStream . range ( 0 , 10 ). boxed (). collect ( Collectors . toList ());
  bars . add ( bar );
}
foo . f4 = bars ;
// Can be zero-copy read by python
BinaryRow binaryRow = encoder . toRow ( foo );
// can be data from python
Foo newFoo = encoder . fromRow ( binaryRow );
// zero-copy read List<Integer> f2
BinaryArray binaryArray2 = binaryRow . getArray ( 1 );
// zero-copy read List<Bar> f4
BinaryArray binaryArray4 = binaryRow . getArray ( 3 );
// zero-copy read 11th element of `readList<Bar> f4`
BinaryRow barStruct = binaryArray4 . getStruct ( 10 );

// zero-copy read 6th of f2 of 11th element of `readList<Bar> f4`
barStruct . getArray ( 1 ). getInt64 ( 5 );
RowEncoder < Bar > barEncoder = Encoders . bean ( Bar . class );
// deserialize part of data.
Bar newBar = barEncoder . fromRow ( barStruct );
Bar newBar2 = barEncoder . fromRow ( binaryArray4 . getStruct ( 20 ));

Python

 @ dataclass
class Bar :
    f1 : str
    f2 : List [ pa . int64 ]
@ dataclass
class Foo :
    f1 : pa . int32
    f2 : List [ pa . int32 ]
    f3 : Dict [ str , pa . int32 ]
    f4 : List [ Bar ]

encoder = pyfury . encoder ( Foo )
foo = Foo ( f1 = 10 , f2 = list ( range ( 1000_000 )),
         f3 = { f"k { i } " : i for i in range ( 1000_000 )},
         f4 = [ Bar ( f1 = f"s { i } " , f2 = list ( range ( 10 ))) for i in range ( 1000_000 )])
binary : bytes = encoder . to_row ( foo ). to_bytes ()
foo_row = pyfury . RowData ( encoder . schema , binary )
print ( foo_row . f2 [ 100000 ], foo_row . f4 [ 100000 ]. f1 , foo_row . f4 [ 200000 ]. f2 [ 5 ])

相容性

架構相容性

Fury java物件圖序列化支援類別模式向前/向後相容性。序列化對等體和反序列化對等體可以獨立新增/刪除欄位。

我們計劃在元壓縮完成後添加跨語言序列化的模式相容性支援。

二進位相容性

我們仍在改進我們的協議，因此目前無法保證 Fury 主要版本之間的二進位相容性。但是，小版本之間是有保證的。如果您將來要升級 Fury，請按 Fury 主要版本對您的資料versioning ，請參閱如何升級 Fury 以了解更多詳細資訊。

Fury 1.0 發佈時將保證二進位相容性。

安全

靜態序列化相對安全。但動態序列化如Fury java/python原生序列化支援反序列化未註冊類型，提供了更多的動態性和靈活性，但也引入了安全風險。

例如，反序列化可能會呼叫init建構函式或equals / hashCode方法，如果方法體中包含惡意程式碼，系統就會面臨風險。

Fury 提供了一個類別註冊選項，預設為此類協定啟用，僅允許反序列化受信任的註冊類型或內建類型。不要停用類別註冊，除非您可以確保您的環境是安全的。

如果停用此選項，您將負責序列化安全性。您可以透過ClassResolver#setClassChecker設定org.apache.fury.resolver.ClassChecker來控制哪些類別允許序列化。

若要回報 Fury 中發現的安全漏洞，請遵循 ASF 漏洞報告流程。

如何建造

請閱讀建置指南以取得有關如何建置的說明。

如何貢獻

請閱讀貢獻指南以獲取有關如何貢獻的說明。

執照

根據 Apache 授權 2.0 版獲得許可

展開

fury

特徵

協定

基準測試

Java序列化

安裝

爪哇

斯卡拉

科特林

Python

JavaScript

戈蘭

快速入門

Fury java物件圖序列化

跨語言物件圖序列化

行格式

爪哇

Python

相容性

架構相容性

二進位相容性

安全

如何建造

如何貢獻

執照

Titan Fury遊戲

殭屍狂暴射擊遊戲（Zombie Fury）

離子之怒

chat.petals.dev

GPT Prompt Templates

GPTyped

redisson

opentelemetry java instrumentation

kkFileView

waymo open dataset

termwind

wp functions