django1.8 model (1):Model syntax

此文翻译自django 1.8.2官方文档

Models

模型是单一的,明确的和你的数据有关的信息的来源.它包含了你存储的数据的基本字段和行为.通常,一个模型对应一个数据库表.
基础知识:
- 每个模型都是django.db.model.Model的子类
- 模型的每个属性都代表一个数据库字段
- 在这2个前提下,django提供了自动生成(automatically-generated)数据库连接(database-access)的API;

Quick example

这个示例模型定义了一个Person,有first_name和last_name:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

first_name和last_name是模型的字段.一个字段就是一个类属性,每个属性都映射一个数据库的列.
上面的Person模型会像这样创建一个数据库:

CREATE TABLE myapp_person(
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
)

一些技术要点:
- 表的名字,myapp_person,是由模型的元数据(metaclass)自动生成的,但可以重写.
- id字段是自动添加的,这个行为(behavior)也可以重写.
- 这段建表SQL语句用的是PostgreSQL语法格式化的.值得注意的是,django根据settings文件里指定的数据库驱动来使用SQL.

Using models

在你定义了模型之后,要告诉django你将要使用这些模型.编辑你的settings文件,更改INSTALLED_APPS设置,添加包含你的models.py的模块名.

INSTALLED_APPS = {
    # ...
    'myapp',
    # ...
}

当你添加新app到INSTALLED_APPS后,确保运行manage.py migrate,也可以先运行manage.py makemigrations.

Fields

模型最重要的部分-并且是唯一必需的部分-是它定义的数据库字段.这些字段由类属性指定.小心选择字段名,不要和模型API冲突,比如clean,save或delete.例如:

from django.db import models

class Musician(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    instrument = models.CharField(max_length=100)

class Album(models.Model):
    artist = models.ForeignKey(Musician)
    name = models.CharField(max_length=100)
    release_date = models.DateField()
    num_stars = models.IntegerField()

Field types

模型里的每个字段都是一个合适的Field类的实例.django使用field class类型来决定一些事情:
- 数据库字段类型(例如 INTEGER, VARCHAR).
- 渲染表单字段时,默认使用的HTML widget(例如,)
- 最基本的验证需求,在django的admin模块和自动生成的表单里有使用.

django有很多内置的字段类型;如果内置的不够用,你可以很容易的定制你自己的字段.

Field options

每个字段都有一些指定字段专用(field-specific)的参数.例如,CharField(和它的子类)需要max_length参数来指定数据库里用来存储数据的VARCHAR的长度.
同样有些通用参数适用于所有字段类型.这些都是可选的.这里是最常用的参数的摘要:
- null
如果是True,django会将空数据当作NULL存入数据库.默认是False.
- blank
如果是True,字段允许是空值(blank).默认是False.
注意这和null不同.null是纯数据库相关的(pure database-related),但是blank是验证相关的(validation-related).如果字段有blank=True,表单验证会允许输入空字符.如果字段是blank=Flase,字段值不能是空字符.
- choices
由2元素元组(2-tuples)组成的可迭代对象,作为字段的choices.如果有这个属性,默认的表单widget就是一个下拉选框而不是标准的文本字段,并限制选择给出的选项.
一个choices list 就像这样:

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)

每个元组的第一个元素是要存到数据库的值,第二个元素是默认显示在表单widget里或在ModelChoiceField里.给定一个模型对象的实例,choices字段的显示值可以通过get_FOO_display方法获取.例如:

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
)
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)

>>> p = Person(name='Fred Flintstone', shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

• default
  字段的默认值.可以是一个值或者可调用对象.如果是可调用对象,新建对象是会被调用.
• help_text
  表单widget里显示的额外的”help”文本.就算你的字段在表单里不使用,也可用于文档
• primary_key
  如果为True,这个字段就是模型的主键.
  如果你没有在模型里指定任何字段primary_key=True,django会自动的添加一个IntegerFiled作为主键,如果你不需要任何主键,你就得重写默认的主键方法.
  主键字段是只读的.如果你更改一个已存在对象的主键的值并保存,这会创建一个新对象.例如:

from django.db import models

class Fruit(models.Model):
    name = models.CharField(max_length=100, primary_key=True)

>>> fruit = Fruit.objects.create(name='Apple')
>>> fruit.name = 'Pear'
>>> fruit.save()
>>> Fruit.objects.values_list('name', flat=True)
['Apple', 'Pear']

• unique
  如果为True,这个字段值在表中必须唯一

再次说明,这些只是最常用的字段可选参数的简短描述,全部详情请查看参考文档.

Automatic primary key fields

默认情况下,django会给每个模型一个字段:

id = models.AutoField(primary_key=True)

这是一个自增长主键.
如果你想指定一个自定义的主键,只需要再其中一个字段中指定primary_key=True就行了.如果django看到你显式的设置了Field.primary_key,就不会自动添加id字段了.
每个模型都必须要有一个字段是primary_key=True(显示声明或者自动添加)

Verbose field names

每个字段类型,除了ForeignKey,ManyToManyField和OneToOneField,都有一个可选的第一位置的参数-别名(verbose name).如果没有给定别名,django会自动的使用属性名来创建别名,下划线会转换为空格.
这个例子中,别名是”person’s first name”:

first_name = models.CharField("person's first name", max_length=30)

在这个例子里,别名是”first name”:

first_name = models.CharField(max_length=30)

ForeignKey,ManyToManyField和OneToOneField的第一位置参数必须是模型类,所以使用verbose_name关键字参数:

poll = models.ForeignKey(Poll, verbose_name="the related poll")
sites = models.ManyToManyField(Site, verbose_name="list of sites")
place = models.OneToOneField(Place, verbose_name="related place")

约定verbose_name的首字母不需要大写.django会自动将首字母改成大写.

Relationships

显然,关系型数据库的强大在于表关联.django提供提供了定义3中常用的数据库关联关系的方法:多对一,多对多,一对一.
- Many-to-one relationships
使用django.db.models.ForeignKey来定义多对一关系.使用起来就像其他字段类型一样:就像你的模型的类属性一样包含它就行了.
ForeignKey需要一个位置参数:模型的关联类.
例如,如果一个Car模型有一个Manufacturer-就是说一个Manufacturer制造多个汽车,但是每个Car只能由一个Manufacturer-使用下面的定义:

from django.db import models

class Manufacturer(models.Model):    
    # ...
    pass

class Car(models.Model):
    manufacturer = models.ForergnKey(Manufacturer) 
    # ...

You can also create recursive relationships (an object with a many-to-one relationship to itself) and relationships to models not yet defined; see the model field reference for details.
建议,但不强制要求,ForeignKey字段(上面的例子是manufacturer)的名字是模型名的小写.当然,你也可以自己取名.例如:

class Car(models.Model):
    company_that_makes_it = models.ForeignKey(Manufacturer)

• Many-to-many relationships
  使用ManyToManyField来定义多对多关系.就像其他字段类型一样使用就行:模型里包含它就像一个类属性.
  ManyToManyField需要一个位置参数:模型关联的类.
  例如,一个Pizza有多个Topping对象-也就说说,一个Topping可以用于多种pizza的同时每个Pizza有多种topping-就这样表示:

from django.db import models

class Topping(models.Model):
    # ...
    pass

class Pizza(models.Model):
    # ...
    toppings = models.ManyToManyField(Topping)

和ForeignKey一样, you can also create recursive relationships (an object with a many-to-many relationship to itself) and relationships to models not yet defined; see the model field reference for details.
建议但不强制要求,ManyToManyField的名字(这个例子中是toppings)用关联对象的复数形式.
无论是哪个模型用ManyToManyField都可以,只要其中一个有就行了,不是2个都要有.
通常情况下,ManyToManyField实例放到需要在表单里编辑的对象里.在上面的例子中,toppings在Pizza里(而不是Topping有一个pizzas ManyToManyField)因为一个披萨用多种调料比一种调料可以用于多种披萨更符合自然思维.在上面的的设置中,Pizza表单中用户可以选择多个topping.
ManyToManyField有许多可选参数,详情请看参考文档.
- Extra fields on many-to-many relationships
当你处理简单的多对多关系就像混合,匹配披萨和调料时,标准的ManyToManyField就是你需要的.但是有时候你可能需要处理的数据和2个模型都有关联.例如,假设有一个应用要记录乐手属于哪个组合.这里就有个多对多关系,一个人和这个人参加过的组合,所以你可以使用ManyToManyField来表现这种关系.但是有很多关于成员的细节你要考虑到,比如乐手加入组合的时间.
为了应付这种情况,django允许你定制模型用于多对多关系.你可以在中介模型(intermediate model)里加入额外的字段(extra field).中介模型使用through参数来关联到ManyToManyField,从而指明模型是中介模型(act as an intermediary).就用musician的例子,代码就像下面这样:

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

    def __str__(self):  # python2使用__unicode__
        return self.name

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

    def __str__(self):  # python2使用__unicode__
        return self.name

class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField() 
    invite_reason = models.CharField(max_length=64)

使用中介模型时,显式指定多对多关系模型的外键.这个显式声明定义了2个模型是怎么关联到一起的.
使用中介模型有一些限制:

中介模型必须包含有且只有一个源模型(source model)(这里的例子中是Group)的外键,否则你必须使用ManyToManyField.through_fields来显式指定外键.如果你有多个外键并且through_fields没有指定,会抛出一个validation error.对于目标模型(target model)(这里的例子中是Person),这个规则也适用.
对于一个使用中介模型的有多对多关系的模型来说,允许有2个外键指向同一个模型,但是他们必须当作2个不同的多对多关系处理.If there are more than two foreign keys though, you must also specify through_fields as above, or a validation error will be raised.
When defining a many-to-many relationship from a model to itself, using an intermediary model, you must use symmetrical=False

django1.7更改:

在django1.6及更早版本中,多对多关系的模型每个模型只能有一个外键在中介模型里.
现在你可以像这样来使用

>>> ringo = Person.objects.create(name='Ringo Starr')
>>> paul = Person.objects.create(name='Paul McCartney')
>>> beatles = Group.objects.create(name='The Beatles')
>>> m1 = Membership(person=ringo, group=beatles,date_joined=date(1962, 8, 16), invite_reason='Needed a new drummer.')
>>> m1.save()
>>> beatles.members.all()
[]
>>> ringo.group_set.all()
[]
>>> m2 = Membership.objects.create(person=paul, group=beatles, date_joined=date(1960, 8, 1), invite_reason='Wanted to form a band.')
>>> beatles.members.all()
[,]

和普通的多对多字段不同,你不能使用add,create或者赋值语句(例如,beatles.members=[…])来创建关联:

# 这个不会起作用
>>> beatles.memebers.add(john)
# 这个也是
>>> beatles.members.create(name='George Harrison')
# 这个也是
>>> beatles.members = [john, paul, ringo, george]

为什么呢,你不能只是新建一个Person和Group的关联-你要指定所有在Membership模型中需要的详情.简单的add,create和赋值调用没有提供一个指定额外细节的方法.
所以,他们对使用中介模型的多对多关系不起作用.唯一的途径是新建中介模型的实例.
remove()方法不起作用,也是这个原因.但是clear()方法可以移除一个实例的所有多对多关系:

>>> # 披头士解散
>>> beatles.members.clear()
>>> # 这将删除中介模型实例
>>> Membership.objects.all()
[]

在通过创建中介模型实例来确立了多对多关系后,你可以开始使用查询了.就像普通的多对多关系一样,你能使用多对多关系模型的属性来查询:

# 找出有成员名字以'Paul'开头的组
>>> Group.objects.filter(members__name__startwith='Paul')
[]

如果你使用了中介模型,你也可以用他的属性来查询:

# 找出披头士在1 Jan 1961后加入的成员
>>> Person.objects.filter(group__name='The Beatles', membership__date__joined__gt=date(1961,1,1))
[]

如果你要查看membership的信息,你可以直接查询Membership模型:

>>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)
>>> ringos_membership.date_joined
datetime.date(1962, 8, 16)
>>> ringos_membership.invit_reason
'Needed a new drummer.'

另一个方法是通过Person对象来查询(多对多反向关系)many-to-many reverse relationship:

>>> ringos_membership = ringo.membership_set.get(group=beatles)
>>> ringos_membership.date_joined
datetime.date(1962, 8, 16)
>>> ringos_membership.invite_reason
'Needed a new drummer.'

• One-to-one relationships
  使用OneToOneField来定义一对一关系.就像其他字段类型一样来使用:就像一个模型的属性一样来包含它.
  当一个对象’继承’另一个对象时,这是最有用的方法,在主键上使用.
  OneToOneField需要一个位置参数:关联模型类.
  例如,如果你有一个’places’库,它有address,phone number等等,如果你另外想建一个restaurants库,没有必要在Restaurant模型里重复这些字段,你可以将Restaurant和Place作一对一关联(因为一个餐馆’是’一个地方,实际上,通常使用继承,它包含了一个隐形的一对一关系).
  As with ForeignKey, a recursive relationship can be defined and references to as-yet undefined models can be made; see the model field reference for details.
  OneToOneField fields also accept one specific, optional parent_link argument described in the model field reference.
  OneToOneField classes used to automatically become the primary key on a model. This is no longer true (although you can manually pass in the primary_key argument if you like). Thus, it’s now possible to have multiple fields of type OneToOneField on a single model.

Models across files

模型可以跨应用关联.为此,需要在定义模型的文件头部import关联模型.然后,在需要的地方关联其他模型就可以了.例如:

from django.db import models
from geography.models import ZipCode

class Restaurant(models.Model):
    # ...
    zip_code = model.ForeignKey(ZipCode)

Field name restrictions

django只有2个模型字段名限制:
1. 字段名不能是python关键字,因为这会造成python语法错误.例如:

class Example(models.Model):
    pass = models.IntegerField()  # 'pass'是关键字!

1. 字段名不能使用连续多个下划线,因为和django的查询方法的语法冲突.例如:

class Example(models.Model):
    foo__bar = models.IntegerField()  # 'foo__bar'有2个下划线!

这些限制是可以规避的,因为你的字段名没有必要一定和和数据库字段名相同.详情见db_column可选项.
SQL关键字,例如join,where或select允许作为模型字段名,因为在每个SQL查询中django都对表名和字段名进行了转义.它使用特定的数据库引擎的引号语法.

Custom field types

如果现有的模型字段都不适用或者你想使用一些非常用数据库字段类型,你可以创建你自己的字段类.详情请查看参考文档.

Meta options

使用内部类来给模型添加元数据(metaclass),就像下面的:

from django.db import models

class Ox(models.Model):
    horn_length = models.IntegerField()

    class Meta:
        ordering = ['horn_length']
        verbose_name_plural = 'oxen'

模型元数据是”不是字段的其他任何东西”(anything that’s not a field),比如说ordering选项(ordering),数据库表名(db_table)或者人类可读的(human-readable)单数和复数形式(verbose_name和verbose_name_plural).Meta类是可选的,非必需.
详情请看参考文档.

Model attributes

objects
模型最重要的属性是Manager.它是提供给django模型的数据库查询接口,用于从数据库中查询实例.如果没有自定义Manager,默认的名称是objects.Manager只能通过模型类来访问,而不是模型实例.

Model methods

通过定义模型方法可以给对象添加”row-level”functionality.不同于Manager方法用于整个表(intended to do ‘table-wide’ things),模型方法可以作用于单个模型实例.
这个技巧将业务逻辑保存到模型里.
例如,这个模型有几个自定义方法:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    birth_date = models.DateField()

    def baby_boomer_status(self):    
        "Return the person's baby-boomer status"
        import datetime
        if self.birth_date < datetime.date(1945, 8 ,1):
            return "Pre-boomer"
        elif self.birth_date < datetime.date(1965, 1, 1):
            return "Baby boomer"
        else:
            return "Post-boomer"

    def _get_full_name(self):
        "Returns the person's full name"
        return '%s %s' % (self.first_name, self.last_name)
    full_name = property(_get_full_name)

例子最后一个方法是property
每个模型都会自动添加一些方法,大部分都可以重写,详情请看参考文档.有几个是常用的:
__str__() (python3)
python3中等价于__unicode__()
__unicode__() (python2)
python的’magic method’,返回一个对象的unicode表示.当一个模型实例需要被显示为普通字符串时python和django会使用这个方法.最常见的,当你使用交互命令行或admin显示一个对象时就会用到.
最好定义这个方法,默认的很不好用.
get_absolute_url()
这表示django怎么为一个对象计算URL.在admin接口或其他任何需要计算对象的URL的时候django会用到这个方法.
任何有唯一标识URL的对象应该定义这个方法.

Overriding perdefined model methods(重写已定义的模型方法)

还有一组模型方法,封装了一些数据库动作,你可以自定义.特别是save()和delete()方法,经常改写.
你可以任意改写这些方法(或其他任何模型方法)来改变数据库行为.
一个重写内置方法的典型案例是当你保存一个对象时想做些什么.例如:

from django.db import models

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def save(self, *args, **kwargs):
        do_something()
        super(Blog, self).save(*args, **kwargs)  # 调用"真的"save()方法
        do_something()

你也可以阻止保存

from django.db import models

class Blog(models.Model):
    name = models.CharField(max_length=100)
    tagline = models.TextField()

    def save(self, *args, **kwargs):
        if self.name == "YoYo Ono's blog":
            return  # Yoko不能有自己的blog!
        else:
            super(Blog, self).save(*args, **kwargs)

一定要记得调用父类的方法-super(Blog, self).save(*args, **kwargs)-确保对象保存到数据库里.如果你忘记调用父类的方法,默认的行为将不会发生,数据库不会有变化.
另一点非常重要的是你传递了参数到模型方法*args, **args.django会时不时的添加新参数来扩展内置方法.如果你在方法定义里使用了*args和**kwargs,就能确保当有新参数添加时你的代码能自动支持这些参数.

Overridden model methods are not called on bulk operatins
注意,当使用QuerySet删除大量对象时,delete()方法不一定会被调用.为了确保自定义的删除逻辑会被执行,你可以使用pre_delete()或post_delete()信号.
不幸的是,当大量create或update对象时没有变通方法.Unfortunately, there isn’t a workaround when creating or updating objects in bulk, since none of save(), pre_save, and post_save are called.

Executing custom SQL

另外一个常用的模式是在模型方法和模块级方法里写自定义的SQL语句.详情请看参考文档.

Model inheritance

django的模型继承的工作方式和正常的Python类继承几乎一样,但是还有有些基本原则要遵守的.基类一定是django.db.models.Model.
你唯一要做的决定是父模型是否有属于自己的模型的权利(有自己的数据库表),或者说父类只保留公共信息,只有通过子模型才有可见性(only be visible throuth the child models).
django有3中继承方式.
1. 通常，你只会想使用父类来保存你不想要键入每个子模型的信息.这种类几乎不会单独使用,那么抽象基类(Abstract base class)就是你要的.
2. 如果你继承了一个已存在的模型(也许是另外一个应用),并希望每个模型都有自己的数据库表,就使用多表继承(Multi-table inheritance).
3. 最后,如果你只想修改一个模型的Python-level behavior,而不改变模型的字段,你可以使用代理模型(Proxy models).

Abstract base classes

当你想把一些公共信息保存到另外的模型时抽象基类很有用.写一个基类并在Meta类里添加abstract=True.这个模型不会在数据库里建任何表.当它用于作其他模型的基类时,它的字段会被添加到子类里.如果父类有字段名和子类相同,django会抛出异常.
一个例子:

from django.db import models

class CommonInfo(models.Model):
    name = models.CharField(max_length=100)
    age = models.PositiveIntegerField()

    class Meta:
        abstract = True

class Student(CommonInfo):
     home_group = models.CharField(max_length=5)   

Student模型会有3个字段:name, age和home_group.CommonInfo模型不能挡着普通的django模型来使用,因为它是一个抽象类.它不会生成数据库表,没有manager,不能实例化,不能直接保存(saved directly).
你可以使用这种形式的模型继承应对大多是情况.它提供了一个方法在python层面来抽取公共信息,数据库层面一个子类一个表.

• Meta inheritance
  新建一个抽象基类时,django会将在基类里声明的内部类Meta当作一个属性.如果子类没有声明自己的Meta类,就会继承父类的Meta.如果子类想扩展父类的Meta类,就继承它,例如:

from django.db import Model

class CommonInfo(models.Model):
    # ...
    class Meta:
        abstract = True
        ordering= ['name']

class Student(CommonInfo):
    # ...
    class Meta(CommonInfo.Meta):
        db_table = 'student_info'

django会对抽象基类的Meta类有一个调节(adjustment):在使用Meta属性前,设置abstract=True.这就是说抽象基类的子类不会自动变成抽象类.当然,你也可以是一个抽象基类继承自另一个抽象基类.你只要记得显式的设置abstract=True就行了.
有些属性出现在抽象基类的Meta类里就没有意义了.例如,其中有db_table就表示子类(没有定义自己的Meta)将会使用同样的数据库表,这肯定不是你想要的.

• Be careful with related_name
  如果你在ForeignKey或ManyToManyField上使用了related_name属性,你必须为字段指定一个唯一的反向名称(unique reverse name).这就会给抽象基类造成一个问题,因为类的字段会出现在每一个子类中,而且值相同.
  为了解决这个问题,你在抽象基类中使用related_name时,名称部分应该要包含”%(app_label)s”和”%(class)s”.
  
  • ’%(class)s’指字段所在的子类的lower-cased name.
  • ‘%(app_label)s’指子类所在的应用的lower-cased name.每个应用名都必须是唯一的,应用内的模型类名称在应用内也必须是唯一的,所以最后的名称都是不相 同的.

例如,common/models.py:

from django.db import models

class Base(models.Model):
    m2m = models.ManyToManyField(OtherModel, related_name="%(app_label)s_%(class)s_related")    

    class Meta:
        abstract = True

class ChildA(Base):
    pass

class ChildB(Base):
    pass

另一个app rare/models.py:

from common.models import Base

class ChildB(Base):
    pass

common.ChildA.m2m字段的反向名称(reverse name)是common_childa_related,同时common.ChildB.m2m字段的反向名称时common_childb_related,最后rare.ChildB.m2m字段的反向名称时rare_childb_related.这取决于你怎么使用’%(class)s’和’%(app_label)s’来组成你的关联名称,但是如果你忘记使用,在使用系统检查(或运行migrate)时django会抛出异常.
如果你没有在抽象基类里为字段指定related_name属性,默认的反向名称将是子类的名称跟着’_set’,就像是你直接在子类里声明变量时正常生成的那样.例如,在上面的代码中,如果related_name属性省略了,m2m字段的反向名称在ChildA里是childa_set,在ChildB里是childb_set

Multi-table inheritance

django支持的第二种模型继承是每个模型在层次结构中它本身就是一个模型.每个模型都有对应的数据库表,能查询,能直接创建.通过子类和它的每个父类(通过一个自动创建的OneToOneField)来介绍这种继承关系.例如:

from django.db import models

class Place(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=80)

class Restaurant(Place):
    serves_hot_dogs = models.BooleanField(default=False)
    serves_pizza = models.BooleanField(default=False)

Place的所有字段在Restaurant里都是有效的,虽然数据存储在不同的数据库表.所以下面的都有效:

>>> Place.objects.filter(name="Bob's Cafe")
>>> Restaurant.objects.filter(name="Bob's Cafe")

如果你有一个Place同时也是Restaurant,你可以用小些的模型名称从Place对象中获取Restaurant对象:

>>> p = Place.objects.get(id=12)
# 如果p是一个Restaurant对象,就会得到子类:
>>> p.restaurant

但是,如果上面例子中的p不是一个Restaurant(它是直接创建的Place对象或是其他类的父类),p.restaurant就会抛出Restaurant.DoesNotExist异常.

• Meta and multi-table inheritance
  在多表继承中,子类继承父类的Meta是没有意义的.All the Meta options have already been applied to the parent class and applying them again would normally only lead to contradictory behavior (this is in contrast with the abstract base class case, where the base class doesn’t exist in its own right).
  所以,子模型不访问父模型的Meta类.但是也有例外:如果子类没有指定ordering属性或get_lasted_by属性,子类就会继承父类的.
  如果父类有ordering属性,而你不想子类有自然排序,你可以显示指定它无效:

class ChildModel(ParentModel):
    # ...
    class Meta:
        # 移除父类的ordering影响
        ordering = []

• Inheritance and reverse relations
  因为多表继承使用了隐式的OneToOneField来连接子类和父类,it’s possible to move from the parent down to the child,在上面的例子中.然而它使用的名称related_name默认是给ForeignKey和ManyToManyField关系用的.如果你想使用,就必须指定每个字段的related_name.如果你忘记了,django会抛出validate error.
  例如,还是使用上面的Place类,让我们用ManyToManyField创建另一个子类:

class Supplier(Place):
    customers = models.ManyToManyField(Place)

这会造成错误:

Reverse query name for 'Supplier.customers' clashes with reverse query
name for 'Supplier.place_ptr'.

HINT: Add or change a related_name argument to the definition for
'Supplier.customers' or 'Supplier.place_ptr'.

给customers字段添加related_name能解决这个错误:
models.ManyToManyField(Place, related_name=’provider’)

• Specifying the parent link field
  正如前面提到的,如果父类不是抽象类,django会自动的为子类添加一个OneToOneField.如果你想控制连接父类的属性的名称,你可以自己创建OneToOneField并设置parent_link=True.

Proxy models

使用多表继承时,每个子模型都有一个数据库表.通常这就是你想要的,因为子类需要一个地方来存储另外的父类没有的数据字段.但是,有时候,你只是想更改模型的python行为-也许是更改默认的manager,或添加一个新方法.
这就是代理模型要做的:为原始模型创建一个代理.你可以创建,删除和更新代理模型的实例并且所有的数据会像原始模型一样保存.不同之处在于你可以在代理模型中更改一些东西,比如默认的ordering或默认的manager,而不必改变原始模型.
代理模型声明方式和普通的模型一样.你通过设置Meta类中的proxy属性为True来告诉django这是一个代理模型.
例如,假设你想给Person模型添加一个方法,你可以这样做:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

class MyPerson(Person):
    class Meta:
        proxy = True

    def do_something(self):
        # ...
        pass

MyPerson操作的数据库表和Person是一样的.任何Person的新实例都可以通过MyPerson访问,反过来也是一样:

>>> p = Person.objects.create(first_name='foobar')
>>> MyPerson.objects.get(first_name='foobar')

你也可以使用代理模型来定义不同的ordering.你可能不会将Person模型排序,但使用代理时可以更具last_name属性排序.这很容易:

class OrderedPerson(Person):
    class Meta:
        ordering = ['last_name']
        proxy = True

现在普通的Person查询不会排序,OrderedPerson查询会根据last_name排序.

• QuerySets still return the model that was required
  django没办法使Person查询返回MyPerson对象.查询Person还是返回Person类型的对象.The whole point of proxy objects is that code relying on the original Person will use those and your own code can use the extensions you included (that no other code is relying on anyway). It is not a way to replace the Person (or any other) model everywhere with something of your own creation.

• Base class restrictions
  一个代理模型必须继承自一个非抽象类,不能继承自多个非抽象类.一个代理模型能继承多个抽象模型类,如果他们没有定义任何模型字段.

• Proxy model managers
  如果你没有在代理模型里指定manager,它就会继承父模型的manager.如果你定义了manager,它就会变成末日呢的,虽然父类里定义的manager仍然可用.
  继续上面的例子,你可以查询Person模型时可以改变默认的manager:

from django.db import models

class NewManger(models.Manager):
    # ...
    pass

class MyPerson(Person):
    objects = NewManager()

    class Meta:
        proxy = True

如果你想给代理模型添加新的manager,而不代替默认的,你可以c使用ustom manager文档里介绍的技巧:新建一个基类包含新的manager,然后继承它.

# 为新manager创建一个抽象类.
class ExtraManagers(models.Model):
    secondary = NewManger()

    class Meta:
        abstract = True

class MyPerson(Person, ExtraMangers):
    class Meta:
        proxy = True

你可能很少需要这样用,但是当你需要时,这就很必要了.

• Differences between proxy inheritance and unmanaged models
  代理模型看起来很像是创建一个unmanaged模型,在模型的Meta类里使用managed属性.2种方案不一样,你得仔细考虑要使用哪一种.
  一个不同点是你可以(实际上是必须,除非你想要一个空模型)在Meta.managed=False的模型里指定模型字段.You could, with careful setting of Meta.db_table create an unmanaged model that shadowed an existing model and add Python methods to it. However, that would be very repetitive and fragile as you need to keep both copies synchronized if you make any changes.
  另一个对代理模型很重要的不同点是模型manager怎么处理.代理模型设计成就像它代理的模型一样运作.所以他们继承了父模型的manager,包含了默认的manager. In the normal multi-table model inheritance case, children do not inherit managers from their parents as the custom managers aren’t always appropriate when extra fields are involved.
  When these two features were implemented, attempts were made to squash them into a single option. It turned out that interactions with inheritance, in general, and managers, in particular, made the API very complicated and potentially difficult to understand and use. It turned out that two options were needed in any case, so the current separation arose.(这段话的意思是,反正情况很复杂)
  所以,通用规则是:
  
  1. 如果你想复制一个已有的模型或数据库表,但不是想要所有表字段,就使用Meta.managed=False.这个选项用于模型视图并且表不收django控制.
  2. 如果你想改变一个模型的python-only方法,但要保留和原始模型一样的的所有字段,使用Meta.proxy=True.这样的话,当数据保存时,代理模型就是一个原始模型的存储结构的拷贝.

Multiple inheritance

就像python的子类一样,django模型有可能继承自多个父模型.Keep in mind that normal Python name resolution rules apply.特殊名称(例如Meta)出现的第一个基类将会被使用;例如,如果多个父类都有Meta类,只有第一个会被使用,其他的会忽略.
通常,没有必要使用多继承.主要使用”mix-in”类:adding a particular extra field or method to every class that inherits the mix-in.尽量使你的继承关系简单明了,这样你就不会被数据到底是哪来的搞的头大了.

django1.7更改
在django1.7之前,继承自多个模型,并有一个id主键字段不会抛出异常,但是会导致数据丢失.例如,看看这些模型(因为冲突的id字段所以不再验证):

class Article(models.Model):
    headline = models.CharField(max_length=50)
    body = models.TextField()

class Book(models.Model):
    title = models.CharField(max_length=50)

class BookReview(Book, Article):
    pass

这个代码片段展示了怎么创建一个子对象,重写先前创建的父对象的值:

>>> article = Article.objects.create(headline='Some piece of news.')
>>> review = BookReview.objects.create(headline='Review of Little Red Riding Hood.', title='Little Red Riding Hood')
>>>
>>> assert Article.objects.get(pk=article.pk).headline == article.headline
Traceback (most recent call last):
  File "", line 1, in 
AssertionError
>>> # "Some piece of news."headline被重写了.
>>> Article.objects.get(pk=article.pk).headline
'Review of Little Red Riding Hood.'

为了正常使用多继承,你可以在基类中使用显式的AutoField:

class Article(models.Model):
    article_id = models.AutoField(primary_key=True)
    ...

class Book(models.Model):
    book_id = models.AutoField(primary_key=True)
    ...

class BookReview(Book, Article):
    pass

或者使用共同的父类来控制AutoField(Or use a common ancestor to hold the AutoField):

class Piece(models.Model):
    pass

class Article(Piece):
    ...

class Book(Piece):
    ...

class BookReview(Book, Article):
    ...

Field name “hiding” is not permitted

在普通的python类继承中,子类可以重写父类的任何属性.在django里,重写字段实例属性是不允许的(至少目前不允许).如果基类有个字段叫author,你不能在子类中创建一个字段叫author.
重写父类的字段涉及到很复杂的问题,比如初始化新实例(在Model.init里指定实例化哪个字段)和序列化.这些特性不能用普通的python类继承来处理,所以django模型继承和python类继承有很大的不同.
这个限制只针对于字段实例属性.普通的python属性可以被重写,如果你愿意. It also only applies to the name of the attribute as Python sees it:如果你手动指定了数据库字段名,在多表继承中,你能在子类和父类中看到相同的字段名出现(在2个不同的数据库表中的字段).
如果你重写父模型中的模型字段,django会抛出FieldError异常.

你可能感兴趣的:(django)

• Ubuntu18.04 Docker部署Kinship(Django)项目过程 Dante617
  1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
• 软件测试/测试开发/全日制 |利用Django REST framework构建微服务 霍格沃兹-慕漓 django微服务sqlite
  霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
• 锋哥写一套前后端分离Python权限系统 基于Django5+DRF+Vue3.2+Element Plus+Jwt 视频教程 ，帅呆了~~ java1234_小锋 Python权限系统django权限系统pythonweb权限系统djangoDRFVUE权限python
  大家好，我是java1234_小锋老师，最近写了一套【前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt】视频教程，持续更新中，计划月底更新完，感谢支持。视频在线地址：打造前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt视频教程（火爆连载更新中..）_哔哩哔哩_bilibili项目介绍本课程采
• 2.8.5Django --8.2 单表操作 寒暄_HX
  Django目录：https://www.jianshu.com/p/dc36f62b3dc5Yuan先生-Django模型层（1）Django与SQLAlchemy的ORM操作本质上是一样的，但是语法略有不同，如果是用Django进行开发最好使用原生的ORM或者直接使用原生SQL。创建表app06创建模型在app06中的models.py文件内，新建一个模板。one_exa.app06.mode
• 关于django中几个重要的gunicorn worker的配置 给我起把狙 djangogunicorn
  关于django中几个重要的gunicornworker的配置一、worker_classworker_class是Gunicorn的配置参数之一，它指定了工作进程（worker）的类型。不同的worker_class提供了不同的并发模型，适合不同类型的应用场景。sync和gevent是两种常见的worker_class，它们的作用和区别如下：1.sync（同步worker）默认值：如果没有指定w
• gunicorn未重启，导致代码没拉到最新问题。 给我起把狙 gunicornlinux运维
  问题描述：我的测试环境的django项目是用gunicorn启动的，然后我本地使用pythonmanagy.py启动的，新写了个接口，在本地测试没问题，在测试环境报404。我发现发了最新代码到远端，然后我在测试环境pull下来的时候出问题了，代码不是最新的，后来我的经理告诉我说要重启gunicorn的主进程给了我一条指令"kill-HUPgunicorn_pid(最小的)”，针对这个问题我大致做了
• python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 pythondjangoflaskjavaspringboot数据分析
  前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
• Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 javaspringboot数据分析pythondjangovue.jsflask
  前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
• 分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警) yjjpp2301 Celery分布式djangopython后端
  Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
• 基于django+vue代驾管理系统【开题报告+程序+论文】-计算机毕设 zhjie102 djangovue.js课程设计
  本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着城市化进程的加速和人们生活水平的提高，私家车数量急剧增加，但随之而来的酒驾问题也日益严峻，严重威胁着道路交通安全与公众生命财产安全。为了有效遏制酒驾行为，代驾服务应运而生并迅速普及。然而，当前市场上的代驾服务大多依赖于电话预约、人工调度等传统方式，存在效率低下
• Python+Django毕业设计校园易购二手交易平台（程序+LW+部署） Python、JAVA毕设程序源码 课程设计javamysql
  项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
• python毕业设计作品：python闲置物品二手交易平台系统设计与实现毕业设计源代码（Django框架） 黄菊华老师 毕设资料python二手交易平台系统
  博主介绍：黄菊华老师《Vue.js入门与商城开发实战》《微信小程序商城开发》图书作者，CSDN博客专家，在线教育专家，CSDN钻石讲师；专注大学生毕业设计教育和辅导。所有项目都配有从入门到精通的基础知识视频课程，学习后应对毕业设计答辩。项目配有对应开发文档、开题报告、任务书、PPT、论文模版等项目都录了发布和功能操作演示视频；项目的界面和功能都可以定制，包安装运行！！！如果需要联系我，可以在CSD
• 由于篇幅和复杂性限制，我无法在这里直接为你提供一个完整的、用多种编程语言实现的购物商城代码。但是，我可以为你概述如何使用几种流行的编程语言（如Python, JavaScript/Node.js, J NewmanEdwarda2 pythonjavascriptnode.js
  Python（后端，使用Flask或Django）Flask示例（后端API）gjijg.compythonfromflaskimportFlask,request,jsonifyapp=Flask(name)假设的数据库商品列表products=[{“id”:1,“name”:“苹果”,“price”:10.0},{“id”:2,“name”:“香蕉”,“price”:5.0},]@app.ro
• Django 安装指南 lly202406 开发语言
  Django安装指南Django是一个高级的PythonWeb框架，它鼓励快速开发和干净、实用的设计。本指南将详细介绍如何在不同的操作系统上安装Django，包括Windows、macOS和Linux。在Windows上安装Django先决条件Python:Django要求Python3.8或更高版本。可以从Python官网下载适用于Windows的Python安装程序。pip:Python的包管
• 基于Python爬虫四川成都二手房数据可视化系统设计与实现(Django框架) 研究背景与意义、国内外研究现状_django商品房数据分析论文(1) 莫莫Android开发 信息可视化python爬虫
  3.国外研究现状在国外，二手房数据可视化也是一个热门的研究领域。以美国为例，有很多公司和网站提供了专门的二手房数据可视化工具，如Zillow、Redfin等。这些工具通常提供房价趋势图、房价分布图、房源信息等功能，帮助用户更好地了解房市动态。综上所述，虽然国内外在二手房数据可视化方面已经有了一些研究成果，但对于四川成都地区的二手房市场还没有相关的研究和可视化系统。因此，本研究旨在设计并实现一个基于
• django中F()和Q()的用法 给我起把狙 django数据库python
  django中F()和Q()的用法一、F()表达式的详细介绍1.基本概念：F()表达式用于引用模型中的字段，允许你直接在数据库层面进行计算、比较或更新操作，而不需要将数据加载到Python内存中进行操作。这样可以提高性能，避免racecondition（数据竞争）。2.常见用法：1.字段间运算：你可以使用F()对同一记录中的不同字段进行运算。比如，你有一个模型Product，其中包含price和d
• Django 开发实战 2-2 模型 -创建模型类 爱之泪伤 python项目实战linuxubuntu网络
  python开发实战-创建模型类一、介绍：二、根据迁移文件生成映射书库据表。三、查看数据库是否根据牵引文件的需求生成数据库，因此返回终端去连接`filmdatabase`数据库。四、最后，了解一些数据库的知识说明。一、介绍：  模型类被创建在"应用目录/models.py"文件中。模型类必须继承自Model类，位于包dango.db.models中。接下来首先以"影片-人物"管理为例进行演示。1定
• Vue + Django的人脸识别系统 DXSsssss pythonDRFtensorflow人脸识别
  最近在研究机器学习，刚好最近看了vue+Djangodrf的一些课程，学以致用，做了一个人脸识别系统。项目前端使用Vue框架，用到了elementui组件，写起来真是方便。比之前传统的dtl方便了太多。后端使用了drf，识别知识刚开始打算使用opencv+tensorflow,但是发现吧识别以后的结果返回到浏览器当中时使用opencv比较麻烦（主要是我太菜，想不到比较好的方法），因此最终使用了tf
• Django 创建好的模块怎么在后台显示 u010373106 pythonDjangodjango数据库sqlite
  1、配置模型及其需要显示的数据刚才创建好的tests的增删改查，在后台是不显示的，所以需要进行配置,在刚才创建好的模块里找到admin.py文件，在里面进行如下配置fromdjango.contribimportadminfrom.importmodelsfrom.modelsimportTests#Registeryourmodelshere.classTestsAdmin(admin.Mode
• 【django】创建模型类(已更新) 敲代码敲到头发茂密 Django#ORM框架djangopython后端
  ORM框架一、创建模型类二、字段类型说明三、字段选项说明四、外键五、迁移六、添加测试数据a、数据库：需要提前手动创建数据库b、数据表：与ORM框架中的模型类一一对应c、字段：模型类中的类属性（Field子类）d、记录：类似于模型类的多个实例一、创建模型类模型类创建在应用目录/models.py文件中。模型类必须继承Model类，位于包django.db.models中。接下来首先以“影片-人物”管
• Django+Vue基于OpenCV的人脸识别系统的设计与实现 赵广陆 projectdjangovue.jsopencv
  目录1项目介绍2项目截图3核心代码3.1需要的环境3.2Django接口层3.3实体类3.4config.ini3.5启动类3.5Vue4数据库表设计5文档参考6计算机毕设选题推荐7源码获取1项目介绍博主个人介绍：CSDN认证博客专家，CSDN平台Java领域优质创作者，全网30w+粉丝，超300w访问量，专注于大学生项目实战开发、讲解和答疑辅导，对于专业性数据证明一切！主要项目：javaweb、
• Django核心面试题 闲人编程 程序员面试djangopython面试
  Django核心面试题Django核心面试题Django核心面试题1.Django的MVT架构是什么？2.如何创建Django项目和应用？3.DjangoORM是什么？4.什么是Django的middleware？举例说明。5.Django中的静态文件如何处理？6.如何定义Django模型？7.什么是Django的QuerySet？如何使用？8.如何进行Django的数据库迁移？9.Django中
• Django——多apps目录情况下的app注册 叫我DPT Django框架知识点djangopython
  文章目录多apps目录下的app注册方式1-添加python导包路径方式2-修改AppConfig类名多apps目录下的app注册方式1-添加python导包路径importsyssys.path.insert(0,str(BASE_DIR/"apps"))print(sys.path)INSTALLED_APPS=['django.contrib.admin','django.contrib.a
• Django项目中log日志的配置 叫我DPT Django项目中常用组件脚本功能djangologging
  文章目录日志配置模板日志处理器Handlers日志配置模板#日志LOGGING={'version':1,#使用的日志模块的版本，目前官方提供的只有版本1，但是官方有可能会升级，为了避免升级出现的版本问题，所以这里固定为1'disable_existing_loggers':False,#是否禁用其他的已经存在的日志功能？肯定不能，有可能有些第三方模块在调用，所以禁用了以后，第三方模块无法捕获自身
• Django：Python高级Web框架详解及参数设置 零 度° pythonpythondjango前端
  Django是一个高级的PythonWeb框架，它鼓励快速开发和简洁实用的设计。Django遵循MVC设计模式，提供了一套完整的解决方案，用于构建复杂的、数据库驱动的网站。Django的主要特点自动管理数据库：通过ORM（对象关系映射）自动管理数据库。自动生成站点地图：支持搜索引擎优化（SEO）。用户身份认证：内置用户认证系统。中间件支持：强大的中间件支持，可以处理请求和响应。跨站请求伪造（CSR
• Python轻量级ORM框架——peewee 半生浮名只是虚妄 Pythonpython
  这里写目录标题Python中常用的ORM框架peewee使用经验从数据库中导出模型查询统计类查询优化子查询参考文章Python中常用的ORM框架SQLALchemy：重量级框架，适合企业级开发，容易与任意Web框架集成，学习成本更高DjangoORM：Django框架中内嵌的ORM模块，易学易用，只适合Django项目使用peewee：轻量级框架，适合个人开发，容易与任意Web框架集成，API类似
• Ubuntu系统nginx和uwsgi常用命令(部署网站相关命令) 我不是大佬zvj ubuntulinux运维
  以下是我自己在学习使用Ubuntu操作系统部署pythonflask和django网站时常用的命令，作为学习笔记，记录一下，写的比较简单，还有啥需要补充的话欢迎留言。路径相关#进入项目路径cd /var/www/html/Podcaster#nginx配置文件路径‏/etc/nginx/sites-enabled/‌‍default防火墙#查看已经开放的端口sudoufwstatus#打开端口su
• 2025毕业设计指南：如何用Hadoop构建超市进货推荐系统？大数据分析助力精准采购 计算机编程指导师 Java实战集Python实战集大数据实战集课程设计hadoop数据分析springbootjava进货python
  ✍✍计算机编程指导师⭐⭐个人介绍：自己非常喜欢研究技术问题！专业做Java、Python、小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。⛽⛽实战项目：有源码或者技术上的问题欢迎在评论区一起讨论交流！⚡⚡Java实战|SpringBoot/SSMPython实战项目|Django微信小程序/安卓实战项目大数据实战项目⚡⚡文末获取源码文章目录⚡⚡文末获取源码基于hadoop的超市进货推荐系
• Python Web 框架篇：Flask、Django、FastAPI介绍及其核心技术 Switch616 PythonWebpython前端flaskfastapidjango开发语言后端
  PythonWeb框架篇：Flask、Django、FastAPI介绍及其核心技术目录FlaskFlask核心概念（路由、视图函数、模板渲染）FlaskBlueprint模块化应用Flask扩展（Flask-SQLAlchemy、Flask-WTF、Flask-Migrate等）DjangoDjango项目架构DjangoORM及模型定义Django中间件Django信号机制DjangoForm和
• python selenium post,是否可以在Selenium中捕获POST数据？ weixin_39600328 pythonseleniumpost
  I'mworkingwiththeSeleniumWebDriverToolandamwonderingifthistoolprovidesameansforcapturingthePOSTdatageneratedwhensubmittingaform.I'musingthedjangotestframeworktotestthatmydataisprocessedcorrectlyontheb
• 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其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.