Django è un famoso framework Python utilizzato per sviluppare app Web utilizzando il Wgsi (Interfaccia gateway del server Web) e Asgi (Interfaccia del gateway server asincrono) Specifiche del server. WGSI viene utilizzato per lo sviluppo di app Python sincrone e AGSI viene utilizzato per lo sviluppo di app Web asincrone e sincroni. Canale è una caratteristica utile di Django utilizzato per gestire WebSocket, Protocollo di chat, ecc. Accanto al protocollo HTTP. Il canale è costruito sulle specifiche del server ASGI. Una sessione di comunicazione interattiva a due vie tra il browser dell'utente e il server può essere aperta utilizzando un websocket. Il cliente avvia il file WebSocket connessione e il server risponde con un accettare O vicino Messaggio. IL WebSocket I messaggi vengono spinti nel canale utilizzando produttori e inviato al consumatori che stanno ascoltando sul canale. Questo tutorial ti mostra come usare canali gestire WebSocket messaggi.

Prerequisiti

Prima di praticare la sceneggiatura mostrata in questo tutorial, assicurarsi di completare le seguenti attività.

• Installa Django versione 3+ su Ubuntu 20+ (preferibilmente)
• Crea un progetto Django
• Esegui il server Django per verificare se il server funziona correttamente

Imposta un'app Django

Esegui il seguente comando per creare un'app Django denominata socketpp:

$ Python3 Gestisci.Py StartApp SocketApp

Esegui il comando seguente per installare il canale:

$ PIP Installa canali

Aggiungi i canali e il nome dell'app a Installato_app parte di impostazioni.Py file:

Installato_apps = [
..
'canali',
'socketpp'
"

Definire il valore di asgi_application in impostazioni.Py file:

Asgi_application = 'channel_pro.asgi.applicazione'

Crea una cartella denominata modelli dentro il socketpp cartella e impostare la posizione del modello dell'app in Modelli parte di impostazioni.Py file:

Modelli = [

.. .
'Dirs': ['/Home/Fahmida/Channel_Pro/SocketApp/Templates'],
.. .
,
"

Il seguente output apparirà nel terminale dopo aver eseguito il server Django. L'output mostra che ASGI/canali versione 3.0.3 è in esecuzione.

Crea un file modello denominato indice.html Nella posizione del modello definito per visualizzare i dati inviati da WebSocket. L'oggetto socket che viene creato utilizzando JavaScript leggerà i dati utilizzando JSON.Metodo Parse (), quindi passare il valore nel contenuto del

tag che contiene il valore ID, "msg.'

indice.html

testo

Modificare il visualizzazioni.Py File del socketpp Con i seguenti contenuti. IL indice.html Il file modello verrà visualizzato nel browser con testo variabile quando il indice() Il metodo di questo script è chiamato dal URL.Py file. Se non viene trasmesso alcun messaggio dalla presa, il testo 'Linuxhint'verrà visualizzato nel browser.

visualizzazioni.Py

# Importa il modulo di rendering da Django
da Django.scorciatoie rendering di importazione
# Crea la funzione indice per visualizzare il file HTML nel browser
DEF INDICE (richiesta):
rendering render (richiesta ", indice.html ", context = 'text': 'linuxhint')

Modificare il URL.Py File del socketpp Con i seguenti contenuti. Nello script sono definiti due percorsi: il 'amministratore/"Il percorso viene utilizzato per aprire il cruscotto di amministrazione Django e il"msg/'Il percorso viene utilizzato per leggere il messaggio WebSocket.

URL.Py

da Django.AMPIONE AMMINIO DI IMPIT
da Django.percorso di importazione degli URL
Dalle visualizzazioni delle importazioni SocketApp
urlpatterns = [
Path ('Admin/', Admin.luogo.URL),
Path ('msg/', viste.indice)
"

Quando il seguente URL viene eseguito senza definire il consumatore e i file di routing, il protocollo HTTP funzionerà e verrà visualizzato il seguente output.

http: // localhost: 8000/msg

Ora crea un file consumatori.Py file all'interno del socketpp cartella con il seguente script. IL Collegare() metodo di ws_consumer verrà utilizzato per accettare la connessione socket, leggere il valore temporale corrente ogni secondo e inviare l'ora corrente in formato JSON tramite WebSocket quando questo metodo viene chiamato dal file di routing.

consumatori.Py

# Importa il modulo JSON
Importa JSON
# Importa WebSocketConsumer
dai canali.generico.WebSocket Importa WebSocketConsumer
# Importa modulo DateTime
da DateTime Import DateTime
# Importa il modulo Sleep
Dal tempo Import Sleep
# Definisci la classe di consumo per inviare i dati tramite WebSocketConsumer
Classe WS_Consumer (WebSocketConsumer):
def connect (self):
se stesso.accettare()
mentre (vero):
ora = datetime.Ora()
se stesso.Invia (JSON.Dumps ('' TimeValue ': ora.strftime ("%h:%m:%s"))
sonno (1)

Creare il routing.Py dentro il socketpp cartella con il seguente script. IL 'msg/'Il percorso è definito nello script per chiamare il consumatore per l'invio dei dati alla presa.

routing.Py

da Django.percorso di importazione degli URL
da .I consumatori importano WS_Consumer
# Imposta il percorso per chiamare il consumatore
ws_urlpatterns = [
Path ('msg/', ws_consumer.as_asgi ())
"

Modificare il asgi.Py File con il seguente script. I moduli necessari per gestire le richieste HTTP e WebSocket vengono importati nello script.

asgi.Py

# Importa il modulo OS
Import OS
# Importa get_asgi_application per gestire il protocollo HTTP
da Django.nucleo.ASGI Import Get_ASGI_APLICATION
# ProtocoltyPerouter e urlrouter per impostare il routing WebSocket
dai canali.Routing Import ProtocoltyPerouter, Urlrouter
# Importa authmiddleWarestack per gestire WebSocket
dai canali.AUTH Import AuthmiddleWarestack
# Importa routing WebSocket
da SocketApp.Routing Import ws_urlpatterns
# Assegna valore per django_settings_module
sistema operativo.Environ.setDefault ('django_settings_module', 'canale_pro.impostazioni')
# Definire la variabile dell'applicazione per gestire HTTP e WebSocket
applicazione = protocoltyPerouter (
'http': get_asgi_application (),
'WebSocket': AuthmiddleWareStack (UrlRouter (WS_URLPatterns))
)

Ora, esegui nuovamente il seguente URL dal browser per leggere i dati dal WebSocket.

http: // localhost: 8000/msg/

Se il consumatore e il router funzionano correttamente, il seguente orologio digitale verrà visualizzato nel browser. Qui, il router ha inviato la richiesta WebSocket utilizzando il 'msg/'Percorso al consumatore che ha accettato la richiesta e ha inviato i dati al modello per mostrare l'orologio digitale nel browser in cui il secondo valore del tempo corrente si aggiorna ogni secondo.

Conclusione

Questo tutorial ti ha mostrato come implementare un'applicazione in tempo reale utilizzando il framework e i canali Django creando un semplice orologio digitale. Altri tipi di applicazioni in tempo reale possono anche essere implementati utilizzando django e canali, come i sistemi di chat online. Gli script utilizzati in questo tutorial per le versioni Django 3+ e solo versioni di canale 3+. Quindi, se si utilizza una precedente versione Django o canale, dovrai aggiornare la versione prima di testare lo script fornito in questo tutorial.