reactor-netty - TCP/HTTP/UDP client/server with Reactor over Netty

  •        144

TCP/HTTP/UDP client/server with Reactor over Netty

http://projectreactor.io
https://github.com/reactor/reactor-netty

Tags
Implementation
License
Platform

   




Related Projects

reactor-core - Non-Blocking Reactive Foundation for the JVM

  •    Java

Non-Blocking Reactive Streams Foundation for the JVM both implementing a Reactive Extensions inspired API and efficient event streaming support. Reactor 3 requires Java 8 or + to run.

rsocket-java - Java implementation of RSocket

  •    Java

RSocket is a binary protocol for use on byte stream transports such as TCP, WebSockets, and Aeron.Snapshots are available via JFrog.

spring-reactive-sample - Spring 5 Reactive playground

  •    Java

Reactive or Reactive Streams is a hot topic in these days, you can see it in blog entries, presentations, or some online course. Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.This encompasses efforts aimed at runtime environments (JVM and JavaScript) as well as network protocols.

EventMachine - Fast, simple event-processing library for Ruby programs

  •    Ruby

EventMachine is an event-driven I/O and lightweight concurrency library for Ruby. It provides event-driven I/O using the Reactor pattern, much like JBoss Netty, Apache MINA, Python's Twisted, Node.js, libevent and libev.

cyclops - Home of the cyclops integration modules : support for Scala, Clojure, RxJava (1+2), Reactor, FunctionalJava, Guava, Dexx & Vavr

  •    Java

Define ulta-generic code that can be used by types across Vavr, Reactor, cyclops-react, Guava, JDK, Functional Java, RxJava.cyclops & cyclops-react allow collection types from all major functional libraries to be used behind fast lazy & reactive collection apis.


cf-java-client - Java Client Library for Cloud Foundry

  •    Java

The cf-java-client project is a Java language binding for interacting with a Cloud Foundry instance. The project is broken up into a number of components which expose different levels of abstraction depending on need. Both the cloudfoundry-operations and cloudfoundry-client projects follow a "Reactive" design pattern and expose their responses with Project Reactor Monoss and Fluxs.

cyclops-integration - Home of the cyclops integration modules : support for Scala, Clojure, RxJava (1+2), Reactor, FunctionalJava, Guava, Dexx & Vavr

  •    Java

Define ultra-generic code that can be used by types across Vavr, Reactor, cyclops-react, Guava, JDK, Functional Java, RxJava. cyclops & cyclops-react allow collection types from all major functional libraries to be used behind fast lazy & reactive collection apis.

vert.x - Vert.x is a tool-kit for building reactive applications on the JVM

  •    Java

This is the repository for Vert.x core.Vert.x core contains fairly low-level functionality, including support for HTTP, TCP, file system access, and various other features. You can use this directly in your own applications, and it's used by many of the other components of Vert.x.

nettosphere - A Java WebSocket/HTTP server based on the Atmosphere and Netty Framework

  •    Java

NettoSphere: A HTTP/WebSocket server powered by Atmosphere and Netty Framework

Ribbon - IPC library with built in software load balancers

  •    Java

Ribbon is a client side IPC library that is battle-tested in cloud. It provides Load balancing, Fault tolerance, Multiple protocol (HTTP, TCP, UDP), support in an asynchronous and reactive model Caching and batching.

elastic4s - Elasticsearch Scala Client - Non Blocking, Type Safe, HTTP, TCP

  •    Scala

Elastic4s is a concise, idiomatic, reactive, type safe Scala client for Elasticsearch. The client can be used over both HTTP and TCP by choosing either of the elastic4s-http or elastic4s-tcp submodules. The official Elasticsearch Java client can of course be used in Scala, but due to Java's syntax it is more verbose and it naturally doesn't support classes in the core Scala core library nor Scala idioms.Elastic4s's DSL allows you to construct your requests programatically, with syntactic and semantic errors manifested at compile time, and uses standard Scala futures to enable you to easily integrate into an asynchronous workflow. The aim of the DSL is that requests are written in a builder-like way, while staying broadly similar to the Java API or Rest API. Each request is an immutable object, so you can create requests and safely reuse them, or further copy them for derived requests. Because each request is strongly typed your IDE or editor can use the type information to show you what operations are available for any request type.

Netty - Event-driven Asynchronous Network Application Framework

  •    Java

Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients. Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server.

java-game-server - Jetserver is a high speed nio socket based multiplayer java game server written using Netty and Mike Rettig's Jetlang

  •    Java

Note New version of Jetserver is called Nadron and is in a new netty 4 branch of this same repo. JetServer is a java nio based server specifically designed for mutliplayer games. It supports UDP and TCP transports. It uses Netty for high speed network transmission and Jetlang for extremely fast in-vm message passing between player sessions and game rooms. The project also uses spring for its dependency injection. This way, it is highly configurable and you can swap out any part of the server with your own implementations. The pre-built jar files of this project are located in the jetserver/binaries directory. All dependent jars are located in the jetserver/lib directory. You can add them to your favorite IDE’s classpath for coding. If you want to compile from source, then follow steps below.

alpakka - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka

  •    Scala

Systems don't come alone. In the modern world of microservices and cloud deployment, new components must interact with legacy systems, making integration an important key to success. Reactive Streams give us a technology-independent tool to let these heterogeneous systems communicate without overwhelming each other. The Alpakka project is an open source initiative to implement stream-aware, reactive, integration pipelines for Java and Scala. It is built on top of Akka Streams, and has been designed from the ground up to understand streaming natively and provide a DSL for reactive and stream-oriented programming, with built-in support for backpressure. Akka Streams is a Reactive Streams and JDK 9+ java.util.concurrent.Flow-compliant implementation and therefore fully interoperable with other implementations.

alpakka-kafka - Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka

  •    Scala

Systems don't come alone. In the modern world of microservices and cloud deployment, new components must interact with legacy systems, making integration an important key to success. Reactive Streams give us a technology-independent tool to let these heterogeneous systems communicate without overwhelming each other. The Alpakka project is an open source initiative to implement stream-aware, reactive, integration pipelines for Java and Scala. It is built on top of Akka Streams, and has been designed from the ground up to understand streaming natively and provide a DSL for reactive and stream-oriented programming, with built-in support for backpressure. Akka Streams is a Reactive Streams and JDK 9+ java.util.concurrent.Flow-compliant implementation and therefore fully interoperable with other implementations.

MobileIMSDK - 一个专为移动端开发的原创即时通讯框架,超轻量级、高度提炼,完全基于UDP协议,支持iOS、Android、标准Java平台,服务端基于Mina和Netty编写。

  •    Objective-C

一个专为移动端开发的原创即时通讯框架,超轻量级、高度提炼,完全基于UDP协议,支持iOS、Android、标准Java平台,服务端基于Mina和Netty编写。

RxRuby - Reactive Extensions for Ruby

  •    Ruby

Reactive Programming is a hot topic as of late, especially with such things as the Reactive Manifesto. Applications' needs have changed over time, from simple polling for data to a full reactive system where data is pushed at you. Each time, we're adding more complexity, data, and asynchronous behavior to our applications. How do we manage it all? How do we scale it? By moving towards "Reactive Architectures" which are event-driven, resilient, and responsive. With the Reactive Extensions, you have all the tools you need to help build these systems.The Reactive Extensions for Ruby (RxRuby) is a set of libraries for composing asynchronous and event-based programs using observable sequences and fluent query operators that many of you already know in Ruby. Using RxRuby, developers represent asynchronous data streams with Observables, query asynchronous data streams using our many operators, and parameterize the concurrency in the asynchronous data streams using Schedulers. Simply put, RxRuby = Observables + Operators + Schedulers.

Ratpack - A toolkit for JVM web applications

  •    Java

Ratpack is a set of Java libraries for building modern HTTP applications. It provides just enough for writing practical, high performance, apps. It is built on Java 8, Netty and reactive principles. It is similar to NodeJS, helps to implement non blocking HTTP apps in Java.

TymeacRSE - Java Reactive Streams Push Engine

  •    Java

TymeacRSE is a Recursive Streams push engine for managing the publication and distribution of items to subscribers. An efficient push engine allowing (Reactive Stream) Publishers to generate asynchronous streams for routing to Subscribers. It provides an efficient multitasking service that allows many resource-intensive applications to coexist in a single microservice.

RxPY - Reactive Extensions for Python

  •    Python

Reactive Extensions for Python (RxPY) is a set of libraries for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in Python. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize concurrency in data/event streams using Schedulers.Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, Tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer object. The Observable notifies the subscribed Observer instance whenever an event occurs.You can put various transformations in-between the source Observable and the consuming Observer as well.