目录： 1、下载安装MySQL 2、在安装目录新建配置 3、添加环境变量 4、安装 5、启动服务 6、卸载 现在 Windows 下安装 MySQL 的时候需要首先下载 MySQL Installer，通过这个软件来联网安装管理不同版本的 MySQL，但是这个软件默认是将 MySQL 安装在 C 盘的，修改安装路径的地方也藏的很隐蔽，并且由于安装时 MySQL Installer 需要联网下载安装包，这对于内网里的机器无疑就是很不友好的。但是从 Oracle 官网下载到的 MSI Installer 程序只是解压出了 MySQL 程序，并没有进行任何的环境变量配置、服务配置，那么就需要通过手动配置程序信息。 1、下载安装MySQL 最新版本下载链接：MySQL :: Download MySQL Community Server 旧版本下载链接：MySQL :: Download MySQL Community Server (Archived Versions) 选择下载某一个版本的 MSI 安装程序或者 ZIP 压缩包，下载完成之后进行安装或解压。 2、在安装目录新建配置 下文中的 MySQL 安装目录以 D:\Program\Environment\MySQL\MySQL Server 5.7 为例： 安装目录下创建一个 “data” 文件夹 安装目录下创建一个 “my.ini” 文本文件，向其中写入以下内容（文件路径根据实际修改）： [mysqld] # mysql 安装目录 basedir="D:\Program\Environment\MySQL\MySQL Server 5.7" # mysql 数据库的数据存放目录 datadir="D:\Program\Environment\MySQL\MySQL Server 5.7\data" sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES # MySQL服务器监听的端口 port=3306 # 服务端编码方式 character-set-server=utf8mb4 [clinet] # 客户端编码方式 loose-default-character-set=utf8mb4 # 端口号设置 port=3306 [WinMySQLadmin] Server="D:\Program\Environment\MySQL\MySQL Server 5.7\bin\mysqld.exe" 3、添加环境变量 右键 “开始菜单” -> “系统” -> “高级系统设置” -> “环境变量” 向 Path 中添加环境变量，值为 MySQL 安装目录下的 bin 文件夹： D:\Program\Environment\MySQL\MySQL Server 5.7\bin 4、安装 上面环境变量配置没有问题的话，就可以在 cmd 窗口中使用 mysqld 命令了。 此时以管理员身份运行 cmd 窗口，执行命令来初始化相关 data 文件： # 在前面配置好的 data 文件夹下会生成初始化的文件 mysqld --initialize-insecure --user=mysql 安装 MySQL 服务： mysqld -install 5、启动服务 可以通过以下命令启动 MySQL 服务： net start mysql 或者在 ”服务“ 窗口中找到 ”MySQL“ 这项服务，右键启动即可： 服务窗口可通过在“运行”窗口输入 “services.msc” 来启动，或者右键 开始菜单 -> 计算机管理 -> 服务和应用程序 -> 服务 找到。 在启动过程中有可能会出现报错： 在 MySQL 的服务属性中可以看到这项服务可执行文件的程序路径是不正确的： 这个窗口里面没有提供可以改这个路径的地方，查了一下，得需要到注册表中改，在注册表中（Win + R 运行窗口中输入“regedit”回车打开）找到 “HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\MySQL” 这个路径，修改其中 ImagePath 的值，将引号里的路径替换为本地 MySQL 安装文件的实际路径（就只替换前面的路径，其他的不用改）： 保存退出之后，再到 “服务” 窗口中刷新一下，可执行文件的路径变成了新的路径之后再次启动即可成功启动 MySQL 服务。 目前本地运行的 MySQL 服务用 root 用户就可以登录，密码为空 MySQL 修改密码： 连接到数据库之后用 SQL 语句为 root 用户更改密码： alter user '用户名'@'localhost' identified by '新密码'; 修改完之后，刷新权限信息： flush privileges; 也可以在 MySQL 控制台中使用 mysqladmin 命令修改用户密码： # 新密码不需要加引号，否则会报错 mysqladmin -u [用户名] -p password [新密码]; 6、卸载 以管理员身份执行命令： mysqld -remove 删除服务： sc delete mysql 删除注册表文件： HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Application\MySQL HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\services\MySQL HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\services\eventlog\Application\MySQL 参考资料： MySQL8.0绿色版本——最纯净的安装体验(免去卸载不掉只能重做系统的‘囧‘境)_mysql8.0 绿色安装-CSDN博客 mysql 启动提示：错误2系统找不到指定文件；（本地计算机上的mysql服务启动后停止，某些服务在未由其他服务或程序使用时将自动停止）_无法编辑imagepath-CSDN博客
目录： 一、Docker 1.1、什么是 Docker 1.2、安装 Docker 1.3、更改镜像源 二、基本概念 2.1、镜像（Image） 2.2、容器（Container） 2.3、标签（Tag） 2.4、仓库（Repository）与注册中心（Registry） 二、命令 2.1、镜像管理 从 Dockerfile 构建镜像： 从远程仓库拉取某个镜像： 将本地镜像推送到远程仓库 列出本地所有镜像 列出与关键词匹配的本地镜像 查看镜像的详细信息（以 JSON 格式输出） 查看镜像的分层历史（各层的创建指令和大小） 删除本地镜像文件 删除所有悬空镜像 删除所有未被任何容器使用的镜像 将镜像保存为 tar 文件（一般用于离线迁移） 从 tar 文件加载镜像到本地 给镜像打标签： 2.2、容器启停 创建并启动容器 只创建容器，不启动 启动已经创建的容器： 在运行的容器中执行命令 停止运行中的容器： 强制停止容器： 重启容器： 2.3、容器管理 查看运行中的容器 删除已停止的容器 删除所有已停止容器 查看容器的标准输出和错误日志： 查看容器内运行的进程 试试监控容器的 CPU、内存、网络等资源使用情况 在主机与容器之间复制文件 导出容器为 tar 文件： 从 tar 文件导入为镜像： 2.4、标签管理 环境：ubuntu 24.04 一、Docker 1.1、什么是 Docker Docker是一个开源平台，用于将应用程序及其所有依赖项打包成标准的容器，从而实现“一次构建，到处运行”。 Docker 与传统虚拟机（Virtual Machine，VM）都是实现环境隔离和应用封装的技术，但它们在架构、性能、资源利用和使用场景上有本质区别。 Docker 容器除了运行其中的应用外，基本不消耗额外的系统资源，保证应用性能的同时，尽量减少系统开销。 传统虚拟机方式运行 N 个不同的应用就要起 N 个不同的虚拟机（每个虚拟机都要单独分配独占的内存、磁盘等资源），而 Docker 只需要启动 N 个隔离的“很薄的”容器，并将应用放进容器内即可。应用获得的是接近原生的运行性能。 对比维度 Docker（容器） 虚拟机（VM） 操作系统 共享宿主机内核 每个 VM 一个完整 OS 启动速度 秒级（0.1～2s） 分钟级 镜像大小 MB ~ 几百 MB GB 级 资源开销 极低 高 性能 接近裸机 有一定损耗 隔离性 进程级隔离 硬件级隔离 安全性 较弱（共享内核） 更强 可移植性 非常强 一般 运维成本 低 高 密度 单机可跑数百容器 单机只能跑少量 VM 虚拟机 = 在硬件上虚拟出一整台“电脑”，解决的是“硬件虚拟化”问题 Docker = 在操作系统上隔离出一个“进程运行环境”，解决的是“应用交付与环境一致性”问题 可以粗略类比为： 虚拟机：每个租户 独立一套房子（含水电） Docker：每个租户 独立一个房间，共用整栋楼的水电 Docker 官网：Docker: Accelerated Container Application Development Docker 官方文档：Manuals | Docker Docs 国内中文翻译文档：Docker中文文档（Docker官方文档，Docker官方教程） 1.2、安装 Docker 使用官方安装脚本： # 下载并执行Docker官方安装脚本 curl -fsSL https://get.docker.com -o get-docker.sh sudo sh get-docker.sh 或者通过添加 Docker 软件源安装： sudo apt-get update sudo apt-get install ca-certificates curl -y sudo install -m 0755 -d /etc/apt/keyrings sudo curl -fsSL https://mirrors.cloud.tencent.com/docker-ce/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc sudo chmod a+r /etc/apt/keyrings/docker.asc echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://mirrors.cloud.tencent.com/docker-ce/linux/ubuntu/ \ $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin 用上面任何一种方法安装完成 Docker 之后启动： # 启动Docker服务 sudo systemctl start docker # 设置开机自启 sudo systemctl enable docker 执行以下命令，检查安装结果： sudo docker info 输出版本信息则说明安装成功。 1.3、更改镜像源 需要说明的是，以往在国内使用很普遍的腾讯云、阿里云和各个大学的 Docker 镜像站点自从 2024 年之后都陆续不可用，现在可使用的镜像源已经很少，也不确定能用多久， 开发者镜像 - 免费手机工具 站长工具 源代码查看器 Docker镜像极速下载服务 - 毫秒镜像 Docker 镜像免费公共测试访问入口 | 轩辕镜像免费版 而在国内买了云服务商的服务器的话，可以使用其提供的内网 Docker 镜像，不过只能在其服务器上使用而无法在外网机器上使用。 腾讯云：腾讯云 - 安装 Docker 并配置镜像加速源，阿里云：阿里云 - 容器镜像服务，文档中明确写 https://mirror.ccs.tencentyun.com 只支持内网访问，不再支持外网域名访问加速。 找到配置镜像源的文件（如果文件不存在请新建） /etc/docker/daemon.json ，写入如下内容： { "registry-mirrors" : [ "https://docker.m.daocloud.io", "https://docker.xuanyuan.me", "https://docker.1ms.run" ] } 之后重新启动服务： sudo systemctl daemon-reload sudo systemctl restart docker 执行 docker info 命令检查配置是否成功，如果输出内容中 Registry Mirrors 一项变成了配置的镜像源，则说明更改镜像源成功。 二、基本概念 2.1、镜像（Image） 镜像是一个用于创建容器（Container）只读模板，可以粗略理解为面向对象编程中的“类”（Class），其包含了运行一个软件所需的代码、运行环境、库、环境变量和配置文件等。 镜像具有如下特点： 不可变：镜像一旦构建完成，内容便默认不可修改 分层结构：镜像采用联合文件系统（UnionFS），以分层方式组织文件，使得多个镜像可以共享相同的基础层，从而节省空间 可分发：镜像可以被推送到远程注册中心（如 Docker Hub）或从注册中心拉取，实现跨平台使用 2.2、容器（Container） 容器时镜像的运行实例，类似于“对象”，是镜像这个“类”的一个具体实例。当启动一个镜像时，Docker 会基于该镜像创建一个容器，并在其中运行应用程序（例如Nginx、MySQL等）。 容器的特点： 可读写：虽然镜像不可修改，但容器在镜像的基础上增加了一个可写层，所有对系统的修改都发生在这个层中。 具有生命周期：可以启动、停止、暂停、删除。 资源隔离：容器之间默认隔离无法交互的，通过 Linux 的 Namespace 和 Cgroups 技术实现进程、网络、文件系统的资源的隔离与限制。 2.3、标签（Tag） 标签用于标识镜像的特定版本或变体。一个镜像可以有多个标签，但它们可能指向同一个镜像 ID（即内容相同）。 如果不指定标签，默认使用 latest 注意：latest 并不一定代表“最新稳定版”，它只是一个约定俗成的标签，实际含义由镜像维护者决定。 2.4、仓库（Repository）与注册中心（Registry） 仓库（Repository）：存储同一软件不同标签（版本）镜像的集合。例如 library/nginx 是 Docker Hub 上 nginx 的官方仓库。 注册中心（Registry）：存放多个仓库的服务。最常见的是 Docker Hub，也可以搭建私有 Registry（如 Harbor、GitLab Container Registry）。 示例完整镜像名： docker.io/library/nginx:1.25 其中： docker.io：Registry 地址（默认可省略） library：命名空间（官方镜像通常省略为 nginx） nginx：仓库名 1.25：标签 二、命令 2.1、镜像管理 Dockerhub 地址：Docker Hub Container Image Library | App Containerization 国内镜像： 从 Dockerfile 构建镜像： 参数： -t 指定镜像标签 --file 指定 Dockerfile 路径，不存在此参数时默认从当前路径下构建 docker build -t <tag> ./ 从远程仓库拉取某个镜像： 镜像标签 <tag> 可省略，默认使用 latest docker pull <image><:tag> 如果没有配置镜像源只是想要临时通过某个（docker.xuanyuan.me）镜像源拉去镜像： docker pull docker.xuanyuan.me/<image><:tag> 将本地镜像推送到远程仓库 docker push <image> 列出本地所有镜像 参数： -a 查看所有镜像 -q 只显示镜像 ID docker image list # 等价于： docker image ls # 等价于： docker images 列出与关键词匹配的本地镜像 docker image list <关键词> # 等价于： docker image ls <关键词> # 等价于： docker images <关键词> 查看镜像的详细信息（以 JSON 格式输出） docker image inspect <image> 查看镜像的分层历史（各层的创建指令和大小） docker image history <image> 删除本地镜像文件 参数： -f 强制删除 -a 删除所有未使用镜像 <image> 可以是文件名，也可以是镜像 ID docker image rm <image> # 简写： docker rmi <image> 注意：当存在依赖于该镜像创建的容器时，镜像文件默认是无法被删除的。尽管可以使用 -f 参数来强制删除一个存在容器依赖的镜像，但并不推荐。正确的做法是，先删除依赖该镜像的所有容器之后再删除镜像。 删除所有悬空镜像 悬空镜像：Dangling Images，即没有标签且未被容器引用的镜像，通常出现在重新构建同名镜像后，旧镜像失去标签但仍存在） docker image prune 删除所有未被任何容器使用的镜像 docker image prune -a 将镜像保存为 tar 文件（一般用于离线迁移） docker save -o <file.tar> <image> 从 tar 文件加载镜像到本地 docker load -i <file.tar> 给镜像打标签： docker tag <image> <tag>qq 2.2、容器启停 Docker 运行容器前需要本地存在对应的镜像（Image）， 如果本地不存在该镜像，Docker 会尝试从配置文件（/etc/docker/daemon.json）的注册中心中下载。 创建并启动容器 参数： -d 后台运行 -it 交互式终端 --name 指定容器名 -p host:container，端口映射 -v /host:/container，卷挂载 --restart 重启策略 docker run [OPTIONS] <image> 例如： docker run -d --name nginx-app-test -p 8080:80 nginx 只创建容器，不启动 参数： --name 容器名 -v 卷挂载 docker create -i <container> --name <name> 启动已经创建的容器： 参数：-i 交互式启动 docker start -i <container> 在运行的容器中执行命令 参数： -it 交互式终端 docker exec -it <container> <command> 停止运行中的容器： 优雅停止容器，会向容器发送 SIGTERM，等待退出 参数：-t 停止等待时间（单位为秒） docker stop -t 强制停止容器： 会向容器发送 SIGKILL。同Linux的kill -9 docker kill <container> 重启容器： 参数：-t 停止等待时间（单位为秒） docker restart <container> 2.3、容器管理 查看运行中的容器 参数： -a 查看所有容器 -q 只显示容器ID docker ps # 等价于： docker container ls 删除已停止的容器 docker rm <container> 若要删除的容器仍在运行，需加上参数 -f： docker rm -f <container> 删除所有已停止容器 docker container prune 查看容器的标准输出和错误日志： 参数： -f 跟踪日志 --tail <n> 显示最后 n 行 docker logs <container> 查看容器内运行的进程 docker top <container> 试试监控容器的 CPU、内存、网络等资源使用情况 docker stats <container> 在主机与容器之间复制文件 docker cp ... 从主机复制文件到容器： docker cp <主机路径> <容器名或ID>:<容器内路径> # 例如： docker cp ./app.conf myapp:/etc/app.conf 从容器复制文件到主机： docker cp <容器名或ID>:<容器内路径> <主机路径> # 例如： docker cp myapp:/var/log/app.log ./ 导出容器为 tar 文件： 参数：-o 指定输出文件名 docker export <container> -o <file.tar> 从 tar 文件导入为镜像： docker import <file.tar> 2.4、标签管理 给镜像打标签： docker tag <image> <tag> 删除特定标签： docker rmi <image>:<tag> 参考文档： Docker - 马燕龙个人博客 云服务器 搭建 Docker_腾讯云 Docker 教程 | 菜鸟教程
关于华为悦盒EC6108V9的一种比较另类的救砖方法
目录： 一、前期准备 1.1、USB转TTL模块 1.2、主板上焊接针脚 二、HiTool 线刷 2.1、跑码 2.2、开始刷机 2.3、系统启动 三、破解 四、后续 五、碰到的坑 5.1、关于在刷机前配置板端ip的问题 5.2、发送数据帧失败，请检查串口连接是否正常 我手上的这个电视盒子，是2016 年家里办宽带的时候电信送的，在 2020 年疫情期间被我刷机给变砖了 :@(狂汗) 。盒子接上电源开机的时候电视完全没有反应，左边绿灯与中间红灯常亮，Recovery 进不去，使用遥控器也没有任何反应。当时还抱着卡刷救砖的希望，尝试了网上说的短接 J15 针脚强制刷机，结果一点用也没有，然后淘宝又买了 TTL 转 USB 模块准备线刷救砖，买来还没操作就被网上那些教程吓住了，再加上那段时间打游戏也打的火热，这个事也就被无限期搁置了（拖延症晚期患者 ::(酸爽) ）。后来直接就买了斐讯 N1，转 N1 的阵营了，一直用到了现在。直到前两天在 B 站刷到这个将华为悦盒刷成 Ubuntu 服务器的视频： {bilibili bvid="BV1Y3411V77b" page=""/} 这个视频让我又有了天晴了雨停了我又觉得我行了的感觉，正好这几天毕业答辩的事也忙完闲下来了，所以花了一（亿）点点时间做一下最后救砖的尝试，当然最后算是成功了，所以写这篇博客来记录一下，为同样变砖的同志提供一个救砖的参考方法。 事先在此说明：这是在华为悦盒使用卡刷、强制卡刷都没有办法救砖时，并且还找不到更适配的固件的情况下，我摸索出来的一个比较另类的救砖方法，目前这个方法只在我的这个盒子上成功了，其他的盒子还没有试过（也没有条件尝试），因此并不能保证这个方法的通用性。在 ZNDS 论坛上有个类似的方式是这个（不过我并没有尝试成功）。 如果你是老司机了，那么本文救砖的方式可以试一试，救砖成功那么恭喜你，如果尝试多次还不成功的话那建议再去找找别的方式，相反如果你此前没有过刷机的经验或者经验不足，且无法独立解决报错问题，那么强烈建议慎用本文所提供的方法！！ 在刷机过程中造成的损坏恕博主不能负责！！！ 在刷机过程中造成的损坏恕博主不能负责！！！ 在刷机过程中造成的损坏恕博主不能负责！！！ 首先说明一下我手上这个盒子的型号规格：型号为华为悦盒 EC6108V9，用的 CPU 型号是 Hi3798MV100，存储规格为 1G + 4G。 型号信息： 主板布局： 一、前期准备 1.1、USB转TTL模块 线刷需要 USB 转 TTL 模块，淘宝几块钱就能买到还送杜邦线，就是这玩意： 无脑买型号是 CH340 的就行，看网上说大部分 CH340 免驱动，但是我手上这个不是，所以建议到时候跟卖家问清楚再买。甚至只要你愿意多花几块钱，还可以买到土豪金配色的（刷机时有神秘 buff 加成 :@(吐舌) ）。 刷机之前检验一下 TTL 模块是否需要驱动，模块插到电脑上之后，在设备管理器 -> 端口选项下面会显示硬件名称跟端口： 如果不显示的话应该是没有驱动，打开 Win10 更新 -> 检查更新，有更新的话就点击安装就行： 1.2、主板上焊接针脚 此外还需要在电视盒子主板的 GND、RX、TX 这三个脚位上焊接三个排针，方便用杜邦线连接 TTL 模块，最后效果是这样： 需要注意的是盒子主板与 TTL 模块针脚连接的对应关系：模块的 GND 脚连接主板的 GND 脚，模块的 RX 与 TX 与主板要反着连，即模块的 RX 连接主板的 TX，TX 连接主板的 RX。 二、HiTool 线刷 线刷工具用到 HiTool，下载地址放在文末。这个软件需要 Java 环境，如果打开报错的话就配置一下 Java 环境，配置方法参考这篇博客：Win10系统配置Java开发环境 - Roookie博客 | 记录 · 收纳 · 分享 (wlplove.com)。 软件启动之后，首先要选择芯片平台，我选择了“Hi3798MV100”，然后进入软件，打开 “HiBurn”模块，这就是线刷需要用到的功能。 2.1、跑码 开始刷机前，简单介绍一下“跑码”。 这个操作在刷机失败之后查找错误原因是非常有用的。我刚开始查资料时看到网上很多人都提到了“跑码”这个词，弄得我一脸懵逼，不过跟着操作了以后就大概理解什么意思了，简单来说，跑码会在硬件启动过程中输出硬件信息、一些提示信息，也会在出现错误的时候输出错误代码，对定位硬件启动的错误有很大的帮助。 在软件菜单栏上点击这个图标打开终端窗口： 在打开的终端窗口上前三个按钮的功能分别是连接、断开连接、设置： 连接前先点击设置按钮配置一下连接端口，端口就是前面设备管理器里显示的 TTL 模块的端口： 设置完成之后，点击连接按钮，然后给盒子通电，首先会在终端输出当前设备的硬件信息，然后盒子会尝试启动系统，同时在终端输出启动过程中的提示信息，比如刚开始我的盒子就是一直循环输出同一段报错信息： 看报错信息应该是在尝试启动的过程中卡在了 fastboot 上。 2.2、开始刷机 相关文件链接已放在文末。 给盒子断电并连接网线，在软件里配置本机与盒子的 IP 地址： 串口：设备管理器里显示的 TTL 模块的连接端口 服务器 IP：本机的 IP 地址 IP 地址：网络盒子的 IP，可以不用改 网关：路由器的 IP 然后找到下方的“烧写eMMC”： 选择刷机文件目录下面的 “xml” 分区表文件，下方表格中就会自动导入相关的分区镜像，选择要刷入的分区文件，点击烧写，当下面控制台出来提示以后给盒子通电，然后等着刷机完成就行了。 这就是整个刷机步骤，很简单吧？ ::(呵呵) 但是吧，实操就不是这样了，因为适配的线刷固件是个大问题。 我找了不少的搜索引擎、论坛、网盘，只找到了几个 CA 版四川电信的盒子线刷固件，并且都是适配 8G 版本的华为悦盒，对比了一下文件结构和大小，最后发现有好几个是同一份文件 ::(挖鼻) ，其他还找到了很多诸如“update.zip”的这类卡刷包以及线刷的 fastboot、recovery 等文件，然而卡刷包对于线刷并没有什么卵用。 鉴于找不到完全适配的线刷固件，所以只能凑活用这个四川电信的 CA 固件了。刚开始我还没有什么思路，我就抱着死马当活马医的心态想着给盒子刷这个固件试试，看能不能刷进去。 点击“刷写”不到一分钟，不出意外地控制台就报错了： 第一点提示说是“烧写的 Fastboot 镜像与当前单板型号或 Flash 不匹配导致”，那就可能是 fastboot 文件的问题？此时我灵机一动，正好有之前下载到的适配我这个盒子的 fastboot 文件啊，于是我就用下载到的 fastboot 文件替换了刷机固件下的 fastboot 文件，然后继续刷机。 果然，这下子没有报错，显示开始刷机了，刷的时间比较长，四十几分钟后提示烧写完成： 2.3、系统启动 我一下来了精神，没想到瞎猫碰到死耗子，竟然真就给刷进去了。我连忙给盒子接到电视上，找出吃灰了两年的遥控器，塞两节电池之后开始开机，果然就见到了那个熟悉的界面： 接下来系统开始进行初始化走进度条，就在我以为救砖成功的时候，进度条卡在了 50% 不动弹了，提示“接入网络故障”： 可问题是我已经给盒子插了网线了啊，莫非是要连接光猫上的“iTV”接口？试了连接到光猫上的网口还是卡在这里，我想着要不然恢复一遍出厂设置吧，结果恢复完之后提示信息又变成“通路故障或AAA认证失败”了： 行吧，虽然依然没进去系统，至少比变砖强点。 这时候想起网上不少的刷机教程，都提到了卡刷这个方式，于是我也下了好几个卡刷包想着试一试卡刷，将刷机文件在硬盘根目录与“upgrade”文件夹各放了一份，开机通过电源键进入 Recovery，选择 “Apply update from external storage（从外部存储更新）”选项卡刷，但是要么直接提示“更新失败”，要么就是好不容易开始更新了，结果一会之后卡进度条还是提示更新失败。 起初我还怀疑是不是刷机包给下错了，但我试了好几个之后都不行之后就大概确定不是了，再尝试了一下短接 J15 针脚强刷，依然没有任何反应，卡在这了。 后面看到这一篇帖子华为悦盒通用刷机救砖破解教程_华为悦盒/华为盒子 ROM固件_小白刷机网 (xiaobaishuaji.com)中提到的更新了签名会导致卡刷失败，按这里面提到的方式刷机前进行一次“三清”，这不清不重要，清完之后启动的时候结果直接变砖无法启动 :@(喷血) ，.......无奈。 三、破解 在这个界面卡了好长时间，结果发现其实按遥控器上的设置建是可以进入设置菜单的，但需要操作码，网上查了一下，我用“6321”进去了。 操作码大概可能有这么多个：一般是运营商客服电话（10000、10086、10010），除此之外还有：8288、6321、2878、3008、8005、1301、123456等，都没有用的话，可以试试专家模式密码189189 来自：华为悦盒ec6108v9高级设置操作码常用汇总 到设置界面看了一下设备信息，我大概知道为什么卡刷失败了，因为这个盒子从 pub 版本被刷成 CA 版的了： 到这里的话，我对卡刷是不报什么希望了。但是好在盒子已经能启动了，虽然还没办法通过系统自带的 IPTV 是进入桌面，但是能进设置界面啊，那就存在破解安装当贝桌面的可能性，然后绕过 IPTV 进入系统当贝桌面。 关于破解华为悦盒安装第三方桌面的步骤，在 ZNDS 论坛的这篇帖子 最新华为悦盒V9_V9U_V9E_V9A_V8通用傻瓜式刷机包！_华为悦盒_ZNDS 里已经写挺详细的，我就懒得写了，直接参考这篇帖子就可以。破解工具在文末。 接下来就比较顺了，破解果然是可以的，破解重启之后就有选择桌面的弹窗了： 四、后续 破解完成之后，安装了几个软件用了一会，体验吧只能说很一般，目前主流的视频软件操作起来卡卡的，盒子发热还比较严重（虽然不摸是感觉不出来的），并且遥控器上的首页按键是没有响应的（估计可能是固件问题）。当然还是不能用太高的要求来评价它，毕竟盒子是七八年前了，实在太老了，就连 CPU 还是 32 位，性能放在今天来看实在是有点捉急。综合来说，安装一个直播软件来看电视直播是比较好的选择。 到这我就准备要收拾家伙事儿不搞了，然后我就在网上又发现了一个线刷固件，适用于 8G 版本盒子，我想着最后尝试一下吧，下载替换 fastboot 文件一气呵成，刷固件依然花了四十多分钟。启动之后还是卡在了运营商自带的 IPTV 界面，进入设置界面查看设备信息之后，发现这个固件是浙江的移动百盒固件，不过是 PUB 版本的，还行，比之前的那个 CA 固件强，用卡刷的方式尝试了一下刷第三方系统，是可以正常刷第三方系统的。因此把这个固件下载链接也放在了文末，有需要的话用这个也行。 最后用卡刷的方式刷入电信的原厂固件，再破解就行了，本来想着还能再认证一下使用 IPTV 来看电视的，但是我尝试之后发现这边的 IPTV 认证地址竟然都挂了，所以就干脆放弃了。 五、碰到的坑 这里记录几个我在刷机过程中碰到的问题，以供参考。碰到问题与报错不要怕，仔细查看分析控制台输出与报错，多猜多尝试。 5.1、关于在刷机前配置板端ip的问题 刚开始我并没有注意到这个问题，所以开始刷机时都是报错： 第一次我还不信邪，多尝试了几次之后我就意识到了问题：我的电视盒子都开不了机了，连接到网线之后路由器后台根本识别不到这个设备，那么现在设置的 IP 地址肯定是无效的呀。 这就是我碰到的第一个大坑，研究了一会我的解决办法是，给家里吃灰的一个旧路由器插上电，用这个路由器来组网，这个局域网里面就只有盒子和笔记本两台设备，修改 HiToll 设置里的 IP 地址，板端 IP 同样随便设置（不能跟笔记本 IP 重复），这下刷机就可以了。 所以关于这个问题我的猜测是这样的（计算机网络学的不好，猜错了大佬轻喷 ::(小红脸) ）：当局域网中设备比较多的时候，笔记本将刷机数据通过路由器给下一个结点传输的时候，设备太多就导致无法确定目标传输设备，所以就会连接超时报错，相反如果只有两个设备的话，路由器传输数据时不是传输给盒子就是传输给笔记本，传输给笔记本应该是不太可能，所以就只能将数据传输给另一设备，这么阴差阳错地就完成了传输。 怎么莫名有种玄学的感觉？？ ::(笑尿) 5.2、发送数据帧失败，请检查串口连接是否正常 刚点击刷写以后，控制这样报错： 以我的情况来看，是 fastboot 文件没有选对，换了适配设备的 fastboot 文件就不报错了。 文末再放上几个刷机查资料过程中发现的几个有用的帖子吧，供有需要的参考： 海思hi3798mv100机型通用twrp_华为悦盒_ZNDS 华为悦盒怎么进入REC模式升级双清恢复出厂设置最全方法_华为悦盒_ZNDS 河南移动cmcc-2 ch电视盒子Hi3798MV310线刷-卡刷-刷机-救砖 - 知乎 (zhihu.com) ec6108v9c刷回安卓看电视 - 海思机顶盒NAS社区 (histb.com) 关于hitool刷写... - 海思机顶盒NAS社区 (histb.com) 华为悦盒EC6108V9 CA高安版1+4G电信4K机顶盒拆机救砖文件TTL线刷 | 西安艾金达贸易有限公司 (aijinda.cn) 华为 悦盒EC6108V9_PUB-8G内存版线刷救砖软件下载_怎么安装第三方软件_应用APP下载_沙发管家 (shafa.com) 【已解决】 EC6108V9 等待boot启动超时，单板上无fastboot或当..._华为悦盒_ZNDS 文件下载链接： https://pan.baidu.com/s/1OZdZQRhWsE49pto_oAzbwQ?pwd=xy6m 提取码: xy6m
目录 一、SpringMVC介绍 二、映射请求路径 2.1、使用@ResquestMapping进行路径映射 2.2、@ResquestMapping的属性 2.2.1、value或path 2.2.2、method 2.2.3、params 2.2.4、headers 2.2.5、consumes 2.2.6、produces 2.3、@ResquestMapping的衍生注解 三、请求参数传递 3.1、GET/POST请求传递基础参数 3.2、传递复杂参数 3.2.1、日期类型 3.2.2、引用类型 3.2.3、数组 3.2.4、集合（List/Set/Map） 3.3、传递Json数据 四、响应 4.1、返回Json数据 4.2、封装返回结果 五、REST风格 5.1、简介 5.2、规则 5.3、相关注解 5.3.1、@RestController 5.3.2、@PathVariable 5.3.3、@RequestParam 5.3.4、@RequestBody 5.4、Rest风格开发示例 5.3.1、查询 5.3.2、新增 5.3.3、修改（更新） 5.3.4、删除 六、异常处理 6.1、自定义异常 6.2、处理异常的方式 6.2.1、使用@ControllerAdvice和@ExceptionHandler 6.2.2、实现HandlerExceptionResolver接口 七、拦截器 7.1、创建拦截器 7.2、注册和配置拦截器 7.3、执行流程和顺序 一、SpringMVC介绍 Spring MVC 是 Spring 框架中的一个模块，专门用于构建基于模型-视图-控制器（Model-View-Controller，MVC）设计模式的 Web 应用程序。 相关依赖坐标： <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency> 在 IDEA 中根据 “maven-archetype-webapp” 模板创建 Webapp 项目： 创建基本项目结构： 在 config 包里面新建初始化 Servlet 的配置类： public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer { protected Class<?>[] getRootConfigClasses() { return new Class[]{SpringConfig.class}; } protected Class<?>[] getServletConfigClasses() { return new Class[]{SpringMvcConfig.class}; } protected String[] getServletMappings() { return new String[]{"/"}; } } 再新建 SpringMVC 配置类： @Configuration @ComponentScan("com.wlplove.controller") public class SpringMvcConfig { } 二、映射请求路径 2.1、使用@ResquestMapping进行路径映射 @RequestMapping 是 Spring MVC 中将 HTTP 请求映射到控制器方法的注解，它用于类级别或方法级别，可以根据请求的 URL、HTTP 请求方法（GET、POST 等）、请求参数、请求头等信息来匹配对应的处理逻辑。 @RequestMapping 注解应用在方法上，可以为该方法映射 URL 请求路径： public class UserController { @RequestMapping("/save") public String save() { // ... } } 也可以应用在类上，为该类中的所有方法设置基础的 URL 请求路径： @RequestMapping("/user") public class UserController { @RequestMapping("/save") public void save() { // ... } @RequestMapping("/delete") public void delete() { // ... } } 2.2、@ResquestMapping的属性 2.2.1、value或path 这两个属性作用相同，用于指定 URL 请求路径。用一个字符串映射一个路径，也可以用一个字符串数组映射多个路径。 @RequestMapping(value = "/save") @RequestMapping(path = "/save") // 映射多个路径 @RequestMapping(value = {"/save", "/saveUser"}) @RequestMapping(path = {"/save", "/saveUser"}) 一般也可以简写： @RequestMapping("/save") // 映射多个路径 @RequestMapping({"/save", "/saveUser"}) 2.2.2、method method 属性用于指定处理的 HTTP 方法。可以是一个 RequestMethod 枚举值或枚举值数组，常见的请求方法有 GET、POST、PUT、DELETE 等。 public class UserController { // save方法只处理POST和GET请求，路径为/save @RequestMapping(value = "/save", method = {RequestMethod.POST, RequestMethod.GET}) @ResponseBody public String save() { // ... } } 2.2.3、params 用于指定请求中必须包含的请求参数和值。可以使用一些特殊的表达式，如 paramName 表示请求中必须包含 paramName 参数；!paramName 表示请求中不能包含 paramName 参数，paramName=value 表示请求中 paramName 参数的值必须为 value。 // 请求中必须包含name参数 @RequestMapping(value = "/save", params = "name") // 请求中不能包含name参数 @RequestMapping(value = "/save", params = "!name") // 请求中name参数的值必须是123 @RequestMapping(value = "/save", params = "name=123") // 请求中name参数的值不能是123 @RequestMapping(value = "/save", params = "name!=123") 2.2.4、headers 用于指定请求中必须包含的请求头及其值，用法与 params 类似。 // 只有当请求/download路径的Accept头的值为application/pdf时，downloadPdf方法才会被调用 @RequestMapping(value = "/download", headers = "Accept=application/pdf") @ResponseBody public String downloadPdf() { // ... } 2.2.5、consumes 用于指定请求的内容类型（Content-Type），即客户端发送给服务器的数据的格式。 // uploadJson方法只处理Content-Type为application/json的请求 @RequestMapping(value = "/upload", consumes = "application/json") @ResponseBody public String uploadJson() { // ... } 2.2.6、produces 用于指定响应的内容类型（Accept），即服务器返回给客户端的数据的格式。 // getHtml方法返回的响应内容类型为text/html @RequestMapping(value = "/get", produces = "text/html") @ResponseBody public String getHtml() { return " Hello "; } 2.3、@ResquestMapping的衍生注解 为了简化代码，Spring 还提供了一些 @RequestMapping 的衍生注解，它们实际上是 @RequestMapping(method = xxx) 的特定形式： @GetMapping：等同于 @RequestMapping(method = RequestMethod.GET)，用于处理 HTTP Get 请求 @PostMapping：等同于 @RequestMapping(method = RequestMethod.POST)，用于处理 HTTP Post 请求 @PutMapping：等同于 @RequestMapping(method = RequestMethod.PUT)，用于处理 HTTP Put 请求 @DeleteMapping：等同于 @RequestMapping(method = RequestMethod.DELETE)，用于处理 HTTP Delet 请求 @PatchMapping：等同于 @RequestMapping(method = RequestMethod.PATCH)，用于处理 HTTP Patch 请求 三、请求参数传递 3.1、GET/POST请求传递基础参数 GET 请求的参数通过 URL 传递，附加在 URL 后面，形式为查询字符串（Query String），例如： http://localhost:8080/save?name=Jerry&age=13 POST 请求数据通过请求体（Request Body）传递，不会显示在 URL 中，在 Postman 中使用传递参数： 在 Java 的控制器方法中使用相同名称的形参，SpringMVC 可以自动将请求参数绑定到控制器方法中同名的形参上： @Controller public class UserController { // 如果要限制使用特定请求方法（POST/GET），将RequestMapping换成PostMapping或者GetMapping即可 @RequestMapping("/save") @ResponseBody public String save(String name, int age) { // ... } } 除此之外，SpringMVC 也支持将请求参数映射到不同名称的形参上，需要用 @RequestParam 注解指定请求参数绑定到控制器方法的哪个形参上： @Controller public class UserController { @RequestMapping("/save") @ResponseBody public String save(@RequestParam("name")String userName, @RequestParam("age")int userAge) { // ... } } @RquestParam 注解的属性： value 或 name：指定请求参数的名称。如果省略，默认使用控制器方法的形参名作为参数名称。 required：指定参数是否为必填项。默认值为 true，表示请求中必须包含该参数，如果请求中缺少该参数，Spring 会抛出 MissingServletRequestParameterException。如果设置为 false，则参数可以为空。 defaultValue：指定参数的默认值。如果请求中未提供该参数，则使用该默认值。 3.2、传递复杂参数 3.2.1、日期类型 在请求中传递特定格式的日期： http://localhost:8080/save?date=2023-10-12 在控制层方法的形参前面加上 @DateTimeFormat 注解并指定日期格式，SpringMVC 就可以将同名请求参数转换为日期格式： @RequestMapping("/dateParse") @ResponseBody public String dateParse(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date) { // ... } 3.2.2、引用类型 例如存在一个 User 对象，其中包含一个引用类型的成员 address： public class Address { // 省 private String province; // 市 private String city; } public class User { // 姓名 private String name; // 年龄 private String age; // 地址——引用对象 private Address address; } 控制器方法中使用 User 对象接收参数： @Controller public class UserController { @RequestMapping("/save") @ResponseBody public String save(User user) { // ... } } 那么在请求中传递参数时保持参数名与控制器方法形参名相同即可（不相同时使用 @RequestParam 绑定）： GET： http://localhost:8080/save?name=Jerry&age=13&address.province=河南&address.city=开封 POST： 3.2.3、数组 控制器方法中使用数组接收参数： @Controller public class UserController { @RequestMapping("/save") @ResponseBody public String save(String[] nameArray) { // ... } } 那么在请求中传递参数时都使用相同名称的参数即可： GET： http://localhost:8080/save?nameArray=Jerry&nameArray=Tom&nameArray=Mike POST： 3.2.4、集合（List/Set/Map） 控制器方法中使用集合接收参数（形参前需要加 @RequestParam 注解）： @Controller public class UserController { @RequestMapping("/save") @ResponseBody public String save(@RequestParam List<String> nameList) { // ... } } 在请求中传递参数的方式与数组相同： GET： http://localhost:8080/save?nameArray=Jerry&nameArray=Tom&nameArray=Mike POST： 3.3、传递Json数据 添加处理 Java 对象与 JSON 数据相互转换的依赖坐标： <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.18.2</version> </dependency> 在 SpringMVC 配置上添加 @EnableWebMvc 注解开启 Spring MVC 的默认配置（其中包括 Java 对象与 JSON 数据的相互转换）： @Configuration @ComponentScan("com.wlplove.controller") @EnableWebMvc public class SpringMvcConfig { // ... } 发送的 JSON 数据： { "name": "Tom", "age": 12 } 控制器方法中用集合或者对象接收时形参前加上 @RequestBody 注解将请求体中的数据绑定到控制器方法的参数上： @RequestMapping("/json") @ResponseBody public String json2Dto(@RequestBody User user) { // ... } 四、响应 4.1、返回Json数据 需要添加 Jackson 的依赖： <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.18.2</version> </dependency> 在控制器方法上使用 @ResponseBody 注解，告知 SpringMVC 将控制层方法的返回值直接写进 HTTP 响应体，而不是解析为视图。最后 SpringMVC 通过 HttpMessageConverter 接口将返回值转换为适当的格式（如 JSON、XML等）。 @RequestMapping("/returnJson") @ResponseBody public User returnJson() { User user = new User(); user.setAge(20); user.setName("QWERT"); return user; } @ResponseBody 支持的返回值类型： 基本类型（String、int、boolean 等）。 自定义对象（User、Product 等）。 集合或数组（List<User>、String[] 等）。 4.2、封装返回结果 新建一个返回结果对象： public class Result { /** 状态码 */ private Integer code; /** 返回内容 */ private String msg; /** 数据对象 */ private Object data; public Result(Integer code, Object data) { this.code = code; this.data = data; } public Result(Integer code, String msg, Object data) { this.code = code; this.msg = msg; this.data = data; } // get和set方法 } 自定义返回编码： public class Code { public static final Integer OK = 000000; public static final Integer ERR =999999; // 其他编码 } 对 controller 方法的返回值都统一成这个返回对象： @Controller @RequestMapping("/users") public class UserController { @Autowired private UserMapper userMapper; @RequestMapping("/{id}") @ResponseBody public Result findById(@PathVariable Integer id) { User user = userMapper.selectById(id); Integer code = user != null ? Code.OK : Code.ERR; String msg = user != null ? "数据查询成功" : "数据查询失败"; return new Result(code, msg, user); } // ... } 五、REST风格 5.1、简介 REST（Representational State Transfer）风格是一种软件架构风格，用于设计网络应用程序，其核心概念旨在通过 HTTP 协议实现客户端与服务器之间简洁、可扩展且高效的交互。 传统风格资源描述形式： http://lcoalhost/user/getById?id=1 http://localhost/user/saveUser REST风格描述形式： http://localhost/user/1 http://localhost/user REST 风格是一种设计接口的约定方式，并非规范。 5.2、规则 REST 使用统一的接口与服务器进行交互，基于 HTTP 协议的标准方法： GET 用于获取资源 POST 用于创建资源 PUT 用于更新资源 DELETE 用于删除资源 5.3、相关注解 5.3.1、@RestController @RestController 是 Spring 4.0 引入的一个组合注解，它是 @Controller 和 @ResponseBody 的结合体。其主要作用是将一个控制器类标记为使用 REST 风格，使用 @RestController 注解的类中的所有处理方法默认都会将返回值直接写入 HTTP 响应体，以 JSON、XML 等数据格式返回，而不是返回视图进行渲染。 5.3.2、@PathVariable @PathVariable 是 Spring MVC 中用于将 URL 中的模板变量绑定到控制器方法形参上的注解。它通常用于 RESTful API 中，从 URL 路径中提取参数值。 如根据 ID 查询用户的控制器方法： @GetMapping("/users/{id}") public String findById(@PathVariable Long id) { // ... } 那么对于 GET 请求链接 http://localhost/users/123456，该控制器可以通过 @PathVariable 将 “123456” 绑定到形参 id 上。 也支持在路径中定义多个路径变量： http://localhost/users/123456/orders/987654321 在控制器方法中接收多个参数： @GetMapping("/users/{userId}/orders/{orderId}") public Order getOrder(@PathVariable Long userId, @PathVariable Long orderId) { // ... } Spring MVC 5.3 及以上版本支持可选路径变量。如果路径变量是可选的，可以设置属性 required = false： @GetMapping("/users/{id}") public User getUser(@PathVariable(required = false) Long id) { if (id == null) { // 返回所有用户 return userService.getAllUsers(); } // 返回指定id的用户 return userService.getUserById(id); } 那么： http://localhost/users id为null，返回所有用户 http://lcoalhost/users/123 返回id为123的用户 5.3.3、@RequestParam 详见 3.1。 5.3.4、@RequestBody 详见 3.3。 5.4、Rest风格开发示例 5.3.1、查询 // 查询全部 @GetMapping("/users") public xxxResponse findAll() { // ... } // 根据主键查询 @GetMapping("/users/{id}") public xxxResponse findById(@PathVariable Long id) { // ... } 5.3.2、新增 @PostMapping("/users") public xxxResponse add(@RequestBody User user) { // ... } 5.3.3、修改（更新） @PutMapping("/users") public xxxResponse update(@RequestBody User user) { //... } 5.3.4、删除 @DeleteMapping("/delete/{id}") public xxxResponse delete(@PathVariable Long id) { // ... } 六、异常处理 6.1、自定义异常 新建一个自定义异常类 BusinessException： public class BusinessException extends RuntimeException { private Integer code; public BusinessException(Integer code, String message) { super(message); this.code = code; } // get和set方法 } 自定义异常编码： public class ErrorCode { public static final Integer TIMEOUT_ERROR = 10001; // 其他异常编码 } 在业务层代码中抛出异常： throw new BusinessException(ErrorCode.TIMEOUT_ERROR, "请求超时，请稍后再试"); 6.2、处理异常的方式 6.2.1、使用@ControllerAdvice和@ExceptionHandler @ControllerAdvice 是 Spring 框架提供的一个用于定义全局异常处理、数据绑定和数据预处理等逻辑的注解。在配合标注了 @ExceptionHandler 注解的方法使用时，可以在拦截到对应的异常之后终止原 controller 方法的执行，并转入该方法执行设定好的异常处理逻辑。 在 controller 包中新建一个全局异常处理类 GlobalExceptionHandler，在类中的方法上面使用 @ExceptionHandler 注解指定这个方法要处理哪种异常： @ControllerAdvice public class GlobalExceptionHandler { // Exception是所有异常的父类，在此表示拦截到所有的异常都会进行处理 @ExceptionHandler(Exception.class) // 方法参数中加入这种异常类型的形参，就可以获取到这个异常的信息 public ResponseEntity<String> doException(Exception ex) { return new ResponseEntity<>("异常信息: " + ex.getMessage()); } // 只处理RuntimeException异常 @ExceptionHandler(RuntimeException.class) public Response<T> doRuntimeException(RuntimeException ex){ // RuntimeException异常处理逻辑 } // 只处理IOException异常 @ExceptionHandler(IOException.class) public Response<T> doIOException(IOException ex){ // IOException异常处理逻辑 } // ... } 如果在控制器中使用 Rest 风格的开发，可以使用 @RestControllerAdvice 注解，@RestControllerAdvice 是 @ControllerAdvice 和 @ResponseBody 的组合注解，类中的方法返回值会自动进行 JSON 或 XML 等格式的序列化，直接作为响应体返回给客户端。 6.2.2、实现HandlerExceptionResolver接口 HandlerExceptionResolver 是 Spring Web 框架中的一个接口，它提供了一种统一处理控制器（@Controller）中抛出的异常的机制。通过实现这个接口，开发者可以自定义异常处理逻辑，以满足不同的业务需求，比如返回特定格式的错误响应、记录异常日志等。 处理异常主要通过该接口中的 resolveException 方法实现 方法参数： HttpServletRequest request：当前请求对象，通过它可以获取请求的各种信息，如请求头、请求参数等。 HttpServletResponse response：当前响应对象，可用于设置响应头、响应状态码等。 Object handler：处理当前请求的处理器对象，通常是一个控制器方法。 Exception ex：在处理请求过程中抛出的异常对象。 方法返回值： ModelAndView 是 Spring MVC 中用于封装视图和模型数据的类。如果返回 null，表示该异常解析器没有处理该异常，Spring 将继续尝试其他的异常解析器。如果返回一个非空的 ModelAndView 对象，Spring 会根据其中的视图信息渲染相应的视图，并将模型数据传递给视图。 新建一个异常处理类 CustomExceptionResolver，用 @Component 注解声明这是一个 Spring Bean，实现 HandlerExceptionResolver 接口中的 resolveException 方法： @Component public class CustomExceptionResolver implements HandlerExceptionResolver { public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) { ModelAndView modelAndView = new ModelAndView(); if (ex instanceof IllegalArgumentException) { modelAndView.setViewName("error/400"); // 跳转到 400 错误页面 modelAndView.addObject("errorMessage", "非法参数: " + ex.getMessage()); response.setStatus(HttpServletResponse.SC_BAD_REQUEST); } else { modelAndView.setViewName("error/500"); // 跳转到 500 错误页面 modelAndView.addObject("errorMessage", "服务器内部错误: " + ex.getMessage()); response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); } return modelAndView; } } 七、拦截器 在 Spring 中，拦截器是利用 AOP（面向切面编程）的思想实现的一种机制，用在请求处理的不同阶段（如请求到达 controller 方法之前、controller 方法执行之后、视图渲染之前等）执行自定义逻辑，在以下的场景中广泛使用： 权限验证：在请求到达控制器之前，检查用户是否具有访问该资源的权限，如验证用户登录状态。 日志记录：记录请求的相关信息，如请求的 URL、参数、处理时间等，方便后续的调试和监控。 性能监控：统计请求的处理时间，找出性能瓶颈。 请求参数处理：对请求参数进行统一的预处理，如编码转换、参数验证等。 7.1、创建拦截器 在 controller 包中新建一个包 interceptor，创建拦截器类 ProjectInterceptor，实现 HandlerInterceptor 接口，并用 @Component 声明为一个 bean： @Component public class ProjectInterceptor implements HandlerInterceptor { // 在控制器处理请求之前调用 @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 通过handler对象经过反射可以获取到原controller方法 System.out.println("preHandle: 请求到达控制器之前"); // 可以在此处进行权限验证、日志记录等操作 // 如果返回 false，请求将被中断，不再执行postHandle与afterCompletion return true; } // 在控制器处理请求之后、视图渲染之前调用 @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("postHandle: 控制器处理请求之后"); // 可以在此处修改模型数据或视图 } // 在视图渲染完成之后调用（无论请求是否成功） @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("afterCompletion: 视图渲染完成之后"); // 可以在此处进行资源清理、日志记录等操作 } } 7.2、注册和配置拦截器 在 config 包下新建一个配置类 SpringMvcSupport，继承 WebMvcConfigurationSupport 类，并重写 addInterceptors 方法，在这个方法中注册和配置拦截器： @Configuration public class SpringMvcSupport extends WebMvcConfigurationSupport { // 注入之前定义好的拦截器类 @Autowired private ProjectInterceptor projectInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(projectInterceptor) // 指定要拦截的路径,可以传入多个路径 .addPathPatterns("/**") // 指定要排除的路径,可以传入多个路径 .excludePathPatterns("/login", "/register"); } } addPathPatterns 和 excludePathPatterns 方法均支持 Ant 风格的路径匹配规则，具体语法规则如下： ?：匹配单个字符。 示例：/user? 可以匹配 /user1、/userA，但不能匹配 /user12。 \*：匹配任意数量的字符（不包括路径分隔符 /）。 示例：/user/* 可以匹配 /user/123、/user/profile，但不能匹配 /user/123/address。 `\**：匹配任意数量的字符（包括路径分隔符/`）。 示例：/user/** 可以匹配 /user/123、/user/123/address。 {variable}：匹配路径变量。 示例：/user/{id} 可以匹配 /user/123，并将 123 绑定到路径变量 id 除了新建一个 SpringMvcSupport 配置类来配置拦截器的方法外，还可以让原来的 SpringMvc 配置类来实现 WebMvcConfigurer 接口中的 addInterceptors 方法，也能达到相同的效果： @Configuration @ComponentScan("com.xxx.controller") @EnableWebMvc public class SpringMvcSupport implements WebMvcConfigurer { // 注入之前定义好的拦截器类 @Autowired private ProjectInterceptor projectInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(projectInterceptor) // 指定要拦截的路径,可以传入多个路径 .addPathPatterns("/**") // 指定要排除的路径,可以传入多个路径 .excludePathPatterns("/login", "/register"); } } 7.3、执行流程和顺序 拦截器执行流程： 如果有多个拦截器，形成拦截器链，它们的执行顺序如下： preHandle：按照注册顺序依次执行，必定运行。 postHandle：按照注册顺序的逆序执行，可能不运行。 afterCompletion：按照注册顺序的逆序执行，可能不运行。 例如拦截器 A、B、C 按顺序注册： preHandle 执行顺序：A → B。 postHandle 执行顺序：B → A。 afterCompletion 执行顺序：B → A。
目录 一、创建Webapp项目 二、Spring配置类 三、数据源对象（以Druid为例） 四、整合MyBatis 4.1、数据库配置 4.2、MyBatis配置 五、整合SpringMVC 六、整合Log4j 七、整合Junit 环境说明： 数据库：MySQL 8.0 Java版本：JDK8 通过注解整合 SSM 框架流程： 创建 Web 工程 SSM 整合 Spring 框架：SpringConfig MyBatis 框架：JdbcConfig / jdbc.properties / MybatisConfig SpringMVC 框架：ServletConfig / SpringMvcConfig 一、创建Webapp项目 在 IDEA 中根据 “maven-archetype-webapp” 模板创建 Webapp 项目： 创建基本项目结构： 二、Spring配置类 引入 spring-conext 的依赖坐标： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.25.RELEASE</version> </dependency> 创建一个 Java 类 SpringConfig 作为 Spring 配置类，类上面添加 @Configuration 注解标识这是一个配置类，添加 @ComponentScan 注解来设置扫描注解的路径 @Configuration @ComponentScan("com.xxx") /** * 如果有多个要扫描的包路径，可以用数组格式： * @ComponentScan({"com.xxx.dao","com.xxx.service"}) */ public class SpringConfig { } 三、数据源对象（以Druid为例） 导入 Druid 数据源的依赖坐标： <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.22</version> </dependency> 新建一个配置数据库连接信息的类 JdbcConfig，里面引入配置文件中的数据库信息，然后用一个方法构造并返回一个 DataSource 对象，最后用 @Bean 注解设置这个方法的返回值成为 Spring IoC 容器的一个 Bean： public class JdbcConfig { @Value("${jdbc.driver}") private String driver; @Value("${jdbc.url}") private String url; @Value("${jdbc.username}") private String username; @Value("${jdbc.password}") private String password; /** * 数据源Bean * @return */ @Bean public DataSource dataSource() { DruidDataSource ds = new DruidDataSource(); ds.setDriverClassName(driver); ds.setUrl(url); ds.setUsername(username); ds.setPassword(password); return ds; } } Spring 配置类 SpringConfig 中用 Import 注解引入 JdbcConfig 这个类： @Configuration @ComponentScan("com.xxx") +@Import({JdbcConfig.class}) public class SpringConfig { } 四、整合MyBatis 4.1、数据库配置 在 src/main/resources 目录下新建一个配置数据库连接信息的配置文件 jdbc.properties： jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?useSSL=false&setUnicode=true&characterEncoding=utf8 jdbc.username=root jdbc.password=root 使用 @PropertySource 注解在 Spring 配置类 SpringConfig 上加载外部的 properties 文件： @Configuration @ComponentScan({"com.xxx"}) +@PropertySource("classpath:jdbc.properties") public class SpringConfig { } 4.2、MyBatis配置 导入 MyBatis 及 MySQL 的相关依赖坐标： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.25.RELEASE</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.16</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.3</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> 新建一个 MyBatis 的配置类 MybatisConfig，配置 SqlSessionFactoryBean 和 MapperScannerConfigurer 这两个 Bean： public class MybatisConfig { @Bean public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) { SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean(); ssfb.setDataSource(dataSource); ssfb.setTypeAliasesPackage("com.xxx.xxx"); return ssfb; } @Bean public MapperScannerConfigurer mapperScannerConfigurer() { MapperScannerConfigurer msc = new MapperScannerConfigurer(); // Mapper的XML映射文件所在路径 msc.setBasePackage("com.xxx.dao"); return msc; } } Spring 配置类 SpringConfig 中用 Import 注解引入 MybatisConfig 这个类： @Configuration @ComponentScan("com.xxx") +@Import({JdbcConfig.class, MybatisConfig.class}) @PropertySource("classpath:jdbc.properties") public class SpringConfig { } 五、整合SpringMVC 导入 SpringMVC、Servlet 与 jackson 的依赖坐标： <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.25.RELEASE</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.18.2</version> </dependency> 新建 SpringMVC 配置类 SpringMvcConfig： @Configuration @ComponentScan("com.wlplove.controller") @EnableWebMvc public class SpringMvcConfig { } 新建 Servlet 的初始化类 ServletInitializer： public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer { protected Class<?>[] getRootConfigClasses() { return new Class[]{SpringConfig.class}; } protected Class<?>[] getServletConfigClasses() { return new Class[]{SpringMvcConfig.class}; } protected String[] getServletMappings() { return new String[]{"/"}; } } 六、整合Log4j 导入 Log4j 的依赖坐标： <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.23.1</version> </dependency> 在 "src/main/java/resources" 下新建一个 Log4j 的配置文件 Log4j2.xml： <?xml version="1.0" encoding="UTF-8"?> <configuration> <Appenders> <Console name="console" target="SYSTEM_OUT"> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> </Console> <!-- <File name="allLog" fileName="logs/AlliInOne.log" append="true">--> <!-- <ThresholdFilter level="ALL" onMatch="ACCEPT" onMismatch="DENY"/>--> <!-- <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5p %c{9.9.9.1}(%L) %m%n"/>--> <!-- </File>--> <RollingFile name="rollingFileInfo" fileName="logs/${date:yyyy-MM}/log-info-${date:yyyy-MM-dd}.log" filePattern="logs/${date:yyyy-MM}/log-info-%d{yyyy-MM-dd}-%i.log"> <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> <Policies> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <SizeBasedTriggeringPolicy size="10MB"/> </Policies> <DefaultRolloverStrategy max="20"/> </RollingFile> </Appenders> <loggers> <!-- level指定日志级别，从低到高的优先级： ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF --> <Logger name="org.mybatis" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <Logger name="org.springframework" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <root level="DEBUG"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </root> </loggers> </configuration> Log4j 配置文件详解：彻底掌握Log4j2 - 蚂蚁小哥 - 博客园 修改 MyBatis 配置类中的 SqlSessionFactoryBean，设置其 Configuration 属性： public class MybatisConfig { // ... @Bean public SqlSessionFactoryBean getSqlSessionFactory(DataSource dataSource) { SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean(); ssfb.setTypeAliasesPackage("com.xxx.xxx"); ssfb.setDataSource(dataSource); + Configuration configuration = new Configuration(); + // 修改MyBatis使用的日志框架为Log4j + configuration.setLogImpl(Log4j2Impl.class); + ssfb.setConfiguration(configuration); return ssfb; } // ... } 七、整合Junit 导入 Junit 和 Spring-test 的依赖坐标： <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.10.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.2.10.RELEASE</version> </dependency> 新建一个测试类： // 在 JUnit 5 中集成 Spring 功能（如果是Junit4则换成@RunWith(SpringJunit4ClassRunner.class)） @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = SpringConfig.class) public class SpringTest { @Autowired private UserMapper userMapper; @Test public void find() { User user = userMapper.select(); } }
目录： 一、通过注解定义Bean 1.1、启用注解支持 1.2、定义Bean 1.3、@Component的派生注解 1.3.1、@Repository 1.3.2、@Service 1.3.3、@Controller 1.3.4、@Configuration 1.4、用注解代替XML配置文件 1.4.1、配置类 1.4.2、初始化IoC容器 二、通过注解使用Bean 2.1、自动装配 2.1.1、@Autowired 2.1.2、@Qualifier 2.1.3、@Resource 2.1.4、@Primary 2.1.5、@Value 2.2、读取properties文件配置 2.3、作用域 2.4、自定义Bean初始化/销毁操作 2.5、总结 三、整合框架 3.1、数据源对象（以Druid为例） 3.2、整合Mybatis 3.3、整合Log4j 3.4、整合Junit 四、Spring事务 一、通过注解定义Bean 1.1、启用注解支持 <context:annotation-config /> 若要以注解方式注入 Bean，则需要开启扫描包中的组件，并用 base-package 属性指定扫描的基本包路径： <context:component-scan base-package="com.xxx" /> 使用 <context:annotation-scan> 标签时，默认将隐式启用对注解的支持。 1.2、定义Bean 在 XML 配置中如果要将一个 Bean 交给 Spring IoC 容器管理，需要进行如下配置： <bean id="userService" class="com.wlplove.service.impl.UserServiceImpl" /> 若用注解要实现相同目的，只需要在要被管理的 Java 类上添加 @Component 注解，并在后面的括号中指定 Bean 的名称： // 注解后面的括号里是 bean 的名称 @Component("userServiceImpl") public class UserServiceImpl implements UserService { // ... } @Component 注解也可以不指定 Bean 名称，Spring 会自动为该 Bean 生成一个默认的名称，通常是类名的首字母小写形式： @Component // 可以用名称“userServiceImpl”来获取这个Bean public class UserServiceImpl implements UserService { // ... } 所以只需要在 Java 类上加入 @Component 注解，用于标识这个类是 Spring 容器中的组件（即 Bean），就可以实现与 XML 配置中的 <bean> 标签相同的作用。 1.3、@Component的派生注解 此外，Spring 还提供了 @Component 的几个派生注解：@Repository、@Service、@Controller、@Configuration，这几个注解的功能和用法与 @Component 相同，但它们在使用场景上有所不同。 1.3.1、@Repository 用于数据访问层（Dao 层）中与数据库交互的类。 Spring 会对使用 @Repository 注解的类进行特定的异常处理（将数据访问层的异常，如 SQLException 等转换为 Spring 的 DataAccessException 异常，方便统一处理和异常传播）。 @Repository public interface UserMapper { // ... } 1.3.2、@Service 用于标识业务逻辑层（Service 层）中处理核心业务逻辑的类。 使用 @Service 注解可以将一个类声明为业务逻辑组件，将其对象存入 Spring 容器中，以便在其他组件（如Controller）中通过注入该 service 类的实例来使用其业务逻辑。 @Service public class UserServiceImpl implements UserService { // ... } 1.3.3、@Controller 用于标识控制层（Controller 层）中处理响应和请求的类。 被 @Controller 标记的类实际上就是一个 Spring MVC Controller 对象，它可以处理请求，并通过 @RequestMapping 等注解将不同的请求分发到对应的方法上。 @Controller public class UserController { // ... } 1.3.4、@Configuration 用于标记替换 XML 配置文件的配置类，这个注解的用法将在 1.4 中详细说明。 1.4、用注解代替XML配置文件 Spring 支持完全去除 XML 配置文件实现纯注解开发，实现的方式就是使用一个 Java 类来代替原本的 XML 配置文件。 1.4.1、配置类 创建一个 Java 类，类上面添加 @Configuration 注解标识这是一个配置类： @Configuration public class SpringConfig { // ... } 在 XML 配置文件中会用到 <context:annotation-config base-package=""> 标签来设置扫描注解的路径，在配置类上添加 @ComponentScan 注解也可以实现相同的效果： @Configuration +@ComponentScan("com.xxx") public class SpringConfig { // ... } 如果有多个包路径，可以用数组格式： @ComponentScan({"com.xxx.dao","com.xxx.service"}) 1.4.2、初始化IoC容器 当创建出一个配置类之后，初始化 Spring IoC 容器的方式也需要改变。 原来是通过 ClassPathXmlApplicationContext 类加载 XML 配置文件初始化得到 IoC 容器： ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml"); 现在改用 AnnotationConfigApplicationContext 类来加载配置类得到 Spring IoC 容器： ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); 二、通过注解使用Bean 2.1、自动装配 2.1.1、@Autowired 在要引用的依赖上面使用 @Autowired 注解开启自动装配注入该依赖： @Service public class BookServiceImpl implements BookService { @Autowired private BookDao bookDao; public void save() { System.out.println("book service save ..."); bookDao.insert(); } } @Autowired 注解默认按照类型（byType）进行自动装配。 2.1.2、@Qualifier 如果 Spring IoC 容器中存在多个类型相同的 Bean 时，仅仅使用 @Autowired 根据类型自动装配时就导致 Spring 无法确定应该自动注入哪一个 Bean，便会抛出 NoUniqueBeanDefinitionException 异常。那么此时使用 @Qualifier 注解来指定要装配的 Bean 名称： @Repository public class BookDao1 implements BookDao { // ... } @Repository public class BookDao2 implements BookDao { // ... } @Service public class BookServiceImpl implements BookService { @Autowired // 存在两个BookDao类型的Bean，这里指定注入名称为bookDao1的Bean @Qualifier("bookDao1") private BookDao bookDao; } 需要注意的是，@Qualifier 不能单独使用，必须与 @Autowired 一起使用。因为 @Autowired 主要是根据类型进行自动装配，而 @Qualifier 则在此基础上匹配 Bean 名称，从而进行更精确的限制。 2.1.3、@Resource 还有一个与 @Autowired 类似的注解是 @Resource，默认按照名称（byName）进行自动装配，通过其 name 属性指定要注入的 Bean 名称： @Service public class BookServiceImpl implements BookService @Resource(name = "bookDao2") private BookDao bookDao; } 不像 @Autowired 是 Spring 框架提供的用于按类型（byType）自动装配的注解，@Resource 是 JavaEE 标准中（javax.annotation.Resource）提供的用于按名称（byName）自动装配的注解，并非 Spring 框架所特有的。 2.1.4、@Primary 与 @Qualifier 类似，@Primary 注解也可以用来解决当存在多个相同类型的 Bean 时应该注入哪一个 Bean 的问题。 如果 Spring IoC 容器中存在多个类型相同的 Bean，给该 Bean 上面添加 @Primary 注解，则 Spring 会优先使用标注了 @Primary 的 Bean。 2.1.5、@Value 使用 @Value 注解实现简单类型的注入： @Service public class UserServiceImpl implements UserService { @Value(30) private int age; @Value("root") private String userName; } @Value 注解除了用于给简单类型的成员注入固定的值以外，也可以用于将配置文件中的属性注入给简单类型的成员，配置文件中的属性名写在占位符 ${} 里面： @Service public class UserServiceImpl implements UserService { @Value("${user.name}") private String userName; } 2.2、读取properties文件配置 在 src/main/resources 目录下新建一个配置数据库连接信息的配置文件 jdbc.properties： jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?useSSL=false&setUnicode=true&characterEncoding=utf8 jdbc.username=root jdbc.password=root 使用 @PropertySource 注解在 Spring 配置类上加载外部的 properties 文件，在要注入值的成员上添加 @Value 注解指定注入哪个属性： /** * Spring配置类 */ @Configuration @ComponentScan({"com.xxx"}) @PropertySource("classpath:jdbc.properties") public class SpringConfig { // ... } /** * 使用属性 */ public class DataBaseConnInfo { // 注入配置文件中的属性 @Value("${jdbc.driverName}") private String driverName; @Value("${jdbc.url}") private String url; } 若要加载多个配置文件应使用数组： @PropertySource({"classpath:jdbc.properties","classpath:appConfig.properties"}) 2.3、作用域 使用注解 @Scope 定义 Bean 的作用域是 prototype（原型/非单例）或者 singleton（单例）。 public class AppConfig { @Bean // @Scope("prototype") @Scope("singleton") public MyBean myBean() { return new MyBean(); } } 2.4、自定义Bean初始化/销毁操作 使用 @PostConstruct 注解定义初始化方法（方法名不限），将在构造方法之后执行该方法。 使用 @PreDestroy 注解定义销毁方法（方法名不限），在容器销毁前执行该方法，一般用来释放占用的资源等。 public class UserServiceImpl implements UserService { @PostConstruct publid void init() { System.out.println("init ...."); } @PreDestroy public void destory() { System.out.println("destory ..."); } } 2.5、总结 三、整合框架 3.1、数据源对象（以Druid为例） 导入 Druid 数据源的依赖坐标： <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.22</version> </dependency> 新建一个配置数据库连接的类 JdbcConfig，里面引入配置文件中的数据库信息，然后用一个方法构造并返回一个 DataSource 对象，最后用 @Bean 注解设置这个方法的返回值成为 Spring IoC 容器的一个对象： public class JdbcConfig { @Value("${jdbc.driver}") private String driver; @Value("${jdbc.url}") private String url; @Value("${jdbc.username}") private String username; @Value("${jdbc.password}") private String password; /** * 数据源 * @return */ @Bean public DataSource dataSource() { DruidDataSource ds = new DruidDataSource(); ds.setDriverClassName(driver); ds.setUrl(url); ds.setUsername(username); ds.setPassword(password); return ds; } } Spring 配置类中用 Import 注解引入 JdbcConfig 这个类： @Configuration @ComponentScan("com.xxx") +@Import({JdbcConfig.class}) public class SpringConfig { // ... } 3.2、整合Mybatis 导入 MyBatis 的依赖坐标： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.1.4</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.16</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.3</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> 新建一个 MyBatis 配置类 MybatisConfig，配置 SqlSessionFactoryBean 和 MapperScannerConfigurer 这两个 Bean： public class MybatisConfig { @Bean public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) { SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean(); ssfb.setDataSource(dataSource); ssfb.setTypeAliasesPackage("com.xxx.xxx"); return ssfb; } @Bean public MapperScannerConfigurer mapperScannerConfigurer() { MapperScannerConfigurer msc = new MapperScannerConfigurer(); // Mapper接口所在的包路径 msc.setBasePackage("com.xxx.mapper"); return msc; } } Spring 配置类中用 Import 注解引入 MybatisConfig 这个类： @Configuration @ComponentScan("com.xxx") +@Import({JdbcConfig.class, MybatisConfig.class}) public class SpringConfig { // ... } 3.3、整合Log4j 导入 Log4j 的依赖坐标： <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.23.1</version> </dependency> 在 "src/main/java/resources" 下新建一个 Log4j 的配置文件 Log4j2.xml： <?xml version="1.0" encoding="UTF-8"?> <configuration> <Appenders> <Console name="console" target="SYSTEM_OUT"> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> </Console> <!-- <File name="allLog" fileName="logs/AlliInOne.log" append="true">--> <!-- <ThresholdFilter level="ALL" onMatch="ACCEPT" onMismatch="DENY"/>--> <!-- <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5p %c{9.9.9.1}(%L) %m%n"/>--> <!-- </File>--> <RollingFile name="rollingFileInfo" fileName="logs/${date:yyyy-MM}/log-info-${date:yyyy-MM-dd}.log" filePattern="logs/${date:yyyy-MM}/log-info-%d{yyyy-MM-dd}-%i.log"> <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> <Policies> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <SizeBasedTriggeringPolicy size="10MB"/> </Policies> <DefaultRolloverStrategy max="20"/> </RollingFile> </Appenders> <loggers> <!-- level指定日志级别，从低到高的优先级： ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF --> <Logger name="org.mybatis" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <Logger name="org.springframework" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <root level="DEBUG"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </root> </loggers> </configuration> Log4j 配置文件详解：彻底掌握Log4j2 - 蚂蚁小哥 - 博客园 修改 Mybatis 配置类中的 SqlSessionFactoryBean，设置其 Configuration 属性： public class MybatisConfig { // ... @Bean public SqlSessionFactoryBean getSqlSessionFactory(DataSource dataSource) { SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean(); ssfb.setTypeAliasesPackage("com.xxx.xxx"); ssfb.setDataSource(dataSource); + Configuration configuration = new Configuration(); + // 修改MyBatis使用的日志框架为Log4j2 + configuration.setLogImpl(Log4j2Impl.class); + ssfb.setConfiguration(configuration); return ssfb; } // ... } 3.4、整合Junit 导入 Junit 和 spring-test 的依赖坐标： <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.10.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.2.10.RELEASE</version> </dependency> 新建一个测试类： // 在 JUnit 5 中集成 Spring 功能，如果是Junit4则换成@RunWith(SpringJunit4ClassRunner.class) @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = SpringConfig.class) public class SpringTest { @Autowired private UserMapper userMapper; @Test public void find() { User user = userMapper.select(); } } 四、Spring事务 导入 Spring 事务的依赖坐标： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.2.10.RELEASE</version> </dependency> 在 Spring 的配置类上添加注解 @EnableTransactionManagement 开启 Spring 的事务管理功能： @Configuration @ComponentScan("com.xxx") @Import({JdbcConfig.class, MybatisConfig.class}) +@EnableTransactionManagement public class SpringConfig { // ... } 配置类中添加 PlatformTransactionManager 这个 Bean： @Bean public PlatformTransactionManager getTransactionManager(DataSource dataSource) { DataSourceTransactionManager dstm = new DataSourceTransactionManager(); dstm.setDataSource(dataSource); return dstm; } 最后在 service 方法或类上面用 @Transactional 注解设置添加事务管理，在执行该方法或类中的方法时便会开启事务管理，如果程序执行时发生异常就回滚之前的数据库操作。 需要注意的是，当在同一类中调用有 @Transactional 注解的方法时，可能不会触发事务管理，因为它绕过了 Spring 的代理机制，解决办法是将这个方法也标记为 @Transactional。
目录： 一、创建Webapp项目 二、加载properties文件 2.1、新建properties文件 2.2、指定要加载的properties文件 2.3、读取properties文件属性值的方式 三、数据源对象（以Druid为例） 3.1、导入Druid数据源依赖坐标 3.2、在XML文件中配置数据源对象为Spring管理的Bean 四、整合MyBatis 4.1、导入依赖坐标 4.2、配置SqlSessionFactoryBean 4.3、配置MapperScannerConfigurer 五、整合Junit 六、整合Log4j 在 pom.xml 文件中导入 Spring 的坐标依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.10.RELEASE</version> </dependency> 一、创建Webapp项目 在 IDEA 中根据 “maven-archetype-webapp” 模板创建 Webapp 项目： 创建基本项目结构： 在 src/main/resources 目录下新建一个 spring-config.xml 文件作为 Spring 的配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans> 二、加载properties文件 2.1、新建properties文件 在 src/main/resources 目录下新建一个配置数据库连接信息的配置文件 jdbc.properties： jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db jdbc.username=root jdbc.password=root 2.2、指定要加载的properties文件 在 Spring 的 XML 配置文件中加载指定 properties 文件，写法有多种： 加载资源路径（src/main/java/resources）下指定的一个 properties 文件： <context:property-placeholder location="classpath:jdbc.properties"/> 也可以加载资源路径下的多个 properties 文件： <context:property-placeholder location="classpath:jdbc.properties,classpath:jdbc2.properties"/> 使用通配符加载 properties 文件：在资源路径或 jar 包中搜索并加载所有 properties 文件 <context:property-placeholder location="classpath*:*.properties"/> 再加上 system-properties-mode="NEVER"，表示 Spring 容器在解析 properties 配置文件时，不使用系统属性来替换配置文件中的属性，从而避免系统属性对配置产生影响： <context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/> 2.3、读取properties文件属性值的方式 <property name="driverClassName" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> 三、数据源对象（以Druid为例） 3.1、导入Druid数据源依赖坐标 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.22</version> </dependency> 3.2、在XML文件中配置数据源对象为Spring管理的Bean <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> <property name="initialSize" value="10"/> <property name="maxActive" value="100"/> <property name="maxWait" value="-1"/> </bean> 四、整合MyBatis 4.1、导入依赖坐标 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.1.4</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.16</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.3</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> 4.2、配置SqlSessionFactoryBean SqlSessionFactoryBean 是 Spring 与 MyBatis 集成时使用的一个关键类，它实现了 Spring 的 FactoryBean<SqlSessionFactory> 接口，用于创建 SqlSessionFactory 对象。 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="mapperLocations" value="classpath*:com/wlplove/dao/*.xml"/> <property name="typeAliasesPackage" value="com.wlplove.domain"/> <!-- <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>--> <property name="configuration"> <bean class="org.apache.ibatis.session.Configuration"> <property name="mapUnderscoreToCamelCase" value="true"/> <property name="cacheEna bled" value="true"/> <property name="defaultExecutorType" value="SIMPLE"/> <property name="logImpl" value="org.apache.ibatis.logging.log4j2.Log4j2Impl"/> </bean> </property> </bean> 4.3、配置MapperScannerConfigurer MapperScannerConfigurer 是 Spring 框架中用于整合 MyBatis 的一个配置类，它可以扫描指定包下的 Mapper 接口，并将它们的实现类自动注入到 Spring IoC 容器中。 <bean name="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.wlplove.dao"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> </bean> 五、整合Junit 导入 Junit 和 spring-test 的依赖坐标： <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.10.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.2.10.RELEASE</version> </dependency> 新建一个测试类： // 在 JUnit 5 中集成 Spring 功能，如果是Junit4则换成@RunWith(SpringJunit4ClassRunner.class) @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = SpringConfig.class) public class SpringTest { @Autowired private UserMapper userMapper; @Test public void test() { User user = userMapper.select(); } } 六、整合Log4j 导入 Log4j 的依赖坐标： <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.23.1</version> </dependency> 在 "src/main/java/resources" 下新建一个 Log4j 的配置文件 Log4j2.xml： <?xml version="1.0" encoding="UTF-8"?> <configuration> <Appenders> <Console name="console" target="SYSTEM_OUT"> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> </Console> <!-- <File name="allLog" fileName="logs/AlliInOne.log" append="true">--> <!-- <ThresholdFilter level="ALL" onMatch="ACCEPT" onMismatch="DENY"/>--> <!-- <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5p %c{9.9.9.1}(%L) %m%n"/>--> <!-- </File>--> <RollingFile name="rollingFileInfo" fileName="logs/${date:yyyy-MM}/log-info-${date:yyyy-MM-dd}.log" filePattern="logs/${date:yyyy-MM}/log-info-%d{yyyy-MM-dd}-%i.log"> <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/> <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/> <Policies> <TimeBasedTriggeringPolicy interval="1" modulate="true"/> <SizeBasedTriggeringPolicy size="10MB"/> </Policies> <DefaultRolloverStrategy max="20"/> </RollingFile> </Appenders> <loggers> <!-- level指定日志级别，从低到高的优先级： ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF --> <Logger name="org.mybatis" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <Logger name="org.springframework" level="WARN" additivity="false"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </Logger> <root level="DEBUG"> <appender-ref ref="console"/> <appender-ref ref="rollingFileInfo"/> </root> </loggers> </configuration> Log4j 配置文件详解：彻底掌握Log4j2 - 蚂蚁小哥 - 博客园 修改 Spring 配置中的 SqlSessionFactoryBean，修改 MyBatis 使用的日志框架为 Log4j2： <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="mapperLocations" value="classpath*:com/wlplove/dao/*.xml"/> <property name="typeAliasesPackage" value="com.wlplove.entity"/> <property name="configuration"> <bean class="org.apache.ibatis.session.Configuration"> <property name="logImpl" value="org.apache.ibatis.logging.log4j2.Log4j2Impl"/> </bean> </property> </bean>
目录： 一、Spring简介 二、Bean配置 2.1、基础配置 2.2、别名配置 2.3、作用域 三、Bean的生命周期 3.1、实例化 3.2、属性赋值 3.3、初始化 3.4、使用 3.5、销毁 3.6、示例：通过XML配置自定义初始化和销毁操作 3.7、示例：通过注解自定义初始化和销毁操作 四、实例化Bean的方式 4.1、无参构造方法 4.2、静态工厂 4.3、实例工厂 4.3.1、方式一 4.3.2、方式二（重要） 五、依赖注入（DI） 5.1、setter 注入 5.1.1、注入简单类型 5.1.2、注入引用类型 5.2、构造器注入 5.2.1、注入简单类型 5.2.2、注入引用类型 5.2.3、构造器注入的其他XML配置写法 type方式 index索引方式 5.3、自动装配 5.3.1、基于XML文件的自动装配 byType byName constructor 5.3.2、基于注解的自动装配 @Autowired @Resource 六、集合的注入 6.1、注入数组 6.2、注入 Set 对象 6.3、注入 List 对象 6.4、注入 Map 类型数据 6.5、注入 property 类型数据 七、Spring 容器的核心操作 7.1、创建容器 7.2、从 Srping 容器获取 Bean 7.2.1、根据 Bean 名称 7.2.2、根据 Bean 类型获取 7.2.3、根据 Bean 名称获取并指定类型 八、一图流总结 8.1、Bean： 8.2、依赖注入： 一、Spring简介 Spring 是一个开源的 Java 平台框架，它由 Rod Johnson 在 2003 年首次发布，旨在简化 Java 开发，为构建企业级应用程序提供全面的基础设施支持。Spring 的核心特性包括依赖注入（DI）和面向切面编程（AOP）。 在 pom.xml 文件中导入 Spring 的坐标依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.10.RELEASE</version> </dependency> 二、Bean配置 Bean 是 Spring 框架中最核心的概念之一，它是构成应用程序主干并由 Spring IoC 容器管理的对象。 Spring Bean 本质上是由 Spring IoC 容器实例化、组装和管理的对象，可以是任何 Java 类的实例，比如表示用户信息的 User 这类简单的 POJO（Plain Old Java Object），在 Spring 容器中被定义为一个 Bean 之后，Spring 可以对该 Java 类的实例进行各种诸如依赖注入等的管理操作。除此之外，Bean 也可以是一个复杂的企业级组件。 在 Java 中，对象一般通过 new 关键字来创建，但在 Spring 框架中由 IoC 容器负责这部分工作，完成对象的创建和依赖注入。这种机制允许开发者将对象的生命周期管理和依赖关系交给 Spring 容器管理，从而简化开发过程并提高代码的可维护性和灵活性。 2.1、基础配置 在 XML 文件中通过 <bean> 标签来配置需要让 Spring 管理的 Bean。 <bean id="userDao" class="com.wlplove.dao.impl.UserDaoImpl"/> <bean id="userService" class="com.wlplove.service.impl.UserServiceImpl"> <property name="userDao" ref="userDao"/> </bean> 在 XML 文件中经过上面的配置之后，就将这个类交给了 Spring IoC 容器进行管理，之后需要使用该类时就可以从容器中获取到实例对象了。 2.2、别名配置 name 属性表示 Bean 的别名，可以设置多个，使用逗号、分号、空格分开。 别名配置完成后，就可以通过别名直接获取 Bean 或者在其他 Bean 的配置中通过别名引用这个 Bean。 <bean id="bookService" name="service service2 bookEbi" class="com.wlplove.service.impl.BookServiceImpl"/> 2.3、作用域 Spring Bean 的 Scope 指的是 Bean 的作用域，它定义了 Bean 实例在 Spring 容器中的生命周期和可见性。一般常用的是 singleton（单例）、prototype（原型/非单例）： singleton：默认作用域，Spring 容器只会创建一个 Bean 实例，并在整个应用程序中共享。这个实例从容器启动时被初始化，直到容器销毁才会被释放。这种模式适用于无状态的服务对象，如 DAO 组件、控制器等。 prototype：每次请求 Bean 时都会创建一个新的实例。这些实例由 Spring 容器创建，但容器不会跟踪它们的管理和销毁，这些任务交由 Java 的垃圾回收机制来处理。适用于需要频繁创建且生命周期较短的 Bean，如用户会话数据对象。 Bean 的作用域通过 scope 属性来配置： <bean id="bookDao" class="com.wlplove.dao.impl.BookDaoImpl" scope="singleton"/> 也可以使用注解 @Scope 定义作用域： public class AppConfig { // @Scope("prototype") @Scope("singleton") public MyBean myBean() { return new MyBean(); } } 除此之外，还有 request、session 作用域。 request：一次 HTTP 请求都会产生一个新的 Bean，该 Bean 仅在当前 HTTP request 内有效。 session：每一次 HTTP 请求都会产生一个新的 Bean，该 Bean 仅在当前 HTTP session 内有效。 三、Bean的生命周期 Spring Bean 的生命周期是指 Bean 在 Spring 中从创建到销毁的整个过程。 对于作用域为 prototype 的 Bean（即非单例模式的 Bean）来说，Spring 在创建好 Bean 交给使用者之后则不会再管理后续的生命周期。 所以一般所说的 Bean 的生命周期主要针对于作用域为 singleton 的 Bean（即单例模式的 Bean），其生命周期主要包括实例化、属性赋值、初始化、使用和销毁五个阶段。 3.1、实例化 实例化指的是由 Spring 容器创建 Bean 实例的过程。 在这个阶段，Spring 容器通过反射机制来创建 Bean 的实例， 那就吗，给 Bean 分配内存空间。 3.2、属性赋值 Spring 容器根据 Bean 信息，为 Bean 的属性进行赋值操作。 这一阶段通常涉及到依赖注入（DI），Spring 容器会自动填充 Bean 的属性并将其他 Bean 的引用注入到当前 Bean 的属性中。 3.3、初始化 初始化阶段是 Spring Bean 生命周期中的一个重要环节，它标志着 Bean 已经准备好被使用。 在这个阶段，Spring 容器会执行一系列初始化操作，其中包括开发者自定义的初始化方法，开发者可以通过以下几种方式自定义初始化操作： XML 配置时在 <bean> 标签中定义属性 init-method 使用 @PostConstruct 注解定义初始化方法 实现接口 InitializingBean 的 afterPropertiesSet() 方法 3.4、使用 这一阶段，Bean 已经被完全初始化，并且可以被 Spring 容器提供给其他组件或服务进行调用。 3.5、销毁 销毁阶段是 Spring Bean 生命周期的最后一个阶段，它发生在 Bean 不再被需要时。 在这个阶段，Spring 容器会执行一系列的清理操作，包括开发者自定义的 Bean 的销毁方法，开发者可以通过以下几种方式： XML 配置时在 <bean> 标签中定义 destroy-method 属性 使用 @PreDestroy 注解定义销毁方法 实现接口 DisposableBean 的 destroy() 方法 这些操作旨在释放 Bean 所占用的资源，确保系统的稳定性和性能。 3.6、示例：通过XML配置自定义初始化和销毁操作 在 Java 类中分别定义一个初始化方法和销毁方法： public class UserServiceImpl implements UserService { @Override public void save() { System.out.println("save ..."); } // Bean 的初始化方法 publid void init() { System.out.println("init ...."); } // Bean 的销毁方法 public void destory() { System.out.println("destory ..."); } } 在 XML 配置中通过 init-method 方法指定 Bean 的初始化方法，destory-method 方法指定 Bean 的销毁方法： <bean id="userService" class="com.wlplove.service.impl.UserServiceImpl" init-method="init" destroy-method="destory" /> 3.7、示例：通过注解自定义初始化和销毁操作 在初始化方法上使用 @PostConstruct 注解，在销毁方法上使用 @PreDestroy 注解 public class UserServiceImpl implements UserService { @Override public void save() { System.out.println("save ..."); } // Bean 的初始化方法 @PostConstruct publid void init() { System.out.println("init ...."); } // Bean 的销毁方法 @PreDestroy public void destory() { System.out.println("destory ..."); } } 四、实例化Bean的方式 4.1、无参构造方法 Java 接口继承类中提供一个无参构造方法： public class UserServiceImpl implements UserService { private UserServiceImpl() { System.out.println("constructor is running ...."); } public void save() { System.out.println("save ..."); } } XML 配置： <bean id="userService" class="com.wlplove.service.impl.UserServiceImpl"/> 在接口继承类中必须要提供无参构造方法，如果不存在，将抛出 BeanCreationException 异常 4.2、静态工厂 单独创建一个工厂类 UserServiceFactory，其中提供一个静态方法 getUserService 作为实例化 Bean 的方法： public class UserServiceImpl implements UserService { // ... } // 工厂类 public class UserServiceFactory { // 静态工厂方法 public static UserService getUserService() { return new UserServiceImpl(); } } 在 XML 配置中 factory-method 指定静态工厂方法： <bean id="userService" class="com.wlplove.factory.UserServiceFactory" factory-method="getUserService"/> 4.3、实例工厂 4.3.1、方式一 定义一个工厂类 UserServiceFactory： // 工厂类 public class UserServiceFactory { // 工厂方法（非静态） public UserService getUserService() { return new UserServiceImpl(); } } XML 配置：' XML 中配置工厂类为 Bean，在需要实例化的 Bean 中通过 factory-bean 指定工厂类，factory-method 方法指定用工厂类的哪个方法来实例化 Bean。 <bean id="userServiceFactory" class="com.wlplove.factory.UserServiceFactory" /> <bean id="userService" factory-bean="userServiceFactory" factory-method="getUserService" /> 4.3.2、方式二（重要） FactoryBean 是 Spring 框架中用于创建复杂对象的一个特殊接口，它允许开发者创建一个工厂类，用于生成其他对象。这个接口定义了三个主要方法： getObject() 作用：返回由该 FactoryBean 创建的对象实例。这是 FactoryBean 最核心的方法，用于实际创建对象实例。 注意：这个方法可能会抛出异常，因为对象的创建过程可能涉及复杂的逻辑和资源管理。 getObjectType() 作用：返回由该 FactoryBean 创建的对象的类型。这有助于 Spring 容器在运行时了解 Bean 的类型信息，从而进行类型匹配和依赖注入。 默认实现：如果未重写此方法，则默认返回 Object.class。 isSingleton() 作用：指定返回的实例是否为单例。如果返回 true，则表示这个 FactoryBean 返回的对象在整个 Spring 容器中是唯一的；如果返回 false，则每次请求都会创建一个新的实例。 默认实现：如果没有明确指定，默认返回 true，即单例模式。 工厂类 UserServiceFactoryBean 继承 FactoryBean<T> 接口，并重写其中的 getObject() 和 getObjectType() 方法 // 省略 UserService 接口与 UserServiceImpl 继承类的定义... public class UserServiceFactoryBean implements FactoryBean<UserService> { @Override public UserServce getObject() throws Exception { return new UserServiceImpl(); } @Override public Class<?> getObjectType() { return UserService.class; } @Override public boolean isSingleton() { // true 返回单例对象，false 返回非单例对象 return ture; } } XML 配置： <bean id="userService" class="com.wlplove.factory.UserServiceFactoryBean" /> 五、依赖注入（DI） 依赖注入（Dependency Injection，简称 DI）是 Spring 框架的核心概念之一，用于实现控制反转（Inversion of Control，即 IoC），其核心思想是：对象的依赖关系由外部容器（如 Spring IoC 容器）在运行时注入，而不是由对象自己创建或查找依赖。 举个例子，假设有一个 UserService 类，它依赖于 UserDao 类。在没有依赖注入的情况下，UserService 需要自己创建 UserDao 的实例。这种方式的问题在于，UserService 和 UserDao 紧密耦合在一起，难以测试和维护。 而使用依赖注入后，UserService 不再自己创建 UserDao 实例，而是通过构造函数、Set 方法或自动装配的方式，由 Spring 容器提供 UserDao 的实例，从而提升代码的松耦合性、可测试性、可维护性和可扩展性 Spring 提供了三种主要的依赖注入方式：setter 注入、构造器注入、自动装配。 5.1、setter 注入 5.1.1、注入简单类型 Java 类中提供成员的 set 方法： public class User { private String name; private int age; public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } } Spring 配置中用 <property> 标签来定义具体成员： <bean id="user" class="com.wlplove.dto.User"> <property name="name" value="test" /> <property name="age" value="20" /> </bean> 5.1.2、注入引用类型 同样的，在 Java 类中提供对象的 set 方法： // 省略接口UserDao接口的定义 ... // 接口继承类 public class UserServiceImpl implements userService { private UserDao userDao; private setUserDao(UserDao userDao) { this.userDao = userDao; } @Override public void save() { userDao.insert(); } } XML 配置： <bean id="userDao" class="com.wlplove.dao.UserDao" /> <bean id="userServiceImpl" class="com.wlplove.service.UserServiceImpl"> <property name="userDao" ref="userDao" /> </bean> 5.2、构造器注入 在对象创建时，所有的依赖都通过构造器参数传入，类似于 setter 注入需要提供成员 set 方法，构造方法注入需要在类中提供构造方法，并且 XML 配置里使用构造器注入的参数顺序必须要与 Java 类构造方法的形参顺序相同。 5.2.1、注入简单类型 构造方法： public class User { private String name; private int age; public void User(String name, int age) { this.name = name; this.age = age; } } XML 配置： <bean id="user" class="com.wlplove.dto.User"> <construct-arg name="name" value="test" /> <construct-arg name="age" value="20" /> </bean> 5.2.2、注入引用类型 public class UserServiceImpl implements userService { private UserDao userDao; private UserServiceImpl(UserDao userDao) { this.userDao = userDao; } @Override public void save() { userDao.insert(); } } XML 配置： <bean id="userDao" class="com.wlplove.dao.UserDao" /> <bean id="userServiceImpl" class="com.wlplove.service.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao" /> </bean> 5.2.3、构造器注入的其他XML配置写法 type方式 在 constructor-arg 标签中使用 type 属性： <bean id="userDao" class="com.wlplove.dao.UserDao" /> <bean id="userServiceImpl" class="com.wlplove.service.UserServiceImpl"> <constructor-arg type="int" value="123" /> <constructor-arg type="java.lang.String" value="test" /> <constructor-arg type="com.wlplove.dao.UserDao" ref="userDao" /> </bean> type 方式解决了构造器注入时 name 属性绑定了形参名称从而造成强耦合的问题，如果一个 Bean 中某种类型（比如 int）的属性只有一个，那么可以用这种方式，反之，当相同类型的属性有很多个时，用这种方式就会给所有这种类型的属性都注入相同的值。 index索引方式 在 constructor-arg 标签中使用 index 属性： <bean id="userDao" class="com.wlplove.dao.UserDao" /> <bean id="user" class="com.wlplove.dao.dto.User"> <constructor-arg index="0" value="20" /> <constructor-arg index="1" value="test" /> <constructor-arg index="2" ref="userDao" /> </bean> 5.3、自动装配 5.3.1、基于XML文件的自动装配 所谓自动装配就是省略手动配置 Bean 依赖的步骤，而使 Spring 容器自动解析 Bean 之间的依赖关系，并将依赖的 Bean 注入到目标 Bean 中。需要注意的是，自动装配只针对于 Bean 中引用类型的依赖，简单类型的依赖无法被自动装配。 byType Spring 容器会根据属性的类型来自动装配。它会在容器中查找与需要注入的属性类型相同的 Bean，并将其注入到该属性中。 要使 Spring 容器按 Bean 类型自动装配，加入 autowire="byType"： <bean id="bookService" class="com.wlplove.service.UserServiceImpl" autowire="byType" /> 使用 byType 这种方式，必须保证配置文件中所有 Bean 的 class 属性值是唯一的，否则就会报错 byName Spring 容器会根据属性名称来自动装配，在容器中查找与需要注入的属性名称相同的 Bean，并将其注入到该属性中。严格来说，此处的属性名称并非是指成员变量名称，而是指 set 方法名去掉 set 之后将首字母小写的名称，比如 User 类中 age 属性的 set 方法为 setAge1()，那么将 set 方法处理之后得到的属性名称为 age1，Spring 容器根据属性名称 age1 自动装配，而不是 age。 要使 Spring 容器按 Bean 名称自动装配，加入 autowire="byName"： <bean id="bookService" class="com.wlplove.service.UserServiceImpl" autowire="byName" /> constructor 基于构造函数的自动装配。Spring 容器会查找与构造函数中形参的数量与类型相同的 Bean，并通过构造函数注入。 <bean id="bookService" class="com.wlplove.service.UserServiceImpl" autowire="constructor" /> 5.3.2、基于注解的自动装配 @Autowired @Autowired 是 Spring 框架提供的自动装配注解，是目前最常用的方式，默认按类型（byType）匹配。 构造器注入（推荐）：将 @Autowired 注解标注在构造器上，Spring 容器根据构造器参数类型来注入依赖。 public class UserServiceImpl implements userService { private UserDao userDao; @Autowired private UserServiceImpl(UserDao userDao) { this.userDao = userDao; } } 从 Spring 4.3 开始，如果类只有一个构造器，@Autowired 也可省略。 Setter方法注入：将 @Autowired 注解标注在 set 方法上，Spring 容器根据 set 方法的名称和参数类型来注入依赖。 public class UserServiceImpl implements userService { private UserDao userDao; @Autowired private setUserDao(UserDao userDao) { this.userDao = userDao; } } 字段注入：直接将 @Autowired 注解标注在字段上，Spring 容器根据字段类型来注入依赖。 public class UserServiceImpl implements userService { @Autowired("name") private String userName; } @Resource @Resource 由 Java EE 提供，默认按名称（byName）匹配（属性名或 name 属性）。若找不到同名 Bean，则回退到按类型匹配。 六、集合的注入 接下来的例子以 setter 注入为例进行说明，构造器注入类似，将 <property></property> 标签修改为 <constructor-arg></constructor-arg> 即可。 6.1、注入数组 <property name="test_array"> <array> <value>123</value> <value>456</value> <value>789</value> <!-- <ref bean="beanId"></ref> --> </array> </property> 6.2、注入 Set 对象 <property name="test_set"> <set> <value>set_qwe1</value> <value>set_asd2</value> <value>set_zxc3</value> <value>set_zxc3</value> </set> </property> 6.3、注入 List 对象 <property name="test_list"> <value>list_qwe1</value> <value>list_asd2</value> <value>list_zxc3</value> </property> 6.4、注入 Map 类型数据 注入 Map 对象： <property name="test_map"> <entry key="contry" value="China"></entry> <entry key="province" value="Gansu"></entry> <entry key="city" value="Lanzhou"></entry> </property> 6.5、注入 property 类型数据 <property name="test_properties"> <props> <prop key="contry">China</prop> <prop key="province">Hehei</prop> <prop key="city">Zhengzhou</prop> </props> </property> <property> 标签表示 setter 方式注入，构造方式注入 <constructor-arg> 标签内部也可以写 <array>、 、<set>、 、<props> 标签 List 的底层也是通过数组实现的，所以 和 <array> 标签可以混用 若要在集合中添加引用类型，只需要把 <value> 标签改成 <ref> 标签，但这种方式用的比较少 七、Spring 容器的核心操作 7.1、创建容器 使用 ClassPathXmlApplicationContext 类通过类路径来加载配置文件的方式创建容器： ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); // 将多个XML文件的Bean配置都加载到一个Spring容器中： ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext1.xml", "applicationContext2.xml"); 也可以使用 FileSystemXmlApplicationContext 通过文件路径来加载配置文件的方式创建容器： ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\applicationContext.xml"); // 将多个XML文件的Bean配置都加载到一个Spring容器中： ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\applicationContext1.xml", "E:\\applicationContext2.xml"); 7.2、从 Srping 容器获取 Bean 7.2.1、根据 Bean 名称 // 需要类型强制转换 BookDao bookDao = (BookDao) ctx.getBean("bookDao"); 7.2.2、根据 Bean 类型获取 // 参数是 类名.class BookDao bookDao = ctx.getBean(BookDao.class); 当按类型获取 Bean 时，必须保证该类型的 Bean 在 Spring 容器中只有一个，否则会抛出 NoUniqueBeanDefinitionException 异常。 7.2.3、根据 Bean 名称获取并指定类型 BookDao bookDao = ctx.getBean("bookDao", BookDao.class); 八、一图流总结 8.1、Bean： 8.2、依赖注入：
目录： 0x01. 查看自增值 1、查看全局自增值 2、查看特定数据表的自增值 0x02. 自增值的取值问题 1、默认取值 2、建表时指定 3、直接指定 4、修改自增字段属性 环境说明： MySQL 5.7 、MySQL 8.0 长期以来，我的博客数据库中连续文章的主键编号一直都不是连续的，让我这个强迫症晚期患看着很不舒服。在忍受了这么长时间以后，趁着给博客换域名的时机，我把所有的文章编号全部改成了连续的，可算是舒服多了。 把改完主键编号的文章数据导入新数据库之后，就产生了一个新问题：现在新数据表的主键自增值还是旧数据表的主键自增值。比如说博客数据库的文章表中有80条数据，下次新创建文章的编号是以旧数据库的自增值202开始递增，生成的新文章编号是203，而不是81。如果要保持文章编号能连续的话，就只能每次发布完新博客之后再去改数据库中的编号，可谓是相当麻烦。 所以我便想着是否可以通过修改数据表里主键的 AUTO_INCREMENT 自动递增值来一步到位，查了一些资料之后，就有了这篇博客。 0x01. 查看自增值 一般来说，数据表中具有自增属性 AUTO_INCREMENT 的字段主要是数据表的主键或者具有唯一性的字段。 如果要查阅其递增值，有这么两种方式： 1、查看全局自增值 SHOW VARIABLES LIKE 'AUTO_INC%'; 这条命令的执行结果会返回两条数据： AUTO_INCREMENT_INCREMENT 表示自增的初始值，AUTO_INCREMENT_OFFSET 表示自增的步长，即每次的自增量。 修改自增初始值与自增量的命令： SET @@AUTO_INCREMENT_INCREMENT=新初始值; SET @@AUTO_INCREMENT_OFFSET=新步长; 注意：这个表示的是数据库全局的自增设置，因此修改以后只会影响到下次新增的带有 AUTO_INCREMENT 属性的列，其自增初始值与自增步长就是新设置的值，对当前已经带有 AUTO_INCREMENT 属性的列的自增初始值与自增步长不起作用。 2、查看特定数据表的自增值 要想查看某个数据表中自增字段的当前自增值，可用以下命令： SHOW TABLE STATUS FROM [数据库名] LIKE [表名]; FROM [数据库名] 与 LIKE [表名] 这两个子句是可选的。 FROM [数据库名] 表示指定查询所在的数据库；LIKE [表名] 指定该数据库下要查询的某个表，如果省略了 LIKE [表名] 子句，则表示查看该数据库下的所有表的信息。 另外，需要注意的是，表名要加引号。 比如查询 TEST 数据库下 test 表的信息： SHOW TABLE STATUS FROM TEST LIKE 'test'; 查询结果中有一个字段名为 “AUTO_INCREMENT”，表示的就是自增值，该表下一条记录的编号就是这个值。 0x02. 自增值的取值问题 1、默认取值 默认情况下，自增值从1开始，每增加一条新记录，自增值便会自增 1。 所以，对于具有 AUTO_INCREMENT 属性的列，不用特意设置列值，而是直接将 NULL 值插入到自增列中去，数据库会自动根据当前的自增值生成列值。 注意： 将 0 插入到自增列中的效果等同于插入 NULL 值； 当插入记录时，如果没有为自增列指明一个值，那么也等同于插入 NULL； 使用 INSERT 语句插入记录时，如果为自增列设置了一个值，那么会出现这样三种情况： 情况一，插入的值与已有的编号重复，则会出现报错 情况二，插入的值大于列的自增值，成功插入这条记录，并且会更新自增值为新值 情况三，插入的值小于列的自增值且与已有的编号不重复，则成功插入这条记录，但自增值不会更新，如果插入的值与已有的值重复，参考情况一 如果用 UPDATE 语句更新自增列，情况与 INSERT 语句相同。 2、建表时指定 我们也可在建表时使用 “AUTO_INCREMENT=自增值” 来指定一个自增的初始值，比如： CREATE TABLE TEST{ -- 建表语句 }AUTO_INCTEMENT=自增值; 3、直接指定 ALTER TABLE [表名] AUTO_INCREMENT=自增值; 如果执行完以后没有效果，那么可以再执行一次 commit 指令以提交更改，使其生效。 4、修改自增字段属性 ALTER TABLE [表名] MODIFY [字段名] [字段类型和约束条件], AUTO_INCREMENT=自增值; 同样的，如果执行完以后没有效果，再执行一次 commit 提交更改。 这个语句相当于直接修改自增字段的属性，包括其数据类型和约束条件。 另外，我在尝试中发现，使用 SQL 语句更改了自增值以后再执行 SHOW TABLE STATUS 语句来验证是否修改成功，本地的数据库显示自增值已经修改过来了。但是，服务器上的数据库自增值依然还是原来的值，可是，当我在重新插入一条记录时，新记录的自增值却是修改过后的值。这属实让我有点摸不着头脑，我也不太确定是不是 MySQL 版本不同的原因，也懒得再尝试了，所以把这种情况记录上来以供参考吧。
目前最流行的版本控制软件：Git的基本使用
前排提示： 本篇博客篇幅较长，建议结合目录查看！ 目录： 写在前面 1、关于版本控制系统 定义 版本控制的必要性： 常见的版本控制系统 2、Git与Github 0x01.安装Git 0x02.Github中的一些基本概念 Repository Issue Star Fork Pull Request Watch Wiki Gist 0x03.添加SSH key 0x04.克隆仓库 0x05.初始化仓库 0x06.提交修改 0x07.分支操作 查看分支 建立新分支 切换分支 建立并切换到新分支 推送本地分支到远程仓库 合并分支 删除分支 重命名分支 0x08.标签操作 附注标签 轻量标签 切换标签 推送标签 删除标签 查看所有标签 给提交打标签 写在前面 1、关于版本控制系统 定义 版本控制（Version control）是维护项目的标准作法，能追踪项目从诞生一直到定案的过程。此外，版本控制也是一种软件工程技巧，借此能在软件开发的过程中，确保由不同人所编辑的同一程序文件都得到同步，记录项目内各个模块的改动历程，并为每次改动都编上序号。 一种简单的版本控制形式如下：工程的初代版本为“1.0”，当做了第一次改变后，版本等级改为“1.1”，以此类推。因此，版本控制能提供给开发者将项目恢复到之前任一状态的选择权，这种选择权在设计过程进入死胡同时特别重要。 版本控制的必要性： 常会利用版本控制来追踪维护源代码、文件以及配置文件等的改动，并且提供控制这些改动控制权的程序； 有时候，一个程序同时存有两个以上的版本，例如：在一个稳定版本中程序错误已经被修正、但没有加入新功能；在另一个开发版本则有新的功能正在开发、也有新的错误待解决，这使得同时间需要不同的版本； 此外，为了找出只存在于某一特定版本中（由于修正了某些问题、或新加功能所导致）的程序错误，或找出程序错误出现的版本，开发者也需要比对不同版本的代码以找出问题的位置。 常见的版本控制系统 集中式版本控制系统：由一台或多台主计算机组成中心服务器，所有业务单元和项目版本库都集中存储在这个中心服务器上，开发时，要先从中央服务器取得项目最新的版本，一次开发完毕之后，再将工作量推送给中央服务器。就像是一个图书馆，如果要改一本书的内容，则需要把书先从图书馆借出来，然后修改，改完之后再放回图书馆。 因此，集中式版本控制系统最的大缺点就是中央服务器出了问题，所有人都没法工作了。 常见的集中式版本控制系统有SVN、CVS等。 分布式版本控制系统：分布式版本系统没有绝对的中央服务器，每个人的电脑上都是一个完整的版本库，多个人进行协同工作时，只需将自己的修改与其他人的修改进行交换即可 和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，其中一个人的电脑坏了不要紧，从其他人那里复制一个就可以了。 Git就是常见的分布式版本控制系统之一，也是目前最流行的版本控制系统。 2、Git与Github 准确地说，Git与Github根本不是同一个概念。 Git是指由Linus（就是那位二十多年前徒手撸出Linux内核的大佬）编写的分布式版本控制系统，于2005年以GPL发布。最初目的是为了更好地管理Linux内核开发。 自2002年以来，Linus一直使用BitKeeper作为Linux内核主要的版本控制系统以维护代码。在Linux社区中，主张应该使用开放源代码的软件来作为Linux内核的版本控制系统。Linus曾考虑过采用现成软件作为版本控制系统（例如Monotone），但这些软件都存在一些问题，特别是性能不佳。 2005年，Linux社区中的安德鲁·垂鸠写了一个可以连接BitKeeper的存储库的简单程序，BitKeeper著作权拥有者拉里·麦沃伊便认为安德鲁·垂鸠对BitKeeper内部使用的协议进行了逆向工程，决定收回无偿使用BitKeeper的许可。Linux内核开发团队与BitMover公司进行磋商无果后，Linus决定自行开发版本控制系统以替代BitKeeper，在十天的时间编写出git第一个版本。于是，世界上最流行的版本控制系统就这么戏剧式地诞生了。 而GitHub是通过Git进行版本控制的软件源代码托管服务平台，由GitHub公司（曾称Logical Awesome）的开发者Chris Wanstrath、P. J. Hyett和Thomas Preston-Werner使用Ruby on Rails编写而成，于2007年10月1日开始开发。beta版本开始上线于2008年2月，4月份正式上线。这是他们的logo，名字叫Octocat： 截止到2020年1月，GitHub已经有超过4000万注册用户和1.9亿代码库（包括至少2800万开源代码库），事实上已经成为了世界上最大的代码存放网站和开源社区，国内很多人戏称为“全球最大同性交友网站”。 2018年6月4日晚，微软宣布以75亿美元的股票收购GitHub。 Github服务器在国外，处于半被墙的状态，有时正常访问，有时又打不开。与之类似的代码托管平台Gitee可以看做是国内版的Github，缺点是开源项目不如Github丰富，当然，由于在访问时速度更快，更适合国内用户托管代码。而且，部分开源项目是同时托管在这两个平台上的，所以碰到无法打开的Github项目时，在Gitee上找找也许会有惊喜。 0x01.安装Git Git在全平台均可使用。 Git官网：Git (git-scm.com) 官方中文文档：Git - Book (git-scm.com) Windows系统Git安装包下载链接：Git - Downloads Linux系统安装Git：Git - Download for Linux and Unix Mac系统安装Git：Git - Download for macOS 安装完成之后在控制台中输入git，如果出现如下输出说明安装成功： 前面提到过，Git只是一个分布式版本管理软件，每个人的计算机都是一份完整的版本库，对这份版本库进行修改之后，将每个人的修改进行合并。但是如果不在同一个内网中，合并修改就会变得困难。此时也需要一个中央服务器来辅助进行代码的合并。这也就是Github、Gitee、Gitlab等平台最基本的作用。 因此，我们还需要注册一个Github/Gitee账号，将我们的代码托管到平台上面（从某种角度上将它看成一个专门存放代码的云盘也未尝不可）。Github注册账号及用户界面介绍可以参考这篇文章：从0开始学习 GitHub 系列之「加入 GitHub」 (qq.com)，本篇博客不再介绍。 0x02.Github中的一些基本概念 Repository 仓库，即项目，要在GitHub上开源一个项目，那就必须要新建一个Repository。 Issue 问题的意思，举个例子，比如开源的项目，别人发现项目中有bug，或者哪些地方做的不够好，他就可以提个Issue，即问题，提的问题多了，也就是 Issues ，然后开发者看到了这些问题就可以去逐个修复，修复ok了就可以一个个的Close掉。 Star 就是给项目点赞，这个star的含金量还是挺高的。 Fork 这个可以翻译成分叉，你想在某个开源项目的基础上做些改进，然后应用到自己的项目中，这个时候就可以Fork这个项目，与此同时你的GitHub主页上就多了一个项目，只不过这个项目是基于这个开源项目（本质上是在原有项目的基础上新建了一个分支）。而你就可以随心所欲的去改进这个项目了，丝毫不会影响原有项目的代码与结构。 Pull Request 发起请求，这个其实是基于Fork的，还是上面那个例子，如果你在项目基础上做了改进，就可以把自己的改进合并到原有项目里，这个时候你就可以发起一个Pull Request（简称PR），原有项目开发者会收到这个请求，这个时候他会review代码，并且测试觉得OK了，就会接受PR，这个时候新的改进会被合并进原有项目。 Watch 可以理解为观察，如果Watch了某个项目，以后如果这个项目有更新，都会收到关于这个项目的通知提醒。 Wiki 一般来说，项目的主页有README文件基本就够了，但是有些时候项目的一些用法很复杂，就需要有详细的说明文档给使用者。这个时候就可以用Wiki，使用markdown语法即可进行编写。 Gist 如果没有项目可以开源，只是单纯的想分享一些代码片段，那这个时候Gist就派上用场了。 0x03.添加SSH key 当我们对代码进行提交时，Github/Gitee要怎么知道是我们提交的代码，而不是别人提交的呢，所以就需要进行授权来确认我们的身份。 Github和Gitee服务器可以选择使用SSH公钥或GPG公钥来进行授权，这里采用SSH授权方式，提交代码之前需要先添加SSH key配置。大概步骤就是先在本地生成SSH key，然后将本地生成的SSH key添加到Github或者Gitee上。 SSH（Secure Shell）是一种建立在应用层基础上的安全协议，一般用于远程登录会话和其他网络服务。由于在传输过程中对数据进行了加密和压缩，因此可以有效防止远程管理过程中的“中间人攻击”，传输速度也会更快，还能够防止”DNS欺骗“和”IP欺骗“等。 生成SSH密钥： ssh-keygen -t rsa 这句命令的意思是用RSA算法生成密钥（windows系统最好在Git Bash下执行，cmd终端可能并没有安装ssh），执行后出来三次提示均按回车，命令执行完会生成id_rsa（密钥）和id_rsa.pub（公钥）这两个文件。Linux/Mac系统在~/.ssh下，windows系统在C:\Users\用户名\.ssh（用户名是自己电脑的用户名）下，需要设置显示隐藏文件选项才能看到。 将id_rsa.pub用文本编辑器打开，复制里面的内容。 添加公钥到Github/Gitee： 进入Github/Gitee的设置界面，在左侧选项列表找到SSH keys选项 将刚才复制的公钥粘贴上去，公钥标题可写可不写，然后保存，这样就完成了公钥的添加。 0x04.克隆仓库 说来惭愧，这是我接触到Github之后很长时间内最常用的操作（因为就只会这一个操作）。命令很简单： git clone [仓库链接] 这个命令的作用就是从Github上下载别人仓库的项目文件，可能是从clone直接音译过来的原因，这个操作一般都称克隆，而不叫下载。 克隆操作只需要有远程仓库链接即可，不需要Github账户也可以进行。克隆完之后项目文件的位置就是执行命令时所处的文件夹。 远程仓库链接在项目主页就可以找到： 0x05.初始化仓库 所谓初始化本地仓库，个人理解就是向本地的项目根目录文件夹中加入一些Git配置文件，使其可以被Git识别以进行版本控制，因为项目文件夹是不能直接进行版本控制的。 初始化本地仓库命令很简单，进入本地项目文件夹（或者用空文件夹），在该目录下执行： git init 也可以在命令后面加入文件夹路径，将指定文件夹初始化成本地仓库： git init [项目文件夹名路径] 项目初始化成功会有Initialized empty Git repository in xxxxxxx的提示，原项目文件夹中多出一个.git隐藏文件夹。此时初始化的本地项目还没有关联到远程仓库。 当然，有本地仓库还不行，我们本意是要把本地仓库推送到远程仓库，因此，还需要在Github/Gitee上建一个远程仓库。点击网站右上角加号，找到“New Repository（新建仓库）” 上图最后三项是用来初始化远程仓库的，如果这三项都不选就创建了仓库，就会提示用命令行来手动初始化远程仓库（所以建议对命令行不感冒的同学直接使用自带的初始化操作）。 来记录一下用命令行手动初始化远程仓库的步骤： 先在本地初始化好的Git项目中新建一个README.md项目说明文件（也可以是别的文件名） 在项目目录下执行命令与远程仓库进行关联： git remote add origin [远程仓库链接] 依次执行以下命令向暂存区加入修改文件，并编辑提交信息 git add README.md # 引号中就是本次提交信息，可修改 git commit -m "first commit" 向远程仓库推送本地仓库文件： Gitee只执行这条命令即可推送： git push -u origin master 从2020年10月开始，Github的默认分支从master变成了main，因此还需要将本地默认主分支重命名为main才能推送成功： git branch -M main git push -u origin main 如果不重命名主分支，就会出现“error: src refspec main does not match any，error: failed to push some refs to ..”的错误。 上述命令执行完之后，再刷新远程仓库界面，就进入了初始化好的远程仓库： 对于都已经初始化过的本地空仓库与远程仓库，使其建立关联可以这样做： # 先关联远程仓库 git remote add origin [仓库远程链接] # 再将远程仓库内容拉取到本地 git pull origin master 0x06.提交修改 所谓修改，就是相对于上次提交之后项目发生的改变（项目文件的增、删、改）。 其中要涉及到push和pull这两个互为相反的概念： Push：直译就是“推”的意思，这个操作可以把本地代码推到远程仓库，这样本地仓库跟远程仓库就可以保持同步了。 Pull：直译为“拉”的意思，如果别人提交代码到远程仓库，这个时候本地仓库代码与远程仓库代码并不一致，所以需要把远程仓库的最新代码拉下来，以保证两端代码的同步。 同时，提交代码前最好设置一下提交者的名字与邮箱，方便在commit记录里显示： git config —global user.name "名字" git config —global user.email "邮箱" 通常一次完整的提交过程如下： 将修改过的文件加入暂存区： git add [修改的文件或者目录] # .表示此目录下所有文件，一次提交的文件较多时，可以使用此命令 git add . 确认提交暂存区中的文件： # -m表示附加提交信息，后面的内容是关于提交的信息说明 git commit -m "提交信息" git add是先把改动添加到一个“暂存区”，可以理解成是一个缓存区域，临时保存改动，而git commit才是最后真正的提交。这样做的好处是防止误提交。 最后将代码推送到远程仓库指定分支，即可完成一次代码提（其中注意，最后提交时Gitee与Github的分支名有所不同）： # 推送代码到指定分支 git push origin [分支名] # Github默认分支是main，用以下命令： git push origin main # Gitee默认分支是master，用以下命令： git push origin master 这里的origin是给远程仓库起的名字，当然名字并不唯一，可以是其他名字，只是因为习惯，一般都起名为origin。 一般在多人协作时，为了不产生代码冲突，提交代码前最好进行一次Pull操作： git pull origin [分支名] 查看git仓库当前状态，比如当前所在分支、被修改过的文件、未提交的文件等等： git status 查看提交时产生的所有commit记录： git log 0x07.分支操作 branch即分支的意思，分支的概念在团队协作的时候很重要，假设两个人都在做同一 个项目，这个时候分支就是保证两人能协同合作的最大利器了。举个例子，A, B两人在做同一个项目不同的模块，这个时候A新建了一个分支叫a，B新建了一个分支叫b，这样 A、B做的所有代码改动都在各自的分支上，互不影响，等到都把各自的模块做完 了，最后再统一把分支合并到master主分支。 在本地执行git init命令初始化仓库时默认生成一个主分支master。 而远程仓库的情况就有所不同了，曾经Github远程仓库的默认主分支也是master，但是去年（2020）10月份之后Github将默认主分支名称从master改成了main（据说是因为master这个词意为奴隶的主人，含有种族歧视意味），这也是在前面手动初始化Github仓库时要将主分支名重命名为main的原因。 而Gitee的主分支名称依然是master。 查看分支 查看本地分支列表： git branch 查看远程分支列表： git branch -r 建立新分支 git branch [分支名] 需要注意的是，新创建的分支的内容与当前所在的分支的内容相同，即新分支是基于当前所在的分支而创建的。 当我们建立了新分支以后，默认不会切换到新分支上，当前做出的任何更改还是基于当前所在的分支，所以需要切换分支。 切换分支 git checkout [分支名] # 切换到新分支之后手动拉取最新内容 git pull origin [分支名] 此时进行的改动就是在新分支下面了。当然，也有办法一步到位，加入-b参数即可。 建立并切换到新分支 git checkout -b [分支名] 推送本地分支到远程仓库 在本地建完新分支之后，就可以将本地新分支推送到远程仓库了，以保证两端同步 git push origin [新分支名] 如果本地推送到远程的分支想取另一个名字，那么可以用这条命令： git push origin [本地分支名]:[远程新分支名] 但是强烈不建议这样，这会导致管理混乱，建议本地分支跟远程分支名要保持 一致。 合并分支 当团队中不同成员都完成了开发之后，就可以将改动都合并到一块了。 # 首先切换到要合并到的分支上来，比如master(main)分支或是指定分支 git checkout [分支名]/main/master # 进行合并，将指定分支合并到当前所在的分支（即上一步切换到的分支）上来 git merge [指定分支] 在没有冲突的情况下，代码就可以合并完成了。合并完记得把新代码push到远程仓库。 删除分支 分支建错或者该分支的代码已经顺利合并到其他分支的时候，就可以删除分支了： git branch -d [分支名] 有些时候可能会删除失败，比如该分支的代码还没有合并到master或者其他分支，执行删除分支操作就会失败，Git会提示这个分支上还有未合并的代码，但是也可以强制删除分支： git branch -D [分支名] 以上仅仅为删除本地分支，若要删除远程分支可以可以运行带有 --delete 选项的 git push 命令： git push origin --delete [远程分支名] 重命名分支 将A分支重命名为B分支： git branch -m A B 类似于删除分支，无法重命名时，也可以强制重命名： git branch -M A B 如果是重命名远程分支，推荐的做法是： 删除远程待修改分支 push本地新分支名到远程 0x08.标签操作 开发的时候经常有版本的概念，比如v1.0、v1.1之类的，不同的版本肯定对应不同的代码，所以给代码打上标签，标签名可以是版本号或者其它标记。 Git 支持两种标签：附注标签（annotated）与轻量标签（lightweight）。 附注标签 附注标签是存储在Git数据库中的一个完整对象， 它们是可以被校验的，其中包含打标签者的名字、邮件地址、日期时间， 此外还有一个标签信息，并且可以使用GNU Privacy Guard（GPG）签名并验证。 通常建议创建附注标签，这样就可以拥有以上所有信息 添加附注标签信息用这条命令： git tag -a [标签名] -m "标签信息" -m参数为可选的，表示指定一条存储在标签中的信息。如果省略-m参数，那么Git会自动打开编辑器，让我们写一句标签信息，就像给提交写注解一样。 利用git show命令可以查看标签信息与对应的提交信息： git show [标签名] 输出会显示打标签者的信息、打标签的日期时间、附注信息与具体的提交信息。 轻量标签 如果只是想用一个临时的标签， 或者因为某些原因不想要保存这些信息，那么就可以用轻量标签。 轻量标签很像一个不会改变的分支——它只是某个特定提交的引用。本质上是将提交校验和存储到一个文件中——没有保存任何其他信息。 创建轻量标签，不需要使用 -a、-s 或 -m 选项，只需要提供标签名： git tag [标签名] 同样的，利用git show命令查看标签信息与对应的提交信息，输出只会显示出提交信息，不会看到额外的标签信息。 切换标签 当要切换到某个tag时，命令与切换分支类似： git checkout [标签名]; 推送标签 同样的，向远程仓库推送单个标签的命令与推送分支也是类似的： git push origin [标签名] 如果一次推送多个标签，可以使用带有--tags的git push命令： git push origin --tags 这条命令会将所有不在远程仓库服务器上的标签全部推送到远程仓库。 删除标签 删除本地标签： git tag -d [标签名] 上述命令并不会从远程仓库中移除这个标签，从远程仓库移除标签有两种办法： git push <remote> :[标签名称] 这种操作的含义是，将冒号前面的空值推送到远程标签名，从而实现删除的效果。 第二种方式相对来说更直观： git push origin --delete [标签名] 查看所有标签 执行git tag命令，就可以列出所有标签： git tag 默认是以字母顺序排列标签。 当然，可带上可选的 -l 选项或者 --list选项，以匹配特定标签名： git tag -l "通配符" # 或者 git tag --list "通配符" 例如，只查阅v2.*版本的标签名： git tag -l "v2.*" 给提交打标签 假设在过去某一个时刻提交了项目更改，后期才想起来忘记给项目打标签了，那么也可以在之后补上标签： git tag -a [标签名] [校验和] 与创建标签命令不同，需要在标签名之后添加一个校验和选项（也可以是部分校验和）。 通过以下命令可以查看每一次提交的校验和与对应的提交信息： git log --pretty=oneline 参考资料： 微信公众号 - stormzhang：从0开始学习Github系列文章 Git 教程 | 菜鸟教程 (runoob.com) Git - Book (git-scm.com) 版本控制 - 维基百科，自由的百科全书 (wikipedia.org) git - 维基百科，自由的百科全书 (wikipedia.org) GitHub - 维基百科，自由的百科全书 (wikipedia.org)