• Ajax cookie session form组件


        1. Cookie是什么
            保存在浏览器端的键值对
            
            为什么要有Cookie?
                因为HTTP请求是无状态的
            
            Cookie的原理?
                服务端可以在返回响应的时候 做手脚
                在浏览器上写入键值对(Cookie)
                
                浏览器发送请求的时候会自动携带该网站保存在我浏览器的键值对(Cookie)
                
            Django 从请求携带的Cookie中取值:
                request.COOKIES.get("is_login")
                request.get_signed_cookie(key, default=None, salt="xxx")
            Django中设置Cookie:(针对的是响应对象)
                rep = HttpResponse()/render(request, "test.html)/redirect()
                rep.set_signed_cookie(key, value, salt="xxx", max_age=7)
            Django中删除Cookie:(注销)
                rep.delete_cookie(key)
    
        2. Session是什么
            Session保存在服务端的键值对
            
            Session依赖于Cookie
            
            dsadasdsadsafsjkndf: {"is_login": 1, "name": "xiaohei", "age":18}
            dsaasdaknfgreryywdf: {"is_login": 1, "name": "xiaobai", "age":20}
            wqrqrteknfgzddasqfg: {"is_login": 0, "name": "xiaohui", "age":48}
            
            给浏览器写入Cookie:
                sessionid:wqrqrteknfgzddasqfg
                
            1. 从用户发来的请求的Cookie中 根据 sessionid 取值, 取到 wqrqrteknfgzddasqfg
            2. 根据特殊字符串找到对应的 Session 数据  --> {"is_login": 0, "name": "xiaohui", "age":48}
            3. request.session.get("is_login")    --> 从Session取值
            
            
            Django中设置Session:
                request.session["is_login"] = 1
                request.session.set_expiry(7)  # 设置超时时间 (Cookie和Session数据的)
                
                
                在settings.py中设置,每次请求都刷新Session超时时间
                SESSION_SAVE_EVERY_REQUEST = True 
            
            Django中删除Session:
                request.session.flush()     清除Cookie和Session数据
                
                request.session.clear_expired()  将所有Session失效日期小于当前日期的数据删除
                
    今日内容
        AJAX
        
        1. 预备知识 JSON
        
        
        2. 我们之前已经学过的发请求的方式:
            1. 直接在地址栏输入URL回车     GET请求
            2. a标签                       GET请求
            3. form表单                    GET/POST请求
            4. AJAX                        GET/POST请求
            
        3. AJAX 特点:
            1. 异步
            2. 局部刷新浏览器(偷偷发请求)
            
        
            
    
     
            
            
            
            
            
            
            
        1. 回顾了一下json数据格式
            1. JS对象        和 json数据格式的互相转换
            2. Python中数据  和 json数据格式的互相转换
        2. AJAX
            1. 我们前端往后端发请求的方式:
                1. 直接在地址栏输入URL
                2. a标签
                3. form表单
                4. AJAX
                
                HTTP请求的类型:
                    GET
                    POST
            2. AJAX特点:
                1. 异步
                2. 局部刷新(偷偷发请求)
                
            3. AJAX缺点:
                请求零碎,滥用对服务端压力大
            
            4. jQuery封装的AJAX方法:
                先导入 jquery.js 
                
                $.ajax({
                    url: "/test/",
                    type: "post",
                    data: {"key": "value", "key2":[[1, 2, 3], [4, 5, 6]]},
                    success: function(arg){
                        // 请求得到响应的时候,自动执行这个回调函数
                        console.log(arg);
                    }
                })
                
    今日内容
        1. form组件的介绍
            
        之前web开发的模式,以注册为例:
            1. 要有一个注册的页面,页面里面要有form表单        --> 生成HTML代码
            2. form表单要能提交数据到后端,后端要做有效性校验  --> 数据有效性校验
            3. 要把校验的提示信息展示在页面上                  --> 校验信息返回并展示,保存原来填写的内容
            
            
            关于校验:
                1. 前端通过JS代码做校验    --> 最好有
                2. 后端做校验              --> 必须要有(因为前端的校验可以被跳过)
            
            
        2. form组件的用法
            1. from django import forms
            2, 定义一个form类
                class RegForm(forms.Form):
                    user = forms.CharField()
                    pwd = forms.CharField()
                    email = forms.EmailField()
            
            生成HTML:
                3. 实例化一个form对象, 传递到模板语言中
                4. 在目标语言中调用form对象的响应方法和属性
                
                三种方式:
                    1. {{ form_obj.as_p }}
                    2. 单独写
                        {{ form_obj.pwd.label }}
                        {{ form_obj.pwd }}
            
            
            做校验:
                1. form_obj = RegForm(request.POST)
                2. form_obj.is_valid()
                
            内置的正则校验器的使用
                mobile = forms.CharField(
                    label="手机",
                    # 自己定制校验规则
                    validators=[
                        RegexValidator(r'^[0-9]+$', '手机号必须是数字'),
                        RegexValidator(r'^1[3-9][0-9]{9}$', '手机格式有误')
                    ],
                    widget=widgets.TextInput(attrs={"class": "form-control"}),
                    error_messages={
                        "required": "该字段不能为空",
                    }
                )
        
        看源码:
            
        
            form_obj.is_valid()都干了什么?
            
            
            self._errors = ErrorDict()  --> {}
            self.cleaned_data = {}     
    
            self.fields.items()
                字段名  字段对象
            
            
            如果有错误:
                self._errors["name"] = ""
            
            没有报错:
                self.cleaned_data["name"] = value(用户填写的值)
                
            注意:
            钩子函数(hook)的使用
            
            def clean_xx():
                """具体字段的自定义校验方法"""
                pass
            
            def clean():
                """全局的自定义校验方法"""
                pass
            
    
    errors:
            
    <ul class="errorlist">
        <li>name
            <ul class="errorlist">
                <li>不符合社会主义核心价值观!</li>
            </ul>
        </li>
        <li>__all__
            <ul class="errorlist nonfield">
                <li>两次密码不一致</li>
            </ul>
        </li>
    </ul>
        
    
    今日内容
        中间件:http://www.cnblogs.com/liwenzhou/p/8761803.html
        
            1. URL的白名单 url = ["/xx/", "/oo/", "/haha/"]
            2. 登陆之后才能访问某些URL    之前使用装饰器
    
        
        中间件的定义:
            wsgi之后 urls.py之前 在全局 操作Django请求和响应的模块!
            
        中间件的使用:
            5个固定的方法
                process_request(self, request)
                    执行顺序:
                        按照注册的顺序(在settings.py里面设置中 从上到下的顺序)
                    何时执行:
                        请求从wsgi拿到之后
                    返回值:
                        返回None,继续执行后续的中间件的process_request方法
                        返回response , 不执行后续的中间件的process_request方法
                        
                process_response
                    执行顺序:
                        按照注册顺序的倒序(在settings.py里面设置中 从下到上的顺序)
                    何时执行:
                        请求有响应的时候
                    返回值:
                        必须返回一个response对象
                        
                process_view(self, request, view_func, view_args, view_kwargs):
                    执行顺序:
                        按照注册的顺序(在settings.py里面设置中 从上到下的顺序)
                    何时执行:
                        在urls.py中找到对应关系之后 在执行真正的视图函数之前
                    返回值:
                        返回None,继续执行后续的中间件的process_view方法
                        返回response,
                        
                        
                process_exception(self, request, exception)
                    执行顺序:
                        按照注册顺序的倒序(在settings.py里面设置中 从下到上的顺序)
                    何时执行:
                        视图函数中抛出异常的时候才执行
                    返回值:
                        返回None,继续执行后续中间件的process_exception
                        返回response,
                        
                        
                        
                process_template_response(self, request, response)
                    执行顺序:
                        按照注册顺序的倒序(在settings.py里面设置中 从下到上的顺序)
                    何时执行:
                        视图函数执行完,在执行视图函数返回的响应对象的render方法之前 
                    返回值:
                        返回None,继续执行后续中间件的process_exception
                        返回response,
        
        
            Django调用 注册的中间件里面五个方法的顺序:
                1. process_request
                    urls.py
                2. process_view
                    view
                3. 有异常就执行 process_exception
                4. 如果视图函数返回的响应对象有render方法,就执行process_template_response
                5. process_response
        
    
    Django已经学过的知识点:
        1. Urls.py 路由系统:
        
            正则
                分组匹配     --> 位置参数
                分组命名匹配 --> 关键字参数
            
            分级路由
                include
            
            给路由起别名
                name="xx"
                
            反向解析url
                view
                    from django.urls import reverse
                    
                    reverse("xx", args=[1, 2, 3])
                    reverse("xx", kwargs={”k": "v"})
                    
            自取其辱
            
        2. 视图 views.py
            request
                request.method
                request.GET     --> URL里面的参数
                request.POST    --> post请求的数据
                
                request.path_info        --> 路径
                request.get_full_path()  --> 路径加路径的参数
            
            
            response
                新手必备3件套
                render(request, "xx.html", {“k”: "v", ...})
                HttpResponse("响应")
                redirect("/index/")
                redirect("http://www.luffycity.com")
                
                from django.http import JsonResponse
                JsonResponse()
                
                FBV和CBV
                
                函数装饰器和方法装饰器的区别
                
        3. 模板
            
            filter
                内置的filter方法
                自定义的filter方法
                
            tag
                内置的tag
                自定义的simpleTag
                自定义的inclusionTag
                
            母版和继承
            
            {% extends ‘base.html’ %}
            
            {% block page-main %}
                {% block small %}
                {% endblock small %}
            {% endblock page-main %}
            
            
            组件 {% include nav %}
            
            
            静态文件相关的tag
            
            在模板语言里面反向解析url
            
                {% url 'url的别名' xx %}
        
            
        4. ORM
            
            对应关系
                类   --> 数据表
                对象 --> 数据行
                属性 --> 字段
                
            
            Django连接MySQL数据库的步骤:
                1. 手动创建库
                2. 配置settings.py中数据库的连接信息
                3. 修改settings.py同目录下的__init__.py文件,添加两句
                    import pymysql
                    pymysql.install_as_MySQLdb()
                4. 在app下面的models.py中定义类,类一定要继承mdoels.Model
                5. 执行两句命令
                    1. python manage.py makemigrations
                    2. python manage.py migrate
        
            操作数据表
            
            操作数据行(增删改查)
                单表
                外键
                多对多
                一对一
                
            
            ORM高级:
                常用字段和方法
                必知必会13条
                神奇的双下划线
                跨表的正向查询反向查询
                
                F和Q
                
                聚合和分组
                
                事务
                
                执行原生的SQL语句
        
        5. Cookie和Session,分页
        
        
        6. AJAX
            
            $.ajax({
                url: “”,
                type: "post",
                data: {"k1": JSON.stringify([1,2,3])},
                success:function(data){
                    
                }
            })
        7. form表单
        
        8. 中间件
        
            
                
                
                
        
  • 相关阅读:
    索引有什么用?
    数据类型的优化策略?
    MySQL的锁策略有什么?
    行锁
    Innodb_lock_waits
    Innodb_locks表
    软件安装笔记
    Spring Boot学习笔记
    AI学习总结
    笔试面试题总结
  • 原文地址:https://www.cnblogs.com/shangchunhong/p/9372843.html
Copyright © 2020-2023  润新知