网络编程技术 期末复习

路由与交换技术 期末复习

课设要求：

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)