Comment implémenter une simple fonction de planification de tâches asynchrones à l'aide de MySQL et Ruby

Comment utiliser MySQL et Ruby pour implémenter une simple fonction de planification de tâches asynchrones

Les applications Web précédentes utilisaient principalement une méthode synchrone pour traiter les requêtes, c'est-à-dire qu'une fois que l'utilisateur envoie une requête, le serveur traitera immédiatement la requête et renvoie le résultat. Cependant, à mesure que la complexité des applications augmente, l'efficacité du traitement des méthodes synchrones devient progressivement inefficace, de sorte que la planification asynchrone des tâches est devenue une exigence courante dans les applications Web modernes.

Cet article expliquera comment utiliser MySQL et Ruby pour implémenter une fonction de planification de tâches asynchrone simple, y compris les étapes de création, de planification et d'exécution de tâches. Nous utiliserons un exemple de robot d'exploration de site Web pour illustrer le processus de mise en œuvre de cette fonction.

1. Créer une table de base de données MySQL

Tout d'abord, nous devons créer une table dans MySQL pour stocker les informations sur les tâches. Vous pouvez utiliser l'instruction SQL suivante pour créer une table :

CREATE TABLE tasks (
  id INT(11) PRIMARY KEY AUTO_INCREMENT,
  url VARCHAR(255) NOT NULL,
  status ENUM('pending', 'completed') DEFAULT 'pending',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Cette table contient des champs tels que l'ID de la tâche, l'URL, le statut et l'heure de création.

2. Connexion à MySQL à l'aide de Ruby

Dans le code Ruby, nous devons utiliser la bibliothèque appropriée pour nous connecter à la base de données MySQL. Ici, nous utilisons la gem "mysql2" pour terminer le travail de connexion. La bibliothèque peut être installée via la commande suivante :

gem install mysql2

Dans le code, nous devons d'abord importer la bibliothèque et établir une connexion à la base de données :

require 'mysql2'
client = Mysql2::Client.new(host: 'localhost', username: 'root', password: 'password', database: 'task_scheduler')

Établissez la connexion en transmettant l'adresse de l'hôte, le nom d'utilisateur, le mot de passe et le nom de la base de données correspondants. .

3. Créer une tâche

L'étape suivante consiste à créer la tâche. Nous pouvons utiliser le code suivant pour créer une tâche :

def create_task(url)
  sql = "INSERT INTO tasks (url) VALUES ('#{url}')"
  client.query(sql)
  puts "Task created successfully."
end

create_task('http://example.com')

Cette fonction accepte un paramètre URL et l'insère dans la table des tâches. Le statut de la tâche sera défini sur « en attente » par défaut.

4. Planification des tâches

La planification des tâches implique d'interroger les tâches en attente et de les envoyer à un processeur asynchrone. Les tâches peuvent être planifiées à l'aide du code suivant :

def schedule_tasks
  sql = "SELECT * FROM tasks WHERE status = 'pending'"
  tasks = client.query(sql)

  tasks.each do |task|
    handle_task_async(task)
  end

  puts "Tasks scheduled successfully."
end

def handle_task_async(task)
  # 执行异步任务处理逻辑
end

schedule_tasks

Dans cet exemple, nous interrogeons d'abord les tâches en attente, puis parcourons chaque tâche et appelons la fonction handle_task_async pour traiter la tâche. La logique réelle de traitement des tâches doit être écrite en fonction des exigences de l'application.

5. Exécuter la tâche

L'exécution de la tâche implique de supprimer la tâche de la file d'attente des tâches et d'exécuter la logique de traitement correspondante. Le code suivant peut être utilisé pour exécuter des tâches :

def execute_tasks
  # 从任务队列中获取任务
  # 执行相应的处理逻辑
end

execute_tasks

Dans les applications pratiques, d'autres méthodes (telles que les files d'attente de messages) peuvent être utilisées pour implémenter des files d'attente de tâches, puis extraire des tâches de la file d'attente et les exécuter. Ceci est juste un exemple simplifié.

Grâce aux étapes ci-dessus, nous avons implémenté une fonction simple de planification de tâches asynchrones. Lorsqu'une tâche est créée, nous l'insérons dans une table de base de données MySQL. Ensuite, grâce au planificateur de tâches, nous pouvons interroger et planifier les tâches en attente et les envoyer au processeur asynchrone pour exécution. Cette approche peut grandement améliorer les performances et l’évolutivité des applications.

L'exemple de code ci-dessus n'est qu'une démonstration, et la mise en œuvre réelle peut impliquer plus de détails et une logique de traitement. Mais j'espère qu'à travers cet exemple, les lecteurs pourront comprendre comment utiliser MySQL et Ruby pour implémenter une simple fonction de planification de tâches asynchrones, et pourront l'étendre et l'optimiser dans des applications pratiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!