面試題之web

django：大而全的全的框架，重武器；内置很多组件：ORM、admin、Form、ModelForm、中间件、信号、缓存、csrf等
flask: 微型框架、可扩展强，如果开发简单程序使用flask比较快速，
             如果实现负责功能就需要引入一些组件：flask-session/flask-SQLAlchemy/wtforms/flask-migrate/flask-script/blinker
            
            这两个框架都是基于wsgi协议实现的，默认使用的wsgi模块不一样。
            还有一个显著的特点，他们处理请求的方式不同：
                django： 通过将请求封装成Request对象，再通过参数进行传递。
                 flask：通过上下文管理实现。
            
            延伸：
                - django组件 
                - flask组件，用途 
                - wsgi
                - 上下文管理
        

web服务网关接口，一套协议。
            实现了wsgi协议的模块本质上就是编写了socket服务端，用来监听用户请求，如果有请求到来，则将请求进行一次封装，
             然后将【请求】交给 web框架来进行下一步处理。
            目前接触：
                wsgiref   （dajngo）
                werkzurg  (flask)
                uwsgi 
                
            
            
            from wsgiref.simple_server import make_server
 
            def run_server(environ, start_response):
                """
                environ: 封装了请求相关的数据
                start_response：用于设置响应头相关数据
                """
                start_response(‘200 OK‘, [(‘Content-Type‘, ‘text/html‘)])
                return [bytes(‘<h1>Hello, web!</h1>‘, encoding=‘utf-8‘), ]
             
             
            if __name__ == ‘__main__‘:
                httpd = make_server(‘‘, 8000, run_server)
                httpd.serve_forever()
                        

class WSGIHandler(base.BaseHandler):
                    request_class = WSGIRequest

                    def __init__(self, *args, **kwargs):
                        super(WSGIHandler, self).__init__(*args, **kwargs)
                        self.load_middleware()

                    def __call__(self, environ, start_response):
                        # 请求刚进来之后 #
                        
                        set_script_prefix(get_script_name(environ))
                        signals.request_started.send(sender=self.__class__, environ=environ)
                        request = self.request_class(environ)
                        response = self.get_response(request)

                        response._handler_class = self.__class__

                        status = ‘%d %s‘ % (response.status_code, response.reason_phrase)
                        response_headers = [(str(k), str(v)) for k, v in response.items()]
                        for c in response.cookies.values():
                            response_headers.append((str(‘Set-Cookie‘), str(c.output(header=‘‘))))
                        start_response(force_str(status), response_headers)
                        if getattr(response, ‘file_to_stream‘, None) is not None and environ.get(‘wsgi.file_wrapper‘):
                            response = environ[‘wsgi.file_wrapper‘](response.file_to_stream)
                        return response

所有方法：
                - process_request
                - process_view
                - process_template_response , 当视图函数的返回值对象中有render方法时，该方法才会被调用。
                - process_response
                - process_excaption

 - 登录验证，为什么：如果不适用就需要为每个函数添加装饰器，太繁琐。
 - 权限处理，为什么：用户登录后，将权限放到session中，然后再每次请求时需要判断当前用户是否有权访问当前url，这检查的东西就可以放到中间件中进行统一处理。
 - 还有一些内置： 
      - csrf，为什么
      - session，为什么
      - 全站缓存 ，为什么
      - 另外，还有一个就是处理：跨域 （前后端分离时，本地测试开发时使用的。）

form表单提交：
                    <form method="POST">
                        {% csrf_token %}
                        <input type=‘text‘ name=‘user‘ />
                        <input type=‘submit‘ />
                    </form>
                    
                ajax提交：
                    $.ajax({
                        url:‘/index‘,
                        type:‘POST‘,
                        data:{csrfmiddlewaretoken:‘{{ csrf_token }}‘,name:‘alex‘}
                    })
                    
                    前提：引入jquery + 引入jquery.cookie  （此模块可以完成从cookie中取出csrftoken）
                    $.ajax({
                        url: ‘xx‘,
                        type:‘POST‘,
                        data:{name:‘oldboyedu‘},
                        headers:{
                            X-CSRFToken: $.cookie(‘csrftoken‘)   
                        }, #在请求头中加上这个信息  注意名字必须是 X-CSRFToken：
                        dataType:‘json‘, // arg = JSON.parse(‘{"k1":123}‘)
                        success:function(arg){
                            
                        }
                    })
                    

    <body>
                            <input type="button" onclick="Do1();"  value="Do it"/>
                            <input type="button" onclick="Do2();"  value="Do it"/>
                            <input type="button" onclick="Do3();"  value="Do it"/>

                            <script src="/static/jquery-3.3.1.min.js"></script>
                            <script src="/static/jquery.cookie.js"></script>  //导入jquery.cookie
                            <script>
                                $.ajaxSetup({  //在以后每一个发送ajax请求之前，每次发送之前    都会执行该函数
                                   beforeSend: function(xhr, settings) {
                                        xhr.setRequestHeader("X-CSRFToken", $.cookie(‘csrftoken‘));
                                    }
                                });

                                 function Do1(){
                                    $.ajax({
                                        url:"/index/",
                                        data:{id:1},
                                        type:‘POST‘,
                                        success:function(data){
                                            console.log(data);
                                        }
                                    });
                                }

                                 function Do2(){
                                    $.ajax({
                                        url:"/index/",
                                        data:{id:1},
                                        type:‘POST‘,
                                        success:function(data){
                                            console.log(data);
                                        }
                                    });
                                }

                                 function Do3(){
                                    $.ajax({
                                        url:"/index/",
                                        data:{id:1},
                                        type:‘POST‘,
                                        success:function(data){
                                            console.log(data);
                                        }
                                    });
                                }
                            </script>
                        </body>
                        

FBV:
                def index(request):
                    pass 
            
CBV:    
                class IndexView(View):
                    
                    # 如果是crsf相关，必须放在此处
                    def dispach(self,request):
                        # 通过反射执行post/get 
                    
                    @method_decoretor(装饰器函数)
                    def get(self,request):
                        pass
                        
                    def post(self,request):
                        pass 
                    
                路由：IndexView.as_view()

　　　　　　　　　　　　from django.views import View
                    from django.utils.decorators import method_decorator

                    def auth(func):
                        def inner(*args,**kwargs):
                            return func(*args,**kwargs)
                        return inner

                    class UserView(View):
                        
                        @method_decorator(auth)
                        def get(self,request,*args,**kwargs):

from django.views.decorators.csrf import csrf_exempt

from django.utils.decorators import method_decorator

# 方式1
# @method_decorator(csrf_exempt,name="dispatch")
class UserView(View):
    #方式二
    #也可以自定义以dispatch()方法
    @method_decorator(csrf_exempt)  #加上这句就可以不验证post请求的csrf内容
    def dispatch(self, request, *args, **kwargs):
        #写上一个print 方法
        print(‘Hollow‘)
        #运行的内容继承dispatch   接收返回值
        res=super(UserView, self).dispatch(request, *args, **kwargs)
        #将返回值返回
        return res
    #定义两个类，get  post这两个
    def get(self,request):
        print(‘get11111‘)
        return HttpResponse(‘getOK‘)
    def post(self,request):
        return HttpResponse(‘postOK‘)

　　　　　　　　　　- extra
                    def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
                        # 构造额外的查询条件或者映射，如：子查询

                        Entry.objects.extra(select={‘new_id‘: "select col from sometable where othercol > %s"}, select_params=(1,))
                        Entry.objects.extra(where=[‘headline=%s‘], params=[‘Lennon‘])
                        Entry.objects.extra(where=["foo=‘a‘ OR bar = ‘a‘", "baz = ‘a‘"])
                        Entry.objects.extra(select={‘new_id‘: "select id from tb where id > %s"}, select_params=(1,), order_by=[‘-nid‘])
                - raw 
                    def raw(self, raw_query, params=None, translations=None, using=None):
                        # 执行原生SQL
                        models.UserInfo.objects.raw(‘select * from userinfo‘)

                        # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
                        models.UserInfo.objects.raw(‘select id as nid,name as title  from 其他表‘)

                        # 为原生SQL设置参数
                        models.UserInfo.objects.raw(‘select id as nid from userinfo where nid>%s‘, params=[12,])

                        # 将获取的到列名转换为指定列名
                        name_map = {‘first‘: ‘first_name‘, ‘last‘: ‘last_name‘, ‘bd‘: ‘birth_date‘, ‘pk‘: ‘id‘}
                        Person.objects.raw(‘SELECT * FROM some_other_table‘, translations=name_map)

                        # 指定数据库
                        models.UserInfo.objects.raw(‘select * from userinfo‘, using="default")
                - 原生
                        from django.db import connection, connections
                        cursor = connection.cursor()  # cursor = connections[‘default‘].cursor()
                        cursor.execute("""SELECT * from auth_user where id = %s""", [1])
                        row = cursor.fetchone() # fetchall()/fetchmany(..)

　　　　　　　 - request/bs4
            - requests模块
                - 参数：
                    - url
                    - headers 
                    - cookies 
                    - data 
                    - json 
                    - params 
                    - proxy
                - 返回值：
                    - content
                    - iter_content
                    - text 
                    - encoding="utf-8"
                    - cookie.get_dict()
            - bs4 
                - 解析：html.parser  -> lxml 
                - find 
                - find_all
                - text 
                - attrs
                - get 
            - 其他：
                常见请求头：
                    - user-agent
                    - host
                    - referer
                    - cookie 
                    - content-type 
                套路：
                    - 先给你cookie，然后再给你授权。
                    - 凭证
                轮询+长轮询
        - scrapy 
            - 高性能相关，单线程并发发送Http请求
                - twisted
                - gevent 
                - asyncio
              本质：基于IO多路复用+非阻塞的socket客户端实现
              问题：异步非阻塞？
              
              问题：什么是协程？
              
            - scrapy框架
                - scrapy执行流程（包含所有组件）
                - 记录爬虫爬取数据深度（层级），request.meta[‘depth‘]
                - 传递cookie
                    - 手动 
                    - 自动：meta={‘cookiejar‘:True}
                    
                - 起始URL
                - 持久化：pipelines/items 
                - 去重
                - 调度器
                - 中间件 
                    - 下载中间件
                        - agent
                        - proxy 
                    - 爬虫中间件
                        - depth 
                - 扩展+信号 
                - 自定义命令
            - scrapy-redis组件，本质：去重、调度器任务、pipeline、起始URL放到redis中。
                - 去重，使用的redis的集合。
                - 调度器，
                        - redis列表
                            - 先进先出队列
                            - 后进先出栈
                        - redis有序集合
                            - 优先级队列
                        
                        PS：深度和广度优先
                - pipelines
                        - redis列表 
                
                - 起始URL 
                        - redis列表
                        - redis集合
                        
                补充：
                    自定义encoder实现序列化时间等特殊类型：
                        json.dumps(xx,cls=MyEncoder)


            - scrapy 

from django.shortcuts import render,HttpResponse
from app01 import models
def index(request):
    # return HttpResponse("...")
    return render(request,‘index.html‘,{‘x‘:123})
from django.forms import Form
from django.forms import fields
class UserForm(Form):
    name = fields.CharField(label=‘用户名‘,max_length=32)
    email = fields.EmailField(label=‘邮箱‘)
    ut_id = fields.ChoiceField(
        # choices=[(1,‘二笔用户‘),(2,‘闷骚‘)]
        choices=[]
    )

    def __init__(self,*args,**kwargs):
        super(UserForm,self).__init__(*args,**kwargs)

        self.fields[‘ut_id‘].choices = models.UserType.objects.all().values_list(‘id‘,‘title‘)

def user(request):
    if request.method == "GET":
        form = UserForm()
        return render(request,‘user.html‘,{‘form‘:form})

from django.forms import Form
                            from django.forms import fields
                            from django.forms.models import ModelChoiceField
                            #用这个类来给页面渲染出标签
                            class UserForm(Form):
                                name = fields.CharField(label=‘用户名‘,max_length=32)
                                email = fields.EmailField(label=‘邮箱‘)
                                #这里渲染出从数据库中查出的数据  要这要写
                                ut_id = ModelChoiceField(queryset=models.UserType.objects.all())    
                            

　　　　　　　　　　　　　　　　class UserType(models.Model):
                                    title = models.CharField(max_length=32)

                                    def __str__(self):
                                    #这个也要写上
                                        return self.title
        

　　　　　　　　　　# 第一步：
                    python manage.py makemigraions 
                
                # 第二步：
                    app01中的表在default数据库创建
                    python manage.py migrate app01 --database=default
                
                # 第三步：
                    app02中的表在db1数据库创建
                    python manage.py migrate app02 --database=db1

m1.UserType.objects.using(‘default‘).create(title=‘VVIP‘)
m2.Users.objects.using(‘db1‘).create(name=‘VVIP‘,email=‘xxx‘)

　　　　　　　　　　　　　　class Router1:
                            def db_for_read(self, model, **hints):
                                """
                                Attempts to read auth models go to auth_db.
                                """
                                if model._meta.app_label == ‘app01‘:
                                    return ‘default‘
                                else:
                                    return ‘db1‘

                            def db_for_write(self, model, **hints):
                                """
                                Attempts to write auth models go to auth_db.
                                """
                                if model._meta.app_label == ‘app01‘:
                                    return ‘default‘
                                else:
                                    return ‘db1‘

DATABASE_ROUTERS = [‘db_router.Router1‘,]

　　　　　　　　　　　　class Router1:
                        def allow_migrate(self, db, app_label, model_name=None, **hints):
                            """
                            All non-auth models end up in this pool.
                            """
                            if db==‘db1‘ and app_label == ‘app02‘:
                                return True
                            elif db == ‘default‘ and app_label == ‘app01‘:
                                return True
                            else:
                                return False
                            
                            # 如果返回None，那么表示交给后续的router，如果后续没有router，则相当于返回True
                            
                        def db_for_read(self, model, **hints):
                            """
                            Attempts to read auth models go to auth_db.
                            """
                            if model._meta.app_label == ‘app01‘:
                                return ‘default‘
                            else:
                                return ‘db1‘

                        def db_for_write(self, model, **hints):
                            """
                            Attempts to write auth models go to auth_db.
                            """
                            if model._meta.app_label == ‘app01‘:
                                return ‘default‘
                            else:
                                return ‘db1‘