一、ContentType

　在django中，有一个记录了项目中所有model元数据的表，就是ContentType，表中一条记录对应着一个存在的model，所以可以通过一个ContentType表的id和一个具体表中的id找到任何记录，及先通过ContenType表的id可以得到某个model，再通过model的id得到具体的对象。

  1. class ContentType(models.Model):
  2.     app_label = models.CharField(max_length=100)
  3.     model = models.CharField(_('python model class name'), max_length=100)
  4.     objects = ContentTypeManager()
  5.  
  6.     class Meta:
  7.         verbose_name = _('content type')
  8.         verbose_name_plural = _('content types')
  9.         db_table = 'django_content_type'
  10.         unique_together = (('app_label', 'model'),)
  11.  
  12.     def __str__(self):
  13.         return self.name

　　這个类主要作用是记录每个app中的model。例如，我们在自己的app中创建了如下几个model：post，event。迁移之后，我们来查看一下ContentType這个数据表中生成的数据：

　　　　　　

　　如上图，生成了app与model的对应关系。那么，這个主要有什么用呢？别急，听我慢慢道来。

　　我们在View视图中，来这样玩玩：

  1. def demo(request):
  2.     obj = models.ContentType.objects.get(id=10)
  3.     print(obj.model_class()) # <class 'app01.models.Post'>
  4.     return HttpResponse('............')

　　看到，我通过model_class就可以获取对应的类。也就是说，今后，我们如果自己定义model如果有外键关联到這个ContentType上，我们就能找到对应的model名称。

二、Django-ContentType-signals　

　　django的signal结合contenttypes可以实现好友最新动态，新鲜事，消息通知等功能。总体来说这个功能就是在用户发生某个动作的时候将其记录下来或者附加某些操作，比如通知好友。要实现这种功能可以在动作发生的代码里实现也可以通过数据库触发器等实现，但在django中，一个很简单的方法的就是使用signals。

　　当django保存一个object的时候会发出一系列的signals，可以通过对这些signals注册listener，从而在相应的signals发出时执行一定的代码。
　　使用signals来监听用户的动作有很多好处，1、不管这个动作是发生在什么页面，甚至在很多页面都可以发生这个动作，都只需要写一次代码来监听保存object这个动作就可以了。2、可以完全不修改原来的代码就可以添加监听signals的功能。3、你几乎可以在signals监听代码里写任何代码，包括做一些判断是不是第一次发生此动作还是一个修改行为等等。

　　想要记录下每个操作，同时还能追踪到这个操作的具体动作。
　　*首先用信号机制，监听信号，实现对信号的响应函数，在响应函数中记录发生的动作（记录在一张记录表，相当于下文的Event）。
　　*其次就是为了能追踪到操作的具体动作，必须从这张表中得到相应操作的model，这就得用到上面说的ContentType。

　　对于新鲜事这个功能来说就是使用GenericRelation来产生一个特殊的外键，它不像models.ForeignKey那样，必须指定一个Model来作为它指向的对象。GenericRelation可以指向任何Model对象，有点像C语言中 void* 指针。

　　这样关于保存用户所产生的这个动作，比如用户写了一片日志，我们就可以使用Generic relations来指向某个Model实例比如Post，而那个Post实例才真正保存着关于用户动作的完整信息，即Post实例本身就是保存动作信息最好的地方。这样我们就可以通过存取Post实例里面的字段来描述用户的那个动作了，需要什么信息就往那里面去取。而且使用Generic relations的另外一个好处就是在删除了Post实例后，相应的新鲜事实例也会自动删除。

　　怎么从这张操作记录表中得到相应操作的model呢，这就得用到fields.GenericForeignKey，它是一个特殊的外键，可以指向任何Model的实例，在这里就可以通过这个字段来指向类似Post这样保存着用户动作信息的Model实例。

　　先来看看model：

  1. from django.db import models
  2. from django.contrib.auth.models import User
  3. from django.contrib.contenttypes import fields
  4. from django.db.models import signals
  5.  
  6. class Post(models.Model):
  7.     author = models.ForeignKey(User)
  8.     title = models.CharField(max_length=255)
  9.     content = models.TextField()
  10.     created = models.DateTimeField(u'发表时间', auto_now_add=True)
  11.     updated = models.DateTimeField(u'最后修改时间', auto_now=True)
  12.  
  13.     events = fields.GenericRelation('Event')
  14.  
  15.     def __str__(self):
  16.         return self.title
  17.  
  18.     def description(self):
  19.         return u'%s 发表了日志《%s》' % (self.author, self.title)
  20.  
  21. class Event(models.Model):
  22.     user = models.ForeignKey(User)
  23.     content_type = models.ForeignKey(ContentType)
  24.     object_id = models.PositiveIntegerField()
  25.  
  26.     content_object= fields.GenericForeignKey('content_type', 'object_id')
  27.  
  28.     created = models.DateTimeField(u'事件发生时间', auto_now_add=True)
  29.  
  30.     def __str__(self):
  31.         return "%s的事件: %s" % (self.user, self.description())
  32.  
  33.     def description(self):
  34.         return self.content_object.description()
  35.  
  36. def post_post_save(sender, instance, signal, *args, **kwargs):
  37.     """
  38.     :param sender:监测的类：Post类
  39.     :param instance: 监测的类：Post类
  40.     :param signal: 信号类
  41.     :param args:
  42.     :param kwargs:
  43.     :return:
  44.     """
  45.     post = instance
  46.     event = Event(user=post.author, content_object=post)
  47.     event.save()
  48.  
  49. signals.post_save.connect(post_post_save, sender=Post)
    #signals.post_save.connect(post_post_sace,sender=Book)可以监听多个类

　　只要model中有object的保存操作，都将执行post_post_save函数，故可以在这个接受函数中实现通知好友等功能。

　　前面说到django在保存一个object的时候会发出一系列signals，在这里我们所监听的是signals.post_save这个signal，这个signal是在django保存完一个对象后发出的，django中已定义好得一些signal, 在django/db/models/signal.py中可以查看，同时也可以自定义信号。 
　　利用connect这个函数来注册监听器， connect原型为：
　　def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
　　第一个参数是要执行的函数，第二个参数是指定发送信号的Class，这里指定为Post这个Model，对其他Model所发出的signal并不会执行注册的函数。
instance这个参数，即刚刚保存完的Model对象实例。创建事件的时候看到可以将post这个instance直接赋给generic.GenericForeignKey类型的字段，从而event实例就可以通过它来获取事件的真正信息了。
　　最后有一点需要的注意的是，Post的Model定义里现在多了一个字段：
      content_object= GenericRelation(‘Event’)

通过这个字段可以得到与某篇post相关联的所有事件，最重要的一点是如果没有这个字段，那么当删除一篇post的时候，与该post关联的事件是不会自动删除的。反之有这个字段就会进行自动的级联删除

三、ContentType其他案例总结

　　案例一、调查问卷表设计

　　例如：设计如下类型的调查问卷表：问卷类型包括（打分，建议，选项），先来看看一个简单的问答，

  • 您最喜欢吃什么水果？

    • A.苹果　　B.香蕉　C.梨子    D.橘子

　　对于上面一个类型的问答，我们可以知道，一个问卷系统主要包括：问卷，问卷中每个题目，每个题目的答案，以及生成问卷记录。常规设计表如下：

  1. from django.db import models
  2. from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
  3. from django.contrib.contenttypes.models import ContentType
  4. class Survery(models.Model):
  5.     """
  6.     问卷
  7.     ID        name            by_class      creator
  8.     1    第一次班级调查      三年级五班     李老师
  9.     """
  10.     name = models.CharField(verbose_name="调查问卷名称", max_length=128, unique=True)
  11.     by_class = models.ForeignKey(verbose_name="问卷调查班级", to="ClassList")
  12.     date = models.DateTimeField(verbose_name="问卷创建日期", auto_now_add=True)
  13.     creator = models.ForeignKey(verbose_name="创建者", to="UserInfo")
  14.  
  15. class SurveryItem(models.Model):
  16.     """
  17.     问卷题目
  18.     ID                 survery                       name                   date          answer_type
  19.      1    1(代表上面创建的第一次班级调查)      您最喜欢吃什么水果?       xxx-xxx-xx           1
  20.      1    1(代表上面创建的第一次班级调查)      您最喜欢什么玩具?         xxx-xxx-xx           2
  21.      1    1(代表上面创建的第一次班级调查)      您最喜欢什么英雄人物?     xxx-xxx-xx           3
  22.     """
  23.     survery = models.ForeignKey(verbose_name='问卷', to='Survery')
  24.     name = models.CharField(verbose_name="调查问题", max_length=255)
  25.     date = models.DateField(auto_now_add=True)
  26.     answer_type_choices = (
  27.         (1, "打分(1~10分)"),
  28.         (2, "单选"),
  29.         (3, "建议"),
  30.     )
  31.     answer_type = models.IntegerField(verbose_name="问题类型", choices=answer_type_choices, default=1)
  32.  
  33. class SurveryChoices(models.Model):
  34.     """
  35.     问卷选项答案(针对选项类型)
  36.     ID    item    content   points
  37.     1       2       A         10分
  38.     1       2       B         9分
  39.     1       2       C         8分
  40.     1       2       D         7分
  41.     """
  42.     item = models.ForeignKey(verbose_name='问题', to='SurveryItem')
  43.     content = models.CharField(verbose_name='内容', max_length=256)
  44.     points = models.IntegerField(verbose_name='分值')
  45.  
  46. class SurveryRecord(models.Model):
  47.     """
  48.     问卷记录
  49.     ID    survery      student_name   survery_item  score  single  suggestion  date
  50.     1        1            1               1          10分   null      null    xxxxx
  51.     1        1            1               2          null     A       null    xxxxx
  52.     1        1            1               3          null   null      XXXXX    xxxxx
  53.     """
  54.     survery = models.ForeignKey(Survery, verbose_name="问卷")
  55.     student_name = models.ForeignKey(verbose_name="学员姓名", to="Student")
  56.     survery_item = models.ForeignKey(verbose_name="调查项", to='SurveryItem')
  57.  
  58.     score = models.IntegerField(verbose_name="评分", blank=True, null=True)
  59.     single = models.ForeignKey(verbose_name='单选', to='SurveryChoices', blank=True, null=True)
  60.     suggestion = models.TextField(verbose_name="建议", max_length=1024, blank=True, null=True)
  61.  
  62.     date = models.DateTimeField(verbose_name="答题日期", auto_now_add=True)

　　但是，如果我有另外一个需求，也需要与SurveryRecord建立外键关系，那么此时应该怎么做呢？是再给上面的表增加一个外键，然后重新修改数据库么？显然是不能，一旦数据库被创建了，我们几乎很少再去修改数据，如果再给其添加额外字段，无疑会带来不必要的麻烦。为此，我们可以利用Django自带的ContentType类，来做这件事情。

　　下面来看看经过修改以后的model：

  1. from django.db import models
  2. from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
  3. from django.contrib.contenttypes.models import ContentType
  4. class Survery(models.Model):
  5.     """
  6.     问卷
  7.     ID        name            by_class      creator
  8.     1    第一次班级调查      三年级五班     李老师
  9.     """
  10.     name = models.CharField(verbose_name="调查问卷名称", max_length=128, unique=True)
  11.     by_class = models.ForeignKey(verbose_name="问卷调查班级", to="ClassList")
  12.     date = models.DateTimeField(verbose_name="问卷创建日期", auto_now_add=True)
  13.     creator = models.ForeignKey(verbose_name="创建者", to="UserInfo")
  14.  
  15. class SurveryItem(models.Model):
  16.     """
  17.     问卷题目
  18.     ID                 survery                       name                   date          answer_type
  19.      1    1(代表上面创建的第一次班级调查)      您最喜欢吃什么水果?       xxx-xxx-xx           1
  20.      1    1(代表上面创建的第一次班级调查)      您最喜欢什么玩具?         xxx-xxx-xx           2
  21.      1    1(代表上面创建的第一次班级调查)      您最喜欢什么英雄人物?     xxx-xxx-xx           3
  22.     """
  23.     survery = models.ForeignKey(verbose_name='问卷', to='Survery')
  24.     name = models.CharField(verbose_name="调查问题", max_length=255)
  25.     date = models.DateField(auto_now_add=True)
  26.     answer_type_choices = (
  27.         (1, "打分(1~10分)"),
  28.         (2, "单选"),
  29.         (3, "建议"),
  30.     )
  31.     answer_type = models.IntegerField(verbose_name="问题类型", choices=answer_type_choices, default=1)
  32.  
  33. class SurveryChoices(models.Model):
  34.     """
  35.     问卷选项答案(针对选项类型)
  36.     ID    item    content   points
  37.     1       2       A         10分
  38.     1       2       B         9分
  39.     1       2       C         8分
  40.     1       2       D         7分
  41.     """
  42.     item = models.ForeignKey(verbose_name='问题', to='SurveryItem')
  43.     content = models.CharField(verbose_name='内容', max_length=256)
  44.     points = models.IntegerField(verbose_name='分值')
  45.     surveryrecord = GenericRelation("SurveryRecord")
  46.  
  47. class Score(models.Model):
  48.     item = models.ForeignKey(verbose_name='问题', to='SurveryItem')
  49.     points = models.IntegerField(verbose_name='分值')
  50.     surveryrecord = GenericRelation("SurveryRecord")
  51.  
  52. class Suggestion(models.Model):
  53.     item = models.ForeignKey(verbose_name='问题', to='SurveryItem')
  54.     suggests = content = models.CharField(verbose_name='内容', max_length=256)
  55.     surveryrecord = GenericRelation("SurveryRecord")
  56.  
  57. class SurveryRecord(models.Model):
  58.     """
  59.     问卷记录
  60.     ID    survery      student_name   survery_item  content_type  object_id
  61.     1        1            1               1              1             1
  62.     1        1            1               2              1              2
  63.     1        1            1               3              1               3
  64.     """
  65.     survery = models.ForeignKey(Survery, verbose_name="问卷")
  66.     student_name = models.ForeignKey(verbose_name="学员姓名", to="Student")
  67.     survery_item = models.ForeignKey(verbose_name="调查项", to='SurveryItem')
  68.  
  69.     content_type = models.ForeignKey(ContentType, blank=True, null=True)
  70.     object_id = models.PositiveIntegerField(blank=True, null=True)
  71.     content_object = GenericForeignKey('content_type', 'object_id') # 這个字段不会再数据库中存在,只是在查询时有用
  72.  
  73.     date = models.DateTimeField(verbose_name="答题日期", auto_now_add=True)

　　案例二、优惠券系统设计

　　应用场景：某一在线教育网，需要为每位积极客户发一些观看视频的优惠券，但是，对于不同类型的视频，优惠券是不同。比如：有一个普通课程，需要发一些满200减30的优惠券，而又有精品课程，需要发满100键70的优惠券。根据以上需求，我们很快就知道，需要三张表，学位课程表，课程表以及优惠券表，那么，这三张表又是如何关联的呢？

　　我们先来看看下面這个：

  1. #A 学位课程表结构
  2. #  ID     名称
  3. #  1    学位课1
  4. #  2    学位课2
  5.  
  6. #B普通课程表
  7. #ID    名称
  8. #1    普通课1
  9. #2    普通课2
  10.  
  11. #优惠券表
  12. #ID     优惠券名称     A(FK）         B(FK)
  13. #1       通用优惠券    null           null  # 两个都为空,说明全场都可以使用
  14. #2       满100-10      1             null  # 给学位课程创建优惠券
  15. #3       满200-30     null            1    # 给普通课程创建优惠券

　　还是与上面一样，如果再来一种课程，上面的优惠券表还需要额外新增一列，为了解决這个问题，我们可以使用ContentType类来实现上述需求。

  1. from django.db import models
  2. from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
  3. from django.contrib.contenttypes.models import ContentType
  4.  
  5. # Create your models here.
  6.  
  7. class DegreeCourse(models.Model):
  8.     """学位课程
  9.      ID    名称
  10.      1    学位课1
  11.      2    学位课2
  12.  
  13.     """
  14.     name = models.CharField(max_length=128, unique=True)
  15.  
  16.     x1 = GenericRelation("Coupon")
  17.  
  18. class Course(models.Model):
  19.     """课程
  20.      ID    名称
  21.      1    普通课1
  22.      2    普通课2
  23.     """
  24.     name = models.CharField(max_length=128, unique=True)
  25.  
  26. class Coupon(models.Model):
  27.     """优惠券生成规则
  28.     ID     优惠券名称                A FK                  B.FK           c.FK
  29.      1       通用                 null                    null
  30.      2       满100-10               8                      1
  31.      3       满200-30               8                      2
  32.      4       满200-30               9                      1
  33.  
  34.     ID     优惠券名称         content_type_id(表)         object_id（表中数据ID）
  35.      1       通用                 null                    null
  36.      2       满100-10               8                      1
  37.      3       满200-30               8                      2
  38.      4       满200-30               9                      1
  39.     总结：
  40.     """
  41.     name = models.CharField(max_length=64, verbose_name="活动名称")
  42.     brief = models.TextField(blank=True, null=True, verbose_name="优惠券介绍")
  43.  
  44.     # 那个表？
  45.     content_type = models.ForeignKey(ContentType, blank=True, null=True)
  46.     # 对象ID
  47.     object_id = models.PositiveIntegerField("绑定课程", blank=True, null=True, help_text="可以把优惠券跟课程绑定")
  48.  
  49.     content_object = GenericForeignKey('content_type', 'object_id')
  50.  
  51. #
  52. #
  53. #
  54. #
  55. # class Homework(models.Model):
  56. #     """
  57. #     ID  User     Name    score
  58. #      1  吴昊   第一模块    30
  59. #      2  吴昊   第二模块    80
  60. #      3  吴昊   第三模块    100
  61. #
  62. #     """
  63. #     name = models.CharField(max_length=32)
  64. #
  65. #     score_choices = (
  66. #         (100,'A'),
  67. #         (80,'B'),
  68. #         (60,'C'),
  69. #         (30,'D'),
  70. #     )
  71. #     score = models.IntegerField(choices=score_choices)
  72. #
  73. #     user = models.ForeignKey('User')
  74. #
  75. #
  76. # class Record(models.Model):
  77. #     """
  78. #      ID  User     Name     score
  79. #      1  吴昊     第一模块    10        5
  80. #      2  吴昊     第二模块    8        10
  81. #     """
  82. #     name = models.CharField(max_length=32)
  83. #     score_choices = (
  84. #         (100, 'A'),
  85. #         (80, 'B')
  86. #     )
  87. #     score = models.IntegerField(choices=score_choices)
  88. #
  89. # class ScoreRecord(models.Model):
  90. #     """
  91. #     ID      Name           表       对象
  92. #      1     作业太差         1
  93. #      2     作业太好         1
  94. #      5     看的太快         null               1
  95. #     """
  96. #     name = models.CharField(max_length=32)
  97. #     content_type = models.ForeignKey(ContentType, blank=True, null=True)
  98. #     # 对象ID
  99. #     object_id = models.PositiveIntegerField("绑定课程", blank=True, null=True, help_text="可以把优惠券跟课程绑定")
  100. #
  101. #
  1. from django.shortcuts import render,HttpResponse
  2. from django.contrib.contenttypes.models import ContentType
  3. from . import models
  4. def test(request):
  5.  
  6.     # models.UserInfo.objects.filter()
  7.  
  8.     # content = ContentType.objects.get(app_label='app01',model='userinfo')
  9.     # model_class = content.model_class()
  10.     # print(model_class.objects.all())
  11.  
  12.     # 给学位课1或普通课创建优惠券
  13.     d1 = models.DegreeCourse.objects.get(id=1)
  14.     models.Coupon.objects.create(name='优惠券', brief='2000-30', content_object=d1)
  15.  
  16.     # d1 = models.Course.objects.get(id=1)
  17.     # models.Coupon.objects.create(name='优惠券', brief='100-90', content_object=d1)
  18.  
  19.     # 当前优惠券，绑定的课程？
  20.     obj = models.Coupon.objects.get(id=1)
  21.     # print(obj.content_object)
  22.  
  23.     # 当前课程，都有哪些优惠券？
  24.     # obj = models.DegreeCourse.objects.get(id=1)
  25.     # print(obj.x1.all())
  26.     # v = models.DegreeCourse.objects.values('name','x1__brief')
  27.     # print(v)
  28.  
  29.     return HttpResponse('...')

根据ContentType字段查询关联字段操作

　　总之，如果一个表与其他表有多个外键关系，我们可以通过ContentType来解决这种关联。

　

f

Django-ContentType-signals 实现牛逼玩法的更多相关文章

  1. 玩转type类型(牛逼克拉斯 )

    一.前言 一说起type()方法肯定有很多人都知道这不就是查看某个对象类型的嘛,其实不然,他还有更牛逼的应用------创建类 >>> type(1) <class 'int' ...

  2. 为什么我会认为SAP是世界上最好用最牛逼的ERP系统，没有之一？

    为什么我认为SAP是世界上最好用最牛逼的ERP系统,没有之一?玩过QAD.Tiptop.用友等产品,深深觉得SAP是贵的有道理! 一套好的ERP系统,不仅能够最大程度承接适配企业的管理和业务流程,在技 ...

  3. 15天玩转redis —— 第八篇 你不得不会的事务玩法

    我们都知道redis追求的是简单,快速,高效,在这种情况下也就拒绝了支持window平台,学sqlserver的时候,我们知道事务还算是个比较复杂的东西, 所以这吊毛要是照搬到redis中去,理所当然 ...

  4. ExceptionLess新玩法 -- 审计日志

    审计日志 这算是一个挺酷的功能,把每个请求都记录下来,之前在abp中看到过这个功能,配合可视化的界面,简直是在装逼 看到了exceptionless后,心念一动,我也可以根据它做一个审计日志的功能.这 ...

  5. 科学家有了钱以后，真是挺吓人的——D.E.Shaw的牛逼人生

    科学家有了钱以后,真是挺吓人的——D.E.Shaw的牛逼人生 黑科技,还是要提D.E.Shaw Research这个奇异的存在. 要讲这个黑科技,我们可能要扯远一点,先讲讲D.E. Shaw这个人是怎 ...

  6. 【Python基础】random 的高级玩法

    random 模块的高级玩法 1.python 随机产生姓名 方式一: import random xing = [ '赵', '钱', '孙', '李', '周', '吴', '郑', '王', ' ...

  7. 历数依赖注入的N种玩法

    历数依赖注入的N种玩法 在对ASP.NET Core管道中关于依赖注入的两个核心对象(ServiceCollection和ServiceProvider)有了足够的认识之后,我们将关注的目光转移到编程 ...

  8. 2 URL的玩法

    preface 这里我主要说说flask的URL玩法 include: 动态URL规则 自定义URL转换器 HTTP方法 唯一的URL 构造URL 跳转和重定向 动态URL规则 URL规则可以添加变量 ...

  9. Chrome 控制台新玩法-向输出到console的文字加样式

    Chrome 控制台新玩法-向输出到console的文字加样式 有兴趣的同学可以文章最后的代码复制贴到控制台玩玩. Go for Code 在正常模式下,一般只能向console 控制台输出简单的文字 ...

随机推荐

  1. Python的生成器进阶玩法

    Python的生成器进阶玩法 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.yield的表达式形式 #!/usr/bin/env python #_*_coding:utf-8 ...

  2. Python基础【day03】：文件操作(六)

    一.概述 我们工作中需要经常操作文件,下面就讲讲如何用Python操作文件 1.文件操作的流程: 打开文件,得到文件句柄赋值给一个变量 通过文件句柄,对文件进行操作 关闭文件 二.入门 1.语法 op ...

  3. Spark记录-实例和运行在Yarn

    #运行实例 #./bin/run-example SparkPi 10   #./bin/spark-shell --master local[2] #./bin/pyspark --master l ...

  4. 运行fdisk命令时，弹出 bash:fdisk:command not found

    原因:命令fdisk 不在你的命令搜索路径中 第一种解决办法,将fdisk添加到你的命令搜索路径中 首先查看你当前的命令搜索路径: [root@host sbin]# echo $PATH/usr/k ...

  5. Mogodb 学习一

    0.MongoDB和关系型数据的几个重要对象对比 MongoDB中的数据库.集合.文档 类似于关系型数据库中的数据库.表.行 MongoDB中的集合是没有模式的,所以可以存储各种各样的文档 1.启动M ...

  6. 20155303 2016-2017-2 《Java程序设计》第六周学习总结

    20155303 2016-2017-2 <Java程序设计>第六周学习总结 课堂笔记 高效学习法推荐 看视频学习(2h)→ 以代码为中心看课本,思考运行结果并验证(3h)→ 课后作业验证 ...

  7. vue-cli 3.0 开启 Gzip 方法

    vue.config.js const path = require('path') const CompressionWebpackPlugin = require('compression-web ...

  8. 使用 scm-manager 搭建 git/svn 代码管理仓库(一)

    1.在官网上下载scm-manager 下载地址  https://www.scm-manager.org/download/ 选择下载文件 2. 配置java 环境 参照文章:https://jin ...

  9. mybatis输入输出映射——（五）

    0.#{}与${}区别 #{}实现的是向prepareStatement中的预处理语句中设置参数值,sql语句中#{}表示一个占位符即?. <!-- 根据id查询用户信息 --> < ...

  10. if 语句 写了return 报错