栀椩
栀椩

Django学习记录

Django学习记录

文章目录

  • Django学习记录
    • Django应用及分布式路由
      • 创建新的应用
      • 分布式路由
    • 模型层及ORM介绍
      • 终端进入MySQL
      • 数据库模型文件
    • ORM基础字段及选项
      • 字段类型
      • 字段选项
      • 模型类Meta
    • ORM基本操作-创建数据
    • ORM查询
    • 小结1
    • 条件查询
      • 普通查询
      • 查询谓词
    • ORM更新操作
      • 后端更改操作
      • 通过前端超链接页面更新
        • 添加视图函数
        • 修改模板文件all_book.html
        • 添加模板文件update_book.html
        • 添加路由
    • 小结2
    • ORM删除操作
      • 删除实例
        • 在模型中添加伪删除字段
        • 视图函数
        • 模板文件修改
        • 路由添加
    • F对象和Q对象
      • F对象
      • Q对象
    • 聚合查询和原生数据库操作
      • 聚合查询
        • 普通聚合
        • 分组聚合
      • 原生数据库操作
        • raw
        • cursor 游标
    • admin后台管理系统
      • 注册自定义的模型类
      • 模型管理器类
      • Meta类修改属性
    • 关系映射
      • 一对一映射
      • 一对多映射
      • 多对对映射
    • cookies和session
      • 会话
      • cookies
      • session
        • 初始配置
        • 调用
        • session存在的问题
    • 云笔记项目
      • 项目准备
      • 项目创建并实现注册功能
      • 优化注册功能
      • 实现登录界面
      • 创建主页
      • 笔记模型
        • 编写装饰器函数
        • 添加增加笔记函数
        • 增加修改笔记的功能
        • 增加笔记删除功能
    • 小结3
    • 缓存
      • Django中设置缓存
      • 整体缓存策略
      • 局部缓存策略
      • 浏览器缓存策略
    • 中间件
      • 编写中间件步骤
      • 中间件练习
      • 跨站请求伪造保护 CSRF
    • 分页
      • Paginator对象
      • Page对象
      • 文件上传与下载
        • csv文件下载
        • 文件上传
    • 内建用户系统
      • auth基本模型操作
    • Django发送邮件
      • 邮件相关协议
      • 邮件发送实例
    • 项目部署上线

这篇博客为个人学习记录，不定期更新

另外，博客是博主使用Markdown语法写完后直接导入的，可能会存在外链图片失效、章节重复等问题，为节约时间，博主不打算处理，仅作为个人查询技术细节使用

Django应用及分布式路由

创建新的应用

  1. 创建方法：终端输入python manage.py startapp news，其中news是新的应用名

  2. 注册创建的APP，在项目的配置文件中（settings.py）找到INSTALLED_APPS列表，并在该列表中添加项目名，如下：

    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'music',
    'sport',
    'news',
]

    最后的news即为新添加的应用

分布式路由

创建分布式路由的目的是为了让单个应用有单个应用的专属路由，不用一直在项目主路由中添加地址，正常的逻辑是创建了新的应用后，应该在项目主路由中为该应用配置专属的路由，而这个新建应用的路由则在自己的路由文件中去添加

  1. 在项目路由中添加新的应用路由地址，如下：

    urlpatterns = [
    path('admin/', admin.site.urls),
    path('img', views.test_static),
    path('music/', include('music.urls')),
    path('sport/', include('sport.urls')),
    path('news/', include('news.urls')),
]

    列表的最后即为news应用的专属路由，而使用include方法，表明以后news的路由应该到news自己的urls.py文件中去添加

  2. 在新建应用下，创建一个urls.py来添加本应用的路由地址和对应的视图函数，如下：

    from django.urls import path
from news import views

urlpatterns = [
    path('index', views.index_view),
]

    index是news应用的地址，这种情况下，访问域名127.0.0.1:8000/news/index，浏览器返回的就是视图函数views中index_view方法所写的内容

模型层及ORM介绍

模型：

是Python的一个类，要求必须继承自django.db.models.Model， 一个模型类代表数据库中的一张数据表，模型类的每个熟悉代表数据库的一个字段，模型是数据增删改查的接口，用来操作数据库

ORM框架：

对象关系映射，允许使用类和对象对数据库进行操作，避免通过SQL语句操作数据库

终端进入MySQL

可以从cmd终端进入，也可以从编译器终端进入，指令都一样

mysql -uroot -p

接下来在终端输入密码

退出在终端输入quit即可

数据库模型文件

通过models.py生成数据表，如下

from django.db import models

# Create your models here.


class Book(models.Model):
    title = models.CharField("书名", max_length=50, default='')
    price = models.DecimalField("定价", max_digits=7, decimal_places=2, default=0.0)

通过上面这个文件，执行后应该会在数据库中生成一张Book数据表，这张表有两个字段，分别是title和price，但仅写完这个文件是不够的，需要在终端执行如下命名：

  1. 生成迁移文件，终端执行python manage.py makemigrations，将应用下的models.py文件生成一个中间件，并保存在migration文件夹中
  2. 执行迁移脚本程序，终端执行python manage.py migrate，将每个应用下的migration目录中的中间文件同步回数据库

ORM基础字段及选项

字段类型

  • BooleanField()布尔型
  • CharField()字符型
  • DateField()日期，参数：
    • auto_now：每次更新对象时，自动设置该字段为当前时间（取值True/False）
    • auto_now_add：对象第一次创建时自动设置当前时间（取值True/False）
    • default：设置当前时间
  • DateTimeField()日期时间，高频使用，比上面那个更频繁使用，基本创建表就会使用，一般会建两个字段，创建时间和修改时间，参数与DateField()相同
  • FloatField()浮点型
  • DecimalField()小数
  • EmailField()，数据库类型：varchar，Django封装好的
  • IntegerField()
  • ImageField()图片的存储路径，字符串
  • TextField() 类型longtext
  • ……

字段选项

  • 主键primary_key
  • blank，设置为True时，可以为空，设置为false时，字段必须填写
  • null，设置为True表示允许为空，默认为False
  • default，设置所在列的默认值，如果null=False建议添加此项
  • db_index，索引
  • unique， 唯一索引
  • db_column，指定字段名，一般不用给
  • verbose_name，admin上的显示名称

模型类Meta

使用内部类给模型赋予属性，比如修改表名

class Meta:
	db_table = 'book'

ORM基本操作-创建数据

models.Model模型类中的objects对象被继承，增删改查都是通过这个objects对象来实现

终端进入Django shell的命令：

python manage.py shell

第一种方法：

MyModel.models.Model.objects.create()

第二种方法：

创建模型对象实例，调用save()保存

obj = MyModel(attr1=value1, attr2=value2....)
obj.attr = value
obj.save()

ORM查询

  • objects.all() == select * from tabel，返回QuerySet容器对象，内部存放模型实例

    一般情况下，为了更好的显示查询结果，都要重新____str____函数，这是为了设置模型的返回值

    以下是查询示例

    from bookstore.models import Book
 al = Book.models.all()

    重写str函数

        def __str__(self):
        return '%s_%s_%s_%s' % (self.title, self.pub, self.price, self.market_price)

    查询结果

    , , , , ]>

  • objects.values(‘列1’, ‘列2’)，查询部分列数据，返回QuerySet字典列表，等同于

    select lie1, lie2
from Book

  • objects.values_list(‘列1’, ‘列2’)，查询部分列数据，返回QuerySet元组列表

  • order_by()查询结果排序

ORM综合练习

目的：将数据库中，所有的book信息显示在all_book页面上，最终结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I3lMPOyo-1652317066151)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220429095725708.png)]

  1. 创建分布式路由：在主项目的urls.py文件中添加bookstore应用的路由，如下

    from django.contrib import admin
from django.urls import path, include

from mysite import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('img', views.test_static),
    path('music/', include('music.urls')),
    path('sport/', include('sport.urls')),
    path('news/', include('news.urls')),
    path('bookstore/', include('bookstore.urls')),
]

    最后一行即为bookstore应用的分布式路由

  2. 在bookstore应用中创建该应用的路由，在应用目录下新建一个urls.py，填入一下路由信息

    from django.urls import path

from bookstore import views

urlpatterns = [
    path('all_book', views.all_book),
]

    也就是当我访问http://127.0.0.1:8000/bookstore/all_book时指向的文件和视图函数

  3. 视图函数，在views.py文件中添加查询和渲染网页的代码

    from django.shortcuts import render
from .models import Book


# Create your views here.


def all_book(request):
    all_book = Book.objects.all()
    return render(request, 'bookstore/all_book.html', locals())

    使用all()方法查询到所有的数据，并把查到的all_book传递给模板文件夹（templates）下bookstore文件夹中的all_book.html文件，locals()函数将查询到的局部变量转换成字典数据，也就是把all_book转换成字典，讲真，我真没理解这个locals到底怎么用的

  4. 模板文件，在模板中填写网页展示的内容，并接受视图函数传递过来的数据，并进行展示

    DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>查看所有表格title>
    <style>
        td, th {
            border: 1px solid;

        }
        .mt {border-collapse: collapse;}
    style>
head>
<body>
<table class="mt">
    <tr>
        <th>idth>
        <th>titleth>
        <th>pubth>
        <th>priceth>
        <th>market_priceth>
        <th>opth>
    tr>
    {% for book in all_book %}
        <tr>
            <td>{{ book.id }}td>
            <td>{{ book.title }}td>
            <td>{{ book.pub }}td>
            <td>{{ book.price }}td>
            <td>{{ book.market_price }}td>
            <td>
                <a href="#" >更新a>
                <a href="#">删除a>
            td>
        tr>

    {% endfor %}
    <tr>tr>
table>
body>
html>

    这里关键是要理解那一段for循环的写法

    不写CSS样式显示出来的表格很丑，没有边框，我在样式中改了一下边框，在两个地方

小结1

其实写到这里，Django的作用和整个操作流程，已经大致显示出来了，有必要做个小结：

  1. 首先启动一个Django项目——mysite
  2. 在Django项目中新建一个应用——bookstore
  3. 为项目（mysite）创建分布式路由，在路由中添加bookstore的分布式路由
  4. 在应用（bookstore）中添加路由，指定地址指向的视图函数
  5. 在应用的视图函数中添加方法，如果需要向数据库传递数据，就要启动数据库模型
    1. 在应用的model.py文件中添加模型，注意，一个模型就是一张表，可以在这个表中进行增删改查操作
    2. 如果有必要，重写一下默认的str方法
    3. 视图函数中对模型数据进行处理，可以查询、排序等操作，并返回查询的值
  6. 在应用中创建模板文件（html文件），需要在应用下新建一个templates文件夹，最好是在templates文件夹下再创建一个与应用同名的文件夹（防止路由找不到模板文件）用来存放模板文件，在模板文件下编写页面文件，并接收视图函数传递过来的数据，使用Django特有的语法处理接收到的数据并写入到模板文件中
  7. 启动项目，访问地址，即可展示页面

条件查询

普通查询

  • filter()方法，返回QuerySet

    MyModel.objects.filter(attr1=value1, attr2=valur2…)

    多个属性在一起时为“与”关系

  • exclude(条件)，不包含此条件的数据集

  • get(条件)，返回单条数据，如果给定的条件超过一条，或者没有数据，都会报错

查询谓词

查询示例：

Book.objects.filter(id__exact=1)

等同于

select * from Book where id = 1

由字段名__谓词组成

  • __exact等值匹配，经常用来匹配是否为空，is null
  • __contains包含指定值查询，**经常使用，**类似于sql中的like ‘%xxx%’
  • __startwith以XXX开始
  • __endwith以XXX结尾
  • __gt大于指定值，常用
  • __gte大于等于指定值，常用
  • __lt小于指定值，常用
  • __lte小于等于指定值，常用
  • __in查找的数据是否在指定范围内，常用，示例Book.objects.filter(id__in = [1,3,5])
  • __range指定区间范围内查询，和sql中的between一样，常用，示例Book.objects.filter(id__range = (20,40))
  • 还有很多…

ORM更新操作

流程：查(使用get)->改->存(使用save)

后端更改操作

单条数据更新的具体示例：

# 单条数据更新
b1 = Book.objects.get(id=1)
b1.price = 22
b1.save()

批量更新，直接将查询结果使用update方法更新

# 批量更新
b1 = Book.objects.filter(price__gt=50)
b1.update(market_price=100)

将所有定价大于50的书市场价均设置为100

通过前端超链接页面更新

前面的图书管理界面上，最后一列“op”绑定了两个空链接，现在先来实现更新功能

一步步来

添加视图函数

views.py中添加的内容

def update_book(request, book_id):
    try:
        book = Book.objects.get(id=book_id)
    except Exception as e:
        print('--update book error is %s' % (e))
        return HttpResponse("书本不存在")
    if request.method == 'GET':
        return render(request, 'bookstore/update_book.html', locals())
    elif request.method == 'POST':
        price = request.POST['price']
        market_price = request.POST['market_price']
        book.price = price
        book.market_price = market_price
        book.save()
        return HttpResponseRedirect('/bookstore/all_book')

这个视图函数还挺复杂的，记录一下逻辑

既然是要更改数据，就说明要像数据库传递数据，那么一般是post请求，但是超链接是get请求，所以实际上要对请求进行判断

  1. 首先，如果是get请求，就跳转到路由指定的模板文件上，并通过local()将get到的局部变量打包成字典，传递给模板文件update_book.html，模板文件见下面小节（添加模板文件）

  2. 如果是post请求，也就是说要通过页面给后台传递参数了，那么把要实现的功能在这里写好，也就是在这里实现数据的更新

    1. 查数据

    2. 改数据

    3. 存数据

    4. 返回HttpResponse实体，代码中是重定向，指定了路由的相对路径，绝对路径应该是http://127.0.0.1:8000/bookstore/all_book

      强调一下，这里的return必须写，至于是render、HttpResponse还是HttpResponseRedirect根据业务需求，不然项目不知道下一步该往哪里去

  3. 逻辑上已经没什么问题，但有一点要注意，查询book是用的get方法，get方法具有唯一性，极易报错，所以有必要进行异常检测

  4. 视图函数中我传递了一个book_id参数，这点非常重要。首先这个参数是我们要查询的书名，其次，路由中也要用到，下面会讲到

修改模板文件all_book.html

实际上就是修改一下表格中“更新”的超链接地址，我上一下完整的内容，后面与此类似，就不上完整的内容了

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>查看所有表格title>
    <style>
        {#为表格增加边框#}
        td, th {
            border: 1px solid;

        }
        {#删掉表格单元格之间的空白#}
        .mt {border-collapse: collapse;}
    style>
head>
<body>
<table class="mt">
    <tr>
        <th>idth>
        <th>titleth>
        <th>pubth>
        <th>priceth>
        <th>market_priceth>
        <th>opth>
    tr>
    {% for book in all_book %}
        <tr>
            <td>{{ book.id }}td>
            <td>{{ book.title }}td>
            <td>{{ book.pub }}td>
            <td>{{ book.price }}td>
            <td>{{ book.market_price }}td>
            <td>
                <a href="/bookstore/update_book/{{ book.id }}" >更新a>
                <a href="#">删除a>
            td>
        tr>

    {% endfor %}
    <tr>tr>
table>
body>
html>
添加模板文件update_book.html

视图函数完成后，就要进行前端页面的设计了，前面的逻辑是点击超链接（get请求）的话，就去渲染网页文件，并向网页传递book参数

update_book.html里的内容

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>更改书籍title>
head>
<body>
<form action="/bookstore/update_book/{{ book.id }}" method="post">
    <p>
        title <input type="text" value="{{ book.title }}" disabled="disabled" />
    p>
    <p>
        publish <input type="text" value="{{ book.pub }}" disabled="disabled" />
    p>
    <p>
        price <input type="text" value="{{ book.price }}" name="price" />
    p>
    <p>
        market_price <input type="text" value="{{ book.market_price }}" name="market_price" />
    p>
    <p>
        <input type="submit" value="更新" />
    p>
form>
body>
html>

看看界面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DqjbC8Yo-1652317066152)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220429142029973.png)]

界面还有待优化，这是CSS的事情，暂时不进行美化

很明显是表单数据，因此使用form标签，form的action参数是表单数据请求指向的地址，也就是路由，这个路由的写法也是用的Django语法

注意get请求向这个网页文件传递了book参数，也就是通过book_id获取到的book信息，因此book.id就是数据库中的id字段，title，pub等等也是，4个input标签中各填入了book的4个参数，通过value匹配，用的也是Django的语法，其中title，pub是不可修改的（“disabled” ）

最后一个input标签是提交按钮，也就是点击后发送post请求到数据库，并重定向到视图函数中写好的地址

添加路由

目前数据库中是有5本书的，也就是说，如果按绝对路径来定义路由的话，要定义5个路由，分别是

path('update_book/1', views.update_book),
path('update_book/2', views.update_book),
path('update_book/3', views.update_book),
path('update_book/4', views.update_book),
path('update_book/5', views.update_book),

这么写明显不合理，如果有100个，是不是要写100行

这里有多种替代方式

  • 通过正则表达式来传递
  • 通过Django的path转换器来传递

这里使用的是path转换器，用path转换器记得在视图函数中传递参数，这点非常重要，前面就已经提到了，视图函数中传递了一个book_id这个参数，视图函数通过这个book_id进行了一系列的操作，使用path路由的时候也要用到，正确的写法如下

urls.py中的内容

from django.urls import path

from bookstore import views

urlpatterns = [
    path('all_book', views.all_book),
    path('update_book/', views.update_book),
]

添加了一个path('update_book/', views.update_book)

path转换器的精髓就在这里，接收视图函数传递的形参，使用<>来转换，前面是这个数据的类型，后面是参数，有点像java中的泛型

小结2

这里算是完成了一个相对初学者来说，比较复杂的功能，涉及到的技术栈有：

  1. 数据库的更新，包括查-改-存
  2. 视图函数的创建，包括两种不同的请求，重定向等
  3. 如何像模板文件传递参数
  4. 如何通过path转换器指定路由

ORM删除操作

单条删除：先get()，然后delete()

批量删除：filter()查找，然后delete()删除

伪删除：在表中添加字段is_active，布尔类型，做伪删除时，把值设为false，显示的时候只显示is_active=True的数据，这样就实现了伪删除操作

删除实例

ORM查询中，表格中还有个删除功能没实现，现在补充一下

过程如下

在模型中添加伪删除字段
class Book(models.Model):
    def __str__(self):
        return '%s_%s_%s_%s' % (self.title, self.pub, self.price, self.market_price)

    title = models.CharField("书名", max_length=50, default='', unique=True)
    pub = models.CharField("出版社", max_length=100, default='')
    price = models.DecimalField("定价", max_digits=7, decimal_places=2, default=0.0)
    market_price = models.DecimalField("零售价", max_digits=7, decimal_places=2, default=0.0)
    # info = models.CharField("描述", max_length=100, default='')
    is_active = models.BooleanField('是否活跃', default=True)

添加的是最后一行，后面删除实际上是将这个字段设置为false

视图函数

在views.py中添加以下函数：

def delete_book(request):
    book_id = request.GET.get('book_id')
    if not book_id:
        return HttpResponse('---book_id不存在')
    try:
        book = Book.objects.get(id=book_id, is_active=True)
    except Exception as e:
        print('delete book get error %s' % e)
        # print('--update book error is %s' % (e))
        return HttpResponse("书本不存在")
    book.is_active = False
    book.save()
    return HttpResponseRedirect('/bookstore/all_book')

注意，这里在函数中没有传形参book_id了，说明路由配置不是之前的那种了，这里跟着老师使用了第二种路由配置方式**，就是通过request.GET.get()方法获取请求中的参数，注意，get方法是寻找名为name（本例中为‘book_id’）的GET参数，而且如果参数没有提交，返回一个空的字符串，如果我点击第5条图书，那么请求的链接应该是http://127.0.0.1:8000/bookstore/delte_book?id=5，也就是说，我的book_id=5**，这一点的理解很重要，不然会陷入一个理解的死循环，就像月读一样，为什么请求链接是这样的呢，那就要看我的模板文件（all_book.html）了。

模板文件修改

这里的模板文件只涉及all_book.html，因为删除后直接重定向到这个文件了，所以对比上面的更新要简单一点，在模板文件中修改成下面的内容

<td>
	<a href="/bookstore/update_book/{{ book.id }}" >更新a>
	<a href="/bookstore/delete_book?book_id={{ book.id }}" onclick="return confirm('是否确认删除');">删除a>
td>

回到上面的问题，我增加了一个传递参数的符号?，表明后面的book_id是要传的参数，其实上面get()方法得到的参数就传到了这里，也就是超链接应该是bookstore/delete_book?book_id=5

然后再回到视图函数，后面是删除操作，说是删除，其实不如理解为修改，因为执行的是伪删除操作，注意修改后需要save一下

路由添加

注意这里的路由不再是用path转换器了，而是直接传递参数，写法如下

from django.urls import path

from bookstore import views

urlpatterns = [
    path('all_book', views.all_book),
    path('update_book/', views.update_book),
    path('delete_book', views.delete_book),
]

最后一行就是添加的路由，后面通过?传参，理解上相对第一种更麻烦一点，我推荐使用第一种

F对象和Q对象

F对象

先上一下数据库中book表

id title price market_price pub is_active
1 python 25.00 50.00 清华大学出版社 1
2 Django 70.00 75.00 清华大学出版社 1
3 JQuery 90.00 85.00 机械工业出版社 1
4 Linux 80.00 65.00 机械工业出版社 1
5 HTML5 90.00 105.00 清华大学出版社 1

F对象代表数据库中某条记录的字段的信息，是对数据库中的字段值在不获取的情况下进行操作，可以解决并发的问题，类似于给数据库加锁，把并发事件转为串联事件，第二个作用的用于字段之间的比较，比如比较售价大于定价的书籍，写法如下：

Book.objects.filter(market_price__gt=F('prive'))

Q对象

使用复杂的逻辑或、逻辑非等操作，可以灵活组合

语法

Book.objects.filter(Q(price__lt=20)|Q(pub="清华大学出版社"))

聚合查询和原生数据库操作

聚合查询

普通聚合

聚合函数： Sum Avg Count Max Min

语法：Book.objects.aggregate(结果变量名=Sum(列))

结果变量名就是sql中的查询结果别名

示例：

Book.objects.aggregate(res=Count('id'))

返回：
{res: 4}

分组聚合

语法：QuerySet.annotate(结果变量名=Sum(列))

sql中的group by

示例——统计每个出版社有多少本书：

pub_set = Book.objects.values('pub')
pub_set_count = put_set.annotate(mycount=Count('pub'))

原生数据库操作

raw

语法：Book.objects.raw(sql语句, 拼接参数)

个人对基础的sql语句是比较熟的，因此个人喜欢用原生的数据库操作，按理说也可以用pandas操作

但是原生的有很多缺陷和漏洞，SQL注入

解决方法：把参数放入拼接参数中

cursor 游标

语法：

from django.db import connection
with connection.cursor() as cur:
    cur.execute('sql语句', '拼接参数')

还是推荐使用ORM

admin后台管理系统

创建超级用户指令

python manage.py createsuperuser

这里需要设置用户名、邮箱和密码

进入用户管理系统地址

http://127.0.0.1:8000/admin

根据上面设置的用户名密码登录，可以进入Django的后台管理系统

注册自定义的模型类

目前模型文件（models.py）文件中有Book和Author两个类，也就是数据库中的两张表，如果要自己定义的模型类也能在/admin后台管理系统中显示和管理，需要将自己的类注册到后台管理界面

方法步骤：

  1. 在应用的admin.py中导入要注册的模型类，from .models import Book
  2. 调用admin.site.register方法进行注册，如admin.site.register(Book)

模型管理器类

可以为后台管理界面添加便于操作的新功能，继承自django.contrib.admin中的ModelAdmin类

什么意思，就是我们自建的模型展现形式很丑，而自带的展示起来更加美观

使用方法：

  1. 在应用的admin.py里进行定义，class XXXManager(admin.ModelAdmin)

  2. 绑定注册模型管理器和模型类

from django.contrib import admin
from .models import *
# Register your models here.


class BookManager(admin.ModelAdmin):
    list_display = ['id', 'title', 'pub', 'price', 'market_price', 'is_active']


admin.site.register(Book, BookManager)

list_display参数是将数据以表格的形式展示是管理后台上，列表中有几个数据，就展示多少个列

除了list_display参数，还有以下几个常用的参数：

  • list_display_link = [‘title’]，修改页面的超链接，默认在ID列上
  • list_filter = [‘pub’] 添加过滤器
  • search_fields = [‘title’] 添加搜索框 模糊查询
  • list_editable = [‘price’, ‘market_price’] 添加可在列表页编辑的字段

Meta类修改属性

模型（models.py）中添加Meta类，见前文**ORM基础字段及选项中**的模型类Meta

示例：

class Book(models.Model):
    def __str__(self):
        return '%s_%s_%s_%s_%s' % (self.title, self.pub, self.price, self.market_price, self.is_active)

    title = models.CharField("书名", max_length=50, default='', unique=True)
    pub = models.CharField("出版社", max_length=100, default='')
    price = models.DecimalField("定价", max_digits=7, decimal_places=2, default=0.0)
    market_price = models.DecimalField("零售价", max_digits=7, decimal_places=2, default=0.0)
    # info = models.CharField("描述", max_length=100, default='')
    is_active = models.BooleanField('是否活跃', default=True)

    class Meta:
        verbose_name = '图书'  # 英文中的单数
        verbose_name_plural = verbose_name  # 英文中的复数，如果不该的话，会在中文字符后面多一个s

关系映射

通常不会把所有的数据都放在同一张表，不易于扩展，如一个学生可以报多个课程，一个课程可以有多个学生报名

一对一映射

语法：OneToOneField(类名，on_delete=xxx)，on_delete是级联删除

新概念：

外键——如果A表中的X字段引用了B表中的主键，A表叫做子表，B表叫做主表，X字段称为A表的外键，外键描述的是表之间的关系。级联删除——如员工表中一项数据是部专门ID,部门ID是部门表的主键，如果是级联删除，当删除了部门A的时候，会把所有属于部门A的员工都属给删除。

级联删除on_delete=models.CASCADE实例，步骤，新建应用oto，在设置文件中添加这个应用，然后在oto应用的模型文件中创建author及wife表

from django.db import models

# Create your models here.


class Author(models.Model):
    name = models.CharField('姓名', max_length=11)
    class Meta:
    	verbose_name = '作者'
        verbose_name_plural = verbose_name     


class Wife(models.Model):
    name = models.CharField('姓名', max_length=11)
    author = models.OneToOneField(Author, on_delete=models.CASCADE)  # 级联删除，与Author表共生死
    class Meta:
    	verbose_name = '作者之妻'
        verbose_name_plural = verbose_name

创建数据：

from oto.models import *
a1 = Author.objects.create(name='hg')  # Author中的表数据创建
w1 = Wife.objects.create(name='zl', author=a1)  # wife表中的数据创建
# 还可以用下面的方式创建外键连接
w1 = Wife.objects.create(name='zl', author_id=a1.id)

正向查询方法：

wife = Wife.objects.get(name='zl')
# 关联到wife的丈夫
wife.author.name

反向查询方法：

author = Author.objects.get(name='hg')
# 关联到author的妻子
author.wife.name

反向查询时，没有外键的一方，可以调用反向属性查询到关联的另一方，author虽然没有wife的外键，但Django在创建Wife模型时，默认创建反向属性

一对多映射

一个学生又多个班级，一个班级有多个学生，一本图书只能属于一个出版社，一个出版社可以出版多本图书

一对多需要明确具体角色，在多表上设置外键

创建一对多的语法：

# 一
class A(model.Model):
	pass

# 多
class B(model.Model):
    attr = models.ForeignKey(A, on_delete=XXX)  # 同样需要定义级联删除
    
## 实例
from django.db import models

# Create your models here.


class Publisher(models.Model):
    name = models.CharField('出版社名称', max_length=255)


class Book(models.Model):
    title = models.CharField('书名', max_length=255)
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

终端进入shell向数据库中添加数据：

from otm.models import *
pub1 = Publisher.objects.create(name='清华大学出版社')
Book.objects.create(title='C++', publisher=pub1)
Book.objects.create(title='JAVA', publisher_id=pub1.id)

正向查询与一对一映射的正向查询一致

反向查询：

## 示例
pub1 = Publisher.objects.get(name='清华大学出版社')
books = pub1.book_set.all()  # 查找所有出版社为pub1的图书

多对对映射

MySQL创建多对多需要依赖第三张表

Django无需手动创建第三张表

使用models.ManyToManyField()来关联，并创建第三张表，创建表的方式与上面两种映射相似，只是无需级联删除

示例：

from django.db import models

# Create your models here.


class Author(models.Model):
    name = models.CharField('姓名', max_length=200)


class Book(models.Model):
    title = models.CharField('书名', max_length=200)
    author = models.ManyToManyField(Author)

场景，两个老师都写了名为Python的书

终端进入shell向数据库中添加数据：

from mtm.models import *
## 方案一，先创建作者
# 创建作者
author1 = Author.objects.create(name='黄某')
author2 = Author.objects.create(name='朱某')
# 创建图书，并关联作者
# 创建书名，用create方法把图书和第一个作者关联
book1 = author1.book_set.create(title='python')
# 用add方法把图书和第二个作者关联
author2.book_set.add(book1)

## 方案二，先创建图书
# 创建图书
book = Book.objects.create(title='python1')
#hzx和author1都参与了Python1的创作
author3 = book.author.create(name='hzx')
book.author.add(author1)

目前数据库中有三张表，分别是author、book和book_author，以下简称a表、b表和ab表

a表中列名是id和name，b表中列名是id和title，ab表中列名是a_id和b_id

正向查询：

谁有属性查谁

反向查询继续用xxx_set方法

cookies和session

会话

服务器和浏览器端进行的交互称为会话

交互行为的记忆

会话保持技术：cookies和session存储技术

cookies

保存在客户端浏览器上的存储空间

特点：

  • 以键值对形式存储，不能是中文
  • 存储的数据有生命周期
  • 数据按域隔离存储
  • 每次访问同一网址时都会携带到服务器端，如果数据过大会影响响应速度

因此，是在网页响应的时候传递的

语法：

HttpResponse.set_cookie(key, value, max_age, expires)

参数名：

  • key——cookie名
  • value——cookie值
  • max_age——存活时间，秒
  • expires——过期时间

不指定max_age和expires时，关闭浏览器失效

获取cookies：

value = request.COOKIES.get('usename')

举个例子：

def get_cookies(request):
    value = request.COOKIES.get('usename')
    return HttpResponse('usename is %s' % value)

页面响应 usename is hg

删除cookies：

response.delete_cookie(key)

session

cookies把用户数据存储在浏览器上，而session则把数据存储在服务器上，相对更安全

实现方式：

  • 使用session需要在浏览器客户端启动cookie，并在cookie中存储sessionid
  • 每个客户端都可以在服务器端有一个独立的session
  • 不同的请求者之间不共享这个数据
初始配置

settings.py中配置（默认配置）

ISTALLED_APPS 添加’django.contrib.sessions’,

中间件中添加’django.contrib.sessions.middleware.SessionMiddleware’

调用

session封装给了request对象，是一个字典

存、取示例：

def set_session(request):
    request.session['usename'] = 'zl'
    return HttpResponse('set session is ok')


def get_session(request):
    value = request.session['usename']
    return HttpResponse('session usename is %s' % value)

在项目的settings.py文件中可以配置session的性能

  1. 修改保存时间：SESSION_COOKIE_AGE
  2. 关闭时失效：SESSION_EXPIRE_AT_BROWSER_CLOSE = TRUE
session存在的问题
  • 存储在数据库中，单表设计，数据量会持续增加
  • 可执行python manage.py clearsessions删除过期的session数据

云笔记项目

用户可以在系统中记录自己的日常学习、旅游笔记，用户数据存储在云笔记平台，用户只有在登录后才能使用笔记功能，且只能查阅自己的笔记内容

用户模块（cookie session）：

  • 注册
  • 登录
  • 退出登录

笔记模块（ORM）：

  • 查看笔记
  • 创建笔记
  • 修改笔记
  • 删除笔记

项目准备

  1. 禁掉csrf，避免出现post请求出现403问题
  2. 语言、时区更改
  3. 数据库配置，创建新的数据库名cloud_note
  4. 创建并注册应用user
  5. 数据库中创建数据库cloud_note

项目创建并实现注册功能

  1. 为应用添加模型（数据表）

    from django.db import models

# Create your models here.


class User(models.Model):
    username = models.CharField('用户名', max_length=200, unique=True)
    password = models.CharField('密码', max_length=32)
    created_at = models.DateTimeField('创建时间', auto_now_add=True)
    updated_at = models.DateTimeField('更新时间', auto_now=True)

    def __str__(self):
        return "用户" + self.username

  2. 数据迁移

  3. 添加视图函数

    from django.http import HttpResponse
from django.shortcuts import render
from .models import *
# Create your views here.


def reg_view(request):
    if request.method == 'GET':
        return render(request, 'user/register.html')
    elif request.method == 'POST':
        username = request.POST['username']
        password1 = request.POST['password1']
        password2 = request.POST['password2']

        if password1 != password2:
            return HttpResponse('两次密码输入不一致')
        old_users = User.objects.filter(username=username)
        if old_users:
            return HttpResponse('用户名已注册')
        User.objects.create(username=username, password=password1)
        return HttpResponse('注册成功')

    get请求则渲染网页，post请求则检验数据并向数据库中添加注册信息

  4. 创建模板文件，在项目应用下创建模板文件夹（cloud_note/user/templates/user）并新建模板文件，并适当美化，这一步可以放在编写视图函数之前

    DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册title>
    <style>
        .input {
            width: 100px;
        }
    style>

head>
<body>
<form action="/user/reg" method="post">
    <p class="input">
        用户名:<input type="text" name="username">
    p>
    <p class="input">
        密码:<input type="text" name="password1">
    p>
    <p class="input">
        再次输入密码:<input type="text" name="password2">
    p>
    <p>
        <input type="submit" value="注册">
    p>
form>
body>
html>

  5. 创建分布式路由

    from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('user/', include('user.urls')),
]

  6. 分布式路由中添加新的路由和视图函数

    from django.urls import path

from user import views

urlpatterns = [
    # path('admin/', admin.site.urls),
    path('reg', views.reg_view),
]

优化注册功能

  1. 上面使用的是将密码明文写入数据库，安全性差

使用哈希算法——给定明文，计算出一段定长的，不可逆的值

修改视图函数

from django.http import HttpResponse
from django.shortcuts import render
from .models import *
import hashlib
# Create your views here.


def reg_view(request):
    if request.method == 'GET':
        return render(request, 'user/register.html')
    elif request.method == 'POST':
        username = request.POST['username']
        password1 = request.POST['password1']
        password2 = request.POST['password2']

        if password1 != password2:
            return HttpResponse('两次密码输入不一致')
        m = hashlib.md5()
        m.update(password1.encode())  # 必须转码
        password_m = m.hexdigest()

        old_users = User.objects.filter(username=username)
        if old_users:
            return HttpResponse('用户名已注册')
        User.objects.create(username=username, password=password_m)
        return HttpResponse('注册成功')

将密码存储为哈希MD5值

  1. 并发问题，多个用户同时注册统一用户名时，即使有if判断，也会因为并发报错，可以使用try来规避

    继续优化视图函数，在创建新的数据时，使用异常检测

            try:
            user = User.objects.create(username=username, password=password_m)
        except Exception as e:
            print(e)
            return HttpResponse('用户名已注册')

  2. 免登陆一天功能

    视图函数中增加session的功能

    request.session['username'] = username
request.session['id'] = user.id

    settings.py中修改session存储时间

    SESSION_COOKIE_AGE = 60 * 60 * 24

实现登录界面

  1. 先写模板文件login.html

    DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录title>
    <style>
        .input {
            width: 100px;
        }
    style>
head>
<body>
<form action="/user/login" method="post">
    <p class="input">
        用户名<input type="text" name="username">
    p>
    <p class="input">
        密码<input type="password" name="password">
    p>
    <p><input type="checkbox" name="remember_me">记住用户名p>
    <p><input type="submit" value="登录">p>
form>
body>
html>

    我在脱离教程独自写这个简单界面的时候犯了一个非常低级的错误，就是没有写form表单标签，上来就直接input，导致怎么点submit按钮都没反应，这再一次验证了form表单的作用

    另外，这里还添加了一个记住用户的CheckBox，后面会用到

  2. 添加路由

    urlpatterns = [
    # path('admin/', admin.site.urls),
    path('reg', views.reg_view),
    path('login', views.login_view),
]

  3. 创建视图函数

    def login_view(request):
    if request.method == 'GET':
        return render(request, 'user/login.html')
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        # remember_me = request.POST['remember_me']
        m = hashlib.md5()
        m.update(password.encode())
        password_m = m.hexdigest()
        try:
            # 取用户名，建议用get，也可以用filter，如果用filter，则应写成user = User.objects.filter(username=username)[0]，
            # 因为filter查出来的是一个集合Queryset
            user = User.objects.get(username=username)
        except Exception as e:
            print(e)
            return HttpResponse('用户名或密码错误')
        # if user:
        #     if password_m != user.password:
        #         return HttpResponse('密码错误')
        # else:
        #     return HttpResponse('用户名不存在')
        if password_m != user.password:
            return HttpResponse('用户名或密码错误')

        # 记住会话状态
        request.session['username'] = username
        request.session['id'] = user.id
        response = HttpResponse('登录成功')
        # 判断用户是否选择了记住用户名
        if 'remember_me' in request.POST:
            response.set_cookie('username', username, 3600 * 24 * 3)
            response.set_cookie('id', user.id, 3600 * 24 * 3)

        return response

    这里的逻辑应该是很清楚的：

    1. 判断是get请求还是post请求

    2. post请求下，取出用户名，密码，密码进行哈希转换

    3. 判断用户名和密码是否正确，我自认为的逻辑是判断用户名是否存在，然后判断密码是否正确，看我注释起来的一段代码，但是听讲课的那个老师讲，实际中不要这么明确，防止别人窃取信息

    4. 记住会话状态，通过设置session和cookie，并修改cookie的存储时间

      记住会话状态是一个非常复杂的过程，对于初学者来说，总体来说，有这么几个步骤：

      • 首先把用户名和id写入到session中去，也可以只保存id，无所谓
      • 看用户是否勾选记住了用户名，如果勾选了，把用户名和id存到cookie里面去，为什么要进行这一步，按理说只有session写了就可以了，看视频教程时，老师说的是因为session是写进数据库了的，如果太多人都勾选的话，这个数据库压力比较大，因此，可以把session的存储时间写短一点，然后cookie中再存储一次，这样数据库的压力会小一点，但在获取是否登录就会相对麻烦一点
      • 在get请求（也就是输入地址）时判断session和cookie是否记录了登录状态，同时校验session和cookie，对应上面的

      这里有一个很坑的地方：

      如果我的用户名是中文的，勾选记住状态时，会报下面的错：

      UnicodeEncodeError: 'latin-1' codec can't encode characters in position 153-154: ordinal not in range(256)

      从报错信息来看，说的是编码的问题，我百度了很多方法，都没能解决，但是都指向同一个问题，就是用户名不能是中文名，因此，在注册时，应该禁止用户输入中文字符，所以我在reg_view()视图函数中添加了一段判断用户名是否包含中文字符的代码，如下：

      def reg_view(request):
    if request.method == 'GET':
        return render(request, 'user/register.html')
    elif request.method == 'POST':
        username = request.POST['username']
        password1 = request.POST['password1']
        password2 = request.POST['password2']

        # 经验证，注册的用户名中不能使用中文，否则登录的时候选择记住用户的话，会报错，所以用户注册时，用户名中不能有中文
        for _char in username:
            if '\u4e00' <= _char <= '\u9fff':
                return HttpResponse('用户名中不能包含中文')

        if password1 != password2:
            return HttpResponse('两次密码输入不一致')
        # 将密码存储为MD5值
        m = hashlib.md5()
        m.update(password1.encode())
        password_m = m.hexdigest()

        old_users = User.objects.filter(username=username)
        if old_users:
            return HttpResponse('用户名已注册')
        # 考虑注册时的并发问题，使用异常检测
        try:
            user = User.objects.create(username=username, password=password_m)
        except Exception as e:
            print(e)
            return HttpResponse('用户名已注册')

        # 免登陆功能
        request.session['username'] = username
        request.session['id'] = user.id
        # request.session
        return HttpResponse('注册成功')

      这样再次注册的时候，就能保证用户名的正确输入了

      回到前文，怎样记住会话状态呢，在login_view()函数的get请求里面添加如下代码：

      def login_view(request):
    if request.method == 'GET':
        # 检查登录状态，如果登录了，显示“已登录”
        if request.session.get('username') and request.session.get(id):
            return HttpResponse('已登录')
        # 检查cookies
        c_username = request.COOKIES.get('username')
        c_id = request.COOKIES.get('id')
        if c_id and c_username:
            # 回写session
            request.session['username'] = c_username
            request.session['id'] = c_id
            return HttpResponse('已登录')
        return render(request, 'user/login.html')

      从代码来看，先是判断session中是否存了usename和id，有的话显示已登录，没有的话检查cookies，也是检查是否存储了这两个值，如果都没有存储，就跳转到登录页面

      至此，逻辑已经相对比较清楚

创建主页

前面在登录的时候，get请求发现用户有登录的时候，直接HttpResponse(‘已登录’)显然是不合理的，正常是系统应该是登录后跳转到一个主页界面，现在就是要干这个事儿

创建应用index，注册应用，添加路由，这些操作不再记录

先写模板文件

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页title>
head>
<body>
{#{{ request.session }}#}
{#{{ request.COOKIES }}#}
{% if request.session.username %}
    <p>
        欢迎 {{ request.session.username }}
    p>
    <p>
        <a href="">退出登录a>
    p>
    <p>
        <a href="">进入我的笔记a>
    p>
{% else %}
    {% if request.COOKIES.username %}
        <p>
            欢迎 {{ request.COOKIES.username }}
        p>
        <p>
            <a href="">退出登录a>
        p>
        <p>
            <a href="">进入我的笔记a>
        p>
    {% else %}
        <p>
            <a href="/user/login">登录a>
        p>
        <p>
            <a href="/user/reg">注册a>
        p>
    {% endif %}
{% endif %}
body>
html>

退出和进入笔记的超链接还没写

登录和注册都已经链接上，注意，登录或注册成功后，应该跳转到首页，同时，检查到cookies和session有过登录，也应该直接跳转的登录后的主页，因此，所有user/views.py中的HttpResponse('已登录')和HttpResponse('登录成功')都应该改成网页跳转，也就是重定向

return HttpResponseRedirect('/index')

给出的是相对地址

注意，还没写视图函数，这里的视图函数就非常简单了，如下

from django.shortcuts import render

# Create your views here.


def index_view(request):

    return render(request, 'index/index.html')

直接渲染文件就行了

笔记模型

创建note应用，注册，添加路由

视图文件views.py中添加视图函数，首先检查是否是登录状态，后续使用装饰器来检查，节省代码

编写装饰器函数
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from .models import *
from django.contrib import messages

# Create your views here.


def check_login(fn):
    def wrap(request, *args, **kwargs):
        if 'username' not in request.session or 'id' not in request.session:
            c_username = request.COOKIES.get('username')
            c_id = request.COOKIES.get('id')
            if not c_username or not c_id:
                return HttpResponseRedirect('/user/login')
            else:
                request.session['username'] = c_username
                request.session['id'] = c_id
        return fn(request, *args, **kwargs)

    return wrap
添加增加笔记函数

仍然在视图文件中添加

@check_login
def add_note(request):
    if request.method == 'GET':
        return render(request, 'note/add_note.html')
    if request.method == 'POST':
        id = request.session['id']
        title = request.POST['title']
        content = request.POST['content']
        Note.objects.create(title=title, content=content, user_id=id)

        # return HttpResponse('添加笔记成功')
        return HttpResponseRedirect('/note/note')  # 重定向，跳转到图书列表

对应的模板文件add_note.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加笔记title>
    <style>
        p {
            width: 150px;
        }
    style>
head>
<body>
<form action="/note/add" method="post">
    <p>
        标题：<input type="text" name="title">
    p>
    <p>
        <textarea cols="30" rows="10" name="content">textarea>
    p>
    <p>
        <input type="submit" value="保存" onclick="alert('保存成功')">
    p>
form>
body>
html>

显示界面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yi84cT29-1652317066153)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220507175730859.png)]

增加笔记视图函数中最后重定向到图书列表，因此要显示一个图书列表模板文件

list_note.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>笔记列表</title>
    <style>
        td, th {
            border: 1px solid;

        }
        .note {border-collapse: collapse;}
    </style>
</head>
<body>
<h3>
    {{ request.session.username }} 的笔记 <a href="/note/add">添加新笔记</a> <a href="/index">返回首页</a>
</h3>
<table class="note">
    <tr>
        <th>ID</th>
        <th>标题</th>
        <th>创建时间</th>
        <th>修改时间</th>
        <th>修改</th>
        <th>删除</th>
    </tr>
    {% for note in all_notes %}
        <tr>
            <td>{{ note.id }}</td>
            <td>{{ note.title }}</td>
            <td>{{ note.created_at }}</td>
            <td>{{ note.updated_at }}</td>
            <td><a href="/note/mod/{{ note.id }}">修改</a></td>
            <td><a href="">删除</a></td>
        </tr>
    {% endfor %}
</table>
</body>
</html>

显示界面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CipFue2A-1652317066154)(C:\Users\HP\Desktop\在办工作2021\99-其他临时工作\个人技术博客\image-20220507175800788.png)]

对应的视图函数

def list_view(request):
    all_notes = Note.objects.all()
    return render(request, 'note/list_note.html', locals())
增加修改笔记的功能

先上模板文件mod.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>修改笔记title>
head>
<body>
<form action="/note/mod/{{ note.id }}" method="post">
    <h3>
        <p>主题:p>
        <p>
            <input type="text" name="title" value="{{ note.title }}">
        p>
    h3>
    <h3>
        <p>笔记详情p>
        <p>
            <textarea cols="30" rows="10" name="content" value="{{ note.content }}">{{ note.content }}textarea>
        p>
    h3>

    <p>
        <input type="submit" value="保存" onclick="alert('保存成功')">
        <a href="/note/note">返回列表页a>
    p>
form>
body>
html>

显示界面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o7oHCNQV-1652317066154)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220507180334442.png)]

视图函数：

def mod_view(request, id):
    try:
        note = Note.objects.get(id=id)
    except Exception as e:
        print("修改出现错误：%s" % e)
        return HttpResponse('笔记不存在')
    if request.method == 'GET':
        return render(request, 'note/mod_note.html', locals())
    if request.method == 'POST':
        title = request.POST['title']
        content = request.POST['content']
        note.title = title
        note.content = content
        note.save()
        return HttpResponseRedirect('/note/note')

注意，这里是有参传入，传入了一个参数id，其实就是书本的id，因此，路由文件中可以使用path转换器来批量添加路由，如下：

note\urls.py

from django.urls import path

from note import views

urlpatterns = [

    path('add', views.add_note),
    path('note', views.list_view),
    path('mod/', views.mod_view),
]

这里个人调试了好久，发现有几个易错点：

  • 路由地址的相对路径和绝对路径问题，如return render(request, 'note/mod_note.html', locals())中的地址最前面是没有斜杆/的，而模板文件中传递的相对路由
    最前面则是有斜杆的
  • path转换器中传递的参数要和视图函数中传递的参数一致
  • 分布式路由中的路由地址到底怎么写，其实主路由已经给到了note，所以后面的路由就不需要再写note了，如果加上了，则会多一个note，比如第二条路由，实际上的访问地址应该是127.0.0.1:8000/note/note，这和课件是有出入的，而模板文件中，如第一个易错点的form标签中的路由地址，这应该是添加在127.0.0.1:8000之后的地址，这点比较重要，理解清楚了，路由就不会再犯错了。
增加笔记删除功能

删除功能的增加相对简单，删除不是真删除，要伪删除，也就是在模型中添加伪删除字段，is_active，默认值是true，笔记列表中仅显示is_active=True的笔记，然后增加删除的视图函数del_view()，将点击删除的笔记的is_active值设置为false，保存后重定向值note列表，具体流程如下：

  1. models.py中添加下面一行代码

    is_active = models.BooleanField('是否显示', default=True)

  2. 数据迁移

  3. 增加视图函数del_view()，如下

    def del_view(request, id):
    try:
        note = Note.objects.get(id=id)
    except Exception as e:
        print("删除出现错误：%s" % e)
        return HttpResponse('笔记不存在')
    note.is_active = False
    note.save()
    return HttpResponseRedirect('/note/note')

  4. 分布式路由中添加删除操作的路由，并绑定视图函数

  5. 模板文件(list_note.html)中添加删除的超链接，如下

    <td><a href="/note/del/{{ note.id }}" onclick="return confirm('是否确认删除');">删除a>td>

  6. 注意，之前显示笔记列表的视图函数查找数据用的是all_notes = Note.objects.all()，这查的是所有的数据，显然不合理，删除后应该不显示伪删除的数据，所以应该改成all_notes = Note.objects.filter(is_active=True)，而且这里的变量名all_notes不能瞎改，因为传入到模板文件list_note.html中的数据就是all_notes

至此，完成云笔记项目的所有功能，后面我会把整个项目放到git上去

小结3

通过这个非常简单的项目，大体上是捋清了使用Django框架进行前后端操作的步骤，总体上应把握以下几点

  • 不同的功能模块应该单独创建应用，实现功能分离
  • 重要的文件是：
    1. 视图函数views.py，用来向模板文件传递数据
    2. 模型文件models.py，用来创建数据表
    3. 模型文件（文件名不固定），用来显示前端页面，以及接收视图函数在执行过程中传递过来的数据在页面上显示，以及实现视图函数要执行的功能
    4. 路由文件urls.py，一般使用分布式路由，针对不同的地址，选择不同的路由方式，在使用路由转换器的时候，注意视图函数应该传递同名参数
  • 地址的写法很重要，使用render渲染网页时，应该写到应用的网页文件，使用HttpResponseRedirect进行重定向时，应该给的是路由，模板文件中超链接给的也是路由

缓存

更快的读取数据的介质，存储临时数据

一般情况下，当数据库中有大量的数据时，使用orm查询数据会非常慢，因此如果缓存中有数据的话，直接从缓存中取出数据，会简单很多

Django官方给的思路：

  1. 页面是否在缓存中，如果在，直接返回缓存页面
  2. 如果不在，该怎么取怎么取，取完后把数据存入缓存

缓存的使用场景：数据变动频率较低

目前，个人科研工作中的项目开发，应该暂时不会去设置缓存，因此不做具体的项目，只做了解

Django中设置缓存

数据库缓存

把一次负责查询的结果直接存储到表里，比如多个条件的过滤查询结果，可以避免重复进行复杂的查询，以提升效率

配置方法，在settings.py中设置CACHES字段

可以存储在数据库中，也可以存在服务器本地内存中，文件系统中

数据库缓存示例：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQL23Kp7-1652317066155)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508141055835.png)]

服务器缓存：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3pukUlxj-1652317066155)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508141123707.png)]

文件系统缓存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9C3as1Ae-1652317066155)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508141259518.png)]

整体缓存策略

  1. 视图函数中的相应内容放到缓存中，使用装饰器

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AZ9rMcET-1652317066159)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508142149690.png)]

  2. 在路由中套上装饰器，与1是一回事

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bs7VV787-1652317066160)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508142221486.png)]

局部缓存策略

整体缓存无法干预，没法删除，简单粗暴，无法认为控制

如果只想缓存视图函数中的某行代码，就可以用到局部缓存

缓存API

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZyS3SlNx-1652317066160)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508143303391.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5oZmz96c-1652317066160)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508143816396.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pP8Us2ez-1652317066161)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508143828878.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a0sEzvkr-1652317066161)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508144052223.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RlXogKB2-1652317066161)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508144124003.png)]

浏览器缓存策略

浏览器是否缓存，需要服务器给暗号

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5Gi8M5h8-1652317066162)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508144952534.png)]

上面这连个参数，都可以通过整体缓存策略中的装饰器传给浏览器，不需要单独配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5GNDsjy7-1652317066162)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508145353529.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FjeQrjpR-1652317066162)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508145527258.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VwqquOzd-1652317066163)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220508145737037.png)]

中间件

用于请求、响应，用于全局改变Django的输入输出

中间件以类的形式体现

每个中间件组件负责一些特定的功能

中间件必须继承自django.utils.desprecation.MiddlewareMixin类

必须实现以下五个方法中的一个或多个（主要前三个）：

  • process_request(self, request)——起拦截作用

    执行路由之前被调用，在每个请求上调用，返回none或HttpResponse对象

  • process_view(self, request, callback_args, callback_kwargs)——拦截

    调用视图之前被调用，在每个请求上调用，返回none或HttpResponse对象

  • process_response(self, request, response)

    响应返回给浏览器之前被调用，返回HttpResponse对象

  • process_exception(self, request, exception)

    处理异常时调用，返回HttpResponse对象，可能项目会报错，比如给用户发个邮件，告诉用户有错误

  • process_template_response(self, request, response)——很少用到

    在视图函数执行完毕且视图返回的对象中包含render方法时被调用，需要返回实现了render方法的响应对象

中间件的大多数方法在返回None时表示忽略当前操作进入下一项事件，当返回HttpResponse对象时表示此请求有问题，要结束，直接返回给客户端

注册方法：

settings.py中注册自定义的中间件

在项目目录下创建一个文件夹middleware（严谨来说，是创建一个Python包），接着去创建一个__init__.py初始化文件和一个中间件Python文件（如mymiddleware.py），在mymiddleware.py中添加类，继承自，，，

写好之后去注册

编写中间件步骤

  • 编写中间件类:
# file : middleware/mymiddleware.py
from django.http import HttpResponse, Http404
from django.utils.deprecation import MiddlewareMixin

class MyMiddleWare(MiddlewareMixin):
    def process_request(self, request):
        print("中间件方法 process_request 被调用")

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("中间件方法 process_view 被调用")

    def process_response(self, request, response):
        print("中间件方法 process_response 被调用")
        return response

    def process_exception(self, request, exception):
        print("中间件方法 process_exception 被调用")

    def process_template_response(self, request, response):
        print("中间件方法 process_template_response 被调用")
        return response
  • 注册中间件:
# file : settings.py
MIDDLEWARE = [
    ...
    'middleware.mymiddleware.MyMiddleWare',
]

#单个中间件输出
MyMW process_request do---
MyMW process_views do ---
----this is test cache views ----
MyMW process_response do ---


#多个中间件时 输出
MyMW process_request do---
MyMW2 process_request do---
MyMW process_views do ---
MyMW2 process_views do ---
----this is test cache views ----
MyMW2 process_response do ---
MyMW process_response do ---
  • 中间件的执行过程
    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IcHEHYb5-1652317066163)(C:\Users\HP\Desktop\第3阶段 Python WEB全栈式工程师（HTML，CSS，JavaScript，MYSQL核心，Django框架，Ajax）\第三阶段\Django\DJANGO02\day07\day07\day07-note\images\middleware.jpeg)]

中间件练习

  • 用中间件实现强制某个IP地址只能向/test 发送 5 次GET请求

  • 提示:

    • request.META[‘REMOTE_ADDR’] 可以得到远程客户端的IP地址
    • request.path_info 可以得到客户端访问的GET请求路由信息

  • 答案:

    from django.http import HttpResponse, Http404
from django.utils.deprecation import MiddlewareMixin
import re
class VisitLimit(MiddlewareMixin):
    '''此中间件限制一个IP地址对应的访问/user/login 的次数不能改过10次,超过后禁止使用'''
    visit_times = {}  # 此字典用于记录客户端IP地址有访问次数
    def process_request(self, request):
        ip_address = request.META['REMOTE_ADDR']  # 得到IP地址
        if not re.match('^/test', request.path_info):
            return
        times = self.visit_times.get(ip_address, 0)
        print("IP:", ip_address, '已经访问过', times, '次!:', request.path_info)
        self.visit_times[ip_address] = times + 1
        if times < 5:
            return

        return HttpResponse('你已经访问过' + str(times) + '次，您被禁止了')

跨站请求伪造保护 CSRF

  • 跨站请求伪造攻击

    • 某些恶意网站上包含链接、表单按钮或者JavaScript，它们会利用登录过的用户在浏览器中的认证信息试图在你的网站上完成某些操作，这就是跨站请求伪造(CSRF，即Cross-Site Request Forgey)。

  • 说明:

  • CSRF中间件和模板标签提供对跨站请求伪造简单易用的防护。

  • 作用:

    • 不让其它表单提交到此 Django 服务器

  • 解决方案:

    1. 取消 csrf 验证(不推荐)

      • 删除 settings.py 中 MIDDLEWARE 中的 django.middleware.csrf.CsrfViewMiddleware 的中间件

    2. 通过验证 csrf_token 验证

      需要在表单中增加一个标签 
{% csrf_token %}

分页

分页是指在web页面有大量数据需要显示，为了阅读方便在每个页页中只显示部分数据

  • 好处:
    1. 方便阅读
    2. 减少数据提取量，减轻服务器压力。
  • Django提供了Paginator类可以方便的实现分页功能
  • Paginator类位于django.core.paginator 模块中。

Paginator对象

掌控全部页面

  • 对象的构造方法

    • Paginator(object_list, per_page)
    • 参数
      • object_list 需要分页数据的对象列表
      • per_page 每页数据个数
    • 返回值:
      • 分页对象

  • Paginator属性

    • count：需要分类数据的对象总数
    • num_pages：分页后的页面总数
    • page_range：从1开始的range对象, 用于记录当前面码数
    • per_page 每页数据的个数

  • Paginator方法

    • Paginator.page(number)
      • 参数 number为页码信息(从1开始)
      • 返回当前number页对应的页信息
      • 如果提供的页码不存在，抛出InvalidPage异常

  • Paginator异常exception

    • InvalidPage：当向page()传入一个无效的页码时抛出
    • PageNotAnInteger：当向page()传入一个不是整数的值时抛出
    • EmptyPage：当向page()提供一个有效值，但是那个页面上没有任何对象时抛出

Page对象

掌控单个页面

  • 创建对象
    Paginator对象的page()方法返回Page对象，不需要手动构造

  • Page对象属性

    • object_list：当前页上所有数据对象的列表
    • number：当前页的序号，从1开始
    • paginator：当前page对象相关的Paginator对象

  • Page对象方法

    • has_next()：如果有下一页返回True
    • has_previous()：如果有上一页返回True
    • has_other_pages()：如果有上一页或下一页返回True
    • next_page_number()：返回下一页的页码，如果下一页不存在，抛出InvalidPage异常
    • previous_page_number()：返回上一页的页码，如果上一页不存在，抛出InvalidPage异常
    • len()：返回当前页面对象的个数

  • 说明:

    • Page 对象是可迭代对象,可以用 for 语句来 访问当前页面中的每个对象

  • 参考文档https://docs.djangoproject.com/en/1.11/topics/pagination/

示例：

视图函数

from django.core.paginator import Paginator
from django.shortcuts import render


def test_page(request):
    # /test_page?page=1 使用查询字符串的方式
    page_num = request.GET.get('page', 1)
    all_data = ['a', 'b', 'c', 'd', 'e']
    paginator = Paginator(all_data, 2)
    c_page = paginator.page(int(page_num))
    return render(request, 'test_page.html', locals())

模板文件test_page.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>分页title>
head>
<body>
{% for p in c_page %}
    <p>
        {{ p }}
    p>
{% endfor %}
{% if c_page.has_previous %}
    <a href="/test_page?page={{ c_page.previous_page_number }}">上一页a>
{% else %}
    上一页
{% endif %}

{% for p_num in paginator.page_range %}
    {% if p_num == c_page.number %}
        {{ p_num }}
    {% else %}
        <a href="/test_page?page={{ p_num }}">{{ p_num }}a>
    {% endif %}
{% endfor %}


{% if c_page.has_next %}
    <a href="/test_page?page={{ c_page.next_page_number }}">下一页a>
{% else %}
    下一页
{% endif %}
body>
html>

路由

from django.contrib import admin
from django.urls import path, include
from cloud_note import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('user/', include('user.urls')),
    path('index/', include('index.urls')),
    path('note/', include('note.urls')),
    path('test_page', views.test_page),
]

文件上传与下载

csv文件下载

视图函数

def make_page_csv(request):
    page_num = request.GET.get('page', 1)
    all_data = ['a', 'b', 'c', 'd', 'e']
    paginator = Paginator(all_data, 2)
    c_page = paginator.page(int(page_num))

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment;filename="page-%s.csv"' % (page_num)
    print(response)
    writer = csv.writer(response)
    for b in c_page:
        writer.writerow([b])
    return response

模板文件

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>分页title>
head>
<body>
<a href="/make_page_csv?page={{ c_page.number }}">生成当前页面csva>
{% for p in c_page %}
    <p>
        {{ p }}
    p>
{% endfor %}
{% if c_page.has_previous %}
    <a href="/test_page?page={{ c_page.previous_page_number }}">上一页a>
{% else %}
    上一页
{% endif %}

{% for p_num in paginator.page_range %}
    {% if p_num == c_page.number %}
        {{ p_num }}
    {% else %}
        <a href="/test_page?page={{ p_num }}">{{ p_num }}a>
    {% endif %}
{% endfor %}


{% if c_page.has_next %}
    <a href="/test_page?page={{ c_page.next_page_number }}">下一页a>
{% else %}
    下一页
{% endif %}
body>
html>

修改路由

关键逻辑在于下面这两行代码

response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment;filename="page-%s.csv"' % (page_num)
  1. 修改HttpResponse响应头中的content_type为文本内容
  2. 在响应中添加key——Content-Disposition为attachment（附件），并定义要下载的文件名
文件上传

  • 文件上传必须为POST提交方式

  • 表单中文件上传时必须有带有enctype="multipart/form-data" 时才会包含文件内容数据。

  • 表单中用标签上传文件

    • 名字xxx对应request.FILES['xxx'] 对应的内存缓冲文件流对象。可通能过request.FILES['xxx'] 返回的对象获取上传文件数据
    • file=request.FILES['xxx'] file 绑定文件流对象，可以通过文件流对象的如下信息获取文件数据
      file.name 文件名
      file.file 文件的字节流数据

  • 上传文件的表单书写方式

    
<html>
<head>
    <meta charset="utf-8">
    <title>文件上传title>
head>
<body>
    <h3>上传文件h3>
    <form method="post" action="/upload" enctype="multipart/form-data">
        <input type="file" name="myfile"/><br>
        <input type="submit" value="上传">
    form>
body>
html>

  • 在setting.py 中设置一个变量MEDIA_ROOT 用来记录上传文件的位置

    # file : settings.py
...
MEDIA_ROOT = os.path.join(BASE_DIR, 'static/files')

  • 在当前项目文件夹下创建 static/files 文件夹

    $ mkdir -p static/files

  • 添加路由及对应的处理函数

    # file urls.py
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^upload', views.upload_view)
]

  • 配置media后，需要手动添加路由，添加方式比较特殊

    # file urls.py
from django.conf import settings
from django.conf.urls.static import static
from django.contrib import admin
from django.urls import path

from mysite08 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('test_upload', views.test_upload),
]
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

    这个过程等价于做了MEDIA_URL开头的路由，Django接到该请求后去MEDIA_ROOT路径查找资源

  • 上传文件的视图处理函数–第一种方法，传统的open写入，但会存在重名文件覆盖的问题

    # file views.py
from django.http import HttpResponse, Http404
from django.conf import settings
import os

def upload_view(request):
    if request.method == 'GET':
        return render(request, 'index/upload.html')
    elif request.method == "POST":
        a_file = request.FILES['myfile']
        print("上传文件名是:", a_file.name)

        filename =os.path.join(settings.MEDIA_ROOT, a_file.name)
        with open(filename, 'wb') as f:
            data = a_file.file.read()
            f.write(data)
            return HttpResponse("接收文件:" + a_file.name + "成功")
    raise Http404

  • 访问地址: http://127.0.0.1:8000/static/upload.html

  • 上传文件的视图处理函数–第二种方法，Django封装好的方法

    数据库中添加一张表，用于存放上传数据的名称和文件名，步骤

    创建应用---->添加模型类---->添加模型---->模型迁移---->视图函数

    模型类（upload_app/models.py）

    from django.db import models

# Create your models here.


class Content(models.Model):
    title = models.CharField('文章名字', max_length=200)
    picture = models.FileField(upload_to='picture')

    视图函数（views.py）

    #!/usr/bin/env python
#-*- coding:utf-8 -*-
# author:HP
# datetime:2022/5/11 10:45
from django.http import HttpResponse
from django.shortcuts import render
# from upload_app import models
from upload_app.models import Content


def test_upload(request):
    if request.method == 'GET':
        return render(request, 'test_upload.html')
    elif request.method == 'POST':
        title = request.POST['title']
        myfile = request.FILES['myfile']
        Content.objects.create(title=title, picture=myfile)
        return HttpResponse('---文件上传成功')

后端缓存：

1， 将视图函数最终结果 转存到其他介质里

【mysql表里，文件里， 内存里】

2，解决了 views重复计算问题 【有效降低视图层时间复杂度】

3，http 1.1 cache头 触发了 浏览器强缓存

浏览器缓存：

1，带有强缓存的响应头 的响应数据，存储自己的硬盘中或内存里

2，当强缓存有数据时，可以完全不给服务器发送请求，直接读取缓存内容 【减少 浏览器与服务器之间的请求次数】

内建用户系统

这里的用户内建系统和云笔记项目中的user应用作用一样

  • Django带有一个用户认证系统。 它处理用户账号、组、权限以及基于cookie的用户会话。

  • 作用:

    1. 添加普通用户和超级用户
    2. 修改密码

  • 文档参见

  • https://docs.djangoproject.com/en/1.11/topics/auth/

  • User模型类

  • 位置: from django.contrib.auth.models import User

  • 默认user的基本属性有：

    属性名 类型 是否必选
    username 用户名 是
    password 密码 是
    email 邮箱 可选
    first_name 名
    last_name 姓
    is_superuser 是否是管理员帐号(/admin)
    is_staff 是否可以访问admin管理界面
    is_active 是否是活跃用户,默认True。一般不删除用户，而是将用户的is_active设为False。
    last_login 上一次的登录时间
    date_joined 用户创建的时间

auth基本模型操作

  • 创建用户

    • 创建普通用户create_user

      from django.contrib.auth import models
user = models.User.objects.create_user(username='用户名', password='密码', email='邮箱',...)

...
user.save()

    • 创建超级用户create_superuser

      from django.contrib.auth import models
user = models.User.objects.create_superuser(username='用户名', password='密码', email='邮箱',...)
...
user.save()

  • 删除用户

    from django.contrib.auth import models
try:
    user = models.User.objects.get(username='用户名')
    user.is_active = False  # 记当前用户无效
    user.save()
    print("删除普通用户成功！")
except:
    print("删除普通用户失败")
return HttpResponseRedirect('/user/info')

  • 修改密码set_password

    from django.contrib.auth import models
try:
    user = models.User.objects.get(username='xiaonao')
    user.set_password('654321')
    user.save()
    return HttpResponse("修改密码成功！")
except:
    return HttpResponse("修改密码失败！")

  • 检查密码是否正确check_password

    from django.contrib.auth import models
try:
    user = models.User.objects.get(username='xiaonao')
    if user.check_password('654321'):  # 成功返回True,失败返回False
        return HttpResponse("密码正确")
    else:
        return HttpResponse("密码错误")
except:
    return HttpResponse("没有此用户！")

  • 登录状态保持

    from django.contrib.auth import login
def login_view(request):
    user = authenticate(username=username, password=password)
    login(request, user)

  • 登录状态校验

    需要使用装饰器login_required

    # 伪代码
from django.contrib.auth import login_required
@login_required
def index_view(request):
    # 该视图必须为用户登录状态下才可访问
    # 当前登录用户可以通过request.user获取
    login_user = request.user
    ...

  • 登录状态取消

    更简单，直接使用内置的logout方法

    from django.contrib.auth import logout
def logout_view(request):
    logout(request)

Django发送邮件

业务场景：

业务警告

邮件验证

密码找回

邮件相关协议

SMTP 简单邮件传输协议 发邮件 推送协议

IMAP 交互式邮件访问协议 收邮件 拉取协议

POP3 支持使用客户端远程管理在服务器上的电子邮件 拉取协议

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tyr8LZZH-1652317066163)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220511135259744.png)]

Django充当邮件客户端的身份，自动发出邮件

原理：

  1. 给Django授权一个邮箱
  2. Django用该邮箱给对应的收件人发送邮件
  3. djang.core.mail封装了电子邮件的自动发送SMTP协议

邮件发送实例

  1. settings.py中配置邮件发送

    # 发送邮件设置
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' # 固定写法
EMAIL_HOST = 'smtp.qq.com' # 腾讯QQ邮箱 SMTP 服务器地址
EMAIL_PORT = 25  # SMTP服务的端口号
EMAIL_HOST_USER = '[email protected]'  # 发送邮件的QQ邮箱
EMAIL_HOST_PASSWORD = '******'  # 邮箱的授权码(即QQ密码)
EMAIL_USE_TLS = True  # 与SMTP服务器通信时，是否启动TLS链接(安全链接)默认false

    这一段根据自己的实际情况添加

  2. settings.py中自定义要发送邮件的对象

    EX_EMAIL = ['马赛克[email protected]', '马赛克[email protected]']

  3. 添加中间件，报错时发送邮件

    from django.http import HttpResponse, Http404
from django.utils.deprecation import MiddlewareMixin
import traceback
from django.core import mail
from django.conf import settings


class ExceptionMW(MiddlewareMixin):
    def process_exception(self, request, exception):
        print(exception)
        print(traceback.format_exc())
        mail.send_mail(
            subject='来自Django的项目告警信息',
            message=traceback.format_exc(),
            from_email='马赛克[email protected]',  # 发送者[当前配置邮箱]
            recipient_list=settings.EX_EMAIL
        )
        return HttpResponse('---对不起 当前网页忙')

    有几点要注意，中间件写好后，要到settings.py中去注册，另外，邮件的接受列表直接调用自第2步中添加的邮件列表

发送邮件结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-44s6QHJE-1652317066164)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20220511152306208.png)]

项目部署上线

部署过程中遇到的问题先记录

  1. 局域网其他设备无法访问的问题

    解决方法：

    1. settings.py中修改ALLOWED_HOSTS = [‘*’]

    2. pycharm终端启动Django服务命令python manage.py runsever 0.0.0.0:8000， 0.0.0.0代表网络内所有的主机都可以访问

    3. 其他设备访问192.168.43.246:8000/index即可，192.168.43.246为主机(服务器)的ip

局域网内手机访问云笔记项目

django项目上线

你可能感兴趣的:(算法,QT开发及web开发等学习笔记,python,django,javascript,html5)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动 李蕾1229
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
  • 向内而求 陈陈_19b4
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 相信相信的力量 孙丽_cdb3
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 春季养肝正当时 dxn悟
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIPHPandroidlinux
    ╔-----------------------------------╗┆                           
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net.net mvc
    在.net mvc5中，在执行某一操作的时候，出现了如下错误：       各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  &
  • Java 对象大小的计算 e200702084 java
                              Java对象的大小 如何计算一个对象的大小呢？    
  • Mybatis Spring 171815164 mybatis
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
  • JVM 不稳定参数 g21121 jvm
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
  • 用户自动登录网站 永夜-极光 用户
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie            每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
  • centos7 安装后失去win7的引导记录 程序员是怎么炼成的 操作系统
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
  • JavaEE开源快速开发平台G4Studio_V3.2发布了 無為子 AOPoraclemysqljavaeeG4Studio
      我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。   访问G4Studio网站 http://www.g4it.org   G4Studio_V3.2版本变更日志 功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
  • Oracle常用的单行函数应用技巧总结 百合不是茶 日期函数转换函数(核心)数字函数通用函数(核心)字符函数
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
  • Mockito异常测试实例 bijian1013 java单元测试mockito
    Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
  • GA与量子恒道统计 Bill_chen JavaScript浏览器百度Google防火墙
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：   为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
  • 【Linux命令三】Top命令 bit1129 linux命令
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果：     top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
  • spring四种依赖注入方式 白糖_ spring
      平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
  • angular.injector boyitech AngularJSAngularJS API
    angular.injector   描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.   使用方法: angular.injector(modules, [strictDi])   参数详解: Param Type Details mod
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
    public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
  • 使用Struts2.2.1配置 Chen.H apachespringWebxmlstruts
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
  • [职业与教育]青春之歌 comsci 教育
           每个人都有自己的青春之歌............但是我要说的却不是青春...        大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的....   &nbs
  • oracle连接(join)中使用using关键字 daizj JOINoraclesqlusing
    在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
  • NIO示例 daysinsun nio
    NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
  • C语言学习homework1 dcj3sjt126com chomework
    0、 课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x);   sizeof(int);   # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
  • select in order by , mysql排序 dcj3sjt126com mysql
    If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
  • 页面校验-新建项目 fanxiaolong 页面校验
    $(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
  • Ehcache（02）——ehcache.xml简介 234390216 ehcacheehcache.xml简介
    ehcache.xml简介          ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
  • junit 4.11中三个新功能 jackyrong java
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
  • 国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windowsPHPunixMicrosoftperl
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的 这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
  • 位运算、异或的实际应用 wenjinglian 位运算
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。       二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。       三． 位操作与空间压缩，针对筛素数进行空间压缩。    &n
  • weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
    好吧，weblogic的问题确实……   问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
  • tomcat7性能调优（01） toknowme tomcat7
        Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1"                useBodyEncodingForURI="t
  • PO VO DAO DTO BO TO概念与区别 xp9802 javaDAO设计模式bean领域模型
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他