Zeker! Hieronder vind je een voorbeeld van hoe je event-driven programmeren in Ruby kunt toepassen voor een chatapplicatie met asynchrone berichtverwerking en gebruikersnotificaties. ### 1. Basisconcepten: Event Emitter en Event Handler In Ruby kun je zelf een eenvoudige event-emitter maken of een bibliotheek gebruiken. Hier laat ik een eenvoudige implementatie zien. ```ruby # Eenvoudige Event Emitter class EventEmitter def initialize @events = {} end def on(event_name, &block) @events[event_name] ||= [] @events[event_name] << block end def emit(event_name, *args) return unless @events[event_name] @events[event_name].each do |handler| Thread.new { handler.call(*args) } # asynchroon uitvoeren end end end ``` ### 2. Voorbeeld: Chatapplicatie met event-driven aanpak ```ruby # Instantiate de emitter emitter = EventEmitter.new # Event handler voor nieuwe berichten emitter.on(:new_message) do |message, gebruiker| # Verwerk het bericht, bijvoorbeeld opslaan in database puts "[#{gebruiker}] stuurt bericht: #{message}" # Stuur notificaties naar andere gebruikers # (Voorbeeld: simulatie) puts "Notificaties verzonden aan andere gebruikers over nieuw bericht van #{gebruiker}." end # Event handler voor gebruikers die zich aanmelden emitter.on(:user_joined) do |gebruiker| puts "#{gebruiker} is nu verbonden met de chat." end # Simulatie van gebeurtenissen emitter.emit(:user_joined, "Jan") sleep(1) # Wacht even voor de duidelijkheid emitter.emit(:new_message, "Hallo allemaal!", "Jan") ``` ### 3. Hoe gebruik je events om de flow te beheren? - **Events definiëren**: zoals `:new_message`, `:user_joined`, `:user_left`. - **Handlers registreren**: voor elke gebeurtenis wat moet gebeuren (opslag, notificaties, logging). - **Events emitten**: wanneer een gebeurtenis plaatsvindt (bijv. een nieuw bericht binnenkomt). Door deze scheiding wordt je code modulair, overzichtelijk en makkelijk uit te breiden. Bijvoorbeeld, je kunt op een simpele manier nieuwe functionaliteiten toevoegen door een nieuwe event handler te registreren zonder de bestaande code aan te passen. ### 4. Performance en schaalbaarheid verbeteren - **Asynchroon verwerken**: door elke handler in een aparte thread uit te voeren, voorkom je dat één handler de rest blokkeert. - **Gebruik van queues**: voor grote schaal kan je een message queue zoals Redis Pub/Sub, RabbitMQ of Kafka integreren om berichten en events te verspreiden. - **Load balancing**: meerdere servers kunnen events via een centrale broker ontvangen en verwerken. - **Caching en database optimalisaties**: minimaliseer latency door gebruik van caching. ### 5. Samenvatting - Ruby's eigen code kan eenvoudig worden uitgebreid met event-driven patronen. - Gebruik `Thread.new` of een achtergrond task manager voor asynchroon verwerken. - Voor grote schaalbaarheid kan je externe message brokers inzetten. - Door events te gebruiken wordt je applicatie modulair, flexibel en beter schaalbaar. --- Heeft je nog verdere vragen of wil je een uitgebreider voorbeeld?

Zeker, ik help je graag met event-driven programmeren in Ruby voor een chatapplicatie. Hier is een uitgebreide uitleg met codevoorbeelden. ## Basisstructuur met EventMachine ```ruby require 'eventmachine' require 'em-websocket' require 'json' class ChatApplication def initialize @connections = [] @event_handlers = {} setup_event_handlers end # Event emitter voor het versturen van berichten def emit_event(event_type, data) event = { type: event_type, data: data, timestamp: Time.now } puts "Event emitted: #{event_type}" # Roep alle geregistreerde handlers aan if @event_handlers[event_type] @event_handlers[event_type].each do |handler| handler.call(event) end end end # Registreer event handlers def on(event_type, &block) @event_handlers[event_type] ||= [] @event_handlers[event_type] << block end private def setup_event_handlers # Handler voor nieuwe berichten on(:new_message) do |event| message = event[:data] puts "Nieuw bericht verwerken: #{message[:content]}" # Asynchrone verwerking EM.defer do process_message(message) emit_event(:message_processed, message) end end # Handler voor notificaties on(:message_processed) do |event| message = event[:data] send_notifications(message) end # Handler voor gebruikersverbindingen on(:user_connected) do |event| user = event[:data] puts "Gebruiker #{user[:name]} is verbonden" @connections << user end on(:user_disconnected) do |event| user = event[:data] puts "Gebruiker #{user[:name]} heeft verbinding verbroken" @connections.delete(user) end end def process_message(message) # Simuleer wat verwerkingstijd sleep(0.1) puts "Bericht verwerkt: #{message[:content]}" end def send_notifications(message) @connections.each do |connection| puts "Notificatie verzonden naar #{connection[:name]}: Nieuw bericht van #{message[:sender]}" # Hier zou je daadwerkelijk de notificatie versturen end end end ``` ## WebSocket Implementatie ```ruby # Main server code EM.run do chat_app = ChatApplication.new EM::WebSocket.run(host: "0.0.0.0", port: 8080) do |ws| ws.onopen do |handshake| user = { name: "User_#{rand(1000)}", connection: ws } chat_app.emit_event(:user_connected, user) end ws.onmessage do |msg| begin data = JSON.parse(msg) chat_app.emit_event(:new_message, { sender: data['sender'], content: data['content'], room: data['room'] }) rescue JSON::ParserError puts "Ongeldig JSON bericht ontvangen" end end ws.onclose do chat_app.emit_event(:user_disconnected, { connection: ws }) end end end ``` ## Gebruiksvoorbeeld ```ruby # Voorbeeld van hoe events worden getriggerd chat_app = ChatApplication.new # Simuleer een binnenkomend bericht chat_app.emit_event(:new_message, { sender: "Jan", content: "Hallo allemaal!", room: "algemeen" }) # Output: # Event emitted: new_message # Nieuw bericht verwerken: Hallo allemaal! # Bericht verwerkt: Hallo allemaal! # Event emitted: message_processed # Notificatie verzonden naar User_123: Nieuw bericht van Jan ``` ## Performance en Schaalbaarheidsverbeteringen ### 1. Gebruik van Message Queues ```ruby require 'bunny' class ScalableChatApplication < ChatApplication def initialize super setup_message_queue end def setup_message_queue @connection = Bunny.new @connection.start @channel = @connection.create_channel @queue = @channel.queue('chat_messages', durable: true) @queue.subscribe(block: false) do |delivery_info, properties, body| message = JSON.parse(body) emit_event(:new_message, message) end end end ``` ### 2. Connection Pooling ```ruby require 'connection_pool' class ConnectionManager def initialize @pool = ConnectionPool.new(size: 5, timeout: 5) do # Database connection of andere resource create_connection end end def with_connection(&block) @pool.with(&block) end end ``` ### 3. Caching Strategie ```ruby require 'redis' class CachedChatApplication < ChatApplication def initialize super @redis = Redis.new @cache_ttl = 300 # 5 minuten end def process_message(message) # Cache recente berichten cache_key = "recent_messages:#{message[:room]}" @redis.lpush(cache_key, message.to_json) @redis.ltrim(cache_key, 0, 99) # Behoud laatste 100 berichten @redis.expire(cache_key, @cache_ttl) end end ``` ## Belangrijke Best Practices 1. **Error Handling**: ```ruby on(:new_message) do |event| EM.defer do begin process_message(event[:data]) rescue => e emit_event(:error, { error: e.message, event: event }) end end end ``` 2. **Monitoring en Metrics**: ```ruby def emit_event(event_type, data) start_time = Time.now # ... bestaande code ... emit_event(:event_processed, { type: event_type, processing_time: Time.now - start_time }) end ``` 3. **Rate Limiting**: ```ruby class RateLimiter def initialize(limit: 100, period: 60) @limit = limit @period = period @counters = {} end def check_limit(user_id) now = Time.now.to_i window = now / @period key = "#{user_id}:#{window}" current = (@counters[key] || 0) + 1 @counters[key] = current current <= @limit end end ``` Deze event-driven aanpak verbetert performance door: - Asynchrone verwerking van berichten - Betere resource utilization - Eenvoudige horizontale schaling - Lagere latentie voor gebruikers - Betere foutisolatie Je kunt verder schalen door meerdere instanties achter een load balancer te zetten en gebruik te maken van gedistribueerde message queues zoals RabbitMQ of Redis Streams.