Evento Framework
  • Introduction
  • Architecture Overview
    • Distributed Systems & Microservices
    • Recative Manifesto & Reactive Principles
    • State-of-the-art Patterns
      • DDD (Domain Driven Design)
      • CQRS (Command Query Responsability Separation)
      • Event Sourcing
      • Messaging
      • Saga
  • GETTING STARTED
    • Quick Start
    • TodoList - RECQ Tutorial
      • Problem Description and Requirement Gathering
      • RECQ Payload Design
      • RECQ Components Design
      • Set up your Development Environment
      • RECQ Payload Evento Implementation
        • Domain Commands
        • Domain Events
        • Views
        • Queries
      • RECQ Components Evento Implementation with Spring Data
        • TodoListAggregate
        • TodoList Model with Spring Data
        • TodoListProjector
        • TodoListProjection
        • TodoList Invoker
      • Expose the RECQ architecture with Spring Web
      • Test Your App
    • Extend TodoList - Handle Complexity Tutorial
      • Unique identifier generation
      • Extends behaviors with Observer and Services
      • Cross Domain Consistency with Sagas
      • Handle Real time data updates with MQTT and Save-Notify Pattern
  • RECQ Patterns
    • RECQ Patterns
    • RECQ System Pattern
      • Component
      • Message Gateway
      • System State Store
    • RECQ Communication Pattern
      • Component to Component
      • Component to System State Store
      • System State Store to Component
    • RECQ Component Pattern
      • Aggregate
      • Projector
      • Projection
      • Service
      • Invoker
      • Saga
      • Observer
  • Evento Framework
    • Evento Framework Introcution
    • Payload and Messages
      • Command
        • Domain Command
        • Service Command
      • Event
        • Domain and Service Event
      • Query and View
    • @Component
      • @Aggregate
        • Aggregate State
        • @AggregateCommandHandler
        • @EventSourcingHandler
      • @Projector
        • Projector @EventHandler
      • @Projection
        • @QueryHandler
      • @Service
        • @CommandHandler
      • @Invoker
      • @Saga
        • SagaState
        • @SagaEventHandler
      • @Observer
    • Dead Event Queues
    • EventoBundle
      • EventoServerMessageBusConfiguration
      • ConsumerStateStore
        • InMemoryConsumerStateStore
        • PostgresConsumerStateStore
        • MysqlConsumerStateStore
      • Context
      • TracingAgend and @Track
        • SentryTracingAgent
      • Autoscaling Protocol
        • ThreadCountAutoscalingProtocol
      • Injector and @Component
  • Evento Server
    • Evento Server Introduction
    • SetUp Evento Server
      • Advanced Options
      • Evento Event Store Modes: APES and CPES
    • Evento Server Cluster
    • Bundle Deploy Script
  • EVENTO GUI
    • Explore RECQ Systems Visually
    • GUI Auth
    • Payload Catalog
    • Component Catalog
    • Bundle Catalog
    • Cluster Status (Experimental)
    • Flows
      • Performance Evaluation
    • Application Graph
    • System State Store
  • Evento CLI
    • Evento CLI Introduction
    • Update Version
    • Publish
Powered by GitBook
On this page
  1. Evento Framework

Evento Framework Introcution

Evento Framework is a Java library designed to simplify the development of reactive systems based on the RECQ architecture. RECQ stands for:

  • Reactive: Systems are responsive to user interactions and data changes.

  • Event-driven: Communication between different parts of the application happens through events.

  • CQRS (Command Query Responsibility Segregation): Separate components handle data reads (queries) and writes (commands) for better performance and scalability.

  • Microservices: The application is broken down into smaller, independent services that communicate with each other.

Evento Framework provides functionalities to implement these RECQ principles effectively. Here are some key features of Evento:

  • Event Handling: Evento offers functionalities for publishing and subscribing to events, enabling communication between different parts of the application.

  • Reactive Components: The framework helps build reactive components that respond asynchronously to events and data changes.

  • CQRS Support: Evento streamlines the implementation of CQRS architecture by providing separate mechanisms for handling commands and queries.

  • Simplified Communication: It facilitates communication between microservices using asynchronous messaging patterns.

Benefits of using Evento Framework:

  • Improved Maintainability: By promoting modularity and clear separation of concerns, Evento makes applications easier to understand and maintain.

  • Scalability: The microservices architecture supported by Evento allows for easier scaling of the application as needed.

  • Resilience: Event-driven communication helps build more resilient applications as failures in one component are less likely to cascade to others.

  • Faster Development: The framework provides reusable components and patterns, speeding up development compared to building everything from scratch.

Who should use Evento Framework?

Evento Framework is well-suited for developers who want to build:

  • Reactive and scalable Java applications

  • Applications leveraging the RECQ architecture

  • Microservices-based systems with asynchronous communication

PreviousObserverNextPayload and Messages

Last updated 1 year ago