Panduan Pembangunan Coroutine Asynchronous: Melaksanakan Sistem Gilir Mel yang Sangat Selaras

Panduan Pembangunan Coroutine Asynchronous: Melaksanakan Sistem Gilir Mel yang Sangat Selaras

Aplikasi web moden memainkan peranan penting dalam mencapai keselarasan, prestasi dan kebolehskalaan yang tinggi. Dalam kes ini, model pengaturcaraan coroutine tak segerak telah menjadi penyelesaian yang sangat popular. Operasi tak segerak selalunya melibatkan sejumlah besar tugas intensif pengiraan atau intensif I/O.

Dalam aplikasi bahagian belakang, baris gilir mel ialah alat yang sangat berguna yang boleh membantu kami menghantar sejumlah besar e-mel secara tidak segerak dan menjadikan aplikasi lebih mantap dan boleh dipercayai semasa menghantar e-mel. Untuk melaksanakan sistem baris gilir mel yang sangat serentak, kita boleh menggunakan model coroutine tak segerak dan menggunakan bahasa pengaturcaraan Python.

Artikel ini akan memperkenalkan anda cara menggunakan coroutine tak segerak untuk membangunkan sistem baris gilir mel serentak tinggi dan memberikan contoh kod terperinci.

Langkah 1: Pasang perpustakaan Python yang diperlukan

Sebelum kita mula menulis kod, kita perlu memasang beberapa perpustakaan Python pihak ketiga untuk melaksanakan coroutine tak segerak. Perpustakaan ini ialah asyncio, aiosmtplib, aiordis.

Anda boleh memasangnya menggunakan arahan berikut:

pip install asyncio aiosmtplib aioredis

Langkah 2: Sambung ke pelayan Redis

Dalam contoh ini, kami akan menggunakan Redis sebagai stor data. Redis ialah pangkalan data dalam memori berprestasi tinggi yang sering digunakan untuk caching dan beratur. Kami akan menggunakan perpustakaan Python "aioredis" untuk menyambung ke pelayan Redis.

import asyncio
import aioredis

async def get_redis():
    return await aioredis.create_redis('redis://localhost')

Langkah 3: Cipta Fungsi Menghantar E-mel

Kami akan mulakan dengan mentakrifkan fungsi async yang akan digunakan untuk menghantar e-mel. Untuk ini kami akan menggunakan perpustakaan Python "aiosmtplib". Berikut ialah contoh kod untuk fungsi e-mel:

async def send_email(to_address, message):
    try:
        smtp_client = aiosmtplib.SMTP(hostname='smtp.gmail.com', port=587)
        await smtp_client.connect()
        await smtp_client.starttls()
        await smtp_client.login(user='your_email_address@gmail.com', password='your_password')
        await smtp_client.sendmail(from_addr='your_email_address@gmail.com', to_addrs=[to_address], msg=message)
        await smtp_client.quit()
        return True
    except:
        return False

Langkah 4: Buat fungsi async untuk menghantar e-mel

Sekarang, kami akan mentakrifkan fungsi async yang akan mendapatkan e-mel daripada baris gilir Redis dan menghantarnya. Berikut ialah kod contoh:

async def process_queue():
    redis = await get_redis()
    while True:
        message = await redis.lpop('email_queue')
        if message is not None:
            to_address, subject, body = message.decode('utf-8').split(',')
            email_message = f'Subject: {subject}

{body}'
            result = await send_email(to_address, email_message)
            if result:
                print(f'Sent email to {to_address}')
            else:
                await redis.rpush('email_queue', message)
        else:
            await asyncio.sleep(1)

Dalam kod di atas, kami telah menentukan fungsi tak segerak yang dipanggil "process_queue" yang akan melakukan perkara berikut:

1. Dapatkan contoh Redis daripada pelayan Redis menggunakan fungsi "get_redis".
2. Dapatkan e-mel seterusnya dari baris gilir Redis dengan menggunakan kaedah "lpop".
3. Jika baris gilir kosong, tunggu 1 saat (menggunakan fungsi "asyncio.sleep").
4. Pisah mesej e-mel kepada tiga bahagian - alamat e-mel penerima, subjek e-mel dan isi e-mel.
5. Gunakan fungsi "send_email" untuk menghantar e-mel secara tidak segerak.
6. Jika e-mel mengembalikan Benar, ini bermakna e-mel telah berjaya dihantar kepada penerima.
7. Jika pengirim e-mel mengembalikan Palsu, tunggu giliran e-mel.

Langkah 5: Tambahkan e-mel ke baris gilir

Kini, kami akan mentakrifkan fungsi yang akan digunakan untuk menambah mesej e-mel ke baris gilir Redis. Berikut ialah contoh kod:

async def add_email_to_queue(to_address, subject, body):
    redis = await get_redis()
    email_message = f'{to_address},{subject},{body}'.encode('utf-8')
    await redis.rpush('email_queue', email_message)

Dalam kod di atas, kami telah mentakrifkan fungsi tak segerak yang dipanggil "add_email_to_queue" yang mengambil tiga parameter (alamat e-mel penerima, subjek e-mel dan badan e-mel) sebagai Input, mesej e-mel dikodkan dan ditambahkan ke barisan Redis.

Langkah 6: Jalankan dalam program utama

Sekarang kami bersedia untuk meletakkan semua kepingan bersama-sama dan menjalankan sistem baris gilir mel dalam program utama. Berikut ialah kod contoh:

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [process_queue() for i in range(10)]
    loop.run_until_complete(asyncio.gather(*tasks))

Dalam kod di atas, kami menggunakan fungsi "get_event_loop" untuk mendapatkan gelung peristiwa tak segerak (juga dikenali sebagai gelung peristiwa). Kami juga mencipta tugas tempatan untuk setiap pemproses baris gilir (banyak sistem pemesejan menggunakan berbilang pemproses untuk memproses e-mel untuk pemprosesan yang tinggi). Akhir sekali, kami menggunakan fungsi "kumpul" untuk mengumpulkan semua tugasan dan menjalankannya.

Seperti yang anda lihat, sangat mudah untuk melaksanakan sistem baris gilir e-mel dengan coroutine tak segerak. Kami boleh menggunakan perpustakaan async terbina dalam Python dan pustaka pihak ketiga untuk melaksanakan aplikasi berprestasi tinggi dan berskala, yang membolehkan kami mengendalikan pengkomputeran berskala besar atau tugas intensif I/O dengan lebih cekap.

Atas ialah kandungan terperinci Panduan Pembangunan Coroutine Asynchronous: Melaksanakan Sistem Gilir Mel yang Sangat Selaras. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!