Python: Djiango-Web后端框架-前后端分离博客项目

CREATE DATABASE IF NOT EXISTS `blog` DEFAULT CHARACTER SET utf8mb4;

use blog

CREATE TABLE `user` (
    `id` INT ( 11 ) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR ( 48 ) NOT NULL,
    `email` VARCHAR ( 64 ) NOT NULL,
    `password` VARCHAR ( 128 ) NOT NULL,
    PRIMARY KEY ( `id` ),
UNIQUE KEY `email` ( `email` )
) ENGINE = INNODB DEFAULT CHARSET = utf8;

CREATE TABLE `auth_user` (
  `id` INT (11) NOT NULL AUTO_INCREMENT,
  `PASSWORD` VARCHAR (128) NOT NULL,
  `last_login` DATETIME (6) DEFAULT NULL,
  `is_superuser` TINYINT (1) NOT NULL,
  `username` VARCHAR (150) NOT NULL,
  `first_name` VARCHAR (30) NOT NULL,
  `last_name` VARCHAR (150) NOT NULL,
  `email` VARCHAR (254) NOT NULL,
  `is_staff` TINYINT (1) NOT NULL,
  `is_active` TINYINT (1) NOT NULL,
  `date_joined` DATETIME (6) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`username`)
) ENGINE = InnoDB AUTO_INCREMENT = 2_DEFAULTCHARSET = utf8mb4;

CREATE TABLE `post` (
    `id` BIGINT ( 20 ) UNSIGNED NOT NULL AUTO_INCREMENT,
    `title` VARCHAR ( 256 ) NOT NULL,
    `author_id` INT ( 11 ) NOT NULL,
    `postdate` datetime NOT NULL,
    PRIMARY KEY ( `id` ),
    KEY `author_id` ( `author_id` ),
CONSTRAINT `fk_post_user` FOREIGN KEY ( `author_id` ) REFERENCES `user` ( `id` ) 
) ENGINE = INNODB DEFAULT CHARSET = utf8;

CREATE TABLE `content` (
    `id` BIGINT ( 20 ) UNSIGNED NOT NULL,
    `content` text NOT NULL,
    PRIMARY KEY ( `id` ) USING BTREE,
CONSTRAINT `fk_content_post` FOREIGN KEY ( `id` ) REFERENCES `post` ( `id` ) 
) ENGINE = INNODB DEFAULT CHARSET = utf8;

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'blog',
        'USER': 'root',
        'PASSWORD': '123456',
        'HOST': '10.0.0.152',
        'PORT': '3306',
    }
}

#安装mysql驱动
pip install mysqlclient

python manage.py startapp user

D:\PROJECT\PYPROJS\TRAE\BLOG10\USER
│  admin.py    # 应用后台管理声明文件
│  apps.py     # 应用的信息定义文件
│  models.py   # 模型层Model类定义
│  tests.py
│  views.py    # 定义URL响应函数或类
│  __init__.py
│
└─migrations   # 数据迁移文件生成目录
        __init__.py

#settings.py文件中
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'user',
]

ALTER TABLE `blog`.`post` DROP FOREIGN KEY `fk_post_user`
DROP TABLE IF EXISTS `blog`.`user`;

#python manage.py makemigrations #可以做，但做了也白做。user 下面还没有modes类。INSTALLED_APPS中user上面的类django已经写好了
python manage.py migrate

(.venv) PS D:\project\pyprojs\trae\blog10> python manage.py makemigrations
No changes detected
(.venv) PS D:\project\pyprojs\trae\blog10> python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

mysql> show tables ;
+----------------------------+
| Tables_in_blog             |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| content                    |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
| post                       |
+----------------------------+

ALTER TABLE `blog`.`post` 
ADD CONSTRAINT `post_ibfk_1` FOREIGN KEY (`author_id`) REFERENCES `blog`.`auth_user` (`id`);

CREATE TABLE `blog`.`auth_user`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `password` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `last_login` datetime(6) NULL DEFAULT NULL,
  `is_superuser` tinyint(1) NOT NULL,
  `username` varchar(150) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `first_name` varchar(150) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `last_name` varchar(150) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `email` varchar(254) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `is_staff` tinyint(1) NOT NULL,
  `is_active` tinyint(1) NOT NULL,
  `date_joined` datetime(6) NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`username` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

#/user/models.py文件
from django.db import models

# user表模型
class User(models.Model):
    class Meta:
        db_table = "user"
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=48,null=False)
    email = models.CharField(max_length=64,unique=True,null=False)
    password = models.CharField(max_length=128,null=False)

    def __repr__(self):
        return "<user {} {}>".format(self.id,self.name)

    __str__ = __repr__

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Django web 模板技术</title>
</head>
<body>
我是模板，数据是{{content}}
</body>
</html>

def index(request:HttpRequest):
    from django.template import loader
    from django.template.backends.django import Template
    t:Template = loader.get_template("index.html") #加载器模块搜索模板并加载它
    print(t.origin, type(t)) #显示模板路径, 类型
    c = {"content":"www.xdd.com"} #字典数据
    text = t.reder(c) # 填空得到字符串
    print(type(text), text)
    return HttpResponse(text)

def render(
    request, template_name, context=None, content_type=None, status=None, using=None
):
    """
    Return an HttpResponse whose content is filled with the result of calling
    django.template.loader.render_to_string() with the passed arguments.
    """
    content = loader.render_to_string(template_name, context, request, using=using)
    return HttpResponse(content, content_type, status)

from django.shortcuts import  render

def index(request:HttpRequest):
    """视图函数：请求进来返回响应"""
    return render(request,"index.html",{"content":"www.xdd.com"})

from django.contrib import admin
from django.urls import path, re_path #url
# from django.shortcuts import HttpResponse #WSGI快捷方法，还可以从django.http中导入
from django.http import HttpResponse, HttpRequest, JsonResponse
from django.core.handlers.wsgi import WSGIRequest
from django.template.loader import get_template
from django.shortcuts import render
# HttpRequest是父类；WSGIRequest是子类

# view函数, 根据请求，返回相应的结果
# function-based view => FBV
# 要求必须提供至少一个参数，第一个参数解决request注入
def index(request:WSGIRequest):
    title = '标题测试'

    # 响应报文正文部分的字符串可以动态生成，也可以从文件中读取
    # 本质上都要一个字符串，也就是说只能给HttpResponse构造函数提供内容字符串就可以了
    # 动态生成就是在内存生成一个待返回给浏览器端的HTML的字符串
    context = {
        'title': title,
        'content': '这是正文内容',
        'p1': 123,
        'p2': 'xyz'
    }
    # 加载模板 --> 填空拼接字符串为HTML --> 封装HTTPResponse对象返回
    # from django.template.backends.django import Template
    # t:Template = get_template('index.html')
    # print(t.origin)
    # result = t.render(context)  #填空，返回的结果是那个HTML的大字符串
    # print(type(result), result)
    # return HttpResponse(result)
    return render(request, 'index.html', context, status=201)

urlpatterns = [
    path('admin/', admin.site.urls), # /admin/ 路径对应，多级url处理
    path('', index), #  '/' => index 函数， request实参
    # path('index', index), # '/index' OK ; '/index/' Wrong
    path('index/', index), # '/index' 301 '/index/'; '/index/' OK
]

from django.shortcuts import  render
import datetime

def index(request:HttpRequest):
    """视图函数：请求进来返回响应"""
    my_dict = {
        "a":100,
        "b":0,
        "c":list(range(10,20)),
        "d":'abc',
        "date":datetime.datetime.now()
    }
    context = {"content":"www.xdd.com","my_dict":my_dict}
    return render(request,"index.html",context)

# blog/urls.py
from django.contrib import admin
from django.urls import path, re_path #url
# from django.shortcuts import HttpResponse #WSGI快捷方法，还可以从django.http中导入
from django.http import HttpResponse, HttpRequest, JsonResponse
from django.core.handlers.wsgi import WSGIRequest
from django.template.loader import get_template
from django.shortcuts import render
# HttpRequest是父类；WSGIRequest是子类

from datetime import datetime

# view函数, 根据请求，返回相应的结果
# function-based view => FBV
# 要求必须提供至少一个参数，第一个参数解决request注入
def index(request:WSGIRequest):

    # 响应报文正文部分的字符串可以动态生成，也可以从文件中读取
    # 本质上都要一个字符串，也就是说只能给HttpResponse构造函数提供内容字符串就可以了
    # 动态生成就是在内存生成一个待返回给浏览器端的HTML的字符串
    context = {
        'a':100,
        'b':0,
        'c':list(range(10,20)),
        'd':dict(zip('abcde','ABCDE')), # d.e 没找到 d['e'] 没找到 d[e]
        's':'abcde',
        'date':datetime.now(),
    }
    return render(request, 'index.html', {'mydict': context} , status=201)

urlpatterns = [
    path('admin/', admin.site.urls), # /admin/ 路径对应，多级url处理
    path('', index), #  '/' => index 函数， request实参
    # path('index', index), # '/index' OK ; '/index/' Wrong
    path('index/', index), # '/index' 301 '/index/'; '/index/' OK
]

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>第一个模板文件</title>
</head>
<body>
{{ mydict.a }} <br> 
{{mydict.c}} | {{ mydict.d }}<hr>
{{ mydict.d.e }} {{ mydict.c.0 }}<br>
{{ mydict.d.keys }} <br>
{{ mydict.d.values }} <br>
{{ mydict.d.items }} <br>
{{ mydict.s.1 }} [{{ mydict.t.0 }}]
</body>
</html>

{% if condition %}
    ... display
{% endif %}

{% if condition %}
    ... display 1
{% elif condition2 %}
    ... display 2
{% else %}
    ... display 3
{% endif %}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Django web 模板技术</title>
</head>
<body>
我是模板，数据是{{content}}

<ul>
{% for athlete in athlete_list  %}
    <li>{{ athlete.name }}</li>
{% endfor %}
</ul>

<ul>
{% for person in person_list %}
    <li> {{ person.name }}</li>
{% endfor %}
</ul>
</body>
</html>

{% for athlete in athlete_list reversed %}
...
{% empty %}
... 如果被迭代的列表是空的或者不存在，执行empty
{% endfor %}

#blog/urls.py
...
def index(request:HttpRequest):

    context = {
        'a':100,
        'b':0,
        'c':list(range(10,20)),
        'd':dict(zip('abcde','ABCDE')), # d.e 没找到 d['e'] 没找到 d[e]
        's':'abcde',
        'date':datetime.now(),
    }
    return render(request, 'index.html', {'mydict':context}, status=201)
...

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>第一个模板文件</title>
</head>
<body>
{{ mydict.a }} <br> 
{{mydict.c}} | {{ mydict.d }}<hr>
{{ mydict.d.e }} {{ mydict.c.0 }}<br>
{{ mydict.d.keys }} <br>
{{ mydict.d.values }} <br>
{{ mydict.d.items }} <br>
{{ mydict.s.1 }} [{{ mydict.t.0 }}]
<hr>

<style>
    ul .ulred{color:red}
    ul .ulgreen{color:green}
</style>
<ul>
    {% for x in mydict.c  reversed %}
        <li>{{ forloop.counter }} - {{ forloop.counter0 }} - 
            {{ forloop.revcounter }} - {{ forloop.revcounter0 }}
            {{ x }}<br></li>
    {% empty %}
    <li>empty空</li>
    {% endfor %}
</ul>
<hr> <!--字典遍历-->
{% for k,v in mydict.d.items %}
{{ k }} {{ v }} <br>
{% endfor%}
</body>
</html>

{% for athlete in athlete_list %}
    <h1>{{ athlete.name }}</h1>
    <ul>
    <% for sport in athlete.sports_played %>
        <li>{{ sport }}</li>
    <% endfor %>
    </ul>
{% endfor %}

{% ifequal user currentuser %}
    <h1>Welcome!</h1>
{% endifequal %}

{% ifequal section 'sitenews' %}
    <h1>Site News</h1>
{% else %}
    <h1>No News Here</h1>
{% endifequal %}

{# 这是一个注释 #}

{% comment %}
这是多行注释
{% endcomment %}

#urls.py
def index(request:WSGIRequest):
    context = {
        'a':100,
        'a1':None,
        'b':0,
        'c':list(range(10,20)),
        'd':dict(zip('abcde','ABCDE')), # d.e 没找到 d['e'] 没找到 d[e]
        's':'abcde',
        's1':'a  b c',
        'c1':['a', 'b', 'ccc'],
        'date':datetime.now(),
    }
    return render(request, 'index.html', {'mydict': context} , status=201)


#index.html
{{  mydict.a | add:'-20' }}
{{ mydict.s |add:'xyz' }}
{{ mydict.s |length|add:1000 }}
{{ mydict.s |join:','|truncatechars:5|upper }}<br>
{{ mydict.s |join:'.'|cut:'.' }}
{{ mydict.s |join:'.'|cut:'c' }}
{{ mydict.s1 |cut:' ' }}

{{ mydict.s |join:'<br>' }} <br>
{{ mydict.s |first }}
{{ mydict.s.0 }}
{{ mydict.c |last }}
{{ mydict.c }}
{{ mydict.c |length|add:-3 }} ***
<hr>
{{ mydict.c| add:mydict.c1 }}
<hr>
{{ mydict.b|yesno:'1,2' }}
<br>
{{ mydict.c1|length|divisibleby:3|yesno:'can,cannot' }}
{{ mydict.a1|default:'缺省值'}}
{{ mydict.a1|default_if_none:'缺省值'}}
<hr>
{{ mydict.date }}
{{ mydict.date|date:'Y' }}
{{ mydict.date|date:'Y-m-d H:i:s' }}

#页面结果
80 abcdexyz 1005 A,B,…
abcde a.b..d.e abc a
b
c
d
e
a a 19 [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 7 ***
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 'a', 'b', 'ccc']
2
can 缺省值 缺省值
June 16, 2025, 5:22 p.m. 2025 2025-06-16 17:22:14

from django.http import HttpResponse,HttpRequest,JsonResponse
from django.template import loader
from django.shortcuts import  render
import datetime

def index(request:HttpRequest):
    """视图函数：请求进来返回响应"""
    mydict = {
        "a":100,
        "b":0,
        "c":list(range(1,10)),
        "d":'abc',
        "date":datetime.datetime.now(),
        'matrix':[
            "{}*{}={}".format(i,j, i*j)
            for i in range(1,10)
            for j in range(1,10)
        ]
       }
    context = {"content":"www.xxx.com","mydict":mydict}
    return render(request,"index.html",context)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Django web 模板技术</title>
</head>
<body>
<ul>
    {% for line in mydict.c %}
    <li style='color:{{forloop.counter|divisibleby:"2"|yesno:"red,green"}}'>
        <span class="">{{line|add:100}} </span>
    </li>
    {%endfor%}
</ul>
</body>
</html>

1*1=1 1*2=2 ... 1*9=9
...
9*1=9 9*2=18.. 9*9=81

user/
    urls.py
    views.py
    templates/
        filter.html
    templatetags/
        __init__.py
        myfilters.py

#user/templatetags/myfilters.py
from django import template

register = template.Library()

@register.filter(name="multiply") # 使用装饰器注册 
def multiply(a, b): #只能1到2个参数
    return a*b

# user/urls.py
from django.urls import path
from .views import reg, user_login, user_logout, get_captcha, test_filter

urlpatterns = [
    path('login', user_login, name='userlogin'),
    path('tf', test_filter), # /users/tf
    path('<int:id>', get_user), # /users/2
]

#user/views.py
...
def test_filter(request):
    return render(request, 'filter.html', {'loop':[1,2,3,4,5,6,7,8,9]})

from django.shortcuts import reverse
def get_user(request, id):
    x = reverse('userlogin') # 拿到url
    print(x, type(x), '+++++++++++')
    return render(request, 'filter.html', {'loop':[1,2,3,4,5,6,7,8,9], 'id':id, 'login_url':x})

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Django web 模板技术</title>
</head>
<body>
<a href="{% url 'userlogin' %}">登录</a><br>
{{ login_url }}
<br>
<span>你的id是{{id}}!!</span>

<h3>2、2层循环实现 b.自定义（不推荐，更应该在python代码中完成）</h3>
{% load myfilters %}

+++{{ loop.0|multiply:2}}+++

<table border="1">
    {% for i in loop %}
    <tr>
        {% for j in loop %}
        <td>{{ i }}*{{ j }}={{i|multiply:j}}</td>
        {% endfor %}
    </tr>
    {% endfor %}
</table>

<h4>奇偶行变化</h4>
<table border="1">
    {% for i in loop %}
    <!--<tr style="color:{{ forloop.counter|divisibleby:2|yesno:'red,green' }}">-->
    <tr style="color:{% cycle 'red' 'green' 'blue' %}"> <!--滚动颜色-->
        {% for j in loop %}
        <!--<td>{{ i }}*{{ j }}={{i|multiply:j}}</td>-->
        <td>{{ forloop.parentloop.counter }}*{{ forloop.counter }}={{i|multiply:j}}</td> <!--parentloop 上层循环-->
        {% endfor %}
    </tr>
    {% endfor %}
</table>


<h3>2、2层循环实现 a.widthratio</h3>
<table border="1">
    {% for i in loop %}
    <tr>
        {% for j in loop %}
        <td>{{ i }}*{{ j }}={% widthratio i 1 j %}</td>
        {% endfor %}
    </tr>
    {% endfor %}
</table>

<!--
<h3>1、一层循环实现</h3>
<table border="1">

        {% for x in mydict.matrix %}
        {% if forloop.counter0|divisibleby:9 %}
        <tr>
        {% endif %}
        <td>{{ x }}</td>
        {% if forloop.counter|divisibleby:9 %}
        </tr>
        {% endif %}
        {% endfor %}
    </tr>
</table>
-->
</body>
</html>

# blog/urls.py文件
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('',index),
    #path('index',index), # index 都可以匹配；index/不能匹配
    path('index/',index), # index index/ 都可以匹配；index/a不能匹配
    path('test/<username>/<int:id>', test), # /test/tom/2 实参注入
    path('users/',include("user.urls")),  #对/users/xxx的访问在user.urls.py中设置
]
# path 第一个参数字符串 --> regexp; 第二个参数  函数、include返回的结果

# 新建user/uls.py
from django.conf.urls import path, include
from .views import reg

# 要去掉前缀/users
urlpatterns = [
    path('',reg), #/users/
]

# 在 user/views.py 文件中添加reg方法
from django.shortcuts import render
from django.http import HttpResponse,HttpRequest

def reg(request:HttpRequest):
    return HttpResponse("user.reg")

{
    "username":"xdd",
    "password":"abc",
    "email":"[email protected]"
}

curl --location 'http://127.0.0.1:8000/users/' \
--header 'Content-Type: application/json' \
--data-raw '{
    "username":"xdd",
    "password":"abc",
    "email":"[email protected]"
}
'

Forbidden (403)
CSRF verification failed. Request aborted.

pip install simplejson

#user/views.py文件

from django.http import HttpResponse,HttpRequest,HttpResponseBadRequest,JsonResponse
import simplejson

def reg(request:HttpRequest):
    print(request.POST)
    print(request.body)
    # print("- " * 30)
    try:
        payload = simplejson.loads(request.body)
        email = payload['email']
        username = payload['username']
        password = payload["password"]
        print(email,username,password)
        return JsonResponse({},status=201) #创建成功返回201
    except Exception as e: #有任何异常，都返回
        print(e)
        return HttpResponseBadRequest() #这里返回实例，这不是异常类

class Messages:
    INVALID_USERNAME_OR_PASSWORD = {'code':1, 'msg':'用户名或密码错误'}
    BAD_REQUEST = {'code':2, 'msg':'请求信息错误'}
    USER_EXISTS = {'code':3, 'msg':'用户已存在'}
    NOT_FOUND = {'code':4, 'msg':'资源不存在'}

ALTER TABLE `blog`.`auth_user` 
MODIFY COLUMN `email` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL AFTER `last_name`,
ADD UNIQUE INDEX(`email`)

#user/urls.py
from django.urls import path
from .views import reg

urlpatterns = [
    path('', reg) # reg POST /users/
]

#user/views.py
from django.shortcuts import render, HttpResponse
from django.http import HttpRequest, HttpResponseBadRequest, JsonResponse
from django.contrib.auth.models import User
import simplejson
from messages import Messages
# from django.core.handlers.wsgi import WSGIRequest

# Create your views here.
def reg(request:HttpRequest):
    print(request.path)
    print(request.GET)  # 查询字符串
    print(request.POST) # 表单提交
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload)
        username = payload.get('username')
        # 判断用户名是否存在？浏览器端有没有提醒过用户，永远不要相信客户端
        count = User.objects.filter(username=username).count()
        if count>0:
            return JsonResponse(Messages.USER_EXISTS)
        # 数据存储
        email = payload['email']
        password = payload['password']
        user = User.objects.create_user(username, email, password)
        print(type(user), user) # 一旦创建成功，登录成功看到的是User实例

        return JsonResponse({}, status=201)
        #return HttpResponse(content_type='application/json', status=201)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

curl --location 'http://127.0.0.1:8000/users/' \
--header 'Content-Type: application/json' \
--data-raw '{
    "username":"abc",
    "password":"abc",
    "email":"[email protected]"
}
'

from django.shortcuts import render, HttpResponse
from django.http import HttpRequest, HttpResponseBadRequest, JsonResponse
from django.contrib.auth.models import User
import simplejson
from messages import Messages
# from django.core.handlers.wsgi import WSGIRequest

def required_methods(methods):
    def method(viewfunc):
        def wrapper(request, *args, **kwargs):
            if request.method.lower() in methods:
                ret = viewfunc(request, *args, **kwargs)
                return ret
            else:
                return JsonResponse({}, status=405)
        return wrapper
    return method

method_get = required_methods(['get'])

#@required_methods(['get', 'post'])
@method_get
def reg(request:HttpRequest):
    # if request.method.lower() == 'post': pass
    print(request.path)
    print(request.GET)  # 查询字符串
    print(request.POST) # 表单提交
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload)
        username = payload.get('username')
        # 判断用户名是否存在？浏览器端有没有提醒过用户，永远不要相信客户端
        count = User.objects.filter(username=username).count()
        if count>0:
            return JsonResponse(Messages.USER_EXISTS)
        # 数据存储
        email = payload['email']
        password = payload['password']
        user = User.objects.create_user(username, email, password)
        print(type(user), user) # 一旦创建成功，登录成功看到的是User实例

        return JsonResponse({}, status=201)
        #return HttpResponse(content_type='application/json', status=201)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

from django.shortcuts import render, HttpResponse
from django.http import HttpRequest, HttpResponseBadRequest, JsonResponse
from django.contrib.auth.models import User
from django.views.decorators.http import require_POST, require_GET, require_http_methods
import simplejson
from messages import Messages
# from django.core.handlers.wsgi import WSGIRequest

@require_POST
def reg(request:HttpRequest):
    pass

# user/views.py文件
from django.shortcuts import render, HttpResponse
from django.http import HttpRequest, HttpResponseBadRequest, JsonResponse
from django.contrib.auth.models import User
from django.views.decorators.http import require_POST, require_GET, require_http_methods
import simplejson
from messages import Messages
# from django.core.handlers.wsgi import WSGIRequest

@require_POST
def reg(request:HttpRequest):
    # if request.method.lower() == 'post': pass
    print(request.path)
    print(request.GET)  # 查询字符串
    print(request.POST) # 表单提交
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload)
        username = payload.get('username')
        # 判断用户名是否存在？浏览器端有没有提醒过用户，永远不要相信客户端
        count = User.objects.filter(username=username).count()
        if count>0:
            return JsonResponse(Messages.USER_EXISTS)
        # 数据存储
        email = payload['email']
        password = payload['password']
        user = User.objects.create_user(username, email, password) #内部调用了user.save()
        print(type(user), user) # 一旦创建成功，登录成功看到的是User实例

        return JsonResponse({}, status=201)
        #return HttpResponse(content_type='application/json', status=201)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

# 测试代码添加在user/views.py

class SimpleMiddleware1:
    def __init__(self,get_response):
        self.get_response = get_response
        # One-time configuration and initialization.

    def __call__(self,request):
        # Conde to be executed for each request before
        # the view (and later middleware) are called.
        print(1,'- '*30)
        print(isinstance(request,HttpRequest))
        print(request.GET)
        print(request.POST)
        print(request.body)

        # 之前相当于老板本的process_request
        #return HttpResponse(b'',status = 404)

        response = self.get_response(request)

        #Code to be executed for each request/response after
        #the view is called.
        print(101,'- '* 30)
        return  response

    def process_view(self,request,view_func,view_args,view_kwargs):
        print(2,"-" * 30)
        print(view_func.__name__,view_args,view_kwargs)
        # 观察view_func名字，说明在process_request之后,process_view之前已经做好了路径映射
        return  None # 继续执行其他的process_view或view
        # return HttpResponse("111",status=201)

# 修改blog/settings.py文件，添加消息中间件

MIDDLEWARE = [
    ...,
    'user.views.SimpleMiddleware1', #增加该中间件
]

#settings.py
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'user.views.SimpleMiddleware1', # 全局过滤
]

#user/urls.py
from django.urls import path
from .views import reg, user_login, user_logout

urlpatterns = [
    path('', reg),
    path('login', user_login),
    path('logout', user_logout),
]

#user/views.py
from django.shortcuts import render
from django.http import HttpRequest, HttpResponse, JsonResponse
from django.contrib.auth.models import User
from django.contrib.auth import authenticate, login, logout
from django.views.decorators.http import require_GET, require_POST, require_http_methods
from django.contrib.auth.decorators import login_required
import simplejson
from messages import Messages

@require_POST
def reg(request:HttpRequest):
    print(request.path)
    print(request.GET)  # 查询字符串
    print(request.POST) # 表单提交
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload)
        username = payload.get('username')
        # 判断用户名是否存在？浏览器端有没有提醒过用户，永远不要相信客户端
        count = User.objects.filter(username=username).count()
        if count>0:
            return JsonResponse(Messages.USER_EXISTS)
        # 数据存储
        email = payload['email']
        password = payload['password']
        user = User.objects.create_user(username, email, password)
        print(type(user), user) # 一旦创建成功，登录成功看到的是User实例

        return JsonResponse({}, status=201)
        #return HttpResponse(content_type='application/json', status=201)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

@require_POST
def user_login(request:HttpRequest):
    # 进入到视图函数中，request中应该有2个动态增加的属性，session、user, 和中间件有关
    print(request.path)
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    print()
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload) #dict
        username = payload['username'] # 登录  该如何处理？
        password = payload['password']
        # 认证函数，解决用户名和密码匹配问题，匹配成功和数据库记录一一对应
        # 真实存在的用户，is_authenticated永远为true
        user = authenticate(username=username, password=password)
        print(type(user), user)
        print(type(request.user), request.user)  #目前是匿名的。匿名用户也是用户，但is_authenticated永远为false
        print(request.session)
        print('='*30)
        if user:
            # cookie和session，首先你必须对认证成功者发一个身份id，response中增加set-cookie
            # 至少应该有sessionID，sessionID必须保存在服务器端
            login(request, user) # 各种后台jsp, php都习惯通过request.session取session值；user绑定到request上
            print(type(user), user)
            print(type(request.user), request.user)
            print('=*'*30)
            response = HttpResponse(status=204)
            # response.set_cookie('xxx')
            return HttpResponse(status=204) # 用户验证成功，之后怎么处理？
        else:
            return JsonResponse(Messages.INVALID_USERNAME_OR_PASSWORD, status=200)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

# @login_required  # 等价于 user_logout = login_required(user_logout)
# @login_required(login_url='users/login') # 等价于 user_logout = login_required(login_url='users/login')(user_logout)
def user_logout(request:HttpRequest):
    print('^^^^ view function user_logout')
    print(request.user)
    print(request.user.__dict__)
    if request.user.is_authenticated:
        s = 200
    else:
        s = 400
    return JsonResponse({}, status=s)

class SimpleMiddleware1:
    def __init__(self, get_response):
        self.get_response = get_response
        # One-time configuration and initialization.

    def __call__(self, request):
        # Code to be executed for each request before
        # the view (and later middleware) are called.
        # 每一个中间件返回response之前调用，做request处理
        print('=-'*30)
        print('SimpleMiddleware1 before response')
        print(request.session.items())
        print(request.user) # 你在认证中间件之后 
        if request.user.is_authenticated:
            response = self.get_response(request) # 调用下一个

            # Code to be executed for each request/response after
            # the view is called.
            # 可能对request和response做处理
            print('SimpleMiddleware1 after response')
            print(response)
            print('=~'*30)

            return response
        else:
            return HttpResponse('提前结束了', status=401)

# user/vews.py
from django.shortcuts import render
from django.http import HttpRequest, HttpResponse, JsonResponse
from django.contrib.auth.models import User
from django.contrib.auth import authenticate, login, logout
from django.views.decorators.http import require_GET, require_POST, require_http_methods
from django.contrib.auth.decorators import login_required
import simplejson
from messages import Messages

@require_POST
def reg(request:HttpRequest):
    print(request.path)
    print(request.GET)  # 查询字符串
    print(request.POST) # 表单提交
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload)
        username = payload.get('username')
        # 判断用户名是否存在？浏览器端有没有提醒过用户，永远不要相信客户端
        count = User.objects.filter(username=username).count()
        if count>0:
            return JsonResponse(Messages.USER_EXISTS)
        # 数据存储
        email = payload['email']
        password = payload['password']
        user = User.objects.create_user(username, email, password)
        print(type(user), user) # 一旦创建成功，登录成功看到的是User实例

        return JsonResponse({}, status=201)
        #return HttpResponse(content_type='application/json', status=201)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

@require_POST
def user_login(request:HttpRequest):
    # 进入到视图函数中，request中应该有2个动态增加的属性，session、user, 和中间件有关
    print(request.path)
    print(request.method)
    print(request.body)
    print(request.content_type) #application/json
    print()
    try:
        payload = simplejson.loads(request.body)
        print(type(payload), payload) #dict
        username = payload['username'] # 登录  该如何处理？
        password = payload['password']
        # 认证函数，解决用户名和密码匹配问题，匹配成功和数据库记录一一对应
        # 真实存在的用户，is_authenticated永远为true
        user = authenticate(username=username, password=password)
        print(type(user), user)
        print(type(request.user), request.user)  #目前是匿名的。匿名用户也是用户，但is_authenticated永远为false
        print(request.session)
        print('='*30)
        if user:
            # cookie和session，首先你必须对认证成功者发一个身份id，response中增加set-cookie
            # 至少应该有sessionID，sessionID必须保存在服务器端
            login(request, user) # 各种后台jsp, php都习惯通过request.session取session值；user绑定到request上
            print(type(user), user)
            print(type(request.user), request.user)
            print('=*'*30)
            response = HttpResponse(status=204)
            # response.set_cookie('xxx')
            return HttpResponse(status=204) # 用户验证成功，之后怎么处理？
        else:
            return JsonResponse(Messages.INVALID_USERNAME_OR_PASSWORD, status=200)
    except Exception as e:
        return JsonResponse(Messages.BAD_REQUEST, status=200)

# @login_required  # 等价于 user_logout = login_required(user_logout)
# @login_required(login_url='users/login') # 等价于 user_logout = login_required(login_url='users/login')(user_logout)
def user_logout(request:HttpRequest):
    print('^^^^ view function user_logout')
    print(request.user)
    print(request.user.__dict__)
    if request.user.is_authenticated:
        s = 200
    else:
        s = 400
    print('^'*30)
    return JsonResponse({}, status=s)

class SimpleMiddleware1:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 每一个中间件返回response之前调用，做request处理
        print('=-'*30)
        print('SimpleMiddleware1 before response; process_request')
        print(request.session.items())
        print(request.user) # 你在认证中间件之后 

        response = self.get_response(request) # 调用下一个

        # 可能对request和response做处理
        print('SimpleMiddleware1 after response; process_response')
        print(response)
        print('=~'*30)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('SimpleMiddleware1 process_view start ++++') # 视图函数执行之前
        print(view_func)
        print('SimpleMiddleware1 process_view end ++++')
        # return None # 如果返回None，不影响流程，继续向后调用
        # return HttpResponse('M1故意的', status=404) # 不会向后调用，从此处返回

class SimpleMiddleware2:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 每一个中间件返回response之前调用，做request处理
        print('=-'*30)
        print('SimpleMiddleware2 before response; process_request')
        print(request.session.items())
        print(request.user) # 你在认证中间件之后 

        response = self.get_response(request) # 调用下一个

        # 可能对request和response做处理
        print('SimpleMiddleware2 after response; process_response')
        print(response)
        print('=~'*30)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print('SimpleMiddleware2 process_view start ++++') # 视图函数执行之前
        print(view_func)
        print('SimpleMiddleware2 process_view end ++++')
        # return None # 如果返回None，不影响流程，继续向后调用
        # return HttpResponse('M2故意的', status=404) # 不会向后调用，从此处返回

#settings.py, 增加中间件
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'user.views.SimpleMiddleware1', # 全局过滤
    'user.views.SimpleMiddleware2', # 全局过滤
]

curl --location '127.0.0.1:8000/users/logout' \
--header 'Content-Type: application/json' \
--data-raw '{
    "password":"adminadmin",
    "username":"admin",
    "email":"[email protected]"
}
'

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
SimpleMiddleware1 before response; process_request
dict_items([])
AnonymousUser
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
SimpleMiddleware2 before response; process_request
dict_items([])
AnonymousUser
SimpleMiddleware1 process_view start ++++
<function user_logout at 0x0000018FA170A3E0>
SimpleMiddleware1 process_view end ++++
SimpleMiddleware2 process_view start ++++
<function user_logout at 0x0000018FA170A3E0>
SimpleMiddleware2 process_view end ++++
^^^^ view function user_logout
AnonymousUser
{'_setupfunc': <function AuthenticationMiddleware.process_request.<locals>.<lambda> at 0x0000018FA188A8E0>, '_wrapped': <django.contrib.auth.models.AnonymousUser object at 0x0000018FA1984830>}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
SimpleMiddleware2 after response; process_response
<JsonResponse status_code=400, "application/json">
=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
SimpleMiddleware1 after response; process_response
<JsonResponse status_code=400, "application/json">
=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~
Bad Request: /users/logout
[26/Jul/2025 18:09:59] "POST /users/logout HTTP/1.1" 400 2

#user/views.py
...., 
class SimpleMiddleware1:
    def __init__(self, get_response):
        self.get_response = get_response
        # One-time configuration and initialization.

    def __call__(self, request):
        # Code to be executed for each request before
        # the view (and later middleware) are called.
        # 每一个中间件返回response之前调用，做request处理
        print('=-'*30)
        print('SimpleMiddleware1 before response')
        print(request.session.items())
        print(request.user) # 你在认证中间件之后 
        if request.user.is_authenticated:
            response = self.get_response(request) # 调用下一个

            # Code to be executed for each request/response after
            # the view is called.
            # 可能对request和response做处理
            print('SimpleMiddleware1 after response')
            print(response)
            print('=~'*30)

            return response
        else:
            return HttpResponse('提前结束了', status=401)

# 修改blog/settings.py文件，添加消息中间件

MIDDLEWARE = [
    ...,
    'user.views.SimpleMiddleware1', #增加该中间件
]

django-admin.py clearsessions
manage.py clearsessions

# post/views.py
from django.http import HttpResponse, JsonResponse, HttpRequest
from django.views import View
import simplejson
from .models import Post, Content
import datetime
from django.db.transaction import atomic
from messages import Messages

class PostView(View):
    def get(self, request): # 方法名一定要小写 文章列表 /posts/?page=3&size=20
        try:
            try: # 有任何异常page给默认值
                page = int(request.GET.get('page', 1)) # 缺省值1
                #/posts/?page=300000000&size=20000000 解决是否超界问题
                page = page if page > 0 and page <51 else 1
            except:
                page = 1
            try:
                size = int(request.GET.get('size', 20))
                size = size if size > 0 and size < 101 else 20
            except:
                size = 20
            print(page, size)

            # 切片
            start = size*(page-1) # 如果第1天 size*(1-1)
            posts = Post.objects.order_by('-pk')[start:start+size] # 全表扫描，要解决分页问题

            return JsonResponse({'posts':[
                {'id':post.id, 'title':post.title}
                for post in posts
            ]})
        except Exception as e:
            print(e)
            return JsonResponse(Messages.BAD_REQUEST)

from django.http import HttpResponse, JsonResponse, HttpRequest
from django.views import View
import simplejson
from .models import Post, Content
import datetime
from django.db.transaction import atomic
from messages import Messages
import math

def validate(d:dict,name:str,default,type_func,validate_func):
    try:
        ret = type_func(d.get(name,default))
        ret = validate_func(ret,default)
    except:
        ret = default
    return ret

class PostView(View):
    def get(self, request): # 方法名一定要小写 文章列表 /posts/?page=3&size=20
        # 页码  
        page = validate(request.GET,"page", 1, int, lambda x,y:x if x>0 and x <51 else y)
        # 每页条数
        #注意，这个数据不要轻易让浏览器端改变，如果允许改变，一定要控制范围
        size = validate(request.GET,"size", 20, int, lambda x,y:x if x>0 and x<101 else y)
        print(page, size)

        try:
            # 分页
            start = size*(page-1) # 如果第1天 size*(1-1)
            mgr = Post.objects
            total = mgr.count()
            posts = mgr.order_by('-pk')[start:start+size]

            return JsonResponse({
                'posts':[{'id':post.id, 'title':post.title} for post in posts],
                'pagination':{
                    'page':page,
                    'size':size,
                    'total':total, # 总共有多少个
                    'pages':math.ceil(total / size) # 总共有多少页 向上取整
                }
            })
        except Exception as e:
            print(e)
            return JsonResponse(Messages.BAD_REQUEST)

curl --location 'http://127.0.0.1:8000/posts/?page=3&size=1' \
--header 'Cookie: sessionid=wh0l46w101gre1z9ytoo6vjyvzfr4z6h'

from django.http import HttpResponse, JsonResponse, HttpRequest
from django.views import View
import simplejson
from .models import Post, Content
import datetime
from django.db.transaction import atomic
from messages import Messages
import math

def validate(d:dict,name:str,default,type_func,validate_func):
    try:
        ret = type_func(d.get(name,default))
        ret = validate_func(ret,default)
    except:
        ret = default
    return ret

class PostView(View):
    def get(self, request): # 方法名一定要小写 文章列表 /posts/?page=3&size=20
        # 页码  
        page = validate(request.GET,"page", 1, int, lambda x,y:x if x>0 and x <51 else y)
        # 每页条数
        #注意，这个数据不要轻易让浏览器端改变，如果允许改变，一定要控制范围
        size = validate(request.GET,"size", 20, int, lambda x,y:x if x>0 and x<101 else y)
        print(page, size)

        try:
            # 分页
            start = size*(page-1) # 如果第1天 size*(1-1)
            mgr = Post.objects
            total = mgr.count()
            posts = mgr.order_by('-pk')[start:start+size]

            return JsonResponse({
                'posts':[{'id':post.id, 'title':post.title} for post in posts],
                'pagination':{
                    'page':page,
                    'size':size,
                    'total':total, # 总共有多少个
                    'pages':math.ceil(total / size) # 总共有多少页 向上取整
                }
            })
        except Exception as e:
            print(e)
            return JsonResponse(Messages.BAD_REQUEST)

    # 必须登录
    def post(self, request): # 如果没有post函数，POST请求无法对应，返回405
        try:
            payload = simplejson.loads(request.body)
            title = payload['title']
            C = payload['content']
            post = Post(title=title)
            content = Content()

            post.postdate = datetime.datetime.now(
                datetime.timezone(datetime.timedelta(hours=8))
            )
            # post.author_id = 2 #request.user.id
            post.author = request.user
            content.content = C

            with atomic():
                post.save()
                content.post  = post
                content.save()


            return JsonResponse({'post':{
                'id':post.id
            }})
        except Exception as e:
            return JsonResponse(Messages.BAD_REQUEST)

def getpost(request:HttpRequest, id:int):
    try:
        post = Post.objects.get(pk=id)
        return JsonResponse({'post':{
            'id':post.pk,
            'title':post.title,
            # "2025-07-28T09:24:40.104Z"
            'postdate':post.postdate, # UTC字符串
            'author_id':post.author_id,
            'author':post.author.username,
            'content':post.content.content
        }})
    except Exception as e:
        print(e)
        return JsonResponse(Messages.NOT_FOUND)   

// src/index.js
import React from 'react';
import { render } from 'react-dom';

const App = props => <div>测试</div>

render(<App />, document.getElementById('root'));

#npm run start
yarn run start
# 浏览器打开 IP:3000 看看效果

#npm install react-router-dom   #在package.json已经指定安装

import React from 'react';
import { render } from 'react-dom';
import {
  BrowserRouter as Router,
  Switch,
  Route,
  Link
} from "react-router-dom";

function Home() {
  return <h2>Home</h2>;
}

function About() {
  return <h2>About</h2>;
}

function Default() {
  return <h2>缺省显示</h2>;
}

function Always() {
  return <h2><hr />页脚</h2>;
}

class App extends React.Component {
  // exact 精确匹配
  render() {
    return <Router>
      <div>
        <Switch>
          <Route exact path={["/", '/index']} component={Home}></Route>
          <Route strict path="/about" component={About}></Route>
          <Route component={Default}></Route>
        </Switch>
        <Route component={Always}></Route>
      </div>
    </Router>
  }
}

render(<App />, document.getElementById('root')); 

<div class="login-page">
<div class="form">
    <form class="register-form">
    <input type="text" placeholder="name"/>
    <input type="password" placeholder="password"/>
    <input type="text" placeholder="email address"/>
    <button>create</button>
    <p class="message">Already registered? <a href="#">Sign In</a></p>
    </form>
    <form class="login-form">
    <input type="text" placeholder="username"/>
    <input type="password" placeholder="password"/>
    <button>login</button>
    <p class="message">Not registered? <a href="#">Create an account</a></p>
    </form>
</div>
</div>

/* 新建文件src/component/login.js */
import React from "react";
import {Link} from "react-router-dom";

export default class Login extends React.Component {
    render() {
        return (
            <div className="login-page">
            <div className="form">
                <form className="login-form">
                <input type="text" placeholder="username"/>
                <input type="password" placeholder="password"/>
                <button>登录</button>
                <p className="message">还未注册？ <Link to="/reg">请注册</Link></p>
                </form>
            </div>
            </div>
        )
    }
}

/* 修改src/index.js文件内容 */
...
import Login from './component/login';

class App extends React.Component {
  // exact 精确匹配
  render() {
    return <Router>
      <div>
        <Switch>
          <Route exact path={["/", '/index']} component={Home}></Route>
          <Route path="/login" component={Login}></Route>

module: {
    rules: [
        {
            test: /\.js$/,
            exclude: /node_modules/,
            use: [
                { loader: 'react-hot-loader/webpack' },
                { loader: 'babel-loader' }
            ]
        },
        {
            test: /\.css$/,
            use: [
                { loader: "style-loader" },
                { loader: "css-loader" },
            ]
         }, 
        {
            test: /\.less$/,
            use: [
                { loader: "style-loader" },
                { loader: "css-loader" },
                { loader: "less-loader" }
            ]
        }
    ]
},

/* src/component/login.js中导入样式表 */
import React from "react";
import {Link} from "react-router-dom";
import "../css/login.css";

/* 新建src/css/login.css文件 */
body {
  font-family: "Roboto", sans-serif;
}

.login-page {
  width: 360px;
  padding: 8% 0 0;
  margin: auto;
}
.form {
  position: relative;
  z-index: 1;
  background: #FFFFFF;
  max-width: 360px;
  margin: 0 auto 100px;
  padding: 45px;
  text-align: center;
  box-shadow: 0 0 20px 0 rgba(0, 0, 0, 0.2), 0 5px 5px 0 rgba(0, 0, 0, 0.24);
}
.form input {
  font-family: "Roboto", sans-serif;
  outline: 0;
  background: #f2f2f2;
  width: 100%;
  border: 0;
  margin: 0 0 15px;
  padding: 15px;
  box-sizing: border-box;
  font-size: 14px;
}
.form button {
  font-family: "Roboto", sans-serif;
  text-transform: uppercase;
  outline: 0;
  background: #4CAF50;
  width: 100%;
  border: 0;
  padding: 15px;
  color: #FFFFFF;
  font-size: 14px;
  -webkit-transition: all 0.3 ease;
  transition: all 0.3 ease;
  cursor: pointer;
}
.form button:hover,.form button:active,.form button:focus {
  background: #43A047;
}
.form .message {
  margin: 15px 0 0;
  color: #b3b3b3;
  font-size: 12px;
}
.form .message a {
  color: #4CAF50;
  text-decoration: none;
}

/*新建src/component/reg.js文件 */
import React from 'react';
import { Link } from 'react-router-dom';
import '../css/login.css';

// 缺省导出
export default class Reg extends React.Component {
  render() {
    return (
      <div className="login-page">
        <div className="form">
          <form className="register-form">
            <input type="text" placeholder="用户名"/>
            <input type="text" placeholder="电子邮箱"/>
            <input type="password" placeholder="密码"/>
            <input type="password" placeholder="确认密码"/>
            <button>注册</button>
            <p className="message">已经注册, <Link to='/login'>请登录</Link></p>
          </form>
        </div>
      </div>
    );
  }
}

/* src/index.js中修改*/
import React from 'react';
import { render } from 'react-dom';
import {
  BrowserRouter as Router,
  Switch,
  Route,
  Link
} from "react-router-dom";
import Login from './component/login';
import Reg from './component/reg';

function Home() {
  return <h2>Home</h2>;
}

function About() {
  return <h2>About</h2>;
}

function Default() {
  return <h2>缺省显示</h2>;
}

function Always() {
  return <h2><hr />页脚</h2>;
}

class App extends React.Component {
  // exact 精确匹配
  render() {
    return <Router>
      <div>
        <Switch>
          <Route exact path={["/", '/index']} component={Home}></Route>
          <Route path="/login" component={Login}></Route>
          <Route path="/reg" component={Reg}></Route>
          <Route path="/about" component={About}></Route>
          <Route component={Default}></Route>
        </Switch>
        <Route component={Always}></Route>
      </div>
    </Router>
  }
}

render(<App />, document.getElementById('root')); 

/* 修改src/index.js文件*/
import React from 'react';
import { render } from 'react-dom';
import {
  BrowserRouter as Router,
  Switch,
  Route,
  Link
} from "react-router-dom";
import Login from './component/login';
import Reg from './component/reg';

function Home() {
  return <h2>Home</h2>;
}

function About() {
  return <h2>About</h2>;
}

function Default() {
  return <h2>缺省显示</h2>;
}

function Always() {
  return <h2><hr />页脚</h2>;
}

class App extends React.Component {
  // exact 精确匹配
  render() {
    return <Router>
      <div>
        <ul>
          <li><Link to="/">主页</Link></li>
          <li><Link to="/login">登录</Link></li>
          <li><Link to="/reg">注册</Link></li>
          <li><Link to="/about">关于</Link></li>
        </ul>
        <Switch>
          <Route exact path={["/", '/index']} component={Home}></Route>
          <Route path="/login" component={Login}></Route>
          <Route path="/reg" component={Reg}></Route>
          <Route path="/about" component={About}></Route>
          <Route component={Default}></Route>
        </Switch>
        <Route component={Always}></Route>
      </div>
    </Router>
  }
}

render(<App />, document.getElementById('root')); 

/* 新建src/service/user.js逻辑 */
export default class UserService {
    login(username, password) {
        console.log('去处理', username, password)
        // TODO 待完成代码
    }
}

/* 修改src/component/login.js文件 */
import React from "react";
import {Link} from "react-router-dom";
import "../css/login.css";

export default class Login extends React.Component {
    handleClick(event){
        console.log(event.target)
    }

    render() {
        return (
            <div className="login-page">
            <div className="form">
                <form className="login-form">
                <input type="text" placeholder="email"/>
                <input type="password" placeholder="password"/>
                <button onClick={this.handleClick.bind(this)}>登录</button>
                <p className="message">还未注册？ <Link to="#">请注册</Link></p>
                </form>
            </div>
            </div>
        )
    }
}

/* 修改src/component/login.js文件 */
import React from 'react';
import { Link } from 'react-router-dom';
import '../css/login.css';
import UserService from '../service/user';

const service = new UserService();

export default class Login extends React.Component {
  render() {
    return <_Login service={service} />
  }
}

class _Login extends React.Component {
  handleClick(event) {
    event.preventDefault(); // 阻止事件默认行为, 阻止提交 Ajax
    console.log('click');
    // 连接到服务器端进行用户名和密码的验证等待回复
    // 组件中只要收集用户名和密码就可以了，验证交给其他的服务层Service层
    // service.login() // service是全局变量，对于组件用props
    // this.props.service.login();
    // console.log('=====',event.target)
    // console.log('=====',event.target.form)
    // let form = event.target.form;
    // console.log(form[0], form[1]); // key
    // console.log(form[0].value, form[1].value); // value
    const [username, password] = event.target.form;
    // console.log(username.value, password.value);
    this.props.service.login(username.value, password.value);
  }
  render() {
    return (
      <div className="login-page">
        <div className="form">
          <form className="login-form">
            <input type="text" placeholder="用户名"/>
            <input type="password" placeholder="密码"/>
            <button onClick={this.handleClick.bind(this)}>登录</button>
            <p className="message">还未注册? <Link to="/reg">请清册</Link></p>
          </form>
        </div>
      </div>
    );
  }
}