#### 1. **Django 中的 Form 功能**
Django 中的 `Form` 有两大核心功能：
- **输入 HTML**：通过 `Form` 类的定义，可以生成相应的 HTML 表单元素，供用户输入数据。
- **验证用户输入**：对用户提交的表单数据进行验证，确保符合规则。

##### 选择 Form 还是 ModelForm 取决于你的具体需求：
- 如果你的表单与数据库模型紧密相关，且希望简化字段的创建和数据的保存，使用 ModelForm。
- 如果你的表单与模型无关，或者你需要更高级的自定义，那么使用 Form 更合适。



#### 2. **Form 示例代码**

```python
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
from django import forms
from django.core.exceptions import ValidationError

# 自定义验证函数，验证手机号格式
def mobile_validate(value):
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
    if not mobile_re.match(value):
        raise ValidationError('手机号码格式错误')

# 定义表单类
class PublishForm(forms.Form):

    user_type_choice = (
        (0, u'普通用户'),
        (1, u'高级用户'),
    )

    user_type = forms.IntegerField(
        widget=forms.widgets.Select(choices=user_type_choice, attrs={'class': "form-control"})
    )

    title = forms.CharField(
        max_length=20,
        min_length=5,
        error_messages={
            'required': u'标题不能为空',
            'min_length': u'标题最少为5个字符',
            'max_length': u'标题最多为20个字符'
        },
        widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'标题5-20个字符'})
    )

    memo = forms.CharField(
        required=False,
        max_length=256,
        widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'详细描述', 'rows': 3})
    )

    phone = forms.CharField(
        validators=[mobile_validate],
        error_messages={'required': u'手机不能为空'},
        widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'手机号码'})
    )

    email = forms.EmailField(
        required=False,
        error_messages={'required': u'邮箱不能为空', 'invalid': u'邮箱格式错误'},
        widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'})
    )
```

#### 3. **视图函数处理表单提交**
在视图函数中，处理表单提交并返回相应的 JSON 响应。

```python
import json
from django.http import HttpResponse
from .forms import PublishForm

def publish(request):
    ret = {'status': False, 'data': '', 'error': '', 'summary': ''}
    if request.method == 'POST':
        request_form = PublishForm(request.POST)
        if request_form.is_valid():
            request_dict = request_form.clean()
            print(request_dict)  # 打印验证后的数据
            ret['status'] = True
        else:
            error_msg = request_form.errors.as_json()
            ret['error'] = json.loads(error_msg)
    return HttpResponse(json.dumps(ret))
```

#### 4. **扩展：ModelForm**
通过 `ModelForm` 可以简化表单和模型字段的定义，直接从模型中生成表单。

- 在使用 `Model` 和 `Form` 时，都需要对字段进行定义并指定类型；而通过 `ModelForm`，可以省去 `Form` 中字段的定义，直接从模型中获取。

##### **ModelForm 示例代码**
```python
from django import forms
from . import models

class AdminModelForm(forms.ModelForm):

    class Meta:
        model = models.Admin  # 绑定到 Admin 模型
        # fields = '__all__'  # 表示生成模型的所有字段
        fields = ('username', 'email')  # 只生成指定字段

        widgets = {
            'email': forms.PasswordInput(attrs={'class': "alex"}),
        }
```

#### 5. **总结**
- `Form` 适合用于自定义的表单，需要手动定义字段和验证规则。
- `ModelForm` 通过与数据库模型的绑定，可以自动生成表单，简化字段的定义和验证。

#### 表单流程总结表格

| **功能**         | **Form**                                           | **ModelForm**                                      |
|------------------|----------------------------------------------------|----------------------------------------------------|
| **字段定义**     | 手动定义字段及其验证规则。                          | 从模型中自动生成字段，并继承模型的验证规则。        |
| **数据验证**     | 需要手动编写验证规则，可以使用 `validators`。          | 自动继承模型中的验证规则，可以额外定义验证。        |
| **HTML 生成**    | 使用 `widgets` 属性自定义表单元素的 HTML 外观。       | 也可以使用 `widgets` 自定义字段的表单元素。         |
| **保存数据**     | 需要手动编写保存逻辑。                               | 提供 `save()` 方法，直接保存数据到数据库。          |
| **使用场景**     | 适用于自定义字段和不直接与数据库交互的表单。           | 适用于基于数据库模型进行创建、更新数据的表单。

Django Form 与 ModelForm 的学习整理

### Django 分页功能整理

分页是网站中常见的功能，用于将数据拆分成多页显示。以下是实现分页的详细步骤及示例代码。

#### 分页流程
1. **设定每页显示数据条数**
   - 确定每页展示多少条数据，如每页显示5条。
   
2. **用户输入页码**
   - 用户通过分页按钮选择页码（如第一页、第二页等）。

3. **计算起始位置**
   - 根据设定的每页显示条数和当前页码，计算数据在数据库中的起始位置。

4. **查询数据库**
   - 根据起始位置查询对应页码的数据。

5. **生成分页导航**
   - 根据当前页和总页数，生成分页按钮，如 `[上一页][1][2][3][4][5][下一页]`。



#### 示例代码

##### 1. **创建分页处理类**

```python
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from django.utils.safestring import mark_safe

class PageInfo(object):
    def __init__(self, current, totalItem, peritems=5):
        """
        :param current: 当前页码
        :param totalItem: 数据总条数
        :param peritems: 每页显示条数（默认 5 条）
        """
        self.__current = current
        self.__peritems = peritems
        self.__totalItem = totalItem

    # 获取数据表中的起始位置
    def From(self):
        return (self.__current - 1) * self.__peritems

    # 获取数据表中的结束位置
    def To(self):
        return self.__current * self.__peritems

    # 计算总页数
    def TotalPage(self):
        result = divmod(self.__totalItem, self.__peritems)
        if result[1] == 0:
            return result[0]
        else:
            return result[0] + 1
```

##### 2. **生成分页 HTML 导航**

```python
def Custompager(baseurl, currentPage, totalpage):
    perPager = 11  # 设置每页显示 11 个页码按钮
    begin = 0
    end = 0

    # 如果总页数小于 11，显示全部页码
    if totalpage <= 11:
        begin = 0
        end = totalpage
    else:
        # 当前页大于 5，显示以当前页为中心的分页
        if currentPage > 5:
            begin = currentPage - 5
            end = currentPage + 5
            if end > totalpage:
                end = totalpage
        else:
            begin = 0
            end = 11

    pager_list = []

    # 首页按钮
    if currentPage <= 1:
        first = "<a href=''>首页</a>"
    else:
        first = "<a href='%s%d'>首页</a>" % (baseurl, 1)
    pager_list.append(first)

    # 上一页按钮
    if currentPage <= 1:
        prev = "<a href=''>上一页</a>"
    else:
        prev = "<a href='%s%d'>上一页</a>" % (baseurl, currentPage - 1)
    pager_list.append(prev)

    # 中间页码按钮
    for i in range(begin + 1, end + 1):
        if i == currentPage:
            temp = "<a href='%s%d' class='selected'>%d</a>" % (baseurl, i, i)
        else:
            temp = "<a href='%s%d'>%d</a>" % (baseurl, i, i)
        pager_list.append(temp)

    # 下一页按钮
    if currentPage >= totalpage:
        next = "<a href='#'>下一页</a>"
    else:
        next = "<a href='%s%d'>下一页</a>" % (baseurl, currentPage + 1)
    pager_list.append(next)

    # 末页按钮
    if currentPage >= totalpage:
        last = "<a href=''>末页</a>"
    else:
        last = "<a href='%s%d'>末页</a>" % (baseurl, totalpage)
    pager_list.append(last)

    # 将分页按钮拼接成 HTML 代码
    result = ''.join(pager_list)
    return mark_safe(result)  # 将字符串标记为安全的 HTML
```

##### 3. **视图函数中处理分页逻辑**

```python
from django.shortcuts import render
from .models import MyModel
from .pagination import PageInfo, Custompager

def my_view(request):
    current_page = int(request.GET.get('page', 1))  # 获取当前页码，默认为第一页
    total_items = MyModel.objects.count()  # 获取数据总条数
    page_info = PageInfo(current_page, total_items, peritems=5)  # 实例化分页对象

    # 查询当前页的数据
    data_list = MyModel.objects.all()[page_info.From():page_info.To()]

    # 生成分页 HTML
    pager = Custompager('/myview/?page=', current_page, page_info.TotalPage())

    return render(request, 'my_template.html', {'data_list': data_list, 'pager': pager})
```

#### 4. **模板显示分页**

在模板中输出分页导航条：

```html
<div>
    {% for item in data_list %}
        
        <p>{{ item.name }}</p>
    {% endfor %}
</div>

<div class="pagination">
    {{ pager }}
</div>
```

### 分页功能总结

1. **创建处理分页数据的类**：`PageInfo` 类负责计算数据的起始和结束位置以及总页数。
2. **根据分页数据获取数据**：视图函数根据当前页和每页条数，从数据库中获取对应页的数据。
3. **输出分页 HTML**：通过 `Custompager` 函数生成分页按钮的 HTML 代码，并在页面上渲染。

这种方式可以灵活控制分页展示方式，满足分页功能的需求，如显示页码范围、上一页/下一页、首页/末页按钮等。

Django 分页功能整理

# 经常使用到的
## 安装第三方模块

```
pip install mysqlclient
```

## 自己创建数据库

- 启动MySQL服务

- 自带工具创建数据库

  ```
  create database database_name DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
  ```
  
## django连接数据库

在settings.py文件中进行配置和修改。

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'database_name',  # 数据库名字
        'USER': 'root',
        'PASSWORD': 'root123',
        'HOST': '127.0.0.1',  # 那台机器安装了MySQL
        'PORT': 3306,
    }
}
```



# 数据库操作

- MySQL数据库 + pymysql

  ```python
  import pymysql
  
  # 1.连接MySQL
  conn = pymysql.connect(host="127.0.0.1", port=3306, user='root', passwd="root123", charset='utf8', db='unicom')
  cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
  
  # 2.发送指令
  cursor.execute("insert into admin(username,password,mobile) values('wupeiqi','qwe123','15155555555')")
  conn.commit()
  
  # 3.关闭
  cursor.close()
  conn.close()
  ```

- Django开发操作数据库更简单，内部提供了ORM框架。

![image-20211124151748712.png](/static/img/1383ceabebe61654b0c2c30c1478ff9f.image-20211124151748712.webp)


### 7.1 安装第三方模块

```
pip install mysqlclient
```

![image-20211124152339567.png](/static/img/64a50e4bd0fcad372fae9954ec5528a0.image-20211124152339567.webp)

## 1. 自己创建数据库

- 启动MySQL服务

- 自带工具创建数据库

  ```
  create database database_name DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
  ```

![image-20211124153042996.png](/static/img/0469ca011d861a9167faf4e416755d64.image-20211124153042996.webp)

## 2. django连接数据库

在settings.py文件中进行配置和修改。

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'gx_day15',  # 数据库名字
        'USER': 'root',
        'PASSWORD': 'root123',
        'HOST': '127.0.0.1',  # 那台机器安装了MySQL
        'PORT': 3306,
    }
}
```

![image-20211124154030823.png](/static/img/8c2a4d54d14b57bb1567cbc81b535d78.image-20211124154030823.webp)

## 3.django操作表

- 创建表
- 删除表
- 修改表

创建表：在models.py文件中

![image-20211124154658774.png](/static/img/b2909c458393303237e030456f5bd4d8.image-20211124154658774.webp)

```sql
create table app01_userinfo(
    id bigint auto_increment primary key,
    name varchar(32),
    password varchar(64),
    age int
)
```



执行命令：

```
python3.9 manage.py makemigrations
python3.9 manage.py migrate
```

注意：app需要提前注册。

![image-20211124155407018.png](/static/img/81c6225716bcb4f92cfc2351653830aa.image-20211124155407018.webp)

在表中新增列时，由于已存在列中可能已有数据，所以新增列必须要指定新增列对应的数据：

- 1，手动输入一个值。

- 设置默认值

  ```
  age = models.IntegerField(default=2)
  ```

- 允许为空

  ```
  data = models.IntegerField(null=True, blank=True)
  ```





以后在开发中如果想要对表结构进行调整：

- 在models.py文件中操作类即可。

- 命令

  ```
  python3.9 manage.py makemigrations
  python3.9 manage.py migrate
  ```

## 4.表中的数据

```python

# #### 1.新建 ####
# Department.objects.create(title="销售部")
# Department.objects.create(title="IT部")
# Department.objects.create(title="运营部")
# UserInfo.objects.create(name="武沛齐", password="123", age=19)
# UserInfo.objects.create(name="朱虎飞", password="666", age=29)
# UserInfo.objects.create(name="吴阳军", password="666")

# #### 2.删除 ####
# UserInfo.objects.filter(id=3).delete()
# Department.objects.all().delete()

# #### 3.获取数据 ####
# 3.1 获取符合条件的所有数据
# data_list = [对象,对象,对象]  QuerySet类型
# data_list = UserInfo.objects.all()
# for obj in data_list:
#     print(obj.id, obj.name, obj.password, obj.age)

# data_list = [对象,]
# data_list = UserInfo.objects.filter(id=1)
# print(data_list)
# 3.1 获取第一条数据【对象】
# row_obj = UserInfo.objects.filter(id=1).first()
# print(row_obj.id, row_obj.name, row_obj.password, row_obj.age)


# #### 4.更新数据 ####
# UserInfo.objects.all().update(password=999)
# UserInfo.objects.filter(id=2).update(age=999)
# UserInfo.objects.filter(name="朱虎飞").update(age=999)
```

Django数据库操作

# 项目结构

![image.png](/static/img/c145e254a25023f5e31279431599fbc5.image.webp)

# 微服务架构下部署的问题
1. 由于服务 + 中间件的复杂度，导致部署复杂度也呈指数级上升  
2. 服务与服务之间的依赖关系  
3. 服务之间的网络共享问题  
4. 考虑有状态服务的数据持久化问题

**问题一：** 利用 docker-compose 的服务编排能力，来实现对多服务的批量化处理

**问题二：** 利用 docker-compose 的 depends_on 属性，来设置依赖服务，必须按依赖服务先启动，当前服务才能启动

**问题三：** 利用自定义网络，或者 links 属性来连接需要通信的服务

**问题四：** 使用数据持卷来进行持久化的数据管理



# 部署流程
## 容器编排
> docker-compose

## Dockerfile 编写
> 针对每一个服务都需要编写自定义的 Dockerfile，需要对所有服务的 Dockerfile 文件进行一个统一的管理。

## 网络问题
> 自定义网络，或者利用 links 属性，将两个容器连接起来，以上两种方案都可以实现基于容器名称的访问

## 日志收集问题
> ELK：利用 Lagstash 或 FileBeat 进行数据收集，将数据存入 ES，通过 Kibana 进行统一的数据可视化展示

## 监控问题
> 应用/容器监控，健康状况、资源使用情况都需要进行监控，基于普罗米修斯实现各个类型的监控

# Dockercompose文件解析
下面是带有详细注释的 `docker-compose.yml` 文件，每个部分的注释直接写在 YAML 文件中，方便阅读和理解。

```yaml
version: '2.4'  # 使用 Docker Compose 文件的版本 2.4

services:  # 定义所有服务

  # Nacos 服务
  trip-nacos:
    container_name: trip-nacos  # 指定容器名称为 trip-nacos
    image: nacos/nacos-server  # 使用官方 Nacos 镜像
    build:
      context: ./nacos  # 构建上下文为本地 nacos 目录
    environment:
      - MODE=standalone  # 环境变量，设置 Nacos 以单机模式运行
    volumes:
      - ./nacos/logs/:/home/nacos/logs  # 将主机的日志目录挂载到容器中
      - ./nacos/conf/application.properties:/home/nacos/conf/application.properties  # 挂载自定义配置文件
    ports:
      - "8848:8848"  # 映射 Nacos 默认的 8848 端口，用于服务注册
      - "9848:9848"  # 用于 Nacos 服务监控
      - "9849:9849"  # 用于 Nacos RPC 通信
    depends_on:
      - trip-mysql  # Nacos 依赖 MySQL 服务，确保 MySQL 在 Nacos 之前启动

  # MySQL 数据库服务
  trip-mysql:
    container_name: trip-mysql  # 指定容器名称为 trip-mysql
    image: mysql:5.7  # 使用官方 MySQL 5.7 镜像
    build:
      context: ./mysql  # 构建上下文为本地 mysql 目录
    ports:
      - "3306:3306"  # 映射 MySQL 默认的 3306 端口，用于数据库访问
    volumes:
      - ./mysql/conf:/etc/mysql/conf.d  # 挂载自定义 MySQL 配置目录
      - ./mysql/logs:/logs  # 挂载日志目录以持久化日志数据
      - ./mysql/data:/var/lib/mysql  # 持久化数据库数据到主机
    command: [
      'mysqld',  # 启动 MySQL 服务
      '--innodb-buffer-pool-size=80M',  # 设置 InnoDB 缓冲池大小为 80M
      '--character-set-server=utf8mb4',  # 使用 UTF-8 字符集
      '--collation-server=utf8mb4_unicode_ci',  # 设置字符排序规则
      '--default-time-zone=+8:00',  # 设置默认时区为东八区
      '--lower-case-table-names=1'  # 表名不区分大小写
    ]
    environment:
      MYSQL_DATABASE: 'trip-cloud'  # 设置数据库名称为 trip-cloud
      MYSQL_ROOT_PASSWORD: 'admin'  # 设置 root 用户密码为 admin

  # Redis 缓存服务
  trip-redis:
    container_name: trip-redis  # 指定容器名称为 trip-redis
    image: redis  # 使用官方 Redis 镜像
    build:
      context: ./redis  # 构建上下文为本地 redis 目录
    ports:
      - "6379:6379"  # 映射 Redis 默认的 6379 端口
    volumes:
      - ./redis/conf/redis.conf:/home/trip/redis/redis.conf  # 挂载自定义 Redis 配置文件
      - ./redis/data:/data  # 持久化 Redis 数据到主机
    command: redis-server /home/trip/redis/redis.conf  # 通过自定义配置文件启动 Redis 服务

  # Website 服务 (Nginx)
  trip-website:
    container_name: trip-website  # 指定容器名称为 trip-website
    image: nginx  # 使用官方 Nginx 镜像
    build:
      context: ./website  # 构建上下文为本地 website 目录
    ports:
      - "80:80"  # 映射 Nginx 默认的 80 端口，用于网站访问
    volumes:
      - ./website/html/dist:/home/trip/projects/trip-ui  # 挂载静态网站资源目录
      - ./website/conf/nginx.conf:/etc/nginx/nginx.conf  # 挂载自定义 Nginx 配置文件
      - ./website/logs:/var/log/nginx  # 持久化 Nginx 日志
      - ./website/conf.d:/etc/nginx/conf.d  # 挂载自定义的 Nginx 虚拟主机配置
    depends_on:
      - trip-gateway  # 确保网关服务在 Website 服务之前启动
    links:
      - trip-gateway  # 通过链接的方式连接网关服务，方便通信

  # Gateway 网关服务
  trip-gateway:
    container_name: trip-gateway  # 指定容器名称为 trip-gateway
    build:
      context: ./trip/gateway  # 构建上下文为本地 gateway 目录
      dockerfile: dockerfile  # 使用指定的 Dockerfile 构建镜像
    ports:
      - "9000:9000"  # 映射网关服务的 9000 端口
    depends_on:
      - trip-redis  # 确保 Redis 服务在网关服务之前启动
    links:
      - trip-redis  # 通过链接的方式连接 Redis 服务

  # User 用户服务
  trip-user:
    container_name: trip-user  # 指定容器名称为 trip-user
    build:
      context: ./trip/user  # 构建上下文为本地 user 目录
      dockerfile: dockerfile  # 使用指定的 Dockerfile 构建镜像
    ports:
      - "9200:9200"  # 映射用户服务的 9200 端口
    depends_on:
      - trip-redis  # 确保 Redis 服务在用户服务之前启动
      - trip-mysql  # 确保 MySQL 服务在用户服务之前启动
    links:
      - trip-redis  # 通过链接的方式连接 Redis 服务
      - trip-mysql  # 通过链接的方式连接 MySQL 服务

  # Article 文章服务
  trip-article:
    container_name: trip-article  # 指定容器名称为 trip-article
    build:
      context: ./trip/article  # 构建上下文为本地 article 目录
      dockerfile: dockerfile  # 使用指定的 Dockerfile 构建镜像
    ports:
      - "8060:8060"  # 映射文章服务的 8060 端口
    depends_on:
      - trip-redis  # 确保 Redis 服务在文章服务之前启动
      - trip-mysql  # 确保 MySQL 服务在文章服务之前启动
      - trip-user  # 确保用户服务在文章服务之前启动
    links:
      - trip-redis  # 通过链接的方式连接 Redis 服务
      - trip-mysql  # 通过链接的方式连接 MySQL 服务
      - trip-user  # 通过链接的方式连接用户服务
```

## 总结：
在这个 `docker-compose.yml` 文件中，每个服务都清楚地定义了其依赖关系、端口映射、数据持久化等重要配置。通过使用 `depends_on` 属性，保证了服务按依赖关系正确启动；通过使用 `links` 属性，确保了服务之间的网络连接。各个服务的数据持久化配置保证了数据的安全性和一致性。

此配置适合用于微服务架构，且能够处理复杂的服务依赖和网络需求。

# shell脚本文件解析
## 拷贝文件部分
- copy.sh
```shell
#!/bin/sh  # 指定解释器为 sh

# 第一部分：拷贝 SQL 文件到 MySQL 容器挂载的目录
echo "begin copy sql "
cp ../profiles/sql/wolf2w-trip-travel.sql ./mysql/db  # 复制旅行相关的 SQL 文件到 MySQL 数据库目录
cp ../profiles/sql/wolf2w-trip-user.sql ./mysql/db  # 复制用户相关的 SQL 文件到 MySQL 数据库目录
cp ../profiles/sql/trip-config.sql ./mysql/db  # 复制配置相关的 SQL 文件到 MySQL 数据库目录

# 第二部分：拷贝前端静态文件到 Nginx 容器挂载的目录
echo "begin copy html "
cp -r ../trip-website-ui/** ./website/html/dist  # 递归复制前端网站的所有静态资源到 Nginx 的 dist 目录

# 第三部分：拷贝 Java JAR 文件到各个服务的目录
echo "begin copy trip-gateway "
cp ../trip-api-gateway/target/trip-gateway.jar ./trip/gateway/jar  # 复制网关服务的 JAR 文件到网关服务的 JAR 目录

echo "begin copy trip-user "
cp ../trip-servers/trip-user-server/target/trip-user.jar ./trip/user/jar  # 复制用户服务的 JAR 文件到用户服务的 JAR 目录

echo "begin copy trip-article "
cp ../trip-servers/trip-travel-server/target/trip-article.jar  ./trip/article/jar  # 复制文章服务的 JAR 文件到文章服务的 JAR 目录
```
- SQL 文件拷贝： 将预先准备好的 SQL 文件拷贝到 ./mysql/db 目录下，这些 SQL 文件将在 MySQL 容器启动时被导入数据库中。
- HTML 文件拷贝： 将前端项目生成的静态文件拷贝到 Nginx 容器的挂载目录，以便 Nginx 能够提供这些文件作为前端页面。
- JAR 文件拷贝： 将后端服务的 JAR 文件拷贝到对应的服务目录下，Docker 镜像将会使用这些 JAR 文件来启动服务。

## 服务管理脚本：
- deploy.sh:
```shell

#!/bin/sh  # 再次指定解释器为 sh

# 使用说明，用来提示输入参数
usage() {
	echo "Usage: sh 执行脚本.sh [base|services|stop|rm]"  # 打印使用说明，提示可用的命令参数
	exit 1  # 退出脚本
}

# 启动基础环境（必须）
base(){
	docker-compose up -d trip-mysql trip-redis trip-nacos  # 以后台模式启动基础服务：MySQL、Redis 和 Nacos
}

# 启动程序模块（必须）
services(){
	docker-compose up -d trip-website trip-gateway trip-user trip-article  # 以后台模式启动业务服务：Website、Gateway、User 和 Article
}

# 关闭所有环境/模块
stop(){
	docker-compose stop  # 停止所有 Docker Compose 管理的服务
}

# 删除所有环境/模块
rm(){
	docker-compose rm  # 删除所有已停止的服务容器
}

# 根据输入参数，选择执行对应方法，不输入则执行使用说明
case "$1" in  # 根据传入的参数执行对应的函数
"base")
	base  # 如果参数是 "base"，则调用 base 函数
;;
"services")
	services  # 如果参数是 "services"，则调用 services 函数
;;
"stop")
	stop  # 如果参数是 "stop"，则调用 stop 函数
;;
"rm")
	rm  # 如果参数是 "rm"，则调用 rm 函数
;;
*)
	usage  # 如果参数不匹配，调用 usage 函数
;;
esac  # 结束 case 语句
```
- base 函数： 启动 MySQL、Redis 和 Nacos 服务，这些是所有其他服务的基础依赖。
- services 函数： 启动 Website、Gateway、User 和 Article 服务，这些是实际的业务逻辑服务。
- stop 函数： 停止所有运行中的服务。
- rm 函数： 删除所有已停止的服务容器，释放资源。

Docker项目实战(微服务)

# Redis 介绍
![image.png](/static/img/f7d394c5851c400f13ec56f5560f2eda.image.webp)

> Redis，英文全称是Remote Dictionary Server（远程字典服务），是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

> 与MySQL数据库不同的是，Redis的数据是存在内存中的。它的读写速度非常快，每秒可以处理超过10万次读写操作。因此redis被广泛应用于缓存，另外，Redis也经常用来做分布式锁。除此之外，Redis支持事务、持久化、LUA 脚本、LRU 驱动事件、多种集群方案。



# 基本操作 & 字符串(String)
## 设置数据(键值对)
### Redis中的数据是以键值对的方式进行存储的

```powershell
SET key value [expiration EX seconds|PX milliseconds] [NX|XX]
```

例: 设置一个键值对
```powershell
127.0.0.1:6379> SET name gyc
OK
127.0.0.1:6379> GET name
"gyc"
```

### Redis中的键是区分大小写的 
```powershell
127.0.0.1:6379> SET Name GYC
OK
127.0.0.1:6379> GET Name
"GYC"
```

### Redis 中默认使用字符串来存储数据, 二进制安全的, 因此可以存储许多不同类型的数据
```powershell
127.0.0.1:6379> SET age 18
OK
127.0.0.1:6379> GET age
"18"
```

## 删除键
```powershell
127.0.0.1:6379> DEL name
(integer) 1
127.0.0.1:6379> get name
(nil)
```
- 返回为`nuil`则表示此键已经被删除掉

## 使用`EXISTS`命令判断此键是否存在
```powershell
127.0.0.1:6379> EXISTS name
(integer) 0

```
- 返回值为0则表示此键不存在

```powershell
127.0.0.1:6379> EXISTS age
(integer) 1
```
- 返回值为1则表示此键存在

## 使用`KEYS`命令判断存在哪些键
- * 查找所有的键
```powershell
127.0.0.1:6379> KEYS *
1) "age"
2) "Name"
```

- *me 查找所有以me结尾的键
```powershell
127.0.0.1:6379> KEYS *me
1) "Name"
```

## 使用`FLUSHALL`删除所有的键
```powershell
 127.0.0.1:6379> FLUSHALL
OK
127.0.0.1:6379> KEYS *
(empty list or set)
```

## 由于Redis是以二进制的方式存储数据, 所以对中文的支持有缺陷(乱码)
```powershell
127.0.0.1:6379> set name ﾸ￟ￔﾴﾳ￉
OK
127.0.0.1:6379> GET name
"\xb8\xdf\xd4\xb4\xb3\xc9"
```
- 以二进制方式显示

### Redis客户端添加 `--raw` 参数， 以解决Redis中文乱码的情况
```powershell
127.0.0.1:6379> quit
PS C:\Users\30372> redis-cli.exe --raw
127.0.0.1:6379> GET name
高源成
```
- `--raw` 参数表示以原始的方式显示

## 使用`clear`命令清空屏幕
```powershell
127.0.0.1:6379> clear
```

## 键值对的过期时间
### 使用`TTL`(Time to live)命令查看键值对的过期时间
```powershell
127.0.0.1:6379> TTL name
-1
```
- 返回`-1`表示没有设置过期时间

### 使用`EXPIRE`命令设置键值对的过期时间
```powershell
127.0.0.1:6379> EXPIRE name 10
1
127.0.0.1:6379> TTl name
3
127.0.0.1:6379> TTl name
2
127.0.0.1:6379> TTl name
0
127.0.0.1:6379> TTl name
-2
127.0.0.1:6379> GET name
```
- 当返回值为`-2`时表示当前键值对过期

### 使用`SETEX`命令设置一个带过期时间的键值对
```powershell
127.0.0.1:6379> SETEX name 10 gyc
OK
127.0.0.1:6379> GET name
gyc
127.0.0.1:6379> TTl name
6
127.0.0.1:6379> TTl name
5
127.0.0.1:6379> TTl name
4
127.0.0.1:6379> TTl name
1
127.0.0.1:6379> TTl name
-2
```

### `SETNX`命令, 只有当键不存在时才设置键的值
```powershell
127.0.0.1:6379> SETNX Name Gyc
1
127.0.0.1:6379> GET Name
Gyc
127.0.0.1:6379> SETNX Name gyc
0
```
- 返回值为`1`则表示键不存在，成功设置值
- 返回值为`0`则表示键存在，不进行任何设置操作

# 列表(List)
## 列表介绍
> 列表(List)，一般用来存储一组有顺序的数据, 与数组的概念有些相似, 常用`LPUSH`及`RPUSH`命令将元素添加到头部或者尾部.

## 列表操作
### 添加和获取列表元素
**添加元素**
```powershell
127.0.0.1:6379> LPUSH letter a
(integer) 1
```

**获取元素**
```powershell
127.0.0.1:6379> LRANGE letter 0 -1
1) "a"
```
- 使用`LRANGE`命令获取元素
- `0 -1` 指定元素的位置, 0 为默认起始位置, -1 为最后一个元素位置

### 添加顺序
```powershell
127.0.0.1:6379> LRANGE letter 0 -1
1) "a"
127.0.0.1:6379> LPUSH letter b
(integer) 2
127.0.0.1:6379> LRANGE letter 0 -1
1) "b"
2) "a"
127.0.0.1:6379> LPUSH letter c d e
(integer) 5
127.0.0.1:6379> LRANGE letter 0 -1
1) "e"
2) "d"
3) "c"
4) "b"
5) "a"
```
- `LPUST` 会安照从左相右的顺序添加, 因此最后添加的元素就会排在最前面

![image.png](/static/img/63063d06ee965b676b391ba39b55df2e.image.webp)

```powershell
127.0.0.1:6379> RPUSH letter f
(integer) 7
127.0.0.1:6379> LRANGE letter 0 -1
1) "e"
2) "d"
3) "c"
4) "b"
5) "a"
6) "f"
```
- `RPUST` 会安照从右向左的顺序添加, 元素就会排在最后面


![image.png](/static/img/3372a0369535f9e0072746dda530291f.image.webp)


### 删除列表的元素(LPOP、RPOP)
**使用`LPOP`和`RPOP`来删除列表的元素**

![image.png](/static/img/f35764dd6d0df75b16aa5d1ea478d3f8.image.webp)

```powershell
127.0.0.1:6379> RPOP letter
"f"
127.0.0.1:6379> LRANGE letter 0 -1
1) "e"
2) "d"
3) "c"
4) "b"
5) "a"
```
#### 删除多个元素
- **对于 Redis 6.2 及以上版本，可以使用 LPOP 的可选参数 count 来弹出多个元素**
```powershell
127.0.0.1:6379> LPOP letter 2
127.0.0.1:6379> LRANGE letter 0 -1
1) "c"
2) "b"
3) "a"
```

### 查看列表的长度（LLEN）
```powershell
127.0.0.1:6379> LLEN letter
(integer) 3
```

### 使用`LTRIM`命令删除指定元素以外的元素
```powershell
127.0.0.1:6379> flushall
OK
127.0.0.1:6379> lpush letter a b c d e
(integer) 5
127.0.0.1:6379> LRANGE letter 0 -1
1) "e"
2) "d"
3) "c"
4) "b"
5) "a"
127.0.0.1:6379> LTRIM letter 1 3
OK
127.0.0.1:6379> LRANGE letter 0 -1
1) "d"
2) "c"
3) "b"
```
- 删除索引范围不在1和3之间的元素, 即`e`和`a`

# 集合(Set)
## 集合介绍
> 集合(set) 是一种无序集合, 和列表的区别在于列表的元素可以重复, 而集合(set)中元素是不能重复的   
> set中的相关命令都是以`S`开头

## 集合操作
### 添加元素(SADD)
```powershell
127.0.0.1:6379> SADD course Redis
(integer) 1
127.0.0.1:6379> SMEMBERS course
1) "Redis"
```
- `SADD` `集合名称` `添加元素`
- 使用`SMEMBERS`命令查看集合中的元素

#### 不能添加重复的元素
```powershell
127.0.0.1:6379> SADD course Redis
(integer) 0
127.0.0.1:6379> SMEMBERS course
1) "Redis"
```
- 返回值为0 添加失败

### 使用`SISMEMBER`命令判断元素是否在集合中
```powershell
127.0.0.1:6379> SISMEMBER course Redis
(integer) 1
127.0.0.1:6379> SISMEMBER course Python
(integer) 0
```
- 返回值为`1`表示元素在集合中
- 返回值为`0`表示元素不在集合中

### 删除集合中的元素(SREM)
```powershell
127.0.0.1:6379> SREM course Redis
(integer) 1
127.0.0.1:6379> SMEMBERS course
(empty list or set)
```

# 有序集合（SortedSet）
## 有序集合（SortedSet）介绍
> 有序集合（SortedSet）/ （ZSet), 与集合的区别为`ZSet`的每个元素会关联一个浮点类型的分数, 后会按照分数对集合中的元素按照从小到大的顺序进行排序  
> 有序集合的成员都是唯一的, 但是分数是可以重复的  
> 有序集合的命令都是以`Z`开头的

![image.png](/static/img/37298c61db40f9b68b15609af995b200.image.webp)

## 有序集合操作
### 添加元素
```powershell
127.0.0.1:6379> ZADD result 680 A 660 B 650 C 640 D
(integer) 4
```
- `ZADD` `有序集合的名字` `分数` `元素（成员）`

### 查看有序集合中的元素
```powershell
127.0.0.1:6379> ZRANGE result 0 -1
1) "D"
2) "C"
3) "B"
4) "A"
```
- `ZRANGE` `有序集合名字` `起始位置` `结束位置`

#### `ZRANGE` 加上 `WITHSCORES` 会显示分数
```powershell
127.0.0.1:6379> ZRANGE result 0 -1 WITHSCORES
1) "D"
2) "640"
3) "C"
4) "650"
5) "B"
6) "660"
7) "A"
8) "680"
```

### 单独查看元素分数(ZSCORE)
```powershell
127.0.0.1:6379> ZSCORE result A
"680"
```
- `ZSCORE` `有序集合名字` `查询元素名字`

### 查看元素排名(ZRANK ZREVRAK)
```powershell
127.0.0.1:6379> ZRANK result A
(integer) 3
```
- 从大到小排名

```powershell
127.0.0.1:6379> ZREVRANK result A
(integer) 0
```
- 从大到小

# 哈希(Hash)
## 哈希(Hash)介绍
> 哈希(Hash)是一个字符类型的字段和值的映射表, 键值对的集合, 常用来存储对象  
> 哈希相关命令常以`H`开头

## 哈希(Hash)操作
### 添加键值对(HSET)
```powershell
127.0.0.1:6379> HSET person name gyc
(integer) 1
127.0.0.1:6379> HSET person age 18
(integer) 1
```

### 获取哈希(Hash)键值对(HGET)
```powershell
127.0.0.1:6379> HGET person name
"gyc"
127.0.0.1:6379> HGET person age
"18"
127.0.0.1:6379> HGETALL person
1) "name"
2) "gyc"
3) "age"
4) "18"
```

### 删除键值对(HDEL)
```powershell
127.0.0.1:6379> HDEL person age
(integer) 1
127.0.0.1:6379> HGET person age
(nil)
127.0.0.1:6379> HGETALL person
1) "name"
2) "gyc"
```

# 判断键值对是否存在(HEXISTS)
```powershell
127.0.0.1:6379> HEXISTS person age
(integer) 0
127.0.0.1:6379> HEXISTS person name
(integer) 1
```
- 返回`1` 表示存在
- 返回`0` 表示不存在

# Redis订阅模式
## 订阅模式操作(PUBLISH SUBSCRIBE)
```powershell
127.0.0.1:6379> PUBLISH gyc "Hi Redis"
(integer) 1
```
- 创建频道并发布内容
- `PUBLISH` `频道名称` `发布消息内容`

```powershell
127.0.0.1:6379> SUBSCRIBE gyc
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "gyc"
3) (integer) 1
1) "message"
2) "gyc"
3) "Hi Redis"
```
- 订阅并接收频道信息
- `SUBSCRIBE` `频道名称`

## 订阅模式特性
> 可以有多个订阅频道(终端)
### 局限性
> 消息无法持久化  
> 无法记录历史消息 等

# 消息队列(Stream)
## 消息队列介绍
> 消息队列(Stream)是redis5.0后, 引入的新的数据结构, 是一种轻量型的消息队列, 用来解决发布模式的一些局限性   
> 消息队列(Stream)的命令都以`X`开头

## 消息队列操作
### 添加消息(XADD)
```powershell
127.0.0.1:6379> XADD gyc * course Redis
"1721541334092-0"
127.0.0.1:6379> XADD gyc * course git
"1721541339773-0"
127.0.0.1:6379> XADD gyc * course Docker
"1721541342874-0"
```
- `XADD` `流的名称(频道名称)` `消息ID` `字段名` `字段的值`
- `*` 代表自动生成条目ID

### 查看Stream流中的内容(XRANGE)
```powershell
127.0.0.1:6379> XRANGE gyc - +
1) 1) "1721541334092-0"
   2) 1) "course"
      2) "Redis"
2) 1) "1721541339773-0"
   2) 1) "course"
      2) "git"
3) 1) "1721541342874-0"
   2) 1) "course"
      2) "Docker"
```
- `XRANGE` `流的名称(频道名称)` `start` `end`
- `-`和`+`代表所有消息

```powershell
127.0.0.1:6379> XRANGE gyc 1721541334092-0 1721541334092-0
1) 1) "1721541334092-0"
   2) 1) "course"
      2) "Redis"
```
- 代表只查看特定范围内的消息
-`XRANGE` `流的名称(频道名称)` `ID范围`

### 删除消息(XDEL XTRIM)
```powershell
127.0.0.1:6379> XDEL gyc 1721541339773-0
(integer) 1
127.0.0.1:6379> XRANGE gyc - +
1) 1) "1721541334092-0"
   2) 1) "course"
      2) "Redis"
2) 1) "1721541342874-0"
   2) 1) "course"
      2) "Docker"
```
- `XDEL` `流的名称(频道名称)` `要删除的ID`

### 修剪流(消息)(XTRIM)
```powershell
127.0.0.1:6379> XTRIM gyc MAXLEN 0
(integer) 2
127.0.0.1:6379> XRANGE gyc - +
(empty list or set)
```
- `XTRIM` `流的名称` `设置的最大条目数`
- `0` 表示将流的最大长度设置为 0。这意味着会删除所有条目，因为长度 0 不允许有任何条目。

### 手动添加并读取消息
```powershell
127.0.0.1:6379> XADD student 100-1 course Redis
"100-1"
127.0.0.1:6379> XADD student 100-2 course git
"100-2"
127.0.0.1:6379> XADD student 100-3 course python
"100-3"
127.0.0.1:6379> XREAD COUNT 2 BLOCK 1000 STREAMS student 0
1) 1) "student"
   2) 1) 1) "100-1"
         2) 1) "course"
            2) "Redis"
      2) 1) "100-2"
         2) 1) "course"
            2) "git"
 ```
- **`XREAD` `指定最大读取消息条数` `指定阻塞时间(ms)` `STREAMS` `流的名称` `起始ID`**
- `COUNT 2`
    - COUNT 指定一次读取的最大条目数。
    - 2 是读取的条目数量上限。此命令会读取最多 2 个条目。
- `BLOCK 1000`
    - BLOCK 指定阻塞读取的最大时间，单位为毫秒。
    - 1000 是阻塞时间上限，表示如果流中暂时没有新消息，命令会等待最多 1000 毫秒（即 1 秒）以查看是否有新消息可读取。
- `STREAMS`
    - STREAMS 后面跟着要读取的流名称及其对应的起始 ID。
- `student`
    - student 是流的名称，即你要读取数据的流。
- `0`
    - 0 是起始 ID，表示从流的开头开始读取。

```powershell
127.0.0.1:6379> XREAD COUNT 2 BLOCK 1000 STREAMS student 100-1
1) 1) "student"
   2) 1) 1) "100-2"
         2) 1) "course"
            2) "git"
      2) 1) "100-3"
         2) 1) "course"
            2) "python"
127.0.0.1:6379> XREAD COUNT 2 BLOCK 1000 STREAMS student 100-2
1) 1) "student"
   2) 1) 1) "100-3"
             2) 1) "course"
            2) "python"
127.0.0.1:6379> XREAD COUNT 2 BLOCK 1000 STREAMS student 100-3
(nil)
(1.09s)
```
- `100-1` 由于ID是从`100-0`开始的, 因此只读到了后两条消息
- 当起始ID不存在时会阻塞1s并返回`nil`

### 获取最新的消息
```powershell
127.0.0.1:6379> XADD student 100-6 course Lua
"100-6"
127.0.0.1:6379> XREAD COUNT 2 BLOCK 10000 STREAMS student $
1) 1) "student"
   2) 1) 1) "100-6"
         2) 1) "course"
            2) "Lua"
(7.05s)
```
- `$` 表示从最新的消息开始读取。即只会读取在命令执行之后新添加的消息。

## 消费者组
### 消费者组操作
#### **创建消费者组**
```powershell
127.0.0.1:6379> XGROUP CREATE student group1 0
OK
```
- `XGROUP CREATE` `消息名称` `组名` `ID`

#### **查看消费者组**
```powershell
127.0.0.1:6379> XINFO GROUPS student
1) 1) "name"
   2) "group1"
   3) "consumers"
   4) (integer) 0
   5) "pending"
   6) (integer) 0
   7) "last-delivered-id"
   8) "0-0"
```

#### 添加消费者
> `CREATECONSUMER` 命令式Redis 6.2.0 后出现的命令

# 地理空间(Geospatia)
## 地理空间(Geospatia)介绍
> 地理空间(Geospatia)是Redis 3.2 版本中的新特性, 提供一种用于存取地理位置信息的数据结构, 同时支持对地理位置进行各种计算操作(例如计算两地间的距离、获取经纬度、查找附近的人等)  
> 地理位置相关命令都以 `GEO` 开头

## 地理空间(Geospatia)相关操作
### 添加地理位置(GEOADD)
```powershell
127.0.0.1:6379> GEOADD city 116.405285 39.904989 beijing
(integer) 1
```
- `GEOADD` `key的名称` `经度` `纬度` `城市名称(值的名称)`

```powershell
127.0.0.1:6379> GEOADD city 121.472644 31.231706 shanghai 114.085947 22.547 shenzhen 37 23.125178 guangzhou 120.153576 30.287459 hangzhou
(integer) 4
```
- 添加多个信息
- 添加几条, 返回几条

### 获取位置信息(GEOPOS)
```powershell
127.0.0.1:6379> GEOPOS city beijing
1) 1) "116.40528291463851929"
   2) "39.9049884229125027"
```

### 计算距离(GEODIST)
```powershell
127.0.0.1:6379> GEODIST city beijing shanghai
"1067597.9668"
```
- 默认单位是米

```powershell
127.0.0.1:6379> GEODIST city beijing shanghai km
"1067.5980"
```
- 后可跟单位

### 搜索位置(GEORADIUSBYMEMBER)
```powershell
127.0.0.1:6379> GEORADIUSBYMEMBER city shanghai 2000 km
1) "shenzhen"
2) "hangzhou"
3) "shanghai"
4) "beijing"
```
- 以指定范围为圆心, 指定距离为半径搜索

#

1. Django 中的 Form 功能

选择 Form 还是 ModelForm 取决于你的具体需求：

Django 分页功能整理

分页流程

经常使用到的

安装第三方模块

自己创建数据库

django连接数据库

项目结构

微服务架构下部署的问题

Redis 介绍