django 基础框架学习 (二)

Django框架基础-02

Django缓存
cookie

1.说明
        当我们服务器在响应数据的同时，希望写⼊⼀些缓存数据到客户端
        我们可以选择在响应的同时，将要写⼊到客户端的缓存数据写⼊到⽤户的浏览器的cookie中
    2.创建response对象
        # 创建响应对象
        response = HttpResponse('OK')
        # response = JsonResponse({"name":"python"})
        # response = redirect(reverse('users:index'))
        # response = render('模板')
    3.设置cookie  response.set_cookie(' 键 ' , ' 值 ' , max_age= 过期时间，单位秒)
        response.set_cookie('name', ' python' , max_age= 3600)
    4.读取cookie  name = request.COOKIES.get('name')

session
    1.session说明
        1.session和 cookie都可以做缓存数据
        2.但是，session是将缓存的数据存储在服务器端 cookie存储缓存数据在⽤户浏览器
        3.⼴义：指session机制，会话，⽤于记录多次http请求之间的关系，关系就是状态数据，⽐如登录状态
        4.狭义：指session数据，会话数据，记录会话的状态数据，⽐如登录后存储user_id记录登录状态
    2.Django中使⽤session说明
        1.默认开启了session机制
            安装应⽤ ' django.contrib.sessions' ,
            注册中间件 ' django.contrib.sessions.middleware.SessionMiddleware' ,
        2.存储⽅案
            1.默认存储⽅案（数据库） SESSION_ENGINE=' django.contrib.sessions.backends.db',                
                存储到数据库的django_session这个表
            2.本地缓存（本机内存） SESSION_ENGINE=' django.contrib.sessions.backends.cache'
            3.混合缓存 SESSION_ENGINE=' django.contrib.sessions.backends.cached_db',先内存找，再数据库找
            4.Redis
        3.本地缓存的跨机访问问题
            问题
                1.如果将缓存数据存储到Django程序运⾏空间中
                2.⽤户在请求时会由nginx服务器转发请求 可能多次转发到的服务器不⼀样
                3.那么如果转发到没有写⼊缓存数据的电脑，将得不到缓存
            图解:

4.Redis存储session数据配置
            1.安装django-redis pip install django-redis
            2.配置缓存后端

# 配置缓存（缓存后端为Redis）
CACHES = {
        "default": {
        "BACKEND": " django_redis.cache.RedisCache" ,
        "LOCATION": "redis://192.168.103.132:6379/1",
        "OPTIONS": {
        "CLIENT_CLASS": " django_redis.client.DefaultClient" ,
        }
    }
 }
SESSION_ENGINE = " django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

5.设置和读取session数据
            1.代码实现

def session_demo(request):
"""设置和读取session"""
# 设置session
    request.session['user_id'] = 100
# 读取session
    user_id = request.session.get('user_id')
    print(user_id)
    return HttpResponse('ok')

2.session机制说明
                1.设置session时，会将session数据写⼊到redis数据库，并⽣成session_id作为key
                2.设置session时，会将session_id数据写⼊到⽤户浏览器
                3.读取session时，会先从request对象中，读取COOKIES中的session_id
                4.读取session时，再使⽤session_id读取redis中的session数据

类视图

类视图介绍
    1.以类的形式定义视图 继承⾃View
    2.代码阅读性好 将多个请求业务逻辑封装在⼀个类的多个函数中
    3.扩展性好 可以使⽤类的继承，实现功能的集成

类视图定义和使⽤
    1.类视图定义

class DefineClassview(View):
     """类视图定义"""
    def get(self, request):
     """GET请求业务逻辑"""
        return HttpResponse('GET请求业务逻辑' )
    def post(self, request):
     """GET请求业务逻辑"""
        return HttpResponse('POST请求业务逻辑' )

2.类视图绑定路由 url(r'^define_classview/$', views.DefineClassview.as_view()),
        类视图实现原理: django 源代码

类视图装饰器
    1.定义装饰器

def my_decorator(view_func):
"""定义装饰器装饰视图"""
    def wrapper(request, *args, **kwargs):
        print( ' 装饰器被调⽤了' )
        print(request.method)
    # 调⽤被装饰的视图
        return view_func(request, *args, **kwargs)
return wrapper

2.在路由匹配中使⽤装饰器 url(r'^define_classview/$', views.my_decorator(views.define_classview.as_view())),
    3.在类视图中使⽤装饰器
        ⽅案⼀：装饰整体逻辑

@ method_decorator(my_decorator, name= 'dispatch')
    class define_classview(View):
     """类视图定义"""
        def get(self, request):
        """GET请求业务逻辑"""
            return HttpResponse('GET请求业务逻辑' )
        def post(self, request):
        """GET请求业务逻辑"""
            return HttpResponse('POST请求业务逻辑' )

⽅案⼆：装饰局部逻辑

@ method_decorator(my_decorator, name= 'post')
    class define_classview(View):
        """类视图定义"""
        def get(self, request):
        """GET请求业务逻辑"""
            return HttpResponse('GET请求业务逻辑' )
        def post(self, request):
        """GET请求业务逻辑"""
            return HttpResponse('POST请求业务逻辑' )

类视图Mixin扩展类
    1.使⽤说明 当类视图中的业务逻辑，在其他类中已经实现，可以将其他类以类扩展的形式继承到类视图
    2.扩展类

class ListModelMixin(object):
"""
list扩展类
"""
    def list(self, request, *args, **kwargs) :
    ...
class CreateModelMixin(object):
"""
create扩展类
"""
    def create(self, request, *args, **kwargs) :
    ...

3.继承扩展类

class BooksView( CreateModelMixin, ListModelMixin, View):
    """
    同时继承两个扩展类，复⽤list和 create⽅法
    """
    def get(self, request):
        self.list(request)
        ...
    def post(self, request):
        self.create(request)
        ...

中间件
    1.介绍
        监听请求和响应的整个过程 类似于Flask⾥⾯的请求勾⼦
        可以修改请求和响应信息
    2.定义和使⽤
        1.定义
            项⽬路径/middleware.my_middleware

def my_middleware(get_response):
    print( 'init 被调⽤' )
    def middleware(request):
        print( 'before request 被调⽤' )
        response = get_response(request)
        print( 'after response 被调⽤' )
        return response
return middleware

2.使⽤

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' ,

       'middleware.my_middleware', # 添加⾃⼰定义的中间件
       'middleware.my_middleware2',
  ]

3.⼯作原理
            1.理论说明  •在请求视图被处理前 ，中间件由上⾄下依次执⾏
                      •在请求视图被处理后 ，中间件由下⾄上依次执⾏

模板
    1.模板定义
        1.准备模板⽂件夹 项⽬根路径/templates/
        2.配置模板查找路径

TEMPLATES = [
 {
       'BACKEND': ' django.template.backends.django.DjangoTemplates' ,
       'DIRS': [os.path.join(BASE_DIR, 'templates')],
       'APP_DIRS': True,
       'OPTIONS': {
       'context_processors': [
       ' django.template.context_processors.debug' ,
      ' django.template.context_processors.request' ,
      ' django.contrib.auth.context_processors.auth' ,
      ' django.contrib.messages.context_processors.messages' ,
       ],
       },
       },
        ]

3.准备模板⽂件 项⽬根路径/templates/index.html

2.模板渲染

class templates_demo(View):
 """模板演示"""
    def get(self,request):
        context = {
        'city': ' beijing' ,
        ' alist' :[1 , 2 , 3 ],
        ' adict' :{
        'name': 'python'
        }
        }
         return render(request, 'index.html', context)

3.模板语法
        Flaks模板语法整体和Django模板语法⼀致
            1.读取列表数据
                Django语法 < h1> {{ alist. 0 }}</h1>
                Flask语法 < h1> {{ alist[0] }}</h1>
            2.遍历循环
                Django语法
                读取索引：{{forloop.counter}}
                遍历为空：{%empty%}
                Flask语法
                读取索引：{{loop.index}}
                遍历为空：{%else%}
            3.过滤器
                Django语法 最多只能传⼀个参数到过滤器
                Flask语法 可以传⼊多个参数到过滤器
            4.模板复⽤
                Django语法 模板继承

MySQL数据库准备
MySQL数据库ORM介绍
    1. O是 object，也就类对象的意思，R 是 relation，翻译成中⽂是关系，也就是关系数据库中数据表的意思，M 是 mapping，是映射的意思。
    2. 在ORM框架中，它帮我们把类和数据表进⾏了⼀个映射，可以让我们通过类和类对象就能操作它所对应的表格中的数据。
    3. ORM框架还有⼀个功能，它可以根据我们设计的类⾃动帮我们⽣成数据库中的表格，省去了我们⾃⼰建表的过程。
    4. django中内嵌了ORM框架，不需要直接⾯向数据库编程，⽽是定义模型类，通过模型类和对象完成数据表的增删改查操作。
    5.使⽤步骤
        1. 配置数据库连接信息
        2. 在 models.py中定义模型类
        3. 迁移
        4. 通过类和对象完成数据增删改查操作

MySQL数据库驱动介绍
ORM识别的驱动MySQLdb 只⽀持python2版本
    安装python3的驱动PyMySQL 并转成MySQLdb这个名字

MySQL数据库配置
　1.默认配置

DATABASES = {
     'default': {
     'ENGINE': ' django.db.backends.sqlite3' ,
     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
     }
    }

2.配置MySQL数据库

DATABASES = {
     'default': {
     'ENGINE': ' django.db.backends.mysql' ,
     'HOST': '127.0.0.1', # 数据库主机
     'PORT': 3306, # 数据库端⼝
     'USER': 'root', # 数据库⽤户名
     'PASSWORD': 'mysql', # 数据库⽤户密码
     'NAME': ' django_demo' # 数据库名字
     }
    }

3.安装驱动
    pip install PyMySQL

配置驱动
    from pymysql import install_as_MySQLdb
    # 将 python3⽀持的MySQL驱动转成ORM识别的MySQLdb
    install_as_MySQLdb()

ORM模型类 模型类定义

# 定义图书模型类BookInfo
class BookInfo(models.Model):
    btitle = models.CharField(max_length= 20, verbose_name= ' 名称' )
    bpub_date = models.DateField(verbose_name= ' 发布⽇期' )
    bread = models.IntegerField(default= 0 , verbose_name= ' 阅读量' )
    bcomment = models.IntegerField(default= 0 , verbose_name= ' 评论量' )
    is_delete = models.BooleanField(default= False, verbose_name= ' 逻辑删除' )
    class Meta:
        db_table = 'tb_books' # 指明数据库表名
        verbose_name = ' 图书' # 在 admin站点中显示的名称
        verbose_name_plural = verbose_name # 显示的复数名称
    def __str__( self):
        """定义每个数据对象的显示信息"""
        return self.btitle
# 定义英雄模型类HeroInfo
class HeroInfo(models.Model):
    GENDER_CHOICES = (
    (0 , 'male'),
    (1 , 'female')
    )
    hname = models.CharField(max_length= 20, verbose_name= ' 名称' )
    hgender = models.SmallIntegerField(choices=GENDER_CHOICES, default= 0 , verbose_name= ' 性别' )
    hcomment = models.CharField(max_length= 200, null= True, verbose_name= ' 描述信息' )
    hbook = models.ForeignKey(BookInfo, on_delete=models.CASCADE, verbose_name= ' 图书' ) # 外键
    is_delete = models.BooleanField(default= False, verbose_name= ' 逻辑删除' )
    class Meta:
        db_table = 'tb_heros'
        verbose_name = ' 英雄'
        verbose_name_plural = verbose_name
    def __str__(self):
        return self.hname

模型类字段数据类型和选项

1.字段类型
    2.选项

模型类迁移建表
    1.⽣成迁移⽂件 python manage.py makemigrations
    2.执⾏迁移⽂件 python manage.py migrate

shell⼯具和mysql⽇志

1.shell⼯具 python manage.py shell
    2.mysql⽇志
        sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf

相关源码连接:

github,技术交流,欢迎指教