activej下载 - activej源代码下载

activej

网站数据

1.0.0

下载

介绍

ActiveJ是一个从头开始建造的现代Java平台。它旨在自给自足（没有第三方依赖性），简单，轻巧，并提供竞争性能。 ActiveJ由一系列正交库组成，从依赖注入和高性能异步I/O（由Node.js启发）到应用程序服务器和大数据解决方案。

这些库相对于彼此具有尽可能少的依赖关系，并且可以一起使用或分别使用。 ActiveJ在不是另一个框架中迫使用户在全有或全无的基础上使用它，但是它可以为用户提供尽可能多的自由，以选择特定任务的库组件。

ActiveJ组件

ActiveJ由几个模块组成，可以将其分组为以下类别：

异步- 高性能异步IO，具有有效的事件循环，Nio，Promises，Promises，Streaming和CSP。替代Netty，Rxjava，Akka等。（Promise，Eventloop，Net，CSP，DataStream）

 // Basic eventloop usage
public static void main ( String [] args ) {
    Eventloop eventloop = Eventloop . create ();

    eventloop . post (() -> System . out . println ( "Hello, world!" ));

    eventloop . run ();
}

 // Promise chaining
public static void main ( String [] args ) {
    Eventloop eventloop = Eventloop . builder ()
        . withCurrentThread ()
        . build ();

    Promises . delay ( Duration . ofSeconds ( 1 ), "world" )
        . map ( string -> string . toUpperCase ())
        . then ( string -> Promises . delay ( Duration . ofSeconds ( 3 ))
            . map ( $ -> "HELLO " + string ))
        . whenResult ( string -> System . out . println ( string ));

    eventloop . run ();
}

 // CSP workflow example
ChannelSuppliers . ofValues ( 1 , 2 , 3 , 4 , 5 , 6 )
    . filter ( x -> x % 2 == 0 )
    . map ( x -> 2 * x )
    . streamTo ( ChannelConsumers . ofConsumer ( System . out :: println ));

 // Datastream workflow example
StreamSuppliers . ofValues ( 1 , 2 , 3 , 4 , 5 , 6 )
    . transformWith ( StreamTransformers . filter ( x -> x % 2 == 0 ))
    . transformWith ( StreamTransformers . mapper ( x -> 2 * x ))
    . streamTo ( StreamConsumers . ofConsumer ( System . out :: println ));

HTTP-高性能HTTP服务器和client具有WebSocket支持。它可以用作简单的Web服务器或应用程序服务器。替代其他常规HTTP客户和服务器。（HTTP）

 // Server
public static void main ( String [] args ) throws IOException {
    Eventloop eventloop = Eventloop . create ();

    AsyncServlet servlet = request -> HttpResponse . ok200 ()
        . withPlainText ( "Hello world" )
        . toPromise ();

    HttpServer server = HttpServer . builder ( eventloop , servlet )
        . withListenPort ( 8080 )
        . build ();

    server . listen ();

    eventloop . run ();
}

 // Client
public static void main ( String [] args ) {
    Eventloop eventloop = Eventloop . create ();

    HttpClient client = HttpClient . create ( eventloop );

    HttpRequest request = HttpRequest . get ( "http://localhost:8080" ). build ();

    client . request ( request )
        . then ( response -> response . loadBody ())
        . map ( body -> body . getString ( StandardCharsets . UTF_8 ))
        . whenResult ( bodyString -> System . out . println ( bodyString ));

    eventloop . run ();
}

ActiveJ注入- 依赖注入的轻质库。优化用于快速应用程序启动和运行时性能。支持基于注释的组件接线以及无反射接线。（ActiveJ注入）

 // Manual binding
public static void main ( String [] args ) {
    Module module = ModuleBuilder . create ()
        . bind ( int . class ). toInstance ( 101 )
        . bind ( String . class ). to ( number -> "Hello #" + number , int . class )
        . build ();

    Injector injector = Injector . of ( module );

    String string = injector . getInstance ( String . class );

    System . out . println ( string ); // "Hello #101"
}

 // Binding via annotations
public static class MyModule extends AbstractModule {
    @ Provides
    int number () {
        return 101 ;
    }

    @ Provides
    String string ( int number ) {
        return "Hello #" + number ;
    }
}

public static void main ( String [] args ) {
    Injector injector = Injector . of ( new MyModule ());

    String string = injector . getInstance ( String . class );

    System . out . println ( string ); // "Hello #101"
}

启动- 用于运行和监视ActiveJ应用程序的生产的工具。同时控制服务生命周期的依赖性。具有JMX和Zabbix支持的各种服务监视实用程序。（发射器，服务图，JMX，触发器）

 public class MyLauncher extends Launcher {
    @ Inject
    String message ;

    @ Provides
    String message () {
        return "Hello, world!" ;
    }

    @ Override
    protected void run () {
        System . out . println ( message );
    }

    public static void main ( String [] args ) throws Exception {
        Launcher launcher = new MyLauncher ();
        launcher . launch ( args );
    }
}

字节码操纵

ActiveJ CodeGen-在ObjectWeb ASM库顶上的类和方法的动态字节码生成器。摘要直接字节码操作的复杂性，并允许您使用类似LISP的AST表达式即时创建自定义类。（ActiveJ Codegen）

 // Manually implemented method
public class MyCounter implements Counter { 
    @ Override
    public int countSum () {
        int sum = 0 ;
        for ( int i = 0 ; i < 100 ; i ++) {
            sum += i ;
        }
        return sum ;
    }
}

 // The same method generated via ActiveJ Codegen 
public static void main ( String [] args ) {
    DefiningClassLoader classLoader = DefiningClassLoader . create ();

    Counter counter = ClassGenerator . builder ( Counter . class )
        . withMethod ( "countSum" ,
            let ( value ( 0 ), sum ->
                sequence (
                    iterate (
                        value ( 0 ),
                        value ( 100 ),
                        i -> set ( sum , add ( sum , i ))),
                    sum
                )))
        . build ()
        . generateClassAndCreateInstance ( classLoader );

    System . out . println ( counter . countSum ()); // 4950
}

ActiveJ Serializer-使用字节码工程创建的快速和空间效率的序列化器。介绍无模式的方法以获得最佳性能。（ActiveJ序列化器）

 // A class to be serialized
public class User {
    private final int id ;
    private final String name ;

    public User ( @ Deserialize ( "id" ) int id , @ Deserialize ( "name" ) String name ) {
        this . id = id ;
        this . name = name ;
    }

    @ Serialize
    public int getId () {
        return id ;
    }

    @ Serialize
    public String getName () {
        return name ;
    }
}

 // Serialization and deserialization
public static void main ( String [] args ) {
    BinarySerializer < User > userSerializer = SerializerFactory . defaultInstance ()
        . create ( User . class );

    User john = new User ( 1 , "John" );

    byte [] buffer = new byte [ 100 ];
    userSerializer . encode ( buffer , 0 , john );

    User decoded = userSerializer . decode ( buffer , 0 );

    System . out . println ( decoded . id );   // 1
    System . out . println ( decoded . name ); // John
}

 // Serialization of Java records
@ SerializeRecord
public record User ( int id , String name ) {
}

 // StreamCodec usage example
public static void main ( String [] args ) throws IOException {
    StreamCodec < User > userStreamCodec = StreamCodec . create ( User :: new ,
        User :: getId , StreamCodecs . ofVarInt (),
        User :: getName , StreamCodecs . ofString ()
    );

    List < User > users = List . of (
        new User ( 1 , "John" ),
        new User ( 2 , "Sarah" ),
        new User ( 3 , "Ben" )
    );

    ByteArrayOutputStream baos = new ByteArrayOutputStream ();
    try ( StreamOutput streamOutput = StreamOutput . create ( baos )) {
        for ( User user : users ) {
            userStreamCodec . encode ( streamOutput , user );
        }
    }

    ByteArrayInputStream bais = new ByteArrayInputStream ( baos . toByteArray ());
    try ( StreamInput streamInput = StreamInput . create ( bais )) {
        while (! streamInput . isEndOfStream ()) {
            User decoded = userStreamCodec . decode ( streamInput );
            System . out . println ( decoded . getId () + " " + decoded . getName ());
        }
    }
}

ActiveJ Specializer-通过将类实例自动将类实例转换为专业静态类和类实例字段的创新技术，以提高运行时的类表现。为静态类提供了各种各样的JVM优化，否则是不可能的：消除死亡代码，积极的方法和静态常数。（ActiveJ Specializer）

 // Operators
public record IdentityOperator () implements IntUnaryOperator {
    @ Override
    public int applyAsInt ( int operand ) {
        return operand ;
    }
}

public record ConstOperator ( int value ) implements IntUnaryOperator {
    @ Override
    public int applyAsInt ( int operand ) {
        return value ;
    }
}

public record SumOperator ( IntUnaryOperator left , IntUnaryOperator right ) implements IntUnaryOperator {
    @ Override
    public int applyAsInt ( int operand ) {
        return left . applyAsInt ( operand ) + right . applyAsInt ( operand );
    }
}

public record ProductOperator ( IntUnaryOperator left , IntUnaryOperator right ) implements IntUnaryOperator {
    @ Override
    public int applyAsInt ( int operand ) {
        return left . applyAsInt ( operand ) * right . applyAsInt ( operand );
    }
}

 // Expression specialization
public static void main ( String [] args ) {
    // ((x + 10) * (-5)) + 33
    IntUnaryOperator expression = new SumOperator (
        new ProductOperator (
            new ConstOperator (- 5 ),
            new SumOperator (
                new ConstOperator ( 10 ),
                new IdentityOperator ()
            )
        ),
        new ConstOperator ( 33 )
    );

    Specializer specializer = Specializer . create ();
    expression = specializer . specialize ( expression );

    System . out . println ( expression . applyAsInt ( 0 ));  // -17
}

云组件

ActiveJ FS-文件系统上的异步抽象，用于构建有效的，可扩展的本地或远程文件存储，以支持数据冗余，重新平衡和重新降低。（ActiveJ FS）

 public static void main ( String [] args ) throws IOException {
    Eventloop eventloop = Eventloop . builder ()
        . withCurrentThread ()
        . build ();

    HttpClient httpClient = HttpClient . create ( eventloop );

    ExecutorService executor = Executors . newCachedThreadPool ();

    Path directory = Files . createTempDirectory ( "fs" );

    FileSystem fileSystem = FileSystem . create ( eventloop , executor , directory );

    String filename = "file.txt" ;

    fileSystem . start ()
            // Upload
            . then (() -> fileSystem . upload ( filename ))
            . then ( consumer -> httpClient . request ( HttpRequest . get ( "http://localhost:8080" ). build ())
                . then ( response -> response . loadBody ())
                . then ( body -> ChannelSuppliers . ofValue ( body ). streamTo ( consumer )))

            // Download
            . then (() -> fileSystem . download ( filename ))
            . then ( supplier -> supplier . streamTo ( ChannelConsumers . ofConsumer ( byteBuf ->
                System . out . println ( byteBuf . asString ( StandardCharsets . UTF_8 )))))

            // Cleanup
            . whenComplete ( executor :: shutdown );

    eventloop . run ();
}

ActiveJ RPC-高性能二进制客户端服务器协议。允许建筑物分布式，碎片和容忍缺陷的微服务应用。（ActiveJ RPC）

 // Server
public static void main ( String [] args ) throws IOException {
    Eventloop eventloop = Eventloop . create ();

    RpcServer server = RpcServer . builder ( eventloop )
        . withMessageTypes ( String . class )
        . withHandler ( String . class , name -> Promise . of ( "Hello, " + name ))
        . withListenPort ( 9000 )
        . build ();

    server . listen ();

    eventloop . run ();
}

 // Client
public static void main ( String [] args ) {
    Eventloop eventloop = Eventloop . create ();

    RpcClient client = RpcClient . builder ( eventloop )
        . withStrategy ( RpcStrategies . server ( new InetSocketAddress ( 9000 )))
        . withMessageTypes ( String . class )
        . build ();

    client . start ()
        . then (() -> client . sendRequest ( "John" ))
        . whenResult ( response -> System . out . println ( response )) // "Hello, John"
        . whenComplete ( client :: stop );

    eventloop . run ();
}

各种额外服务：ActiveJ CRDT，Redis客户端，Memcache，Olap Cube，DataFlow

快速开始

将这个片段粘贴到您的终端...

 mvn archetype:generate -DarchetypeGroupId=io.activej -DarchetypeArtifactId=archetype-http -DarchetypeVersion=6.0-beta2

...并在您喜欢的IDE中打开项目。然后构建应用程序并运行它。在Localhost：8080打开您的浏览器，以查看“ Hello World”消息。

具有依赖项注入的全功能嵌入式Web应用程序服务器：

 public final class HttpHelloWorldExample extends HttpServerLauncher {
    @ Provides
    AsyncServlet servlet () {
        return request -> HttpResponse . ok200 ()
            . withPlainText ( "Hello, World!" )
            . toPromise ();
    }

    public static void main ( String [] args ) throws Exception {
        Launcher launcher = new HttpHelloWorldExample ();
        launcher . launch ( args );
    }
}