Django é uma estrutura Python popular usada para desenvolver aplicativos da web usando o WGSI (Interface do gateway do servidor da web) e Asgi (Interface de gateway de servidor assíncrona) Especificações do servidor. O WGSI é usado para desenvolver aplicativos síncronos de Python, e o AGSI é usado para desenvolver aplicativos da web assíncronos e síncronos. Canal é um recurso útil do Django que é usado para lidar. ao lado do protocolo HTTP. O canal é construído nas especificações do servidor ASGI. Uma sessão de comunicação interativa de mão dupla entre o navegador do usuário e o servidor pode ser aberto usando um webSocket. O cliente inicia o WebSocket conexão e o servidor responde com um aceitar ou fechar mensagem. O WebSocket As mensagens são empurradas para o canal usando produtores e enviado para o consumidores que estão ouvindo no canal. Este tutorial mostra como usar canais lidar WebSocket mensagens.

Pré -requisitos

Antes de praticar o script mostrado neste tutorial, conclua as seguintes tarefas.

• Instale o Django Versão 3+ no Ubuntu 20+ (de preferência)
• Crie um projeto Django
• Execute o servidor Django para verificar se o servidor está funcionando corretamente

Configure um aplicativo Django

Execute o seguinte comando para criar um aplicativo django nomeado SocketApp:

$ python3 gerencia.Py StartApp SocketApp

Execute o seguinte comando para instalar o canal:

$ pip install canais

Adicione os canais e o nome do aplicativo ao Instalado_app parte de configurações.py arquivo:

Instalado_apps = [
..
'canais',
'SocketApp'
]

Definir o valor de asgi_application no configurações.py arquivo:

Asgi_application = 'canal_pro.asgi.aplicativo'

Crie uma pasta chamada modelos dentro de SocketApp pasta e defina a localização do modelo do modelo no aplicativo no MODELOS parte de configurações.py arquivo:

Modelos = [

.. .
'Dirs': ['/home/fahmida/canal_pro/sokepApp/modelos'],
.. .
,
]

A saída a seguir aparecerá no terminal após a execução do servidor Django. A saída mostra que asgi/canais versão 3.0.3 está em execução.

Crie um arquivo de modelo chamado índice.html no local do modelo definido para exibir os dados enviados pelo WebSocket. O objeto de soquete criado usando JavaScript lerá os dados usando o JSON.Método parse () e depois transmita o valor para o conteúdo do

tag que contém o valor de identificação, 'msg.'

índice.html

texto

Modifique o Visualizações.py arquivo do SocketApp com o seguinte conteúdo. O índice.html O arquivo de modelo será exibido no navegador com o texto variável quando o índice() O método deste script é chamado do URLs.py arquivo. Se nenhuma mensagem for transmitida do soquete, o texto 'Linuxhint'será exibido no navegador.

Visualizações.py

# Importar módulo de renderização de Django
de Django.Atalhos de importação renderizar
# Crie função de índice para exibir o arquivo HTML no navegador
Def Index (solicitação):
render renderização (solicitação, "índice.html ", context = 'text': 'linuxhint')

Modifique o URLs.py arquivo do SocketApp com o seguinte conteúdo. Dois caminhos são definidos no script: o 'admin/'O caminho é usado para abrir o painel do governo Django e o'msg/'O caminho é usado para ler a mensagem WebSocket.

URLs.py

de Django.Contrible Import Admin
de Django.URLs Caminho de importação
De SocketApp Import Views
urlpatterns = [
caminho ('admin/', admin.site.URLs),
caminho ('msg/', visualizações.índice)
]

Quando o URL a seguir for executado sem definir os arquivos de consumidor e roteamento, o protocolo HTTP funcionará e a seguinte saída será exibida.

http: // localhost: 8000/msg

Agora, crie um consumidores.py Arquivo dentro do SocketApp pasta com o seguinte script. O conectar() método de ws_consumer será usado para aceitar a conexão do soquete, ler o valor atual a cada segundo e enviar a hora atual no formato JSON via WebSocket quando esse método for chamado do arquivo de roteamento.

consumidores.py

# Importar módulo JSON
importar json
# Importe websocketconsumer
de canais.genérico.WebSocket Import WebSocketConsumer
# Importar módulo DATETIME
Do DateTime Import DateTime
# Importar módulo de sono
Desde o tempo de importação do sono
# Defina a classe de consumo para enviar os dados através do WebSocketConsumer
Classe ws_consumer (websocketconsumer):
Def Connect (self):
auto.aceitar()
enquanto (verdadeiro):
agora = datetime.agora()
auto.Send (JSON.despejos ('timeValue': agora.strftime ("%h:%m:%s")))
sono (1)

Crie o roteamento.py dentro de SocketApp pasta com o seguinte script. O 'msg/'O caminho é definido no script para ligar para o consumidor para enviar os dados para o soquete.

roteamento.py

de Django.URLs Caminho de importação
de .Consumidores importam ws_consumer
# Defina o caminho para chamar o consumidor
ws_urlpatterns = [
caminho ('msg/', ws_consumer.as_asgi ())
]

Modifique o asgi.py Arquivo com o seguinte script. Os módulos necessários para lidar com as solicitações HTTP e WebSocket são importadas no script.

asgi.py

# Importar o módulo OS
OS de importação
# Importar get_asgi_application para lidar com o protocolo HTTP
de Django.essencial.ASGI import get_asgi_application
# Importar ProtocoltyPerouter e Urlouter para definir o roteamento do WebSocket
de canais.roteamento de importação protocoltyperouter, urlouter
# Importar authmiddlewarestack para lidar com o websocket
de canais.Auth Import authmiddlewarestack
# Importar roteamento WebSocket
de sokepApp.roteamento de importação ws_urlpatterns
# Atribuir valor para django_settings_module
OS.Environ.SetDefault ('Django_settings_module', 'Channel_Pro.configurações')
# Defina a variável de aplicativo para lidar com HTTP e WebSocket
Application = ProtocoltyPerouter (
'http': get_asgi_application (),
'WebSocket': Authmiddlewarestack (urlouter (ws_urlpatterns))
)

Agora, execute o seguinte URL do navegador novamente para ler os dados do WebSocket.

http: // localhost: 8000/msg/

Se o consumidor e o roteador estiverem funcionando corretamente, o seguinte relógio digital será exibido no navegador. Aqui, o roteador enviou a solicitação do WebSocket usando o 'msg/'caminho para o consumidor que aceitou a solicitação e enviou os dados para o modelo para mostrar o relógio digital no navegador, onde o segundo valor da hora atual está atualizando a cada segundo.

Conclusão

Este tutorial mostrou como implementar um aplicativo em tempo real usando a estrutura e canais do Django, criando um relógio digital simples. Outros tipos de aplicativos em tempo real também podem ser implementados usando Django e canais, como sistemas de bate-papo online. Os scripts usados ​​neste trabalho tutorial para as versões Django 3+ e o canal versões 3+ somente. Portanto, se você estiver usando um django ou versão anterior do canal, precisará atualizar a versão antes de testar o script fornecido neste tutorial.