课设要求：

1. 员工信息管理：维护员工的基本信息，包括工号、姓名、职位、入职日期等。
2. 薪资计算：根据员工的职位、基本工资、绩效、加班情况自动计算每月薪资，支持多种薪酬方案。
3. 扣款和福利管理：处理社会保险、公积金扣缴、个人所得税计算，以及各种福利补贴的发放。
4. 工资条生成：自动生成详细的工资条，包括各组成部分的明细，支持电子版与纸质版。
5. 审批流程：薪资变动或特殊津贴需要经过部门经理、财务部门审批，系统支持审批流管理。
6. 报表与分析：生成薪资发放汇总报表，进行成本分析，支持历史数据对比，为决策提供依据。



烂完了，真的烂完了。

### 1 整体结构分析

先明确所有用户的角色类型：

1. 正常员工：可以访问和修改自己的基本信息，生成自己的工资条。
2. 部门经理：可以访问和修改自己和部门下所有员工的基本信息，为员工确认绩效、出勤、加班情况。
3. 财务部门管理员：可以访问和修改自己的基本信息，为所有员工处理社保、公积金扣缴、个人所得税信息和各种福利补贴的发放。
4. 人事部门管理员：可以访问和修改自己的基本信息，新建员工，确认员工职位，管理所有职位的薪资水平，转岗管理确认，部门管理确认。

之后是数据库设计：

1. 用户表，字段包括所有用户id，姓名，密码。
3. 员工表，字段包括工号，职位，入职日期，上级员工id，所属部门id，社保扣款，公积金扣款，并且和用户表的用户id建立关联。
4. 职位表，字段包括职位id，职位名称，基本工资。
5. 工资表，和用户表的用户id建立关联，字段包括基本工资，绩效，出勤，社保扣款，公积金扣款，个人所得税扣款，加班情况和最终的工资。
6. 部门表，字段包括部门id，部门名称。
7. 个人所得税表，字段包括档位和对应税率。

上述设计对应数据库语句如下：

``` sql
create database WebCourseDesign character set utf8 collate utf8_general_ci;

use WebCourseDesign;

create table user (
    id int primary key auto_increment,
    userName varchar(30) not null ,
    userPassword varchar(200) not null
);

create table position (
    id int primary key auto_increment,
    positionName varchar(30) not null,
    positionBaseSalary int not null
);

create table department (
    id int primary key auto_increment,
    departmentName varchar(50) not null
);

create table employee (
    id int primary key auto_increment,
    userID int not null ,
    employeeID varchar(50) not null ,
    positionID int,
    joiningDate date not null ,
    departmentID int,
    leaderID int not null,
    socialInsurance int not null,
    providentFund int not null,

    foreign key (userID) references user(id) on delete cascade on update cascade
);

create table salary (
    id int primary key auto_increment,
    employeeID int not null,
    month date not null ,
    basicSalary int not null,
    performance int not null,
    attendance int not null,
    socialInsurance int not null,
    providentFund int not null,
    personalIncomeTax int not null,
    workOvertime int not null,
    result int
);

create table personalIncomeTax (
    id int primary key auto_increment,
    gap int,
    taxRate float
);

CREATE TRIGGER calculateResultTrigger
    BEFORE INSERT ON salary
    FOR EACH ROW
BEGIN
    SET NEW.result = NEW.basicSalary + NEW.performance + NEW.attendance + NEW.workOvertime - NEW.socialInsurance - NEW.providentFund - NEW.personalIncomeTax;
END;

CREATE TRIGGER calculateResultUpdateTrigger
    BEFORE UPDATE ON salary
    FOR EACH ROW
BEGIN
    SET NEW.result = NEW.basicSalary + NEW.performance + NEW.attendance + NEW.workOvertime - NEW.socialInsurance - NEW.providentFund - NEW.personalIncomeTax;
END;
```

### 2 Controller层

1. `AdminEmployeeController`，该接口作用是为管理员提供编辑员工信息的入口，get为获取操作者范围下的所有员工信息（经理，两种管理员），post为编辑员工信息。
2. `DepartmentAdminController`，该接口作用是为管理员提供编辑部门信息的入口，get为获取所有部门信息，post为编辑部门信息。
3. `DepartmentAdminMessageController`，
4. `DepartmentManagerSalaryController`，该接口作用是为部门经理提供对部门内员工的绩效，出勤，加班情况进行查询和管理的入口，get为获取操作者范围下所有员工的薪水的绩效，出勤和加班信息，post就是对这些信息进行编辑。
5. `EmployeePageController`，该接口作用为返回普通员工页面。
6. `FinancialAdminMessageController`，
7. `FinancialAdminSalaryController`，该接口作用是为财务部门管理员对所有员工的社保，公积金和个人所得税进行管理，作用同`DepartmentManagerSalaryController`。
8. `GenerateNewSalaryController`，该接口作用是为所有员工自动生成一个月的薪资基本情况，不计算别的杂项，只有基本工资，财务部门管理员有权限调用，只有post。
9. `GetSalaryInfoController`，该接口作用是获取员工个人的所有工资情况，只有get。
10. `LoginController`，该接口作用是登录，get获取登录页面，post进行登录，登录成功会自动定向到/route。
11. `PositionAdminController`，
12. `RouteController`，该接口作用是为通过登录的不同角色路由到不同页面。
13. `UserInfoController`，该接口作用是为所有员工提供修改个人用户信息的入口，只有post。

员工所需要的：

1. 登录（✓）
2. 查询自己的工资条（✓）
3. 编辑自己的个人信息（✓）

部门经理所需要的：

1. 登录（✓）
2. 查询自己的工资条（✓）
3. 编辑自己的个人信息（✓）
4. 管理自己员工的绩效，出勤，加班情况（✓）

财务部门管理员所需要的：

1. 登录（✓）
2. 查询自己的工资条（✓）
3. 编辑自己的个人信息（✓）
4. 管理所有员工的公积金，社保，个人所得税情况（✓）
5. 批量生成所有员工的每月工资

Web体系结构与程序设计 课程设计

主要内容：

1. Logger设计与实现
2. String数据类型可用操作
3. StringIndex实现



### 1 Logger设计与实现

先说说我认知中的Logger的基本要求：

1. 在代码的全局范围内都能够被调用，调用之后能够输出想要输出的调试信息。
2. 每一次记录，都可以记录等级，记录log发生的时间，记录从调用处传过来的log信息。
3. 有并发保护，毕竟全局范围内调用，指不定哪块就有两个发生时间完全一致的调试信息。
4. 当有error或者panic时，我能够选择是否输出堆栈信息和发生错误的参数。

基于这些条件，Logger的基本结构就有了：

1. Logger包内提供两个对外的函数GenerateInfoLog和GenerateErrorLog两个函数，分别用于记录普通级别信息的日志和错误级别的日志。
2. Logger包内有一个带缓冲区的channel，上述的两个函数会作为生产者将日志信息写入一个LogInfo结构体内再放入该channel，channel另一头是消费者ListenLoggerChannel，该函数会运行在另一个线程上，持续对channel进行select。如果有新的LogInfo，该函数会将其转换为字符串写入文件并且输出到控制台。
3. 关于获取堆栈信息，GenerateErrorLog函数会通过runtime包来获取。

``` go
// logger.go
package logger

import (
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"
)

var logInputChannel = make(chan LogInfo, 10)

type LogLevel string

const (
	Error LogLevel = "E"
	Panic          = "P"
	Info           = "I"
)

// LogInfo 传递Log信息的结构体
type LogInfo struct {
	level      LogLevel
	timeString string
	message    string
}

func GenerateInfoLog(message string) {
	log := LogInfo{
		level:      Info,
		timeString: time.Now().Format("2006-01-02 15:04:05"),
	}
	pc, _, _, ok := runtime.Caller(1)
	if !ok {
		log.message = "Can not Get Caller Function, Message: " + message
	} else {
		log.message = runtime.FuncForPC(pc).Name() + " :" + message
	}
	logInputChannel <- log
	return
}

func GenerateErrorLog(isPanic bool, needStackTrace bool, message string, keyParams ...string) {
	log := LogInfo{
		timeString: time.Now().Format("2006-01-02 15:04:05"),
	}
	if isPanic {
		log.level = Panic
	} else {
		log.level = Error
	}
	param := strings.Join(keyParams, " ")
	if needStackTrace { // 需要全部堆栈信息
		log.message = "Message: " + message + ", parameters: " + param + "\n"
		log.message += "Stack Trace: \n"

		pcs := make([]uintptr, 100)
		n := runtime.Callers(1, pcs) // 获取当前调用堆栈的程序计数器 参数1指定要跳过的堆栈帧数 不包括Callers函数本身 返回的n是实际的程序计数器数量
		pcs = pcs[:n] // 调整切片容量
		frames := runtime.CallersFrames(pcs) // 获取CallersFrames结构 该结构能够对程序计数器进行迭代

		for frame, more := frames.Next(); more; frame, more = frames.Next() { // 迭代
			log.message += frame.File + ": " + strconv.Itoa(frame.Line) + ", Function: " + frame.Function + "\n"
		}
	} else { // 不需要
		pc, _, _, ok := runtime.Caller(1)
		if !ok {
			log.message = "Can not Get Caller Function, Message: " + message + ", parameters: " + param
		} else {
			log.message = runtime.FuncForPC(pc).Name() + " :" + message + ", parameters: " + param
		}
	}

	logInputChannel <- log
}

func (li *LogInfo) toByteArray() []byte {
	return []byte(fmt.Sprintf("%s %s: %s \n", li.level, li.timeString, li.message))
}

// Logger 记录log信息的结构体
type Logger struct {
	loggerFile *os.File

	isStop bool
}

// NewLogger 传入log文件存储的路径 以获取一个新的Logger
func NewLogger(logPath string) (*Logger, error) {
	result := &Logger{}
	f, e := os.OpenFile(GenerateLogFilePath(logPath), os.O_CREATE|os.O_RDWR, 0644)
	if e != nil {
		return nil, e
	}
	result.loggerFile = f
	result.ListenLoggerChannel()
	return result, e
}

func (logger *Logger) StopLogger() {
	logger.isStop = true
}

// ListenLoggerChannel 开始监听channel以接收log信息 写入log文件并且打印
func (logger *Logger) ListenLoggerChannel() {
	go func() {
		var (
			log   LogInfo
			bytes []byte
			e     error
		)
		for { // 循环监听
			select {
			case log = <- logInputChannel:
				// 记录log
				bytes = log.toByteArray()
				_, e = logger.loggerFile.Write(bytes)
				if e != nil { // 写入logger失败 准备关闭logger
					fmt.Println("Can Not Write Log Cause of: ", e.Error())
					fmt.Println("Will Close Logger!")
					logger.isStop = true
				}
				fmt.Println(string(log.level) + " " + log.timeString + " " + log.message)
			default:
				if logger.isStop {
					close(logInputChannel) // 销毁channel
					e = logger.loggerFile.Sync()
					if e != nil {
						fmt.Println("Can Not Sync Log File Cause of: ", e.Error())
					}
					e = logger.loggerFile.Close() // 关闭文件
					if e != nil {
						fmt.Println("Can Not Close Log File Cause of: ", e.Error())
					}
					return
				}
			}
		}
	}()
}

func GenerateLogFilePath(path string) string {
	fileName := "log." + time.Now().Format("2006_01_02_15_04_05") + ".misaka"
	return filepath.Join(path, fileName)
}
```

### 2 String数据类型可用操作

1. set [key] [value]
2. set [key] [value] expired [time] time是Unix时间戳
3. setnx [key] [value]
4. setnx [key] [value] expired [time]
5. get [key]
6. getrange [key] [start] [end] start和end都是数字
7. getset [key] [value]
8. append [key] [appendValue]
9. del [key]

### 3 StringIndex实现

还是和Hash类型一样的步骤，按照上面的可用操作一个一个来，以跳表为主索引结构，写就完事了。

:::tip{title="提示"}
String数据类型在Redis服务器那块的解析已经在前一次的记录中了。
:::

:::danger{title="警告"}
跳表目前在StringIndex中的表现极差，插入速度极其慢，甚至到了内存比硬盘慢的地步。经过分析个人认为原因有以下两点：

1. strings.Compare函数占用了大量的时间。当初设计跳表时没多想，为了Redis考虑，键设置为字符串，顺序是字典序。但是没想到该函数在插入过程中极其耗时，甚至已经到了不可接受的程度：

![image.png](https://www.misaka19327.cc/static/img/8449d913f31301ce23fc06f825f8057f.image.png)

2. 实现跳表的代码中，添加节点的代码不合理。添加节点的过程中，确定update数组的过程是每次都从头节点确定。实际上并不需要，每次只需要从上一次确定的update节点的下一层索引开始即可。

关于这两点问题，之后会做出调整：

1. 优化跳表，跳表采用int作为键。
2. 实现ART树，并使其作为String数据类型的主索引结构。
:::

以下是还没作出调整的StringIndex。

``` go
// stringIndex.go
package index

import (
	"MisakaDB/customDataStructure/skipList"
	"MisakaDB/logger"
	"MisakaDB/storage"
	"errors"
	"sync"
	"time"
)

type StringIndex struct {
	index        *skipList.SkipList
	mutex        sync.RWMutex
	activeFile   *storage.RecordFile
	archivedFile map[uint32]*storage.RecordFile
	
	fileIOMode     storage.FileIOType
	baseFolderPath string
	fileMaxSize    int64
	syncDuration   time.Duration
}

// BuildStringIndex 给定当前活跃文件和归档文件 重新构建String类型的索引 该方法只会在数据库启动时被调用 如果不存在旧的文件 则新建一个活跃文件
func BuildStringIndex (activeFile *storage.RecordFile, archivedFile map[uint32]*storage.RecordFile, fileIOMode storage.FileIOType, baseFolderPath string, fileMaxSize int64, syncDuration time.Duration) (*StringIndex, error) {
	
	result := &StringIndex{
		index: skipList.NewSkipList(),
		activeFile: activeFile,
		archivedFile: archivedFile,
		fileIOMode: fileIOMode,
		baseFolderPath: baseFolderPath,
		fileMaxSize: fileMaxSize,
		syncDuration: syncDuration,
	}
	
	var (
		e error
		offset int64
		fileLength int64
		entryLength int64
		entry *storage.Entry
	)
	
	// 如果活跃文件都读取不到的话 肯定也没有归档文件了 直接返回即可
	if activeFile == nil {
		result.activeFile, e = storage.NewRecordFile(result.fileIOMode, storage.String, 1, result.baseFolderPath, result.fileMaxSize)
		if e != nil {
			return nil, e
		}
		result.archivedFile = make(map[uint32]*storage.RecordFile) // 如果activeFile为空 那么传进来的archivedFile一定也为空 这时再赋值会报错
		result.archivedFile[1] = result.activeFile
		result.activeFile.StartSyncRoutine(syncDuration) // 开始定时同步
		return result, nil
	}
	
	// 有归档文件的话 挨个读取归档文件 构建索引
	// 读取所有归档文件的entry 因为活跃文件也在这个归档文件里 所以不再单独读取活跃文件
	for i := uint32(1); i <= uint32(len(archivedFile)); i++ {
		recordFile, ok := archivedFile[i]
		if ok == false {
			continue
		}
		offset = 0
		fileLength, e = recordFile.Length()
		if e != nil {
			return nil, e
		}
		for offset < fileLength {
			entry, entryLength, e = recordFile.ReadIntoEntry(offset)
			if e != nil {
				return nil, e
			}
			e = result.handleEntry(entry, recordFile.GetFileID(), offset)
			if e != nil {
				return nil, e
			}
			offset += entryLength
		}
	}
	result.activeFile.StartSyncRoutine(syncDuration)
	
	return result, nil
}

// CloseIndex 关闭Hash索引 同时停止定时Sync 关闭文件
func (si *StringIndex) CloseIndex() error {
	si.mutex.Lock()
	defer si.mutex.Unlock()
	for _, v := range si.archivedFile {
		if v.IsSyncing {
			v.StopSyncRoutine()
		}
		e := v.Close()
		if e != nil {
			return e
		}
	}
	return nil
}

// Set 给定key和value 设定值 如果key存在则为更新值
func (si *StringIndex) Set (key string, value string, expiredAt int64) error {
	entry := &storage.Entry{
		EntryType: storage.TypeRecord,
		ExpiredAt: expiredAt,
		Key: []byte(key),
		Value: []byte(value),
	}
	indexNode := &IndexNode{
		expiredAt: expiredAt,
	}
	
	si.mutex.Lock()
	defer si.mutex.Unlock()
	
	// 写入文件
	offset, e := si.writeEntry(entry)
	if e != nil {
		return e
	}
	indexNode.offset = offset
	indexNode.fileID = si.activeFile.GetFileID()
	indexNode.value = []byte(value)
	
	// 写入索引
	e = si.index.AddNode(key, indexNode)
	if e != nil {
	
	}
	return nil
}

// Get 根据给定的key尝试获取value
func (si *StringIndex) Get (key string) (string, error) {
	
	si.mutex.RLock()
	
	value, e := si.index.QueryNode(key)
	if e != nil {
		si.mutex.RUnlock()
		return "", logger.KeyIsNotExisted
	}
	indexNode := assertIndexNodePointer(value)
	
	// 如果过期时间为-1则说明永不过期
	if indexNode.expiredAt < time.Now().Unix() && indexNode.expiredAt != -1 {
		logger.GenerateInfoLog(logger.ValueIsExpired.Error() + key)
		// 读取的Entry过期 删索引
		si.mutex.RUnlock()
		si.mutex.Lock()
		e = si.index.DeleteNode(key)
		si.mutex.Unlock()
		if e != nil {
			logger.GenerateErrorLog(false, false, e.Error(), si.index.ToString(), key)
			return "", e
		}
		return "", logger.ValueIsExpired
	}
	
	si.mutex.RUnlock()
	return string(indexNode.value), nil
}

// GetRange 返回key中字符串值的子字符
func (si *StringIndex) GetRange (key string, start int, end int) (string, error) {
	if start > end {
		return "", logger.ParameterIsNotAllowed
	}
	value, e := si.Get(key)
	if e != nil {
		return "", e
	}
	return value[start:end], nil
}

// GetSet 先按key获取旧的值 然后再设置新的值并且返回旧值
func (si *StringIndex) GetSet (key string, newValue string) (string, error) {
	
	si.mutex.RLock()
	
	// 先尝试Get
	value, e := si.index.QueryNode(key)
	if e != nil {
		logger.GenerateErrorLog(false, false, e.Error(), key)
		return "", e
	}
	indexNode := assertIndexNodePointer(value)
	
	// 如果过期时间为-1则说明永不过期
	if indexNode.expiredAt < time.Now().Unix() && indexNode.expiredAt != -1 {
		logger.GenerateInfoLog(logger.ValueIsExpired.Error() + key)
		// 读取的Entry过期 删索引
		si.mutex.RUnlock()
		si.mutex.Lock()
		e = si.index.DeleteNode(key)
		si.mutex.Unlock()
		if e != nil {
			logger.GenerateErrorLog(false, false, e.Error(), si.index.ToString(), key)
			return "", e
		}
		return "", logger.ValueIsExpired
	}
	
	si.mutex.RUnlock()
	
	entry := &storage.Entry{
		EntryType: storage.TypeRecord,
		ExpiredAt: indexNode.expiredAt,
		Key: []byte(key),
		Value: []byte(newValue),
	}
	oldValue := string(indexNode.value)
	
	// 再尝试Set
	si.mutex.Lock()
	
	// 先写入文件
	offset, e := si.writeEntry(entry)
	if e != nil {
		return "", e
	}
	// 再更新indexNode
	indexNode.value = []byte(newValue)
	indexNode.offset = offset
	indexNode.fileID = si.activeFile.GetFileID()
	
	si.mutex.Unlock()
	
	// 之后就不再需要写入索引了
	return oldValue, nil
}

// SetNX 只有在key不存在时设置key的值
func (si *StringIndex) SetNX (key string, value string, expiredAt int64) error {
	_, e := si.Get(key)
	if e != nil {
		return si.Set(key, value, expiredAt)
	} else {
		return logger.KeyIsExisted
	}
}

// Append 在key存在的情况下 向其已经存在的value追加一个字符串
func (si *StringIndex) Append (key string, appendValue string) error {
	
	si.mutex.RLock()
	value, e := si.index.QueryNode(key)
	if e != nil {
		si.mutex.RUnlock()
		return logger.KeyIsNotExisted
	}
	indexNode := assertIndexNodePointer(value)
	
	si.mutex.RUnlock()
	
	entry := &storage.Entry{
		EntryType: storage.TypeRecord,
		ExpiredAt: indexNode.expiredAt,
		Key: []byte(key),
		Value: append(indexNode.value, []byte(appendValue)...),
	}
	
	// 再尝试Set
	si.mutex.Lock()
	
	// 先写入文件
	offset, e := si.writeEntry(entry)
	if e != nil {
		return e
	}
	// 再更新indexNode
	indexNode.value = append(indexNode.value, []byte(appendValue)...)
	indexNode.offset = offset
	indexNode.fileID = si.activeFile.GetFileID()
	
	si.mutex.Unlock()
	return nil
}

// Del 如果key存在 则删除key对应的value
func (si *StringIndex) Del (key string) error {
	si.mutex.RLock()
	value, e := si.index.QueryNode(key)
	if e != nil {
		si.mutex.RUnlock()
		return logger.KeyIsNotExisted
	}
	indexNode := assertIndexNodePointer(value)
	si.mutex.RUnlock()
	
	entry := &storage.Entry{
		EntryType: storage.TypeDelete,
		Key: []byte(key),
		Value: indexNode.value,
		ExpiredAt: 0,
	}
	
	si.mutex.Lock()
	_, e = si.writeEntry(entry)
	if e != nil {
		return e
	}
	e = si.index.DeleteNode(key)
	if e != nil {
		logger.GenerateErrorLog(false, false, e.Error(), key)
		return e
	}
	si.mutex.Unlock()
	return nil
}

// writeEntry 尝试将entry写入文件 如果活跃文件写满则自动新开一个文件继续尝试写入 如果写入成功则返回nil和写入前的offset
func (si *StringIndex) writeEntry(entry *storage.Entry) (int64, error) {
	offset := si.activeFile.GetOffset()
	e := si.activeFile.WriteEntryIntoFile(entry)
	// 如果文件已满
	if errors.Is(e, logger.FileBytesIsMaxedOut) {
		// 先结束旧文件的定时同步
		si.activeFile.StopSyncRoutine()
		// 开一个新的文件 这个新的活跃文件的序号自动在之前的活跃文件上 + 1
		si.activeFile, e = storage.NewRecordFile(si.fileIOMode, storage.String, si.activeFile.GetFileID()+1, si.baseFolderPath, si.fileMaxSize)
		if e != nil {
			return 0, e
		}
		// 这个新的活跃文件写入归档文件映射中
		si.archivedFile[si.activeFile.GetFileID()] = si.activeFile
		// 先开启定时同步
		si.activeFile.StartSyncRoutine(si.syncDuration)
		// 再尝试写入
		offset = si.activeFile.GetOffset()
		e = si.activeFile.WriteEntryIntoFile(entry)
		if e != nil {
			return 0, e
		}
	} else if e != nil {
		return 0, e
	}
	return offset, nil
}

// handleEntry 接收Entry 并且写入String索引 注意它只对索引进行操作
func (si *StringIndex) handleEntry(entry *storage.Entry, fileID uint32, offset int64) error {
	var e error
	
	si.mutex.Lock()
	defer si.mutex.Unlock()
	
	switch entry.EntryType {
	case storage.TypeDelete:
		{
			e = si.index.DeleteNode(string(entry.Key))
			if e != nil {
				logger.GenerateErrorLog(false, false, e.Error(), si.index.ToString(), string(entry.Key), string(entry.Value))
			}
		}
	case storage.TypeRecord:
		
		// 这里之所以只对RecordEntry进行检查 是因为对map的delete函数 如果传入的map本身就是空或者要删除的键找不到值 它就直接返回了 并不会报错
		// 所以DeleteEntry不需要过期检查 过期就过期吧 过期了也只是no-op而已
		// 如果过期时间为-1则说明永不过期
		if entry.ExpiredAt < time.Now().Unix() && entry.ExpiredAt != -1 {
			// attention 过期logger
			return nil
		}
		
		e = si.index.AddNode(string(entry.Key), &IndexNode{
			value:     entry.Value,
			expiredAt: entry.ExpiredAt,
			fileID:    fileID,
			offset:    offset,
		})
		if e != nil {
			logger.GenerateErrorLog(false, false ,e.Error(), si.index.ToString(), string(entry.Key), string(entry.Value))
		}
	}
	return nil
}
```

MisakaDB-kv型小型数据库 | 记录4

记录实验5过程及代码。



碎碎念：~~哥们是真的不会前端和c++，怎么最近就总能碰见这俩东西，而且JSP是真的不会，调试我都懵圈不知道怎么调，直接问AI让它帮我写了。~~

:::tip{title="提示"}
这次实验需要引入JSTL库，我的Tomcat 10对应的JSTL的maven依赖：

``` xml
<dependency>
    <groupId>org.glassfish.web</groupId>
    <artifactId>jakarta.servlet.jsp.jstl</artifactId>
    <version>2.0.0</version>
</dependency>

<dependency>
    <groupId>org.apache.taglibs</groupId>
    <artifactId>taglibs-standard-spec</artifactId>
    <version>1.2.5</version>
</dependency>
```

Tomcat 9及以下用的JSTL库就不一样了，建议根据自己的项目的管理方式和Tomcat版本进行查询。
:::

### 1 JSP 基础语法练习

``` html
<%-- experiment5_1.jsp --%>
<%--
  Created by IntelliJ IDEA.
  User: Misaka19327
  Date: 2024/5/25
  Time: 20:44
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%
    String test1 = "Test Out Info";
    System.out.println(test1);
%>

<jsp:useBean id="person" class="org.example.webstructure.experiment5.Person" scope="session"/>

<jsp:setProperty name="person" property="name" value="John"/>
<jsp:setProperty name="person" property="age" value="30"/>

<p>
    姓名：
    <jsp:getProperty name="person" property="name"/>
    <br/>
    年龄：
    <jsp:getProperty name="person" property="age"/>
</p>

</body>
</html>
```

![image.png](https://www.misaka19327.cc/static/img/912b35304625cf5d475659b8226fb281.image.png)

### 2 EL 表达式应用

``` html
<%-- experiment5_2.jsp --%>
<%--
  Created by IntelliJ IDEA.
  User: Misaka19327
  Date: 2024/5/25
  Time: 20:53
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>EL表达式示例</h1>

<%-- 获取请求参数 --%>
<c:set var="paramValue" value="${param.paramName}"/>

<%-- 获取Session属性 --%>
<c:set var="attributeValue" value="${sessionScope.attributeName}"/>

<%-- 获取Application范围内的共享数据 --%>
<c:set var="attributeValue" value="${applicationScope.attributeName}"/>

<%-- 条件显示 --%>
<c:if test="${not empty param.paramName}">
    <p>请求参数存在</p>
</c:if>

<%-- 列表遍历 --%>
<%-- 假设名为 "list" 的列表已在后台设置 --%>
<jsp:useBean id="list" scope="request" type="java.util.List"/>
<c:forEach var="item" items="${list}">
    <p>${item}</p>
</c:forEach>
</body>
</html>
```

``` java
// Experiment5_2.java
package org.example.webstructure.experiment5;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@WebServlet(value = "/ELExample")
public class Experiment5_2 extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 设置请求参数
        request.setAttribute("paramName", "paramValue");

        // 设置Session属性
        request.getSession().setAttribute("attributeName", "attributeValue");

        // 设置Application范围内的共享数据
        getServletContext().setAttribute("attributeName", "attributeValue");

        // 设置列表数据
        List<String> list = new ArrayList<>();
        list.add("Item 1");
        list.add("Item 2");
        list.add("Item 3");
        request.setAttribute("list", list);

        // 转发到JSP页面
        request.getRequestDispatcher("Experiment5/experiment5_2.jsp").forward(request, response);
    }
}
```

![image.png](https://www.misaka19327.cc/static/img/3b611bfee105124b1842e57368f9448d.image.png)

### 3 结合 JavaBean 构建动态页面

``` html
<%-- experiment5_3.jsp --%>
<%--
  Created by IntelliJ IDEA.
  User: Misaka19327
  Date: 2024/5/25
  Time: 21:35
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>JavaBean示例</h1>

<h2>从请求作用域获取JavaBean数据:</h2>
<p>Name: ${person.name}</p>
<p>Age: ${person.age}</p>

<h2>从会话作用域获取JavaBean数据:</h2>
<p>Name: ${sessionScope.person.name}</p>
<p>Age: ${sessionScope.person.age}</p>
</body>
</html>
```

``` java
// Person.java
package org.example.webstructure.experiment5;

import java.beans.JavaBean;

@JavaBean
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
```

``` java
// Experiment5_3.java
package org.example.webstructure.experiment5;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet(value = "/Experiment5_3")
public class Experiment5_3 extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 创建JavaBean对象
        Person person = new Person();

        // 设置JavaBean的属性
        person.setName("TestName");
        person.setAge(24);

        // 将JavaBean放入请求作用域
        request.setAttribute("person", person);

        // 将JavaBean放入会话作用域
        request.getSession().setAttribute("person", person);

        // 转发到JSP页面
        request.getRequestDispatcher("Experiment5/experiment5_3.jsp").forward(request, response);
    }
}
```

![image.png](https://www.misaka19327.cc/static/img/137a5ce385392cd55be04b1264eb4c1f.image.png)

### 4 实验要求4～8

#### 4.1 Model

``` java
// UserEntity.java
package org.example.webstructure.experiment5;

import java.beans.JavaBean;

@JavaBean
public class UserEntity {
    private String userName;
    private String password;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
```

``` java
// UserDAO.java
package org.example.webstructure.experiment5;


import java.sql.*;

public class UserDAO {
    Connection connection;

    public UserDAO() throws SQLException, ClassNotFoundException {
        Class.forName("com.mysql.jdbc.Driver");
        connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:19327/test", "root", "123456");
    }

    public boolean checkPassword (UserEntity user) throws SQLException {
        PreparedStatement preparedStatement = connection.prepareStatement("select userPassword from userinfo where userName = ?");
        preparedStatement.setString(1, user.getUserName());
        ResultSet result = preparedStatement.executeQuery();
        result.next();
        return result.getString(1).equals(user.getPassword());
    }

    public boolean addUser (UserEntity user) throws SQLException {
        PreparedStatement preparedStatement = connection.prepareStatement("insert into userinfo (userName, userPassword) value (?, ?)");
        preparedStatement.setString(1, user.getUserName());
        preparedStatement.setString(2, user.getPassword());
        int result = preparedStatement.executeUpdate();
        return result == 1;
    }
}
```

``` sql
CREATE TABLE `userinfo` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `userName` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `userPassword` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

insert into userinfo (userName, userPassword) value (这里想填啥用户名和密码就填啥);
```

#### 4.2 Controller

``` java
// EnrollController.java
package org.example.webstructure.experiment5;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.MultipartConfig;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.Part;

import java.io.IOException;
import java.io.Writer;
import java.sql.SQLException;

@WebServlet(value = "/experiment5_enroll")
@MultipartConfig
public class EnrollController extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        RequestDispatcher dispatcher = req.getRequestDispatcher("Experiment5/enroll.jsp");
        dispatcher.forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String userName, userPassword;
        userName = req.getParameter("userName");
        userPassword = req.getParameter("userPassword");

        UserEntity user = new UserEntity();
        user.setUserName(userName);
        user.setPassword(userPassword);
        Writer writer = resp.getWriter();
        try {
            UserDAO dao = new UserDAO();
            if (dao.addUser(user)) {
                writer.write("Enroll Successful");
            } else {
                writer.write("Enroll Failed");
            }
        } catch (SQLException | ClassNotFoundException e) {
            writer.write(e.getMessage());
            resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }
}
```

``` java
// LoginController.java
package org.example.webstructure.experiment5;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.MultipartConfig;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.Part;

import java.io.IOException;
import java.io.Writer;
import java.sql.SQLException;

@WebServlet(value = "/experiment5_login")
@MultipartConfig
public class LoginController extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        RequestDispatcher dispatcher = req.getRequestDispatcher("Experiment5/login.jsp");
        dispatcher.forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String userName, userPassword;
        userName = req.getParameter("userName");
        userPassword = req.getParameter("userPassword");

        UserEntity user = new UserEntity();
        user.setUserName(userName);
        user.setPassword(userPassword);
        Writer writer = resp.getWriter();
        try {
            log(user.getPassword());
            UserDAO dao = new UserDAO();
            if (dao.checkPassword(user)) {
                writer.write("Login Successful");
            } else {
                writer.write("Login Failed");
            }
        } catch (SQLException | ClassNotFoundException e) {
            writer.write(e.getMessage());
            resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }
}
```

#### 4.3 View

``` html
<%-- enroll.jsp --%>
<%--
  Created by IntelliJ IDEA.
  User: Misaka19327
  Date: 2024/5/26
  Time: 9:40
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Enroll</title>
</head>
<body>
<h1>Enroll</h1>
<form action="${pageContext.request.contextPath}//experiment5_enroll" method="post">
    <label for="userName">Username:</label>
    <input type="text" name="userName" id="userName" required><br>

    <label for="userPassword">Password:</label>
    <input type="password" name="userPassword" id="userPassword" required><br>

    <input type="submit" value="Enroll">
</form>
</body>
</html>
```

``` html
<%-- login.jsp --%>
<%--
  Created by IntelliJ IDEA.
  User: Misaka19327
  Date: 2024/5/26
  Time: 9:41
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Login</title>
</head>
<body>
<h1>Login</h1>
<h1></h1>
<form action="${pageContext.request.contextPath}//experiment5_login" method="post">
    <label for="userName">Username:</label>
    <input type="text" name="userName" id="userName" required><br>

    <label for="userPassword">Password:</label>
    <input type="password" name="userPassword" id="userPassword" required><br>

    <input type="submit" value="Login">
</form>
</body>
</html>
```

#### 4.4 整体效果

![image.png](https://www.misaka19327.cc/static/img/438b5a7b5159ee7de90224c6452827bc.image.png)

![image.png](https://www.misaka19327.cc/static/img/d3d45e3b23391613d7fba08c16d67439.image.png)

![image.png](https://www.misaka19327.cc/static/img/7025fd8f149615f2188d74e51e3cf49f.image.png)

![image.png](https://www.misaka19327.cc/static/img/c8ac1766c8d72ac915019e4faad42ccf.image.png)

![image.png](https://www.misaka19327.cc/static/img/47cc66f4694180e44026bdab33c4c304.image.png)

Web体系结构与程序设计 实验5

MisakaDB-kv型小型数据库 | 记录3

主要内容：

1. entry编解码的实现
2. 操作文件的接口以及封装文件IO以实现操作文件的接口
3. entry+操作文件统一封装并且暴露接口
4. Hash数据类型操作总结



该项目大量借鉴RoseDB（意思其实就是没有RoseDB估计我写能写好长时间）

### 1 Entry编解码的实现

先记录几个方法：

:::tip{title="提示"}
`binary.PutVarint()`：`func PutVarint(buf []byte, x int64) int`，该方法会将给定的整数x以变长编码的方式转换为字节并且存入buf中，返回的整数值是对x编码后的字节长度。
:::

:::tip{title="提示"}
Go中，切片和切片指针是一个东西，具体看这个图就能理解：

![image.png](https://www.misaka19327.cc/static/img/4f01ad3e03b2dbd0e6352892b5d86460.image.png)
:::

:::tip{title="提示"}
`binary.LittleEndian.PutUint32(buffer[:4], crc)`：`func (littleEndian) PutUint32(b []byte, v uint32)`，以小端字节序将无符号整数v放入字节切片中。小端字节序是一种字节排列方式，它将整数的最低有效字节放在最前面，最高有效字节放在最后面。
:::

:::tip{title="提示"}
`binary.Varint`：`func Varint(buf []byte) (int64, int)`，在给定的字节数组中从头开始解析，尝试解析出一个整数。第一个返回值是被解析出来的整数，第二个返回值是被解析出来的整数的字节长度。如果第二个返回值等于0，说明给定的字节数组太小；如果小于0，则说明要解析的整数的字节长度超过64位。
:::

:::tip{title="提示"}
`crc32.Update`：`func Update(crc uint32, tab *Table, p []byte) uint32`，相当于在已经计算好的crc校验和上，加入新的字节数组继续计算一次。（tab一般为`crc32.IEEETable`）。
:::

Entry结构如下代码所示。

``` go
// entry.go
package storage

import (
	"encoding/binary"
	"hash/crc32"
)

// entry编码结构：
// +-------+--------+----------+------------+-----------+-------+---------+
// |  crc  |  type  | key size | value size | expiresAt |  key  |  value  |
// +-------+--------+----------+------------+-----------+-------+---------+
// |------------------------HEADER----------------------|
//         |--------------------------crc check---------------------------|

// header长度：
// crc32	typ    kSize	vSize	expiredAt
//  4    +   1   +   5   +   5    +    10      = 25 (refer to binary.MaxVarintLen32 and binary.MaxVarintLen64)

// MaxEntryHeaderLength 规定Entry头部信息最长长度为25 同时整个Entry长度不能小于25
const MaxEntryHeaderLength = 25

// EntryType 标识entry类型
type EntryType byte

const (
	TypeDelete   EntryType = iota + 1 // 标识记录删除信息的entry 这个iota写法是让常量从0开始
	TypeRecord                      // 标识记录信息的entry
)

// 因为整个数据库的操作 增删改查 体现在文件上的只有删除和新增两种（改可以通过新增的方式进行覆盖）

// Entry 具体一个Entry所记录的信息
type Entry struct {
	Key       []byte    // 键
	Value     []byte    // 值
	EntryType EntryType // entry类型标识
	ExpiredAt int64 // 过期时间 这里放时间戳
}

// entryHeaderInfo 一个entry所对应的header信息
type entryHeaderInfo struct {
	crc         uint32    // 校验和 对剩余部分进行检验
	entryType   EntryType // entry类型标识
	keyLength   uint32
	valueLength uint32
	expiredAt   int64 // 过期时间 这里放时间戳
}

// Encode 将entry转换为byte数组 另外返回写入内容的长度 byte数组强制必须大于25 如果不够就用0凑足成25 否则读取文件时不够25会EOF
func (e *Entry) Encode() ([]byte, int) {
	if e == nil {
		return nil, 0
	}
	
	header := make([]byte, MaxEntryHeaderLength)
	
	// 先放头信息里除了校验和之外的其他东西
	header[4] = byte(e.EntryType)
	index := 5
	index += binary.PutVarint(header[index:], int64(len(e.Key)))
	index += binary.PutVarint(header[index:], int64(len(e.Value)))
	index += binary.PutVarint(header[index:], e.ExpiredAt)
	
	// 再放key和value
	size := index + len(e.Key) + len(e.Value)
	if size < MaxEntryHeaderLength {
		size = MaxEntryHeaderLength
	}
	buffer := make([]byte, size)
	copy(buffer[:index], header[:])
	copy(buffer[index:], e.Key)
	copy(buffer[index + len(e.Key):], e.Value)
	
	// 最后放crc校验和
	crc := crc32.ChecksumIEEE(buffer[4:index + len(e.Key) + len(e.Value)])
	binary.LittleEndian.PutUint32(buffer[:4], crc)
	return buffer, size
}

// 将给定的byte数组解码为entryHeaderInfo 即Entry的头信息 返回该头信息和头信息的字节长度
func decodeEntryHeader (input []byte) (*entryHeaderInfo, int64) {
	if len(input) <= 4 {
		return nil, 0
	}
	result := &entryHeaderInfo{
		crc:       binary.LittleEndian.Uint32(input[:4]),
		entryType: EntryType(input[4]),
	}
	index := 5
	kSize, n := binary.Varint(input[index:])
	result.keyLength = uint32(kSize)
	index += n
	
	vSize, n := binary.Varint(input[index:])
	result.valueLength = uint32(vSize)
	index += n
	
	e, n := binary.Varint(input[index:])
	result.expiredAt = e
	
	return result, int64(index + n)
}

// getEntryCRC 给定字节数组和Entry 计算该数组+Entry键+Entry值的crc校验和
func getEntryCRC(entry *Entry, h []byte) uint32 {
	if entry == nil { return 0 }
	result := crc32.ChecksumIEEE(h)
	result = crc32.Update(result, crc32.IEEETable, entry.Key)
	result = crc32.Update(result, crc32.IEEETable, entry.Value)
	return result
}
```

### 2 操作文件的接口以及封装文件IO以实现操作文件的接口

``` go
// fileWriter.go
package storage

// FileWriter 定义封装文件操作的基本行为 因为bitcask模型只有对文件的读 追加和整理 所以这里并不涉及对文件的已经写入的数据进行修改
type FileWriter interface {
    Write (input []byte, offset int) error // 在文件的指定位置进行写入
    Read (buf []byte, offset int) error // 在文件的指定位置进行读取
    Sync () error // 强制内存和文件同步一次 以保证一致性
    Delete () error // 删除文件
    Close () error // 关闭文件
    Length () (int64, error) // 返回该文件的长度
}

// attention 实现FileWriter接口的结构体不需要并发安全 因为它和index一一对应 而index会带一个读写锁
```

这个接口定义了如何对文件进行操作。无论是使用传统的文件IO的方式做，还是MMap方式去做，必须实现这五个接口。

之后是对传统的文件IO的方式进行封装：

``` go
// fileIO.go
package storage

import "os"

type FileIO struct {
	file *os.File
}

func NewFileIO (filePath string) (*FileIO, error) {
	file, e := os.OpenFile(filePath, os.O_CREATE | os.O_RDWR, 0644)
	if e != nil {
		// todo logger
		return nil, e
	}
	result := &FileIO{
		file: file,
	}
	return result, nil
}

func (f *FileIO) Write(input []byte, offset int) error {
	_, e := f.file.WriteAt(input, int64(offset))
	return e
}

func (f *FileIO) Read(buf []byte, offset int) error {
	_, e := f.file.ReadAt(buf, int64(offset))
	return e
}

func (f *FileIO) Sync() error {
	return f.file.Sync()
}

func (f *FileIO) Delete() error {
	e := f.file.Close()
	if e == nil {
		// todo logger
		return e
	}
	return os.Remove(f.file.Name())
	// attention *os.File.Remove()只会报PathError 其他的问题导致删除文件不成功的话它报不了错的
	// attention *os.File.Name()返回的是当初创建文件时给定的字符串 不论这个字符串是文件绝对路径还是只是文件名
}

func (f *FileIO) Close() error {
	return f.file.Close()
}

func (f *FileIO) Length () (int64, error) {
	fileStat, e := f.file.Stat()
	if e != nil {
		return 0, e
	}
	return fileStat.Size(), nil
}

// 检查接口实现
var _ FileWriter = (*FileIO)(nil)
```

:::tip{title="提示"}
`os.OpenFile`：`func OpenFile(name string, flag int, perm FileMode) (*File, error)`，标准库中提供的打开文件的方法。flag如下：

``` go
// Flags to OpenFile wrapping those of the underlying system. Not all
// flags may be implemented on a given system.
const (
	// Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
	O_RDONLY int = syscall.O_RDONLY // open the file read-only.
	O_WRONLY int = syscall.O_WRONLY // open the file write-only.
	O_RDWR   int = syscall.O_RDWR   // open the file read-write.
	// The remaining values may be or'ed in to control behavior.
	O_APPEND int = syscall.O_APPEND // append data to the file when writing.
	O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
	O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
	O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
	O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
)
```

第三个参数指定该文件的权限，第一位表示文件类型，后三位就和Linux中的777概念一致。一般情况下0644够用了。
:::

测试文件：

``` go
// fileIO_test.go
package storage

import "testing"

func TestNewFileIO(t *testing.T) {
	file, e := NewFileIO("C:\\Users\\Misaka19327\\OneDrive\\Projects\\GoLandProjects\\MisakaDB\\test.txt")
	if e != nil {
		t.Log(e)
		return
	}
	
	defer func() {
		e = file.Close()
		if e != nil {
			t.Log(e)
		}
	}()
	
	t.Log(file.file.Name())
	e = file.Write([]byte{1, 2, 3, 4, 5}, 0)
	if e != nil {
		t.Log(e)
	}
	buffer := make([]byte, 5)
	e = file.Read(buffer, 0)
	if e != nil {
		t.Log(e)
	} else {
		t.Log(buffer)
	}
}
```

### 3 entry+操作文件统一封装并且暴露接口

数据库所需要的文件操作，就是对一个数据文件写入和读取Entry，同时还需要打开（包括打开已经存在的数据文件），关闭，删除（整理文件时需要）该数据文件。

:::warning{title="注意"}
个人认为文件这里不需要加读写锁，只需要对index加读写锁即可。因为对index的读写一定会一比一地反映到某一个文件上，而如果对index加锁了，那么对文件的读写一定是并发安全的。
:::

``` go
package storage

import (
	"MisakaDB/src/logger"
	storage "MisakaDB/src/storage/file" // 别名写法
	"fmt"
	"hash/crc32"
	"os"
	"path"
	"path/filepath"
	"strconv"
	"strings"
)

// FileForData 指定该数据文件存储的数据类型
type FileForData int8

const (
	String FileForData  = iota
	Hash
	List
	Set
	ZSet
)

var (
	// 文件名的后缀
	fileNameSuffix = map[FileForData]string {
		String: "record.string.",
		Hash: "record.hash.",
		List: "record.list.",
		Set: "record.set.",
		ZSet: "record.zset.",
	}
	
	// 根据文件名解析该文件的存储数据的类型
	filenameToDataTypeMap = map[string]FileForData {
		"string": String,
		"hash": Hash,
		"list": List,
		"set": Set,
		"zset": ZSet,
	}
)

// RecordFile 将数据文件抽象为该结构体
type RecordFile struct {
	file storage.FileWriter // 对文件进行操作的结构体
	fileID uint32 // 文件ID
	newestOffset int64 // 该文件写入位置 或者说最新偏移位也可以
	dataType FileForData // 该文件存储的键值对的类型
	fileMaxSize int64 // 该文件最大的大小
}

// FileIOType 指定文件的读写模式
type FileIOType int8

const (
	MMapIOFile FileIOType = iota // MMap方式
	TraditionalIOFile // 传统IO方式
)

// NewRecordFile 给定路径 读写模式 存储数据类型 文件ID和文件最大大小 新建一个RecordFile
func NewRecordFile (ioType FileIOType, dataType FileForData, fid uint32, path string, fileMaxSize int64) (*RecordFile, error) {
	result := &RecordFile{
		fileID: fid,
		fileMaxSize: fileMaxSize,
		newestOffset: 0,
		dataType: dataType,
	}
	fileFullPath, e := getFileName(fid, dataType, path)
	if e != nil {
		return nil, e
	}
	var fileWriter storage.FileWriter
	switch ioType {
	case MMapIOFile:
		return nil, logger.MMapIsNotSupport
	case TraditionalIOFile:
		fileWriter, e = storage.NewFileIO(fileFullPath)
	}
	result.file = fileWriter
	return result, nil
}

// LoadRecordFileFromDisk 加载一个文件
func LoadRecordFileFromDisk(filePath string, fileMaxSize int64) (*RecordFile, error) {
	if _, e := os.Stat(filePath); e != nil {
		return nil, logger.FileIsNotExist
	}
	file, e := storage.NewFileIO(filePath)
	if e != nil {
		return nil, e
	}
	fileLen, e := file.Length()
	if e != nil {
		return nil, e
	}
	result := &RecordFile{
		file: file,
		fileMaxSize: fileMaxSize,
		newestOffset: fileLen,
	}
	result.fileID, result.dataType, e = parseFileName(path.Base(filePath))
	if e != nil {
		return nil, e
	}
	return result, nil
}

// WriteEntryIntoFile 尝试将Entry写入文件 如果文件剩余大小已经不足以再写入Entry 则返回FileBytesIsMaxedOut错误
func (rf *RecordFile) WriteEntryIntoFile (entry *Entry) error {
	writeContent, length := entry.Encode()
	if int64(length) + rf.newestOffset > rf.fileMaxSize {
		return logger.FileBytesIsMaxedOut
	}
	e := rf.file.Write(writeContent, int(rf.newestOffset))
	rf.newestOffset += int64(length) // 调整偏移位
	return e
}

// ReadIntoEntry 在RecordFile中 从给定的offset开始 尝试读取一个完整的Entry并且返回 第二个返回值为当此读取Entry的长度 用以快速定位下次Entry的offset
func (rf *RecordFile) ReadIntoEntry (offset int64) (*Entry, int64, error) {
	entryHeaderBytes := make([]byte, MaxEntryHeaderLength)
	e := rf.file.Read(entryHeaderBytes, int(offset))
	if e != nil {
		return nil, 0, e
	}
	entryHeader, index := decodeEntryHeader(entryHeaderBytes)
	result := &Entry{
		EntryType: entryHeader.entryType,
		ExpiredAt: entryHeader.expiredAt,
		Key:       make([]byte, entryHeader.keyLength),
		Value:     make([]byte, entryHeader.valueLength),
	}
	e = rf.file.Read(result.Key, int(offset + index))
	if e != nil {
		return nil, 0, e
	}
	e = rf.file.Read(result.Value, int(offset + index) + int(entryHeader.keyLength))
	if e != nil {
		return nil, 0, e
	}
	if crc := getEntryCRC(result, entryHeaderBytes[crc32.Size:index]); crc != entryHeader.crc {
		return nil, 0, logger.CRCCheckSumNotPassed
	}
	entrySize := index + int64(entryHeader.keyLength + entryHeader.valueLength)
	if entrySize < MaxEntryHeaderLength { // 注意Entry的最小长度为25
		return result, MaxEntryHeaderLength, nil
	}
	return result, entrySize, nil
}

// Sync 强制刷新缓冲区到文件中
func (rf *RecordFile) Sync () error {
	return rf.file.Sync()
}

// Delete 删除该文件
func (rf *RecordFile) Delete () error {
	return rf.file.Delete()
}

// Close 关闭该文件
func (rf *RecordFile) Close () error {
	return rf.file.Close()
}

// getFileName 给record文件起名 示例名字：record.string.000000001.misaka
func getFileName (fid uint32, dataType FileForData, path string) (string, error) {
	if _, ok := fileNameSuffix[dataType]; !ok {
		return "", logger.UnSupportDataType
	}
	fileName := fileNameSuffix[dataType] + fmt.Sprintf("%09d", fid) + ".misaka"
	return filepath.Join(path, fileName), nil
}

// parseFileName 给定的FileName中 解析出需要的信息 示例文件名：record.string.000000001.misaka
func parseFileName (fileName string) (uint32, FileForData, error) {
	strs := strings.Split(fileName, ".")
	resultNum, e := strconv.Atoi(strs[2])
	if e != nil {
		return 0, String, e
	}
	return uint32(resultNum), filenameToDataTypeMap[strs[1]], nil
}
```

:::tip{title="提示"}
```
const (
	String FileForData  = iota
	Hash
	List
	Set
	ZSet
)
```

这种定义常量的写法，iota的含义是从0开始。
:::

测试文件：

``` go
package storage

import (
	"fmt"
	"testing"
)

func TestNewRecordFile(t *testing.T) {
	testFile, e := NewRecordFile(TraditionalIOFile, String, 1, "D:\\MisakaDBTest", 65536)
	if e != nil {
		fmt.Println(e)
		return
	}
	testEntry := &Entry{
		Key:       []byte("testKey"),
		Value:     []byte("testValue"),
		EntryType: TypeRecord,
		ExpiredAt: 0,
	}
	e = testFile.WriteEntryIntoFile(testEntry)
	if e != nil {
		fmt.Println(e)
		return
	}
	e = testFile.Sync()
	if e != nil {
		fmt.Println(e)
		return
	}
	testReadEntry, length, e := testFile.ReadIntoEntry(0)
	if e != nil {
		fmt.Println(e)
		return
	}
	fmt.Println(string(testReadEntry.Key))
	fmt.Println(string(testReadEntry.Value))
	fmt.Println(length)
	
	testEntry = &Entry{
		Key:       []byte("testKey----2"),
		Value:     []byte("testValue----2"),
		EntryType: TypeRecord,
		ExpiredAt: 0,
	}
	e = testFile.WriteEntryIntoFile(testEntry)
	if e != nil {
		fmt.Println(e)
		return
	}
	e = testFile.Sync()
	if e != nil {
		fmt.Println(e)
		return
	}
	testReadEntry, length, e = testFile.ReadIntoEntry(25)
	if e != nil {
		fmt.Println(e)
		return
	}
	fmt.Println(string(testReadEntry.Key))
	fmt.Println(string(testReadEntry.Value))
	fmt.Println(length)
	
	testEntry = &Entry{
		Key:       []byte("Key3"),
		Value:     []byte("Value3"),
		EntryType: TypeRecord,
		ExpiredAt: 0,
	}
	e = testFile.WriteEntryIntoFile(testEntry)
	if e != nil {
		fmt.Println(e)
		return
	}
	e = testFile.Sync()
	if e != nil {
		fmt.Println(e)
		return
	}
	testReadEntry, length, e = testFile.ReadIntoEntry(59)
	if e != nil {
		fmt.Println(e)
		return
	}
	fmt.Println(string(testReadEntry.Key))
	fmt.Println(string(testReadEntry.Value))
	fmt.Println(length)
	
	e = testFile.Close()
	if e != nil {
		fmt.Println(e)
		return
	}
}

func TestParseFileName(t *testing.T) {
	result1, result2, e := parseFileName("record.string.000000001.misaka")
	if e != nil {
		t.Log(e)
	} else {
		t.Log(result1)
		t.Log(result2)
	}
}

func TestLoadRecordFileFromDisk(t *testing.T) {
	rf, e := LoadRecordFileFromDisk("D:\\MisakaDBTest\\record.string.000000001.misaka", 65536)
	if e != nil {
		t.Log(e)
		return
	}
	t.Log(rf.newestOffset)
	
	testEntry := &Entry{
		Key:       []byte("testKey5"),
		Value:     []byte("testValue5"),
		EntryType: TypeRecord,
		ExpiredAt: 0,
	}
	e = rf.WriteEntryIntoFile(testEntry)
	if e != nil {
		fmt.Println(e)
		return
	}
	e = rf.Sync()
	if e != nil {
		fmt.Println(e)
		return
	}
	
	testReadEntry, length, e := rf.ReadIntoEntry(84)
	if e != nil {
		fmt.Println(e)
		return
	}
	fmt.Println(string(testReadEntry.Key))
	fmt.Println(string(testReadEntry.Value))
	fmt.Println(length)
	
	testReadEntry, length, e = rf.ReadIntoEntry(59)
	if e != nil {
		fmt.Println(e)
		return
	}
	fmt.Println(string(testReadEntry.Key))
	fmt.Println(string(testReadEntry.Value))
	fmt.Println(length)
	
	fmt.Println(rf.newestOffset)
}
```

![image.png](https://www.misaka19327.cc/static/img/cb63d2a97ba54b502933955aface4bc1.image.png)

### 3 Hash数据操作类型

1. HSet：`hset key field value`，设置值。如果设置成功则返回1，否则返回0。
2. HSetNX：`hsetnx key field value`，设置值，但是它只有在field不存在时才能设置成功。
3. HGet：`hget key field`，获取值，如果key或者field不存在则返回nil。
4. HDel：`hdel key field [field ...]`，删除值，返回被删除的值的数量。
5. HLen：`hlen key`，获取值的field个数。
6. HExists：`hexists key field`，判断field是否存在，存在返回1，反之返回0。
7. HStrLen：`hstrlen key field`，获取value的长度，如果field不存在则返回0。


![image.png](https://www.misaka19327.cc/static/img/f93409a676909f251cd5ea0166d3a883.image.png)