Django to popularna struktura Python używana do tworzenia aplikacji internetowych za pomocą WGSI (Interfejs bramy serwera WWW) i Asgi (Asynchroniczny interfejs bramy serwera) Specyfikacje serwera. WGSI służy do opracowywania synchronicznych aplikacji Python, a AGSI jest używany do opracowywania asynchronicznych i synchronicznych aplikacji internetowych. Kanał jest użyteczną funkcją Django, która jest używana do obsługi WebSocket, protokołu czatu itp. obok protokołu HTTP. Kanał opiera się na specyfikacjach serwera ASGI. Dwukierunkowa interaktywna sesja komunikacyjna między przeglądarką użytkownika a serwerem można otworzyć za pomocą za pomocą WebSocket. Klient inicjuje WebSocket Połączenie i serwer odpowiada na zaakceptować Lub zamknąć wiadomość. WebSocket Wiadomości są wypychane do kanału za pomocą producenci i wysłane do konsumenci które słuchają na kanale. Ten samouczek pokazuje, jak używać kanały Poradzić sobie WebSocket wiadomości.

Wymagania wstępne

Przed ćwiczeniem skryptu pokazanego w tym samouczku należy wykonać następujące zadania.

• Zainstaluj wersję Django 3+ na Ubuntu 20+ (najlepiej)
• Utwórz projekt Django
• Uruchom serwer Django, aby sprawdzić, czy serwer działa poprawnie

Skonfiguruj aplikację Django

Uruchom następujące polecenie, aby utworzyć aplikację Django o nazwie SocketApp:

$ Python3 Zarządzaj.Py startApp SocketApp

Uruchom następujące polecenie, aby zainstalować kanał:

Kanały instalacyjne $ PIP

Dodaj kanały i nazwę aplikacji do Zainstalowany_app część Ustawienia.py plik:

Instalowane_apps = [
…
„Kanały”,
„SocketApp”
]

Zdefiniuj wartość ASGI_APPLICACJA W Ustawienia.py plik:

Asgi_application = 'channel_pro.Asgi.aplikacja'

Utwórz folder o nazwie szablony w środku SocketApp folder i ustaw lokalizację szablonu aplikacji w Szablony część Ustawienia.py plik:

Szablony = [

… .
„Dirs”: ['/home/fahmida/channel_pro/socketApp/szablony']],
… .
,
]

Następujące dane wyjściowe pojawią się w terminalu po uruchomieniu serwera Django. Dane wyjściowe pokazuje, że ASGI/kanały wersja 3.0.3 działa.

Utwórz plik szablonu o nazwie indeks.html w określonej lokalizacji szablonu, aby wyświetlić dane wysyłane przez WebSocket. Obiekt gniazda, który jest tworzony za pomocą JavaScript, odczytuje dane za pomocą JSON.metoda parse (), a następnie przekazuj wartość do zawartości

tag, który zawiera wartość identyfikatora ”, msg.'

indeks.html

Text

Zmodyfikuj wyświetlenia.py plik SocketApp z następującą treścią. indeks.html plik szablonu zostanie wyświetlony w przeglądarce z tekst zmienna, gdy indeks() Metoda tego skryptu jest wywoływana z URL.py plik. Jeśli z gniazda nie jest przesyłana żadna wiadomość, to tekst 'Linuxhint'będzie wyświetlany w przeglądarce.

wyświetlenia.py

# Importuj moduł renderowania z Django
z Django.KRÓTKI IMPORTOWANE RENDER
# Utwórz funkcję indeksu, aby wyświetlić plik HTML w przeglądarce
indeks def (żądanie):
return render (żądanie ”, indeks.html ", kontekst = 'text': 'Linuxhint')

Zmodyfikuj URL.py plik SocketApp z następującą treścią. Dwie ścieżki są zdefiniowane w skrypcie: 'Admin/„Ścieżka służy do otwarcia pulpitu administracyjnego Django i”MSG/„Ścieżka służy do odczytania wiadomości WebSocket.

URL.py

z Django.Administrator importu
z Django.URL ścieżki importu
z SocketApp Import Views
urlpatterns = [
ścieżka („admin/”, administrator.strona.URL),
ścieżka („MSG/”, widoki.indeks)
]

Po wykonaniu następującego adresu URL bez definiowania plików konsumenta i routingu, protokół HTTP będzie działał i pojawi się następujące dane wyjściowe.

http: // localhost: 8000/msg

Teraz stwórz konsumenci.py plik wewnątrz SocketApp folder z następującym skryptem. łączyć() metoda WS_Consumer będzie używane do przyjęcia połączenia gniazda, odczytania bieżącej wartości czasu co sekundę i wysyłania bieżącego czasu w formacie JSON za pośrednictwem WebSocket, gdy ta metoda zostanie wywołana z pliku routingu.

konsumenci.py

# Importuj moduł JSON
Importuj JSON
# Importuj WebSocketConsumer
z kanałów.ogólny.WebSocket Import WebSocketConsumer
# Importuj moduł DATETIME
z datetime import datetime
# Importuj moduł snu
Od czasu importuj sen
# Zdefiniuj klasę konsumentów, aby wysłać dane za pośrednictwem WebSocketConsumer
klasa WS_Consumer (WebSocketConsumer):
def Connect (self):
samego siebie.zaakceptować()
While (prawda):
teraz = dataTime.Teraz()
samego siebie.Wyślij (JSON.Zrzuty („TimeValue”: teraz.Strftime („%h:%m:%s”))))
sen (1)

Utwórz rozgromienie.py w środku SocketApp folder z następującym skryptem. ''MSG/„Ścieżka jest zdefiniowana w skrypcie, aby zadzwonić do konsumenta w celu wysyłania danych do gniazda.

rozgromienie.py

z Django.URL ścieżki importu
z .Konsumenci importują WS_Consumer
# Ustaw ścieżkę, aby zadzwonić do konsumenta
WS_URLPATTERNS = [
ścieżka („msg/”, WS_Consumer.as_asgi ())
]

Zmodyfikuj Asgi.py Plik z następującym skryptem. Moduły wymagane do obsługi żądań HTTP i WebSocket są importowane do skryptu.

Asgi.py

# Importuj moduł OS
Import OS
# Importuj get_asgi_application do obsługi protokołu HTTP
z Django.rdzeń.ASGI Import get_asgi_application
# Importuj protokoły i urlrouter, aby ustawić routing WebSocket
z kanałów.ProtocoltyPerouter importowy routingu, urlrouter
# Import AuthmiddleWarestack do obsługi WebSocket
z kanałów.Auth Import AuthmiddleWarestack
# Importuj routing WebSocket
z SocketApp.Import routingu WS_URLPATTERNS
# Przypisz wartość dla django_settings_module
OS.otaczać.setdefault („django_settings_module”, „channel_pro.Ustawienia)
# Zdefiniuj zmienną aplikacji do obsługi HTTP i WebSocket
Application = protocoltyPerouter (
„http”: get_asgi_application (),
„WebSocket”: authmiddlewarestack (urlrouter (WS_URLPATTERNS)))
)

Teraz uruchom następujący adres URL z przeglądarki, aby odczytać dane z WebSocket.

http: // localhost: 8000/msg/

Jeśli konsument i router działają poprawnie, w przeglądarce zostanie wyświetlony następujący zegar cyfrowy. Tutaj router wysłał żądanie WebSocket za pomocą 'MSG/„Ścieżka do konsumenta, który zaakceptował żądanie i wysłał dane do szablonu, aby pokazać zegar cyfrowy w przeglądarce, w której druga wartość bieżącego czasu aktualizuje się co sekundę.

Wniosek

Ten samouczek pokazał, jak wdrożyć aplikację w czasie rzeczywistym za pomocą Django Framework i kanałów, tworząc prosty zegar cyfrowy. Inne rodzaje aplikacji w czasie rzeczywistym można również zaimplementować za pomocą Django i kanałów, takich jak systemy czatu online. Skrypty użyte w tym samouczku działają tylko dla wersji Django 3+ i kanałów 3+. Tak więc, jeśli używasz wcześniejszej wersji Django lub kanału, musisz zaktualizować wersję przed przetestowaniem skryptu podanego w tym samouczku.