Django模型层

转载作者：我是一只小鸟更新时间：2023-01-01 22:33:40

25

4

模型层与ORM
- 1、初步认识ORM
- 2、ORM常用关键字
- 3、ORM查询SQL语句的方法
- 4、神奇的双下划线查询
- 5、ORM外键字段创建
  - 1.ORM外键字段创建理论铺垫
  - 2.ORM外键字段创建相关操作
  - 2、多对多三种创建方式
- 6、多表查询(基于对象和双下划线)
  - 1.ORM跨表查询理论
  - 2.基于对象的跨表查询
  - 3.基于双下划线的跨表查询
  - 4.进阶操作
  - 5.补充说明
- 7、聚合查询
- 8、分组查询
- 9、F与Q查询
- 10、Q查询进阶操作
- 11、ORM查询优化
- 12、ORM批量操作数据(ORM操作优化)
- 十3、ORM事务操作
- 14、ORM常用字段
- 十5、ORM常用字段参数

模型层与ORM

1、初步认识ORM

1.什么是ORM 。

                        
                          对象关系映射

能够让不会SQL语句的python程序员
使用python面向对象的语法来操作数据库

优势>>>:简单方便快捷
劣势>>>:效率可能会低

2.概念对接。

                        
                          类 		   表
对象 		   一条条数据
对象点名字	 数据获取字段对应值

3.基本操作(增删改查) 。

                        
                          models.UserInfo.objects.create()  # insert into 增
models.UserInfo.objects.filter().delete()  # delete from 删
models.UserInfo.objects.filter().update()  # update 改
models.UserInfo.objects.filter()  # where 查

                        
                          from app01 import models


class Info(models.Model):
    # 字段名 = 字段类型 + 约束条件
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    age = models.IntergerField()

4.数据库迁移命令。

                        
                          python38 manage.py makemigrations  # 将操作记录到小本本上
python38 manage.py migirate  # 将操作同步到数据库上
'''每次在models.py中与数据相关的代码 都需要执行数据库迁移命令'''

2、ORM常用关键字

                        
                          # 关键概览
1.create()
2.filter()
3.first() last()
4.update()
5.delete()
6.all()
7.values()
8.values_list()
9.distinct()
10.order_by()
11.get()
12.exclude()
13.reverse()
14.count()
15.exists()

                        
                          # 1.create()  创建数据并直接当前创建的数据对象
res = models.UserInfo.objects.create(name='almra', age=24)

                        
                          # 2.filter() 根据条件筛选数据 结果是QuerySet [数据对象1，数据对象2]
res = models.UserInfo.objects.filter(name='amira')  # 括号没有写默认全部筛选 括号内支持多个条件 默认是and

                        
                          # 3.first() last()  QuerySet支持索引取值但只是支持正数 并且orm不建议使用索引
res = models.UserInfo.objencts.filter()[1]  # 查询到列表对应的数据 对应数据不存在会报错
res = models.UserInfo.objects.filter().first()  # 查询到列表第一个数据 对应数据不存在不会报错返回None

                        
                          # 4.update()  更新数据
res = models.UserInfo.objects.filetr().update()  # 批量更新
res = models.UserInfo.objects.filetr(id=1).update()  # 自定义更新

                        
                          # 5.delete()  删除数据(批量删除)
models.UserInfo.objects.filter().delete()  # 批量删除
models.UserInfo.objects.filter(id=1).delete()  # 单个删除

                        
                          # 6.all()  查询所有数据 结果是QuerySet [数据对象1,数据对象2]
res = models.UserInfo.objects.all()

                        
                          # 7.values()  根据指定字段获取数据    结果是QuerySet [{},{},{},{}]
res = models.UserInfo.objects.all().values('name')
res = models.UserInfo.objects.filter().values()
res = models.UserInfo.objects.values()

                        
                          # 8.values_list()  根据指定字段获取数据 结果是QuerySet [(),(),(),()]
res = models.UserInfo.objects.all().values_list('name','age')

                        
                          # 9.distinct()   去重 数据一定要一模一样才可以 如果有主键肯定不行
res = models.UserInfo.objects.values('name','age').distinct()

                        
                          # 10.order_by()  根据指定条件排序 默认是升序 字段前面加负号就是降序
res = models.UserInfo.objects.all().order_by('age')

                        
                          # 11.get()   根据条件筛选数据并直接获取到数据对象  一旦条件不存在会直接报错 不建议使用
res = models.UserInfo.objects.get(pk=1)

                        
                          # 12.exclude()  取反操作
res = models.UserInfo.objects.exclude(pk=1)

                        
                          # 13.reverse()  颠倒顺序(被操作的对象必须是已经排过序的才可以)
res1 = models.UserInfo.objects.all().order_by('age').reverse()

                        
                          # 14.count()  统计结果集中数据的个数
res = models.User.objects.all().count()

                        
                          # 15.exists()  判断结果集中是否含有数据 如果有则返回True 没有则返回False
res = models.User.objects.all().exists()

3、ORM查询SQL语句的方法

方式1：raw() 。

                        
                          models.User.objects.raw('select * from app01_user;')

方式2：cursor() 。

                        
                          from django.db import connection
cursor = connection.cursor()
cursor.execute('select name from app01_user;')
print(cursor.fetchall())

4、神奇的双下划线查询

                        
                          只要还是queryset对象就可以无限制的点queryset对象的方法
比如:queryset.filter().values().values_list().filter()....

1.查询年龄大于18岁的用户数据/年龄小于38岁的用户数据。

                        
                          res = models.Users.objects.filter(age__gt=18)  # 大于18岁
res = models.Users.objects.filter(age__lt=38)  # 小于18岁

2.查询年龄大于等于18岁的用户数据/年龄小于等于38岁的用户数据。

                        
                          res = models.Users.objects.filter(age__gte=18)  # 大于等于18岁
res = models.Users.objects.filter(age__lte=38)  # 小于等于18岁

3.查询年龄是18岁或28岁或38岁的用户数据。

                        
                          res = models.User.objects.filter(age__in=(18, 28, 38))

4.查询年龄在18岁到38岁之间所有用户数据。

                        
                          res = models.User.objects.filter(age__range=(18, 38))

5.查询名名字中含有字母j的用户数据。

                        
                          res = models.User.objects.filter(name__contains='j')  # 只查j不查J字母
res = models.User.objects.filter(name__incontains='j')  # J,j都会查出来

6.查询注册年份是2022年的用户数据。

                        
                          res = models.User.objects.filter(register_time__year=2022)

5、ORM外键字段创建

1.ORM外键字段创建理论铺垫

                        
                          MySQL外键关系
一对多:外键字段在多的一方
多对多:外键字段统一建在第三张关系表
一对一:建议放在查询频率较高的表

                        
                          ORM确定外键关系
一对多:外键字段在多的一方 跟MySQL一致
多对多:外键字段建在查询频率较高的表(内部自动创建第三张表) 
一对一:建议放在查询频率较高的表 跟MySQL一致

                        
                          ORM创建外键字段代码语句
针对一对多和一对一同步到表中之后会自动加_id的后缀
publish = models.ForeignKey(to='Publish',on_delete=models.CASCADE)
author_detail = models = models.OneToOneFiled(to='AuthorDetail', on_delete=models.CASCADE)
针对多对多不会在表中展示而是创建第三张表
authers = models.ManyToManyField(to='Author')

2.ORM外键字段创建相关操作

                        
                          # 针对一对多 插入数据可以直接填写表中的实际字段
models.Book.objects.create(title='编程基础教学', price=888.88, publish_id=1)
models.Book.objects.create(title='编程进阶教学', price=999.99, publish_id=1)
# 针对一对多 插入数据也可以填写表中的类中字段
publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.create(title='高级编程指导书', price=1000, publish=publish_obj)

                        
                          '''一对一与一对多 一致'''
既可以传数字也可以传对象
# 针对多对多关系绑定
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.add(1)  # 在第三张关系表中给当前书籍绑定作者
book_obj.authors.add(2, 3)
book_obj = models.Book.objects.filter(pk=4).first()
author_obj1 = models.Author.objects.filter(pk=1).first()
author_obj2 = models.Author.objects.filter(pk=2).first()
book_obj.authors.add(author_obj1)
book_obj.authors.add(author_obj1, author_obj2)
book_obj = models.Book.objects.filter(pk=1).first()

                        
                          book_obj.authors.set((1, 3))  # 修改关系
book_obj.authors.set([2, ])  # 修改关系
author_obj1 = models.Author.objects.filter(pk=1).first()
author_obj2 = models.Author.objects.filter(pk=2).first()
book_obj.authors.set((author_obj1,))
book_obj.authors.set((author_obj1, author_obj2))
book_obj.authors.remove(2)
book_obj.authors.remove(1, 3)
book_obj.authors.remove(author_obj1,)
book_obj.authors.remove(author_obj1,author_obj2)
book_obj.authors.clear()

2、多对多三种创建方式

                        
                          1.全自动创建
2.纯手动创建
3.半自动创建

                        
                          1.全自动创建
class Book(models.Model):
    title = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Authors', on_delete=models.CASCADE)
class Authors(models.Model):
    name = models.CharField(max_length=32)
    
# 优势:自动创建第三张表 并提供了add、remove、set、clear四种操作
# 劣势:第三张表无法创建更多的字段 扩展性比较差

                        
                          2.手动创建
class Book(models.Moldel):
    title = model.CharField(max_length=32)
class Author(models.Model):
    name = moldel.CharField(max_length=32)
class Book2Author(models.Model):
    book = models.ForeignKey(to='Book',on_delete=models.CASCADE)
    others = models.CharField(max_length=32)
    join_time = models.DateField(auto_now_add=True)
    
# 优势:第三张表自己创建 扩展性强
# 劣势:编写繁琐并不再支持add、remove、set、clear以及正反向概念

                        
                          3.半自动创建
class Book(models.Model):
    title = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author',
                                     through='Book2Author',
                                     through_fields=('book', 'author')
                                     )


class Author(models.Model):
    name = models.CharField(max_length=32)


class Book2Author(models.Model):
    book = models.ForeignKey(to='Book', on_delete=models.CASCADE)
    author = models.ForeignKey(to='Author', on_delete=models.CASCADE)
    others = models.CharField(max_length=32)
    join_time = models.DateField(auto_now_add=True)
    
# 优势:第三张表完全由自己创建 扩展性强 正反向概念依然清晰可用
# 劣势:编写繁琐不再支持add、remove、set、clear

                        
                          # 总结
add()\remove()	     多个位置参数(数字 对象)
set()			    可迭代对象(元组 列表) 数字 对象 
clear()			    情况当前数据对象的关系

6、多表查询(基于对象和双下划线)

1.ORM跨表查询理论

                        
                          MySQL跨表查询
子查询:分布操作(将一条SQL语句用括号括起来当作另外一条SQL语句的条件)
连表操作:先整合多张表之后基于单表查询即可('inner'/left/right/union join)

                        
                          正反向查询(重要)
正向:由外键字段所在的表数据查询关联的表查询
反向:无外键字段的表数据查询关联的表数据查询
# 技巧:核心就看外键字段在不在当前数据所在的表中

                        
                          ORM跨表查询口诀(重要)
正向查询按外键字段
反向查询按表名小写

2.基于对象的跨表查询

                        
                          # 1.查询主键为1的书籍对应的出版社名称
# 先根据条件获取数据对象
book_obj = models.Book.objects.filter(pk=1).first()
# 再判断正反向的概念  由书查出版社 外键字段在书所在的表中 所以是正向查询
print(book_obj.publish.name)

                        
                          # 2.查询主键为4的书籍对应的作者姓名
# 先根据条件获取数据对象
book_obj = models.Book.objects.filter(pk=4).first()
# 再判断正反向的概念  由书查作者 外键字段在书所在的表中 所以是正向查询
print(book_obj.authors)  # app01.Author.None
print(book_obj.authors.all())
print(book_obj.authors.all().values('name'))

                        
                          # 3.查询almira的电话号码
author_obj = models.Author.objects.filter(name='almira').first()
print(author_obj.author_detail.phone)

                        
                          # 4.查询北方出版社出版过的书籍
publish_obj = models.Publish.objects.filter(name='新疆维吾尔出版社').first()
print(publish_obj.book_set)  # app01.Book.None
print(publish_obj.book_set.all())

                        
                          # 5.查询almira写过的书籍
author_obj = models.Author.objects.filter(name='almira').first()
print(author_obj.book_set)  # app01.Book.None
print(author_obj.book_set.all())

                        
                          # 6.查询电话号码是18988998899的作者姓名
author_detail_obj = models.AuthorDetail.objects.filter(phone=18988998899).first()
print(author_detail_obj.author)
print(author_detail_obj.author.name)

3.基于双下划线的跨表查询

                        
                           # 1.查询主键为1的书籍对应的出版社名称
res = models.Book.objects.filter(pk=1).values('publish__name','title')
print(res)

                        
                          # 2.查询主键为4的书籍对应的作者姓名
res = models.Book.objects.filter(pk=4).values('title', 'authors__name')
print(res)

                        
                           # 3.查询almira的电话号码
res = models.Author.objects.filter(name='almira').values('author_detail__phone')
print(res)

                        
                          # 4.查询北方出版社出版过的书籍名称和价格
res = models.Publish.objects.filter(name='新疆维吾尔出版社').values('book__title','book__price','name')
print(res)

                        
                          # 5.查询almira写过的书籍名称
res = models.Author.objects.filter(name='almira').values('book__title', 'name')
print(res)

                        
                          # 6.查询电话号码是110的作者姓名
res = models.AuthorDetail.objects.filter(phone=110).values('phone', 'author__name')
print(res)

4.进阶操作

                        
                          # 1.查询主键为1的书籍对应的出版社名称
res = models.Publish.objects.filter(book__pk=1).values('name')
print(res)

                        
                          # 2.查询主键为4的书籍对应的作者姓名
res = models.Author.objects.filter(book__pk=4).values('name','book__title')
print(res)

                        
                          # 3.查询almira的电话号码
res = models.AuthorDetail.objects.filter(author__name='almira').values('phone')
print(res)

                        
                          # 4.查询北方出版社出版过的书籍名称和价格
res = models.Book.objects.filter(publish__name='新疆维吾尔出版社').values('title','price')
print(res)

                        
                          # 5.查询almira写过的书籍名称
res = models.Book.objects.filter(authors__name='almira').values('title')
print(res)

                        
                          # 6.查询电话号码是18988998899的作者姓名
res = models.Author.objects.filter(author_detail__phone=18988998899).values('name')
print(res)

5.补充说明

                        
                          # 查询主键为4的书籍对应的作者的电话号码
res = models.Book.objects.filter(pk=4).values('authors__author_detail__phone')
print(res)
res = models.AuthorDetail.objects.filter(author__book__pk=4).values('phone')
print(res)
res = models.Author.objects.filter(book__pk=4).values('author_detail__phone')
print(res)

7、聚合查询

                        
                          聚合函数:Max Min Sun Count Avg
在ORM中支持单独使用聚合函数 用关键字:aggregate
    
from django.db.models import Max, Min, Sum, Avg, Count
res = models.Book.objects.aggregate(Max('price'), Min('price'), Sum('price'), Avg('price'), Count('pk'))
print(res)

8、分组查询

                        
                          # 温馨提示来袭哟!
如果执行ORM分组查询报错 并且有关键字sql_mode strict mode 
移除sql_mode中的only_full_group_by 即可! 代码如下

set global sql_mode='stric_trans_tables';

1.统计每一本书的作者个数。

                        
                          res = models.Book.objects.annotate(author_num=Count('authors_pk')).values('title', 'author_num')
print(res)

2.统计出每个出版社卖出的最便宜的书的价格。

                        
                          res = models.Publish.objects.annotate(min_price=Min('book_price')).values('name', 'min_price')
print(res)

3.统计不止一个作者的书。

                        
                          # 1.先统计每本书作者个数
res = models.Book.objects.annotate(author_num=Count('author_pk'))
# 2.再从中筛选作者个数大于1的数据
res.filter(author_num_gt=1).values('title', 'author_num')

3.查询每个作者的书总价格。

                        
                          res = models.Author.objects.annotate(totalprice=Sum('book__price'),count_book=Count('book_pk')).values('name','totalprice','count_book')
print(res)

                        
                          # 按照表名分组
models.表名.objects.annotate()
# 按照values括号内指定的字段分组
models.表名.objects.values('字段名').annotate()

                        
                          res = models.Book.objects.values('publish_id').annotate(count_pk=Count('pk')).values('publish_id','count_pk')
print(res)

9、F与Q查询

                        
                          1.什么是F查询?
F查询:同一张表格的不同字段之间的查询
当查询条件不是明确的 也需要从数据库中获取 就需要使用F查询

                        
                          2.什么是Q查询?
Q查询:需要复杂的逻辑关系的时候使用Q查询
逗号默认是and,处理不了or not 这样的更复杂查询条件 这时Q查询用上排场了

                        
                          | 表示取或or
& 表示取且and
~ 表示取反not

1.查询库存数量大于卖出的书籍数量。

                        
                          from django.db.models import F
res = models.Book.objects.filter(stock__gt=F('sold'))
print(res)

2.将所有书的价格涨800 。

                        
                          from django.db.models import F
models.Book.objects.update(price=F(price) + 800)

3.将所有书的名称后面追加爆款。

                        
                          from django.db.models import F
from django.db.models.functions import Concat
from django.db.models import Value

models.Book.objects.update(title=Concat(F('title'),Value('爆款')))

4.查询主键是1或者大于2000的书籍。

                        
                          from django.db.models import Q
res = models.Book.objects.filter(Q(pk=1) | Q(price__gt=2000))

10、Q查询进阶操作

                        
                          from django.db.models import Q
q_obj = Q()  # 1.产生Q对象
q_obj.connector = 'or'  # 默认多个条件的连接是and可以修改为or
q_obj.children.append(('pk', 1))  # 2.添加查询条件
q_obj.children.append(('price__gt', 2000))  # 支持添加多个
res = models.Book.objects.filter(q_obj)  # 查询支持直接填写q对象
print(res)

11、ORM查询优化

1.ORM的查询默认都是惰性查询。

                        
                          如果你仅仅只是书写了ORM语句  没有用该语句所查询出来的参数
那么ORM会自动识别 直接不执行 这个性质可以提升效率 节省资源

2.ORM自带分页查询(limit) 。

                        
                          平时我们学习过程当中处理数据的量很少 我们没有注意到ORM自带的分页查询功能
将来在工作过程中要处理的数据上千万的  这个时候我们得关注一下ORM的分页查询 
如果没有分页查询功能那数据库内存也会  受不了的 直接回导致项目瘫痪 系统崩掉

3.only与defer 。

                        
                          res = models.Book.objects.only('title', 'price')  # only关键字查询详解
print(res)  # 结果是queryset对象[数据对象、数据对象]
for obj in res:
    print(obj.title)  # 点击括号内填写的字段 不走SQL查询语句
    print(obj.publish_time)  # 可以执行括号内没有的字段并获取数据 但是会走SQL查询语句

                        
                          res = models.Book.objects.defer('title', 'price')  # defer关键字查询详解
print(res)  # 结果是queryset对象[数据对象、数据对象]
for obj in res:
    print(obj.title)  # 点击括号内填写的字段 走SQL查询语句
    print(obj.publish_time)  # 点击括号内没有的字段获取数据 不会走SQL查询语句

4.selected_related与prefetch_related 。

                        
                          res = models.Book.objects.selected_related('authors')  # selected_related相当于连表查询 不支持多对多
for obj in res:
    print(res)

                        
                          res = models.Book.objects.prefetch_related('publish')  # prefetch_related相当于子查询
for obj in res:
    print(obj.publish.name)

12、ORM批量操作数据(ORM操作优化)

                        
                          关键字:
bulk_create()  # 批量创建数据
bulk_update()  # 批量更新数据

                        
                          def ab_bk_func(request):
    book_obj_list = []  # 可以用列表生成式[... for i in ... if ...] 
    for i in range(1, 100000):
        book_obj = models.Books01(title='第%s本书' % i)  # 单纯的用类名加括号产生对象
        book_obj_list.append(book_obj)
    models.Books01.objects.bulk_create(book_obj_list)  # 批量插入数据
    """使用orm提供的批量插入操作 5s 10万条左右"""
    book_queryset = models.Books01.objects.all()  # 查询出所有的表中并展示到前端页面
    return render(request, 'BkPage.html', locals())

十3、ORM事务操作

1.SQL事务相关理论知识。

                        
                          1.事务的四大特性(ACID)
    A(Atomicity 原子性)
    C(Consistency 一致性)
    I(Isolation 隔离性)
    D(Durability 持续性) 

2.相关SQL关键字
    start transaction;  # 启动事务
    rollback;  # 回退 回滚
    commit;  # 把事务保存到数据库
    savepoint;  # 在回滚中保存一个节点下次直接定位到此节点

3.相关SQL重要概念
    脏读:是指一个线程中的事务读取到了另外一个线程中未提交的数据
    幻读 :指一个线程中的事务读取到了另外一个线程中提交的insert的数据
    不可重复读: 是指一个线程中的事务读取到了另外一个线程中提交的update的数据
    MVCC多版本控制:是通过数据行的多个版本管理来实现数据库的并发控制

2.django orm 提供了三种开启事务方法。

                        
                          # 方法一:在配置文件里写如下代码 全局有效
'ATOMIC_REQUESTS':True

                        
                          # 方法二:装饰器 局部有效
from django.db import transation
@transaction.atomic
def index():pass

                        
                          # 方法三:with上下文管理  局部有效
from django.db import transation
def reg():
    with transaction.atomic():pass

14、ORM常用字段

                        
                          1.AutoFiled(primary_key=True)  # 主键
2.CharField(max_length=32)  # 字符
3.IntegerField  # 整型
4.BigIntegerField  # 大整型
5.DecimalField(max_digits=8, decimal_places=2)  # 十进制字段
6.DateField(auto_now, auto_now_add)	 # 年月日
7.DateTimeField(auto_now, auto_now_add)  # 年月日时分秒
8.BooleanField  # 传布尔值自动存0或1
9.TextField  # 存储大段文本
10.EmailField  # 存储邮件格式数据
11.FileField  # 传文本对象 自动保存到提前配置好的路径下并保存路径信息

                        
                          # 可以自定义字段
class MyCharField(models.Field):
    def __init__(self,max_length, *args, **kwargs):
        self.max_length = max_length
        super().__init__(max_length=manx_length, *args, **kwargs)
        
    def db_type(self, connection):
        return 'char(%s)' % self.max_length
    
    
class User(models.Model):
    name = models.CharField(max_length=32)
    info = MyCharField(max_length=64)

十5、ORM常用字段参数

                        
                          primary_key  # 主键
verbose_name  # 注释
max_length  # 字段长度
max_digits  # 小数总共多少位
decimal_places  # 小数点后面的位数
auto_now  # 每次操作数据自动更新事件
auto_now_add  # 首次创建自动更新事件 后续不会自动更新
null  # 允许字段为空
default  # 字段默认值
unique  # 唯一值
db_index  # 给字段添加索引
choices  # 当某个字段的可能性能被列举完全的情况下使用

                        
                          外键字段
to  #关联表
to_field  # 关联字段
on_delete=models.CASCADE  # 级联操作 当主表删除一条数据 从表关联数据同时被删除
on_delete=models.SET_NULL  # 当主表删除一条数据 从表关联字段设置为null 定义外键必须可以允许为空
on_delete=models.PROTECT  # 当主表删除一条数据 从表关联字段是受保护的外键 所以都不允许删除
on_delete=models.SET_DEFAULT  # 当主表删除一条数据 从表关联字段设置为默认值 定义外键必须有一个默认值
on_delete=models.SET()  # 当主表删除一条数据 从表关联字段设置为SET()中设置的值
on_delete=models.DO_NOTHING  # 什么都不做 一切都看数据库级别的约束

                        
                          # 详细说一下choices参数 因为在项目里常用
class User(models.Model):
    name = models.CharField(max_length=32)
    info = MyCharField(max_length=64)
    gender_choice = (
         (1, '男性')
         (2, '女性')
         (3, '其他')
    )
    gender = models.IntegerField(choices=gender_choice,null=True)
user_obj = User.objects.filter(pk=1).first()
user_obj.gender
user_obj.get_gender_display()

最后此篇关于Django模型层的文章就讲到这里了,如果你想了解更多关于Django模型层的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

25

4

0

文章推荐：【博学谷学习记录】超强总结，用心分享|前端CSS总结（一）

文章推荐：关于微服务，这些你都了解吗-微服务介绍

文章推荐： C#开发的线程池和管理器-开源研究系列文章

文章推荐：贪心算法Dijkstra

c# - Mvvm 模型 View 模型
可不可以命名为MVVM模型？因为View通过查看模型数据。 View 是否应该只与 ViewModelData 交互？我确实在某处读到正确的 MVVM 模型应该在 ViewModel 而不是 Mode
javascript - 模型 -> 观察者 -> View -> Controller -> 模型 ->
我正在阅读有关设计模式的文章，虽然作者们都认为观察者模式很酷，但在设计方面，每个人都在谈论 MVC。我有点困惑，MVC 图不是循环的，代码流具有闭合拓扑不是很自然吗？为什么没有人谈论这种模式: mo
c# - WPF 中的便笺项目。模型、 View 、 View 模型
我正在开发一个 Sticky Notes 项目并在 WPF 中做 UI，显然将 MVVM 作为我的架构设计选择。我正在重新考虑我的模型、 View 和 View 模型应该是什么。我有一个名为 Not
C# 根据模型中的枚举属性将列表<模型> 转换为字典<枚举，列表<模型>>？
不要混淆:How can I convert List to Hashtable in C#? 我有一个模型列表，我想将它们组织成一个哈希表，以枚举作为键，模型列表(具有枚举的值)作为值。 publi
c# - 实体 vs 模型 vs View 模型
我只是花了一些时间阅读这些术语(我不经常使用它们，因为我们没有任何 MVC 应用程序，我通常只说“模型”)，但我觉得根据上下文，这些意味着不同的东西: 实体这很简单，它是数据库中的一行: 2) In
c# - 在大型应用程序中使用 MVVM - 共享 View 模型、模型、状态等
我想知道你们中是否有人知道一些很好的教程来解释大型应用程序的 MVVM。我发现关于 MVVM 的每个教程都只是基础知识解释(如何实现模型、 View 模型和 View )，但我对在应用程序页面之间传递
swift - 清除 Realm 中除一种对象类型(模型)之外的所有对象类型(模型)的方法
我想realm.delete() 我的 Realm 中除了一个模型之外的所有模型。有什么办法可以不列出所有这些吗？也许是一种遍历 Realm 中当前存在的所有类型的方法？最佳答案您可以从您的 R
php - Mocking Laravel Eloquent 模型 - AppServiceProvider 中使用的 Mocking 模型
我正在尝试使用 alias 指令模拟一个 Eloquent 模型，如下所示: $transporter = \Mockery::mock('alias:' . Transporter::class)
R Stargazer 与 pglm 模型 - 在 plm 模型中转换二项式 pglm 模型
我正在使用 stargazer 创建我的 plm 汇总表。 library(plm) library(pglm) data("Unions", package = "pglm") anb1 <- pl
ASP.NET MVC + EF 4.1 分层、模型、 View 模型
我读了几篇与 ASP.NET 分层架构相关的文章和问题，但是读得太多后我有点困惑。 UI 层是在 ASP.NET MVC 中开发的，对于数据访问，我在项目中使用 EF。我想通过一个例子来描述我的问题
ios -/ml 模型/Inception V3.ml 模型 : unable to read document
我收到此消息错误: Inceptionv3.mlmodel: unable to read document 我下载了最新版本的 xcode。 9.4 版测试版 (9Q1004a) 最佳答案您没有
c# - ASP.NET MVC3 Automapper View 模型/模型 View 验证
(同样，一个 MVC 验证问题。我知道，我知道......) 我想使用 AutoMapper ( http://automapper.codeplex.com/ ) 来验证我的创建 View 中不在我
android - 如何使用 sharedview 模型 koin android 注入(inject)具有作用域的 View 模型
需要澄清一件事，现在我正在处理一个流程，其中我有两个 View 模型，一个依赖于另一个 View 模型，为了处理这件事，我尝试在我的基本 Activity 中注入(inject)两个 View 模型，
wpf - 如何在 Window.Resources 标签中使用带有数据绑定(bind)的 View 模型、模型、命令类？
如果 WPF MVVM 应该没有代码，为什么在使用 ICommand 时，是否需要在 Window.xaml.cs 代码中实例化 DataContext 属性？我已经并排观看并关注了 YouTube
asp.net - 模型-存储库-服务-验证器- View - View 模型- Controller 设计模式(？)
当我第一次听说 ASP.NET MVC 时，我认为这意味着应用程序由三个部分组成:模型、 View 和 Controller 。然后我读到 NerdDinner并学习了存储库和 View 模型的方法
python - 如何使用 mmconvert 将 tensorflow 模型(InceptionResnetV2 pb 文件)转换为 pytorch 模型？
Platform : ubuntu 16.04 Python version: 3.5.2 mmdnn version : 0.2.5 Source framework with version :
swift - 在 super.init 初始化 self super.init 之前，在属性访问 'self' 中使用 'model'(品牌 : brand, 模型:模型)
我正在学习本教程:https://www.raywenderlich.com/160728/object-oriented-programming-swift ...并尝试对代码进行一些个人调整，看看
AngularJS 模型
我正试图围绕 AngularJS。我很喜欢它，但一个核心概念似乎在逃避我——模型在哪里？例如，如果我有一个显示多个交易列表的应用程序。一个列表向服务器查询匹配某些条件的分页事务集，另一个列表使用不同
模型、业务规则和持久性
我在为某个应用程序找出最佳方法时遇到了麻烦。我不太习惯取代旧 TLA(三层架构)的新架构，所以这就是我的来源。在为我的应用程序(POCO 类，对吧？？)设计模型和 DAL 时，我有以下疑问: 我的模
Django - 模型 - 如何描述两个模型之间的特定双向关系？
我有两个模型:Person 和 Department。每个人可以在一个部门工作。部门可以由多人管理。我不确定如何在 Django 模型中构建这种关系。这是我不成功的尝试之一 [models.py]:

首页

博学

6Ren·AI

商城

Django模型层

模型层与ORM

1、初步认识ORM

2、ORM常用关键字

3、ORM查询SQL语句的方法

4、神奇的双下划线查询

5、ORM外键字段创建

1.ORM外键字段创建理论铺垫

2.ORM外键字段创建相关操作

2、多对多三种创建方式

6、多表查询(基于对象和双下划线)

1.ORM跨表查询理论

2.基于对象的跨表查询

3.基于双下划线的跨表查询

4.进阶操作

5.补充说明

7、聚合查询

8、分组查询

9、F与Q查询

10、Q查询进阶操作

11、ORM查询优化

12、ORM批量操作数据(ORM操作优化)

十3、ORM事务操作

14、ORM常用字段

十5、ORM常用字段参数

首页

博学

6Ren·AI

商城

Django模型层

模型层与ORM

﻿1、初步认识ORM

2、ORM常用关键字

3、ORM查询SQL语句的方法

4、神奇的双下划线查询

5、ORM外键字段创建

1.ORM外键字段创建理论铺垫

2.ORM外键字段创建相关操作

2、多对多三种创建方式

6、多表查询(基于对象和双下划线)

1.ORM跨表查询理论

2.基于对象的跨表查询

3.基于双下划线的跨表查询

4.进阶操作

5.补充说明

7、聚合查询

8、分组查询

9、F与Q查询

10、Q查询进阶操作

11、ORM查询优化

12、ORM批量操作数据(ORM操作优化)

十3、ORM事务操作

14、ORM常用字段

十5、ORM常用字段参数

1、初步认识ORM