Repository navigation
Expand file tree
/
Copy pathsearch.json
More file actions
1 lines (1 loc) · 376 KB
/
Copy pathsearch.json
File metadata and controls
1 lines (1 loc) · 376 KB
1
{"posts":[{"title":"记一次重写博客","description":"我的博客已经使用butterfly这个主题很长一段时间了,虽然期间做了很多样式微调,但也难免产生了一点审美疲劳,一直想换一个新的风格。恰逢最近挺无聊的,于是重新搭建一套属于自己的博客系统。 其实重写博客的想法,早在两三年前就已经萌生。当时我特别倾向于前后端分离的动态博客,认为这种动态博客更加的灵活。为此我还专门用 SpringBoot3 + Vue3 实现了一版butterfly版本的动态博客与后台管理系统,但在实际体验了一会Halo这","content":"我的博客已经使用butterfly这个主题很长一段时间了,虽然期间做了很多样式微调,但也难免产生了一点审美疲劳,一直想换一个新的风格。恰逢最近挺无聊的,于是重新搭建一套属于自己的博客系统。 其实重写博客的想法,早在两三年前就已经萌生。当时我特别倾向于前后端分离的动态博客,认为这种动态博客更加的灵活。为此我还专门用 SpringBoot3 + Vue3 实现了一版butterfly版本的动态博客与后台管理系统,但在实际体验了一会Halo这种比我写的更完善的博客后,我发现这种动态博客并不完全适合我的使用场景。我只是想设计实现一套系统罢了,就下意识认为这种动态博客更好,却忽略了我的习惯和强行让自己自适应。最终就放弃了继续优化和完善这套方案,也一直使用butterfly至今。 过去一年多,自从DeepSeek-R1发布以后,AI就像打了鸡血一样,发展的更快了。相较于其他的生成式AI,在本就推崇开源的行业,大模型的编程能力更是迎来了爆发式的提升,大模型已经可以高效完成大量的编码工作,十几分钟就可以完成一天的代码量。于是这次重构,就打算尝试全程不手动修改代码,完全由AI完成开发。 在让 AI 编码之前,首先要确定技术栈,毕竟AI可以提供建议,但最终方向还需自己把控。 我最先确定的事情,就是刚刚提到的,继续采用纯前端静态博客,放弃带服务端的动态博客。 很多人都偏爱Halo,WordPress这类动态博客,甚至为静态博客额外接入服务端。更有甚者逐步把博客做成社区形态,引入登录、发帖、权限等复杂功能,不仅开发和维护成本高,备案也会变得麻烦。 有部分人是小白,这种动态博客适合他们,但是我更习惯用 Typora 本地写作,不喜欢在网页编辑器里写,因此静态博客是更适合我习惯的选择。 确定方向后,我看了很多静态站点生成器后,选择了扩展性更好的 Astro负责页面构建;样式与脚本则直接使用原生 CSS + TypeScript,没有引入 Tailwind CSS 这类框架。既然代码都是由 AI 完成,不如回归简洁,大道至简。 整个开发过程,除了反复思考设计风格耗费了太多的时间外,主体功能用几天就全部完成。 设计阶段我仅短暂试用了 Figma。它主要的功能就是把自然语言转换成可预览的界面框架,我觉得应该不是生成的代码在后台跑,就只是简单的框架加上图片交互,有点类似墨刀吧。我感觉更偏向产品与设计师的协作工具。 对我这种全干来说,先让 AI 生成设计图再实现,反而不如直接脑补设计,再让 AI 直接生成更高效,毕竟AI生成代码很快,不用考虑花半天时间实现代码后发现不符合心意的问题。而且这样也能更清楚实现成本与取舍,快速更改设计和技术方案吧。 代码环节我主要使用了两款AI吧 - 主力:codex (GPT-5.4) - 简单任务和设计: Gemini3.1 虽然很多人都说Gemini写前端最好,codex写前端一言难尽,但是就我的实际体验来看,Gemini仅仅在设计审美方向上更好,生成代码的稳定性、逻辑准确性等等很多方面都不如codex。使用Gemini的时候,我经常会碰到修改一个功能,组件的样式直接错乱,或者代码生成到一半就中断了,还说已经完成了。而我用codex,在使用同个提示词的情况下,基本可以一次通过,就算不通过,也不会出现样式错乱和逻辑冲突的问题。 我不喜欢安装过多的skill,既占用上下文,又可能导致提示词之间互相干扰,导致一加一小于一的情况。本次只使用了两个: - superpowers: 规范开发流程,提供实现方案与测试工作流 - impeccable: 提高设计审美 impeccable就不评价了,让你风格和色彩统一,设计审美更好一点。 superpowers 能让简单项目的开发更规范,但缺点也很明显Token 消耗极高,很多输出冗长。最影响效率的是它会无差别触发完整工作流,哪怕只是修改一个颜色,也会自动生成一整套单元测试,大量时间被无效测试浪费,只能去更新他很多的提示词做矫正,但这也很难阻止大多情况的故意复杂化了。也不是说测试不好,但这个skill是无法判断是否需要启动这个工作流,也无法判断是否需要进行测试,容易导致大量Token被浪费掉。使用Gemini就是这样,有时候会假模假样的加个单元测试,测试成功了样式也会错落,功能也没有实现。 所以当发现AI输出的内容,处理问题的方向出错了,偏离了预期,就要立即中断,重新引导或者重新开另一个会话,避免白白浪费Token或者把逻辑思路引导到更难解决的方向。 AI写代码一开始就要设计整体的架构和组件的设计和调用,最好就是有想法了,就让AI去判断这个设计行不行,不然越到后面越难改。总体架构设计好后,直接让AI协助生成一份项目的提示词,把架构,边界,代码处理都写好,避免AI乱改代码。经过大改动的话,就让AI优化一下AGENTS.md和GEMINI.md就行。 虽然这么说,但是开发到后面,代码写的太快,加上不经常写样式和脚本,于是review就及其痛苦,你也不知道写的是不是最好的方案,写的是不是有问题,看不过来的,即使是让AI开高推理去review,这个项目也难免变成半个黑盒,反正是没出现过怎么修都修不好的bug,只是有些心里负担罢了。 除了项目文档,还写了一些其他的辅组skill。比如风格色彩,git规范提交,文档处理等等,原本想写成command的,发现command已经被codex和claude code淘汰了,功能合并到skill里面,只有gemini还保存这个管理command的功能,没几个月就成为时代的眼泪了。 现在AI发展的很快,感觉博客和Stack Overflow一样,越来越少人写东西,问问题了,遇事不决就问AI。 搞的我也不知道要写什么了,除了比较冗长不好问到的东西,基本都是问AI了。 可能后面随缘写点其他东西吧hh。","url":"/posts/ebb85548/","category":"我的技术学习物语果然有问题","date":"2026.04.24","dateTime":"2026-04-24T00:00:00.000Z"},{"title":"自建busuanzi网站计数服务","description":"自建busuanzi网站计数服务","content":"不蒜子(busuanzi) 是一个广受欢迎的免费网页计数服务,能够轻松实现网站的页面浏览量(PV)和独立访客数(UV)统计。许多基于Hexo的网站都在使用busuanzi来实现访问统计功能,我的博客当前使用的主题是Butterfly,这个主题也是通过集成busuanzi计数器来实现网页计数。 然而,随着使用人数的不断增多,这个由作者为爱发电的免费服务开始出现稳定性问题,访问速度也变得起伏不定。 因此,我决定自己开发一个服务来代替busuanzi,为我的网站提供稳定的计数服务。 我简单分析了一下,发现busuanzi这个网页计数服务实现起来并不复杂,主要是通过获取访问请求的来源地址来实现PV和UV的计数增长,因此服务的核心就是一个统计接口。 基于这个分析,技术栈的选择也相对明确: 1. **接口开发**:由于我最熟悉Java,所以选择使用SpringBoot3和Java17来实现这个接口。(只实现一个接口的话,用SpringBoot感觉有些重,后续有时间可以考虑用Go重写一遍) 2. **数据存储**:数据库选择很多,但考虑到服务需要记录的数据主要是网站的PV和UV,对于请求IP等信息并非必须存储,所以我选择使用Redis。Redis对于这类频繁操作的数据处理速度非常快,而且配置好Redis的持久化后,也不怎么需要担心数据丢失问题。如果还是不太放心,可以在增加一个定时任务,定时从Redis中读取数据,存储到关系型数据库当中去,但是我感觉没有必要。 为了避免修改Butterfly主题中集成busuanzi的代码(以免在后续主题升级时进行频繁修改),需要让自建服务的接口访问方式和数据显示方式与原版busuanzi完全一致。因此,首先需要分析当前busuanzi的具体工作流程。 访问官网,可以看到官网提示的信息,只需要两行代码即可搞定计数。 从这两行代码可以看出,busuanzi通过引入busuanzi.pure.mini.js脚本来修改busuanzi_container_site_pv标签的内容,从而实现计数显示。数据获取流程的核心就在这个脚本中。由于该脚本经过了代码压缩,我使用claude code对其进行了脚本还原,以提高代码可读性。 虽然对JavaScript不是很熟悉,但这个脚本逻辑相对清晰,不难读懂。以下是该脚本的核心工作流程: 1. 等待浏览器DOM准备 2. DOM准备完成后,发起JSONP请求 3. 解析请求返回的标签数据,如果请求错误,数据异常就隐藏所有统计容器 4. 获取到计数的数据后,更新携带有ID为busuanzi_value_或busuanzi_container_统计标签的数据,然后修改容器的display属性,从而实现容器和内容的显示 > JSONP其实就是GET请求,主要是利用 标签可以跨域加载资源的特性,将数据请求伪装成脚本加载,服务器返回的也不是纯数据,而是一个函数调用,从而绕过浏览器的同源策略限制。 前端操作通过这个简单的脚本即可实现,接下来分析后端接口的实现方式。 网页计数服务的核心功能是记录URL的UV和PV数据。这些指标又分为站点级别和页面级别,理论上应该有四个数据(但busuanzi不计算页面UV,因此只有三个),这里按四个指标数据计算。下面逐一分析这些数据的计算方法。 PV,即浏览量,根据定义也不难知道计算的方法。当前端访问接口的时候,站点浏览量进行加1,页面浏览量进行加1既可以获得这两个PV数据量。 那么后端接口如何获知是哪个页面发起的请求呢?回头查看busuanzi脚本并未发现页面的相关信息,因此需要观察busuanzi脚本发送的具体HTTP请求信息。 经过仔细观察,容易发现请求头中的referer字段记录了当前页面的信息。切换到不同页面时,该字段也会相应变为相应页面的URL。基于这个信息,就可以计算出所需的两个PV数据: 1. **site_pv**(站点浏览量):从referer请求头中提取站点Host地址,在Redis中存储一个键值对,并对该值进行递增操作 2. **page_pv**(页面浏览量):直接使用referer请求头信息作为键,在Redis中存储键值对,并对该值进行递增操作 UV(独立访客数)的统计重点在于两个关键概念:每日和独立访客。 对于每日统计,除了存储UV值外,还需要维护一个当日访客集合。当新请求到达时,通过查询该集合可以判断当前访客今日是否已经访问过。若已访问,则UV数据保持不变;若为首次访问,则UV数据递增。 独立访客的识别相对复杂,因为Hexo博客是纯静态页面,难以直接区分不同访客。前面的请求脚本中也未发现访客标识相关数据,于是我推测访客信息应该记录在HTTP请求中。为了对标busuanzi的实现机制,需要进一步分析具体请求。最好重新打开浏览器或清理缓存,以观察UV增长时的请求响应信息。 从响应请求头可以看出,busuanzi采用了浏览器Cookie机制来识别独立访客。服务端在响应中设置Cookie,浏览器会在后续请求中自动携带该Cookie。通过检测请求中是否包含Cookie,服务端可以判断是否为首次访问。基于这个机制,可以得出UV数据的计算方法: 1. **site_uv**(站点每日独立访客数):从referer请求头获取站点Host地址。若请求不包含Cookie,则生成新Cookie并添加至当日站点访客集合,同时返回Cookie并将UV数据递增。若请求已携带Cookie,则不进行任何增长操作 2. **page_uv**(页面每日独立访客数):使用referer请求头信息作为页面标识。若请求不包含Cookie,则生成新Cookie并添加至当日页面访客集合,同时返回Cookie并将UV数据递增。若请求已携带Cookie,则不进行任何增长操作 这里我先展示所有使用到的Redis的键和类型,方便后续查找修改。 host表示站点地址,url表示资源地址,date表示日期。 | 数据名称 | Redis键名 | Redis类型 | | :---------------------------: | :----------------------: | :-------: | | site_pv(站点浏览量) | pv:{host} | string | | page_pv(页面浏览量) | pv:page:{url} | string | | site_uv(站点每日独立访客数) | uv:{host} | string | | 每日站点访客数(缓存7天) | uvtime:{date}:{host} | set | | page_uv(页面每日独立访客数) | uv:page:{url} | string | | 每日页面访客数(缓存7天) | uvtime:page:{date}:{url} | set | > 对于Redis数据结构的选择,个人认为使用string和set这两种数据结构完全足够了,大部分博客不是什么高流量的网站,string结构的数据很好用而且也很准确,没有多大必要使用hyperloglog或者zset,特别是数据量少的情况。 关于具体的实现,服务分析当中已经写的很明白了,这个服务其实就是一个核心的请求接口,逻辑和代码我就不一一贴出来了,我已经上传到Github上面了,感兴趣可以自行研究,附带一下仓库地址。 https://github.com/whyneh/busuanzi 服务代码除了适配原有的busuanzi的JSONP请求外,还自行进行了一些优化。以下是我进行优化的方向: 1. 因为后端是自己编写的服务,所以不需要前端使用JSONP的方式进行跨域处理,所以直接使用fetch的GET请求即可。 2. 原版busuanzi是使用了cookie进行用户管理,我改为了使用浏览器localStorage进行存储管理用户信息,这样数据更加可以精准。 如果需要进行修改,那么前端的请求脚本也需要修改,我根据原有的脚本进行了简单的优化。 这次涉及的服务有两个,一个是SpringBoot的Java服务,一个是Redis服务,如果是要部署的话,就需要分开部署。 这里我使用了docker-compose来进行部署,也可以更加方便,以下是三个所需的配置文件。 1. 服务的Dockerfile 2. redis的配置文件,这里的路径是容器内的路径,尽量不要修改 3. 服务编排文件docker-compose.yml 将上述三个配置文件和springboot打包生成的jar包放在一个文件夹中,然后执行docker-compose up -d即可运行整个编排服务。 服务部署好后,自行使用nginx进行反向代理,推荐使用1panel,里面的网站部署使用了OpenResty,直接创建一个反向代理即可。如果安装了1panel`,docker相关环境基本全部自动安装好,无需自己手动在安装环境,可以一步到位。 不太想放弃原有的busuanzi数据,可以直接将原有的busuanzi数据迁移到服务部署的redis当中,我讲一下比较简单的一个流程。 1. 获取当前站点的sitemap 2. 然后根据sitemap获取到站点所有的页面URL 3. 然后根据每个页面的URL去请求原有的busuanzi接口 4. 将得到的数据设置到服务的Redis当中即可","url":"/posts/5315dfbb/","category":"我的技术学习物语果然有问题","date":"2025.08.10","dateTime":"2025-08-10T00:00:00.000Z"},{"title":"Java图片处理","description":"最近经常接触Java的图片处理,所以特地来记录一下。","content":"本次处理图片主要使用的依赖是opencv,具体的方法可以去参照官网。 1. 首先去opencv官网去下载与系统对应的jar包和依赖文件。(这里以windows举例) 2. 选择windows版本opencv-4.7.0-windows.exe,然后进行安装。(linux的版本需要先进行编译后获取动态库和jar包) 3. 在安装目录的opencv/build/java的目录下,获得jar包和动态库文件。(注意是安装目录里) 4. 在maven项目引入opencv依赖。 5. 加载opencv动态库 由于opencv的开发语言问题,所以Java在使用opencv相关类的时候,需要先加载对应的动态库才行,不然直接使用会出现异常。需要注意linux和windows的动态库是不一样的。 > 好像最新版本的opencv(4.7.0)不支持Java8,只能有Java11,如果用Java8的话,可以使用4.6.0的版本。 > > 如果觉得opencv配置环境过于麻烦,可以使用Javacv,Javacv其实就是调用opencv进行操作的,虽然官方缺少文档(好像速度也慢一些,封装过的也正常),不过和opencv的调用方法都差不多。 上述的动态库dll格式是windows上使用的,要想在对应的linux上使用,还得在linux上编译opencv的源码,获得对应的jar包和so动态库文件(jar包应该是不分系统的)。 因为Java调用的opencv都是原生native方法,所以使用opencv的方法之前,需要加载动态库。 每次都加载太过于麻烦,如果使用springboot服务的话,可以在启动服务时初始化导入。 > Imgcodecs.imread()这个方法,偶然碰见过一次保存失败的情况,成功运行却没有保存文件,所以还可以通过字节方式保存。 在Java中使用opencv的话,这个操作必不可少。在opencv的库中,几乎都是native方法,所以导致对象的内存管理大多都不是由Java虚拟机管理,需要手动进行释放内存,不然会出现服务的使用内存不断升高,直至内存不够崩溃。而且期间不会出现内存溢出,dump文件也找不到占用很多内存的Mat类。所以释放图片内存是需要注意的。 如果你使用了lombok,可以使用注解@Cleanup来进行释放内存的简化。 获取图片的基本信息,使用opencv并不方便,所以可以使用其他的库来进行。 暂时有两种方法可以获取图片的DPI。 1. commons-imaging依赖 2. metadata-extractor依赖 > 这些操作实质是获取图片的基本信息得到的,所以图片大部分的基本信息都可以通过这些方法修改得到。 Java /** * 图片旋转 * * @param image 输入图片 * @param angle 旋转角度 * @return 输出图片 */ public static Mat rotate(Mat image, double angle) { int w = image.cols(); int h = image.rows(); // 定义参数 double scale = 1.0; Point center = new Point((double) w / 2, (double) h / 2); // 定义旋转矩阵(需要注意的是此处正角度是逆时针旋转,所以取反) @Cleanup(value = \"release\") Mat rotationMatrix = Imgproc.getRotationMatrix2D(center, -angle, scale); // 旋转矩阵 Mat rotatedImage = new Mat(); Scalar backgroundColor = new Scalar(255, 255, 255); Imgproc.warpAffine(image, rotatedImage, rotationMatrix, new Size(w, h), Imgproc.INTER_LINEAR, Core.BORDER_CONSTANT, backgroundColor); return rotatedImage; } 有些时候,电脑会自动对一些图片进行旋转显示(源文件不变),比如手机拍的一些图片,竖着拍的,电脑显示是竖着的,但是源文件其实是横着的,进行图片旋转,其实是按横着的源文件图片进行旋转,所以有时候会感觉旋转角度不对,所以需要先纠正图片旋转。 大多数彩色图片的每个像素都是由红绿蓝三个通道组成的,为了更方便的处理图像,将这三个通道的值按一定比例进行加权平均,得到一个单通道的灰度值,用来表示该像素的颜色亮度。大多数图片处理都会先进行图片灰度化,因为只有一个通道,处理起来方便很多。opencv的灰度化操作,只需要调用方法即可。灰度化操作的话,主要是要考虑图片通道数量的问题。 处理图像时,往往需要对图像进行平滑操作以去除噪声,同时也可以模糊图像以达到柔化的效果。高斯滤波(Gaussian blur)就是一种常用的平滑滤波器,其通过对图像像素进行加权平均的方式来实现平滑和模糊的效果。高斯滤波的原理是使用一个高斯核(Gaussian kernel)对图像像素进行加权平均。一般来说,高斯核的大小或标准差越大,平滑效果越明显,图像的细节丢失也会越多。 图像二值化很好理解,就是把一张彩色图片或者灰度图片转化为黑白二值图像,即每个像素只有两种可能的选值,通常是黑色(0)和白色(255)。主要用于分割某些图片的用途。 二值化具体步骤: 1. 灰度化。这一步是因为在大多数情况下,只考虑像素的亮度信息就足够了,灰度图像的每个像素值表示亮度的强度,通常在0(黑色)到255(白色)之间。 2. 选择一个阈值,阈值是一个灰度值,用于判断像素应该被归类为黑色还是白色。选值方法有很多,大概有以下三种 - 全局阈值:简单地选择一个固定的全局阈值,将所有像素比较与该阈值,高于阈值的像素设置为白色,低于阈值的像素设置为黑色。 - 局部阈值:根据像素的局部区域来选择阈值,每个像素的阈值根据其周围像素的统计特性(如均值、方差等)来确定。 - 自适应阈值:根据图像的不同区域自适应地选择阈值。常见的方法有基于局部均值、基于Otsu算法等。 3. 图片进行二值化处理,对于每个像素,如果其灰度值大于阈值,则将其设为白色(255),否则设为黑色(0)。 腐蚀与膨胀主要用于处理二值化图像或者是灰度图像。 膨胀主要作用是对二值化物体边界点进行扩充,将与物体接触的所有背景点合并到该物体中,使边界向外部扩张。 如果两个物体间隔较近,会将两物体连通在一起。对填补图像分割后物体的空洞有用。 腐蚀主要的作用就是消除物体的边界点,使边界向内收缩,可以把小于结构元素的物体去除。 可将两个有细小连通的物体分开,去除毛刺,小凸起等噪点。如果两个物体间有细小的连通,当结构足够大时,可以将两个物体分开。 边缘是指图像中颜色或亮度发生急剧变化的区域,通常是物体之间的边界或物体内部的纹理。边缘检测算法旨在在图像中找到这些边缘并将其标记出来。具体的步骤如下: 1. 图像灰度化 2. 此处还可以进行(高斯模糊,二值化,图片膨胀,图片腐蚀等操作去除噪点) 3. 进行边缘检测 网上关于图片亮度检测的方法,大概有两种。 使用图片的平均灰度值来代表图片的平均亮度。 网上检测图片清晰度的方法有三种,需要注意的是,这些计算的指标在同一张图片里,越高代表这张图片越清晰。所以可能会出现一种情况,就是有一张模糊的图片指标比有一张清晰的指标高。 亮度调整主要是调整平均亮度值到一个自定义的值当中。 图片纠偏是一个比较难的问题,主要的难点在于如何计算出图片的倾斜角度,最常见的方法就是霍夫变换检测直线了,以下是具体步骤。 1. 图片边缘检测 2. 霍夫变换,获取检测的直线 3. 计算每条直线的倾斜角度 4. 获取所有直线倾斜角度的平均值或者是众数来作为图片的倾斜角度。(关于平均值和众数,总会在某些情况下十分异常,我认为平均数比较可靠,但需要严格筛选需要内容的直线才行。也可以根据某些算法排除掉异常值。) 5. 图片灰度化。 6. 高斯模糊,二值化,膨胀,腐蚀等操作处理图片,去除噪点,以免出现不需要的直线。 7. 图片边缘检测,通过调整参数,把一些无用的边框去除。 8. 霍夫变换检测直线,通过调整参数把一些无用的直线去除。 9. 收集并计算每条直线的倾斜角度。 10. 通过每条直线的倾斜角度,推测出整体图片的倾斜角度。这里有很多种方法,比如平均值,众数,出现次数最多的数,或者是附近角度最多的数等等方法。这里使用了出现次数最多的数用来代替图片整体倾斜角度。 有很多场景,比如说发票,白底黑字文件这种,在OCR识别的过程中,会受到红色印章的影响,所以需要先去除红色印章,在进行OCR识别,这样可以提高OCR的识别率。 我碰到比较多的场景是白底黑字的图片,所以我这里就使用了检测红色像素,痛过红色像素的数量,来检测是否该图片有红色印章。 有些图片看着是没有红色像素的,但是其实会存在有,所以先使用一个只有红色印章的图片进行检测,然后选择一个比较合理的值进行判断就可以。 这种方法不适合除了印章外还有很多红色的图片,那种情况可以考虑使用霍夫圆检测,那种可能会耗费很多时间,所以我没有使用。 我这里去除红色印章的方法,主要的原理就是使用图片二值化,让印章的变成白色即可,但是会出现一个问题,就是红色比黑色更难二值化,所以需要先把图片的红色通道分离出来,红色通道的红色印章的颜色会变淡很多,从而二值化能去除掉红色印章。 这种方法的结果图片,因为去除了蓝绿通道,所以会变得灰色,不过因为主要的目的是给OCR识别,所以无所谓,如果想不改变图片的话,还是挺麻烦的,可能还得识别出椭圆印章,然后精确的去除。 图片的切边矫正还是使用深度学习模型比较准确,使用opencv局限性还是挺大的,简单使用还是可以的。以下的方法借鉴了网上流传比较广的一个关于截取发票的边缘的方法。","url":"/posts/91f4854c/","category":"我的技术学习物语果然有问题","date":"2023.04.18","dateTime":"2023-04-18T00:00:00.000Z"},{"title":"服务器软件","description":"一些服务器软件的安装","content":"使用rpm -qa | grep jdk命令查看当前系统安装的JDK。 使用rpm -e --nodeps的命令去卸载上述查询到的JDK。 使用命令yum -y list java*查询可以安装的Java版本。 这里选择安装1.8的版本。 安装包的下载可以去oracle的官网去下载,这里选择下载Java8的版本。 下载地址 根据自己的系统,选择对应的版本即可,这里选择x64 Compressed Archive的安装包。 将jdk-8u361-linux-x64.tar.gz安装包上传到服务器。 这里将Java放在了/usr/local/java的文件夹中,把安装包解压到该文件夹即可。 在/etc/profile文件尾部,加入以下的JDK的环境配置。 执行以下命令,使环境变量生效。 这条命令,在重启之后会失效,需要再次执行,不想再次执行,需要在/etc/bashrc尾部加入该条命令。 想卸载的话,就将上述的压缩包的文件和环境变量删掉即可。 1. 下载Redis Redis的安装包直接去官网下载即可。 下载地址 2. 解压安装包 这里放到/usr/local/redis下,并执行下面命令进行解压。 3. 编译安装 进入redis源码文件夹,执行以下命令,编译redis并进行安装。 4. 查看是否安装成功,在系统命令中出现redis的命令表示安装成功了。 5. 将Redis安装到系统服务 使用Redis的脚本工具,将Redis安装到系统服务上。 发现有问题,得换种方法。 将utils目录下的systemd-redis_server.service 文件拷贝到系统配置目录下,并改名为redis.server 编辑redis.server. 6. 编辑redis的配置文件 7. 基础命令 redis有些配置需要更改,不然使用起来会出现问题。配置文件就在源码文件夹中的redis.conf redis容器有个比较坑的地方,就是默认是找不到配置文件的,得自己参考配置文件,然后增加配置,映射到容器内部,覆盖掉默认的配置。 1. 拉取容器 2. 创建redis.conf配置文件 3. 启动容器 只部署一个服务的话,还是推荐用docker,有多个容器编排再用docker-compose 将配置文件和docker-compose.yml放在同一个目录,启动容器 Nginx还需要下载一些依赖库。 > 尽量添加sudo执行命令,避免权限出现的问题。 首先需要先去下载nginx的源码 下载地址 比如这里的nginx-1.28.0.tar.gz。 创建服务文件/etc/systemd/system/nginx.service 拉取镜像 配置文件,自用参考 nginx.conf 然后单独配置网页监听,/conf.d/test.conf 启动容器 https://downloads.mysql.com/archives/community/ 选择官网适配有的操作系统,这里就选择Ubantu Linux,版本自己选择。 要是没有对应的版本,就看看使用的操作系统是基于什么的,也可以尝试一下,实在不行就只能试试使用源码进行编译了。 我这里下载的就是第一个Ubuntu Linux 24.10 (x86, 64-bit), DEB Bundle,包含了所有的数据库依赖了。 创建好存储目录 创建配置文件/data/docker/mysql/conf/custom.cnf,具体配置可以自行修改 创建并运行容器 验证容器 > 注意,MySQL容器初始化会在存储目录产生一些初始化文件,如果想重复初始化,得先把之前的配置删干净,不然在创建容器会初始化报错。 安装所需要的依赖包。 鉴于国内网络问题,强烈建议使用国内源,官方源请在注释中查看。 执行下面的命令添加 yum 软件源: 有了依赖包之后,就可以直接安装Docker了。 在测试或开发环境中 Docker 官方为了简化安装流程,提供了一套便捷的安装脚本,CentOS 系统上可以使用这套脚本安装,另外可以通过 --mirror 选项使用国内源进行安装: 执行这个命令后,脚本就会自动的将一切准备工作做好,并且把 Docker 的稳定(stable)版本安装在系统中。 建立docker组 将当前用户加入docker组中 1. 阿里云加速器,可以去阿里云的关于镜像的管理控制台去获取。 2. 网易云加速器,https://hub-mirror.c.163.com 3. 百度云加速器,https://mirror.baidubce.com 查看之前是否配置过镜像地址。 如果该命令有输出,那么请执行 $ systemctl cat docker 查看 ExecStart= 出现的位置,修改对应的文件内容去掉 --registry-mirror 参数及其值,并按接下来的步骤进行配置。 如果以上命令没有任何输出,那么就可以在 /etc/docker/daemon.json 中写入如下内容(如果文件不存在请新建该文件): 出现以上内容则表示安装成功。 下载Docker离线安装包。 下载地址 系统配置文件docker.service 安装脚本。 卸载脚本。 通过安装包,执行安装脚本。 docker-compose本质就是docker命令,所以安装了docker后,只需要把这个命令放到服务器环境中就能调用了 1. 根据架构下载对应二进制命令文件,下载地址https://github.com/docker/compose/releases 2. 比如x86架构,就下载docker-compose-darwin-x86_64,把二进制文件名字改成docker-compose ,然后将命令文件上传到服务器的/usr/local/bin路径中 3. 给命令添加可执行权限 4. 测试命令 这里只记录docker-compose的安装方式,RafFlow涉及的服务有点多,使用docker-compose方便很多。 官方的仓库https://github.com/infiniflow/ragflow.git 下载这个仓库,重点是docker目录 修改配置文件.env,可以根据官方文档自行修改,这里只修改RAGFlow的版本。 在docker目录中启动容器 可能会遇到的问题 1. Mysql容器出现问题,起不来 这个容器很容易出问题,所以得检查数据卷是否已经存在,是否有初始化文件重复问题,请删干净 权限问题,在docker的Mysql配置文件中,即docker/docker-compose-base.yml,添加配置 2. 有其他配套服务起不来 也尝试在配置中添加privileged: ture配置 3. ragflow-server报错 OPENBLAS blas_thread_init: pthread_create failed for thread x of 64: Operation not permitted 有可能是python的问题,详情参考https://stackoverflow.com/questions/52026652/openblas-blas-thread-init-pthread-create-resource-temporarily-unavailable这个修改方案 修改了之后,启动可能还会报一个奇怪的错误,也可以尝试在配置文件docker-compose.yml中添加privileged: ture配置 以上基本都是网上搜集的教程,基本都是复制粘贴,有些已经找不到出处,有出处的我尽量标明在以下链接。 Docker Docker离线安装 Java安装 Redis离线安装 离线安装nginx","url":"/posts/58d09dd7/","category":"我的技术学习物语果然有问题","date":"2023.04.11","dateTime":"2023-04-11T00:00:00.000Z"},{"title":"MybatisPlus常用方法","description":"一些MybatisPlus常见的使用方法。","content":"记录一下常用的一些使用方法。 使用p6spy来打印SQL。 配置文件 这里使用了datafaker这个库来生成假数据。 随机生成600条数据。 环境使用MybatisPlus代码生成器的结构。 > 1. service继承IService > 2. serviceImpl继承ServiceImpl,实现service > 3. mapper继承BaseMapper 根据上述的代码结构,在服务的实现类中,会有两套API。 1. Service CRUD接口 2. Mapper CRUD接口 前者算是对Mapper接口的封装,所以前者会有Mapper接口里基本所有方法,也会添加很多封装后的方法。后者是基础的Mapper使用。 所以以下大多数使用都是基于前者,当有用到Mapper里的方法才会使用后者。 这里以查询的条件构造器为例子。 这个条件构造器使用了Lambda语法,使用起来更方便,而且使用这个方法不用构造条件,不用填写表的字段,因为字段这种不能修改的对开发来说这是十分不友好的,LambdaQueryWrapper可以直接使用实体类属性来构造条件。 1. 使用QueryWrapper的lambda方法获取 2. 使用Wrappers.lambdaQuery()获取(推荐) 以下的条件构造器,都是基于第二种方法生成。 这个插件我感觉还是很有必要的,要是开发出现一点错误,这个插件能多一份保障。当出现全表更新或者是全表删除的SQL时,MybatisPlus能帮我们拦截,并抛出异常。 官方插件说明 分页时需要用到的插件。 官方插件说明 > 多个插件使用的情况,请将分页插件放到 插件执行链 最后面。 > 1. 添加的数据尽量自己先提取在添加,避免添加了不该添加的数据,比如说ID,不建议传入ID,更新用户这些字段,尽量避免这些脏数据。 > 2. 考虑添加数据的条件,比如username是唯一的,某些数据是不为空的,或者某些数据是有什么格式的,都可以先将提取的元素进行判断后在添加。 > 3. 只通过前端校验参数是不合理的。 这里就不从请求上输入用户列表了,通过faker模拟生成用户列表。 这是不推荐的方法,但也算是可行的一种方法,这种方法效率很低。 通过p6spy的打印,可以看到执行的其中一条插入语句。 使用saveBatch最好先通过@EnableTransactionManagement注解开启mybatis-plus的事务管理,不然可能会出现警告。(虽然可能不会影响操作) 通过p6spy的打印,可以看到执行的其中一条插入语句。 > 这里可以发现saveBatch的插入语句和for循环的插入语句是一样的,都是有10条INSERT语句,而不是真正的批量插入,只不过saveBatch是10条SQL语句一起提交,而for循环是10条语句10次提交,这里的效率差距还是很明显的,但由于这样也不算是批量插入,所以saveBatch被称为伪批量插入。 由于是一次提交,如果一次性插入成千上万条数据,也会导致数据库响应缓慢,所以当插入的数据量很大时,还是建议先分片,在提交。 这种方案效率是最高的,但是相应的需要去配置一下。 1. 创建批量插入SQL注入器 2. 将SQL注入器添加到mybatis-plus配置中 3. 在Mapper类中添加方法 > 注意,insertBatchSomeColumn为内部指定的方法名字,不用在xml中写具体的SQL语句。IDE的警告可以忽略,上述添加的SQL注入器会帮我们注入具体的SQL语句,当然不用这么麻烦的配置,自己去xml中拼接SQL也是可以的。 可以看看官方的一个方法解释。 具体的使用。 SQL打印为 > 可以看到这个SQL的格式为 > > INSERT INTO user (..) VALUES (...),(...),(...),(...) > > 这种格式才算是批量插入,而且效率会高上很多。 同理,一次性不建议插入太多条数据,所以还是需要分片。insertBatchSomeColumn这个mapper方法我找了一下源码,好像没见到自带的分片方法,所以需要手动分片然后进行插入。操作如下。 使用第三种发放是效率最高的,所以建议使用第三种,当然嫌麻烦配置,直接用第二种也可以。毕竟数据量不是特别大,差距可以忽略。 > 尽量不要使用for循环的操作进行数据批量操作,消耗的时间是很多的。 > > 所以之后的批量操作,就不记录使用for循环的方案了。 直接调用API即可。 > 这个方法,这里只是用来记录一下,我感觉这个方法十分的危险,实际开发建议不要这样写,当user为空,或者是里面的字段全是空值,就会导致语句变成 > > DELETE FROM user > > 这样的SQL会导致全表数据删除,所以尽量使用ID进行删除。 > > 实在需要用到这种方法,请先判定传入的实体对象条件不为空,而且里面的属性不能全部为空,避免出现全表删除的情况。 > > 或者可以参考补充说明,添加防全表更新与删除插件的插件。 这里有两个方法,对应的SQL语句不太一样。 直接调用API即可。 对应的SQL语句如下。 同样,尽量对ID列表分片,不能一次性删除太多数据。 直接调用API即可。 对应的SQL语句如下。 这个有点类似与saveBatch的操作,多次删除一次提交。 这两种方法我进行了简单的测试。测试结果打印如下。 > 这两个差距还算很明显的了。测试中每次删除1000条数据,要是按更大的长度进行分片,我觉得这两种的方法差距会更加的大,所以尽量使用removeByIds这种方法。 这里以用户名举例,即传入用户名列表,批量进行删除。 由于MybatisPlus没有对应的API,所以需要手动去编写Mapper。 deleteBatchByUsernames方法的mapper可以参考批量删除ID的方法进行编写,这里就模仿removeByIds对应的SQL进行编写。 直接调用API即可。 直接调用API即可。 使用UpdateWrapper的条件去定位数据,更新条件需要设置sqlset。 以下是个简单的例子。 以下是个简单的例子。 这个方法是MybatisPlus里的一个方法,顾名思义,保存或者是更新,先去数据库根据ID查询是否存在该条数据,没有就插入数据,有的话就更新数据。大致用法和update或者是save差不多。 > 这方法确实也挺好用的,不过是更新和插入的混合方法,有点违和就是了,所以这里就不怎么探讨了。 > 这个方法只会返回一条数据,如果查询出多条数据会抛出异常,若是希望查出多条数据不抛出异常,可以自行设置。 > > getOne(queryWrapper, false) 假设根据用户名和昵称进行查询。 这里需要自己手写SQL实现才行了,SQL语句和根据其他条件批量删除的差不多,也是通过IN关键字拼接实现。 MybatisPlus提供了一个分页插件,需要先去配置,配置参考上述的补充说明。 MybatisPlus的分页方法需要IPage这分页模型,可以自己去实现这个分页模型,也可以使用官方提供的Page类(Page继承了IPage,实现了一个简单的分页模型)。Page的对象创建可以直接使用其Page.of方法。 > 注意,MybatisPlus的分页方法是会先查询所有数据的数量,然后才会进行LIMIT分页,也就是说会有两条SQL语句,从打印的SQL就可以看到。 > > > > Consume Time:19 ms > Execute SQL:SELECT COUNT(*) AS total FROM user > > Consume Time:3 ms > Execute SQL:SELECT id,username,password,nickname,avatar,email,sex,phone,status,create_time,create_by,update_time,update_by FROM user LIMIT 10 > > > > 如果用不到总记录数,不想执行count查询,可以通过Page.of(current, size, false)方法去关掉。 根据条件分页查询,其实只需要添加一个条件构造器即可。 这里拿性别举例,分页查询性别为男的数据。 这篇文章主要是介绍一些MybatisPlus的API吧,其实刚刚开始写的时候,是想记录一些常用的用法的,但是后面写着写着,发现其实都是在写官方的API如何使用(确实这个项目考虑的很周全)。后来又怕别人看得更明白些,又写了很多介绍类和使用的注意事项。emm,怎么说的,是写的有些乱了,本来就是给自己看到,写写感觉就偏题了hh,不过还可以吧,将就看一下。","url":"/posts/4e5ad84e/","category":"我的技术学习物语果然有问题","date":"2023.02.02","dateTime":"2023-02-02T00:00:00.000Z"},{"title":"2022年度总结","description":"2022年度总结","content":" 刚打完游戏,发现2022年已经过去了。正好我这夜猫子也睡不着,就赶着2023年年初,来写了这篇年度总结。 > 为什么2021年没有写?其实2022年1月1日的时候,我也是刚和朋友打完游戏,也差不多这个点,我已经写了一篇2021年的年度总结,但是后面写完之后,不记得为什么就删掉了,没发出来,所以就没了,也不想重新写了。 这次没有鸽,肯定写出来hh。 2022年最重要的事应该是我大学毕业了吧。毕业的时候原本想写个大学四年的总结的,后面想想算了,在大学里也没有什么特别的事情,像很多人一样,平平凡凡的上了个大学,平平凡凡的大学毕业。 其实大三大四过得不是很好,成天感觉到很焦虑,我都感觉心理状态有些亚健康了。每天都是上课,考试,刷题,还有那毕设的破事,大学后面两年其实还是有些遗憾的。不过应该也是我太懒了,学习的心情也没有大一大二那两年这么积极了,每天看那两三小时题目,效率也不高,所以后面也没有什么好结果,有些摆烂了。 所以毕业后,就疯玩了一两个月后才找了个班上。 2022年前期毫无开发的心情,所以也没开发什么有趣,好用的东西。上班之后,感觉到很无聊,所以有了很多想做的东西,也捡起了很多之前想弄有没有弄好的东西,继续努力写吧。 其实有些项目拖了很久没写好(拖延症后期的人是这样的),总是想弄得最好,用很多很新的技术,有些时候也增加了很多学习成本,不过毕竟不是很急的东西,都是兴趣爱好,所以就拖着慢慢写了。 就像是这个博客,用着hexo来搭建的,也不是说不好用,但是总是想自己写一个,所以就会考虑UI设计,学习前端项目,想要搭建一个自己的服务器,总之很多需要考虑的东西,还有自己很懒,所以就写的很慢了。(我这不算找借口吧hhh) > 虽然工作也是coding,但是我不是很想写到这里,我还记得高中的时候和朋友讨论的一个话题,当爱好变成工作的时候,爱好还能一直是爱好吗?这个问题其实我回答不出,等我以后讨厌了,可能我才能回答得出来。所以我不是很喜欢把工作和爱好联系起来,工作是工作,爱好是爱好,所以不在这里讨论工作了。 今年学了很多技术,比如 1. springcloud 2. typescript 3. vue3 4. .... 也加深了很多东西的理解,有些东西还是在用到的时候,才会发现这其实有很多讲究,没有想象中的那么简单。 为了更好的学习,在打折的时候,我还买了很多相关的书。 1. MySQL必知必会 2. 漫画算法2 3. 编码 4. 图解Java多线程设计模式 5. Redis深度历险:核心原理与应用实践 6. 现代操作系统 7. 图解TCP/IP 8. labuladong的算法小抄 9. 图解HTTP 10. 操作系统导论 11. 逆流而上 12. 技术之瞳 13. 深入理解Java虚拟机 14. Java并发之美 15. Java编程思想 16. 重学Java设计模式 17. 数据结构与算法之美 其实这些书我都有电子版,不过买纸质版,也算另一种督促我看书的方式,毕竟不是花钱的电子书,就会看的没有那么认真了hh。 > 别问看了多少,问就是正在看着,没全部看完。 游戏方面的话,还是和之前一样,玩来玩去还是那几个,对很多游戏都不感兴趣,不过我觉得也够了。 1. 英雄联盟 2. APEX 3. 星际争霸2 4. 公主连结R 移动端现在就只玩公主连结了,之前会坑了战双一段时间,但是后面没这么多精力又再次退坑了。我还是喜欢像公主连结这种养生的游戏,虽然公会战的几天还是挺累的,不过毕竟一个月一次,还算是能接受。 其实我不怎么玩手游了,确实缺了点意思,但是也不舍得公会里的大家,所以拖着拖着,公主连结也玩了两年多了。在群里看到很多人都退坑了,也还是挺失落的,不过这游戏确实也就这样了,祝各位有缘再见吧。 大三大四后,博客确实写得少了,没有一开始这么积极了,我也看到了友联里的很多人,虽然都在维护博客,但是发表的文章也肉眼可见的变少,甚至有些都不发了。前些天在github上看到一个记录独立博客的项目,确实挺有感慨的,地址如下。 > https://github.com/timqian/chinese-independent-blogs 当初我折腾这个博客的时候花了很多心思,也买了很久yww52.com的域名,现在喜欢折腾博客的人确实变少了很多,也有点感概吧。 今年发现了一些人的博客,看到他们充满生活气息的文章,也让我产生写东西的感觉了。 今年写得很少,大多都是在总结用法,写得少的原因大概有几个。 1. 有些不知道写什么了。 2. 写东西就会想写最好,所以花的时间也很多。 3. 想放弃hexo这个博客框架了,自己写的博客也没写好。 4. 确实事情比较多,耗精力。 每个APP都有年度总结,这里相当于记录一下吧。 今年没有上一年听歌听得这么多了,我发现一旦听歌,精力就不行,我总会去注意歌词,做的事情也会效率很低,所以听的就没这么多了。又是真夜陪伴的一年hh。 :::gallery ::: :::gallery ::: 自从国家对动漫的政策变了之后,就很少在B站看番了,大多都是学习和游戏。 > 看看那个虫族教程,我看了多少遍,谁说学习游戏不是学习,我还是很好学的hh,不得不说一句星际争霸真难玩。扯到星际争霸,就想到暴雪了,该死的暴雪,可惜了这么多好游戏。 2023年就希望自己多看点书,多学习一点东西,多做一点项目,多写点文章,多勤奋一点吧。也没有很大的目标,没有很大的期待,可能我就是一条咸鱼吧。","url":"/posts/622a5765/","category":"个人总结","date":"2023.01.01","dateTime":"2023-01-01T00:00:00.000Z"},{"title":"SpringBoot部署启动","description":"SpringBoot部署启动","content":"在开发中,经常需要部署SpringBoot服务,所以来简单记录一下我比较常用的一些部署方式。 这种方法其实就是直接使用java -jar命令进行启动Jar包,所以得需要系统安装好Java的环境,然后打包好服务 > 注意这种方法,简化了一些重启的操作,会寻找是否有名字为app.jar的服务进程,所以服务器上如果部署有多个服务,那么jar包不要重名,或者修改成路径 这是我自己参考,然后修改的一个脚本文件,只要将该脚本文件和Jar包放入同一个目录下运行即可启动服务。 这种是本地启动的方式,所以需要自行配置服务器的Java环境。 以下是使用方法 > 其实这个脚本文件多多少少还是有一点问题的,提示信息也不是很美观,但是自己使用还是没什么问题的。 这种方法是通过Docker部署的方式,将源码使用maven打包成jar包,然后在容器内运行jar包。 步骤: 1. 拉取Springboot源代码 2. 如果需要自定义maven配置,请添加maven配置文件在于源码目录,或自己添加 3. 修改服务打包生成的JAR包文件名 4. 制作镜像 使用Docker的话,得自行选择需要的JDK镜像和Maven版本镜像,然后修改服务打包出来后的服务名即可。 > 这个制作镜像的方式会有个问题,就是每次制作镜像都需要去跑maven下载依赖,然后打包,时间花费的很多,而且有时候有些maven依赖在仓库上获取不到,所以这种方式适合一些自建有maven仓库的项目,比如自建有Nexus,早就下载好依赖上传到仓库的项目。 > 不然的话还是在本地打包后在制作镜像吧,这样也快速,就是会很麻烦,不够自动化。 步骤 1. 打包好的JAR包 2. 准备Dockerfile 3. 修改服务打包生成的JAR包文件名 4. 制作镜像","url":"/posts/e31003e0/","category":"我的技术学习物语果然有问题","date":"2022.09.28","dateTime":"2022-09-28T00:00:00.000Z"},{"title":"RabbitMQ","description":"RabbitMQ的学习笔记。","content":"MQ,全称为message queue,消息队列,本质就是一个先进先出的队列,是一种跨进程的通信机制,用于上下游传递信息。 MQ的优点 1. 流量削峰 2. 异步处理 3. 应用解耦 1. ActiveMQ - 优点。单机吞吐量万级,时效性为ms级,可用性高,基于主从架构实现高可用性,丢失数据的概率较低。 - 缺点。早期项目,目前社区活跃度低,高吞吐量场景较少使用。 2. Kafka - 优点。在大数据的消息传输方面,举足轻重。方面性能卓越,单机写入TPS约在每秒百万条,最大的优点就是吞吐量很高,时效性为ms级,可用性很高。而且是Kafka是分布式的,一个数据多个副本。 - 缺点。Kafka单机超过64个队列(分区),Load就会发生明显的飙高,发送消息响应时间变长,消息失败不支持重试。支持消息顺序,但是一台代理宕机后,就会产生消息乱序,社区更新较慢。 3. RocketMQ - 优点。RocketMQ出自阿里巴巴,而且用Java语言实现的,对于学习Java的人来说还能自己定制。单机吞吐量达十万级,可用性很高,分布式架构,消息可以做到零丢失,功能较为完善,扩展性也很好,支持10亿级别的消息堆积,不会因为消息堆积而导致性能下降。 - 缺点。支持的客户端语言不多,目前是Java和C++,而且C++方面也还不成熟,没有在MQ核心中去实现JMS等接口,有些系统要迁移需要修改大量的代码。 4. RabbitMQ - 优点。RabbitMQ由erlang实现,由于erlang的高并发特性,性能较好,吞吐量到万级,功能比较完备,稳定易用跨平台,而且支持多种语言,社区活跃度也很高。 - 缺点。商业版需要收费,学习成本较高。 RabbitMQ是一个消息中间件,接收并转发消息,它只接收存储和转发消息数据,并不会处理消息。 四大核心概念。 1. 生产者。 产生数据并发送消息的程序。 2. 交换机。 交换机一方面接收来自生产者的消息,另一方面它将消息推送到队列中。交换机必须确切知道如何处理它接收到的消息,是将这些消息推送到特定队列还是推送到多个队列,亦或者是把消息丢弃,这个得有交换机类型决定。 3. 队列 队列是RabbitMQ中的使用的一个数据结构,用于存储消息。队列仅受主机的内存和磁盘限制的约束,本质上是一个消息缓冲区。生产者将消息发送到队列,消费者从队列中接收消息。 4. 消费者 接收并处理消息的程序。 RabbitMQ的安装可以参考官方的文档。 里面有多种安装的方式,建议使用docker来进行安装,不用考虑这么多环境的问题,只要安装了docker,就只需要一条命令即可。 安装的是管理版本,所以可以访问地址 来进行登录管理RabbitMQ的web界面。 服务器记得开放15672和5672这两个端口,15672是web管理界面的接口,5672是RabbitMQ的服务端口。 如果没设置参数,默认的账号和密码都是guest 官方的教程也是挺好的,可以参考一下。 引入MQ客户端的依赖。 首先先创建一个常量类,用于存储一些配置参数。 生产者发送消息。 运行该程序就能发送一条消息到指定队列了。 消费者消费消息。 此时就能看到消费者获取到了这个消息。 Work Queues,工作队列或者说是任务队列,简单的理解为一个队列的任务可以分配给多个消费者消费。 它的主要思想是避免立即执行资源密集任务,而不得不等待它完成。相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进 程将弹出任务并最终执行作业。当有多个工作线程时,这些工作线程将一起处理这些任务。 生产者和消费者获取连接,信道的方式是一样的,所以可以抽取出来作为一个工具类。 这次先编写两个消费者(工作线程),两个消费者除了打印不一样,其他都一样,所以就不写全了,启动两次或者分两个类启动都行。 接下来编写生产者。 接下来进行发送测试,发送几个消息。 可以看到两个消费者的情况。 > 从这里可以看出一些规律。 > > 每个消息是只能被消费一次的。 > > 消息的消费的轮询的,就是说每个消费者消费了一次消息之后,就轮到下一个消费者去消费,不会连续消费。 消费者完成一个任务需要一段时间,在这段时间内如果它挂掉了,由于RabbitMQ一旦向消费者传递消息后就会立即将该消息标记为删除,所以就会丢失了这段消息的处理。所以为了保证消息在发送过程中不丢失,RabbitMQ引入了消息应答机制。 消息应答就是说,消费者在接收到消息并处理了之后,在通知RabbitMQ处理完成,RabbitMQ才会把该消息删除。 这种方式表示消息发送后就会立即被认为已经传输完成,就会有可能出现上述的消息丢失的情况。这种模式会出现消息丢失的情况,但是可以适用于高吞吐量的场景,毕竟速度和安全并不能全都要。上述的代码演示都是可以看到是自动应答的。 这种模式尽量不使用,因为在大多数情况下,每一个消息都是很重要的,所以尽量使用自定义的应答方式。 - Channel.basicAck() 肯定确认。表示MQ已经知道该消息已经被成功处理了,可以将其丢弃。 - Channel.basicNack() 用于否定确认。 - Channel.basicReject() 用于否定确认。 > 关于参数multiple这个批量应答的处理。 > > 不建议使用批量应答,因为不能保证之前的消息是完成的,批量应答可能会出现应答了没完成的消息。 当消费者由于一些特殊情况导致ACK确认未成功发送给RabbitMQ,RabbitMQ就会让该消息重新排队(上述的requeue参数选择了消息不被丢弃),这就可以解决消息丢失的问题了。 手动应答是消费者设置的,所以生产者不需要特殊的变化,跟上一例子一样。 接下来编写消费者。 消费者二就调整一下时间,设置一个较久的时间,便于我们在暂停期间停止该进程,使其消费失败。 接下来开始测试。 > 开启生产者和这两个消费者,当消费者2出现开始消费的字样,即进入了接收消费的回调之后,停止程序运行,模拟消息丢失。 从这个测试就可以看到,cc这个消息原本应该是在消费者2中消费的,但是我停下了消费者2的进程之后,会发现这个消息转交到了消费者1中执行。 消息应答是消费者出现问题的时候的解决方法,但是当RabbitMQ服务宕机之后,消息还是可能会丢失,所以这就需要启动RabbitMQ的持久化机制了。 之前是有提到过的,队列不开启持久化的话,MQ服务宕机重启的时候,队列就会丢失(因为是临时存储的),所以需要在声明队列的时候就要开启持久化。 主要就是生产者存放消息时声明队列的那个方法。 根据上述所说,当消息不开启持久化,服务宕机之后,即使队列不会丢失,消息也会丢失的,所以也需要开启持久化。 主要就是发送消息的那个方法。 队列和消息都实现持久化之后,并不能保证消息不会丢失,因为有很多特殊情况会影响结果,比如持久化到磁盘的过程中服务宕机,还是会可能丢失数据的,所以这种方法并不能避免一些特殊情况。所以还需要参考下述的发布确认。 生产者将信道设置成 confirm 模式,一旦信道进入 confirm 模式,所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始),一旦消息被投递到所有匹配的队列之后,broker 就会发送一个确认给生产者(包含消息的唯一 ID),这就使得生产者知道消息已经正确到达目的队列了,如果消息和队列是可持久化的,那么确认消息会在将消息写入磁盘之后发出,broker 回传给生产者的确认消息中 delivery-tag 域包含了确认消息的序列号,此外 broker 也可以设置basic.ack的 multiple 域,表示到这个序列号之前的所有消息都已经得到了处理。 confirm 模式最大的好处在于他是异步的,一旦发布一条消息,生产者应用程序就可以在等信道返回确认的同时继续发送下一条消息,当消息最终得到确认之后,生产者应用便可以通过回调方法来处理该确认消息,如果 RabbitMQ 因为自身内部错误导致消息丢失,就会发送一条 nack 消息,生产者应用程序同样可以在回调方法中处理该 nack 消息。 开启发布确认是在生产者端的,所以只需要在生产者端标记信道,开启即可,主要的方法就是这个。 这个方法是将信道标记成confirm,还需要配合下面的方法实现确认。 一般都会使用 最简单的一种发布确认方式,是一种同步的确认发布,也就是说发布一个消息之后,只有它被确认的时候才会返回,如果在指定时间范围内没有被确认,就会抛出异常。 这种方式是最花费时间的,因为每一个发布的消息都要等待确认才能发下一个消息,吞吐量会小很多,不过这种方式也是最安全的,能保证消息不会丢失。 测试如下。 测试结果。 单个确认的效率很慢,所以可以先发布一批消息然后一起确认可以极大提高吞吐量,这种方案也是同步的发布确认方式。 当然问题很明显,当出现故障的时候,不知道具体是哪一个消息出现了问题。 测试如下。 测试结果如下。 异步确认发布在比同步的方式最重要的是效率能高很多,而且因为也是单个确认的,所以也是很可靠的。 这里就是通过监听器来帮忙监听哪些消息是成功的或者是失败的,而不用在逻辑里面等待确认。 添加监听器主要是下面这个方法。 测试如下。 测试结果如下。 从上述的例子可以知道监听器和发布消息的线程不是同一个,所以这个未确认的消息的处理最好还是先存储起来。 一个简单的使用例子。 刚刚学习的时候是可以知道RabbitMQ默认是循环调度,也就是轮询的,这种调度方法,有优点也有缺点,有时候公平并不是一件好事,所以我们可以设置这个消费者的工作内容。 主要是在消费者中设置信道的这个函数。 > 注意当所有工作线程都很忙,你的队列有可能会被填满。 > > 所以需要你添加更多的工作线程,或者是使用其他的策略。 上述只是简单实用,这个方法的完整形式如下(以下为机翻) 在上述的示例中,使用了工作队列,工作队列会将每个任务交付给一个工作线程。当然我们也可以实现向多个消费者传递一条消息,这种模式被称为Publish/Subscribe,也叫发布/订阅。 RabbitMQ消息传递模型的核心思想是生产者从不直接向队列中发送任何消息。实际上生产者经常甚至根本不知道消息是否会被传送到哪个队列。 实际情况是生产者只能将消息发送到交换机中,交换机的任务也很简单,一方面他接收来自生产者的消息,另一方面将消息推入队列。 是应该把这些消息放到特定队列,还是说把他们丢到许多队列中,或者说是丢弃,这些就是由交换机的类型来决定了。 交换机有几种可用的类型。 1. direct(直接) 2. topic(主题) 3. headers(标题) 4. fanout(扇出) 之前使用的就是无名的交换机。 第一个参数是交换机的名称,空字符串就表示默认或者说是无名交换机。消息能路由发送到队列中其实就是由routingKey指定的。 临时队列用于临时存储消息,一旦断开了消费者的连接,队列就会被自动删除。 创建一个随机名称的临时队列。","url":"/posts/b543ced0/","category":"我的技术学习物语果然有问题","date":"2021.12.26","dateTime":"2021-12-26T00:00:00.000Z"},{"title":"SpringCloud","description":"SpringCloud的学习笔记。","content":"Eureka是Netflix开发的一个服务发现框架,SpringCloud将它集成在其子项目spring-cloud-netflix中,主要的功能是服务注册和服务发现。 Eureka有两个组件,对应了两个角色。服务中心和服务的客户端。 引入依赖。 编写配置文件。 开启Eureka Server服务。 引入依赖。 编写配置文件。 开启服务。 集群的配置主要就是要注意,两两注册。 两个Server端。 Client端的配置。 通过发现Client的服务发现,来获取Client端的服务信息。 主启动类中开启服务发现。 服务发现的简单使用。 在Eureka的服务注册中心会看到一行红字,看到了这段红字提示,就代表Eureka进入了自我保护机制。 > EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE. 简单的机器翻译为。 > 紧急情况! EUREKA 可能不正确地声称实例已启动,但实际上并非如此。续订少于阈值,因此实例不会只是为了安全而过期。 保护模式主要用于一组客户端和服务端之间存在网络分区场景下的保护,一旦进入保护模式,服务端将会尝试保护器服务注册表中的信息,不删除服务注册中的数据,也就是不会注销任何微服务。简单来说就是服务注册中心中的某一个Client微服务不可用了,Eureka并不会立刻清理该微服务信息,依旧会保存在服务注册中心。 > 默认情况下,如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳,Eureka会注销该实例(默认90秒)。 > > 如果出现了网络分区的情况,Client与Server之间无法正常通信,这样的注销行为就会很不安全,因为有可能是因为网络问题导致无法接收到心跳,而不是该Client状态不健康,就不应该立刻注销该微服务。Eureka通过自我保护模式来解决了这个问题。 > > 当EurekaServer节点短时间内丢失过多Client时,该节点就会进入自我保护模式。自我保护模式中,Server不会注销任何服务实例,即使是不健康的实例,也会保留。 所以Eureka属于CAP分支中的AP分支。 修改配置就可以关闭自我保护。 设置客户端向服务端发送心跳配置。 官网地址 官网的介绍。 > Consul 是一种服务网格解决方案,提供具有服务发现、配置和分段功能的全功能控制平面。这些功能中的每一个都可以根据需要单独使用,也可以一起使用以构建完整的服务网格。 > > Consul 需要一个数据平面并支持代理和本地集成模型。 > > Consul 附带一个简单的内置代理,因此一切都可以开箱即用,而且还支持 3rd 方代理集成,例如 Envoy。 主要特点。 > 1. 服务发现:Consul 的客户端可以注册一个服务,例如 api或mysql,其他客户端可以使用 Consul 来发现给定服务的提供者。使用 DNS 或 HTTP,应用程序可以轻松找到它们所依赖的服务。 > > 2. 健康检查:Consul 客户端可以提供任意数量的健康检查,要么与给定的服务相关联(“网络服务器是否返回 200 OK”),要么与本地节点(“内存利用率低于 90%”)相关联。操作员可以使用此信息来监视集群健康状况,并且服务发现组件可以使用它来将流量从不健康的主机路由出去。 > > 3. KV 存储:应用程序可以将 Consul 的分层键/值存储用于多种目的,包括动态配置、功能标记、协调、领导选举等。简单的 HTTP API 使其易于使用。 > > 4. 安全服务通信:Consul 可以为服务生成和分发 TLS 证书,以建立相互的 TLS 连接。 意图 可用于定义允许哪些服务进行通信。可以通过实时更改意图轻松管理服务分段,而不是使用复杂的网络拓扑和静态防火墙规则。 > > 5. 多数据中心:Consul 支持开箱即用的多个数据中心。这意味着 Consul 的用户不必担心构建额外的抽象层以扩展到多个区域。 win10下载之后就只有一个consul.exe文件,直接在文件夹中使用CMD即可。 然后访问consul的首页。 引入依赖。 修改配置文件。 开启服务发现。 在Consul的控制台就能查看到该服务的该实例。 | 组件名 | 实现语言 | CAP | 服务健康检查 | 对外暴露接口 | SpringCloud集合 | | :-------: | :------: | :--: | :----------: | :----------: | :-------------: | | Eureka | Java | AP | 可配支持 | HTTP | 集成 | | Consul | GO | CP | 支持 | HTTP/DNS | 集成 | | Zookeeper | Java | CP | 支持 | 客户端 | 集成 | Nacos可以实现服务注册中心,后续提出来专门学习。 Ribbon是基于Neftlix Ribbon实现的一套客户端负载均衡工具,主要功能是提供客户端的软件负载均衡算法和服务调用。 工作流程。 1. 先选择EurekaServer,优先选择在同一个区域内负载较少的server 2. 在根据用户指定的策略,再从server获取的服务注册列表选择一个地址 Ribbon就是负载均衡加上RestTemplate调用。 引入依赖。 Ribbon是基于RestTemplate调用实现的,所以要使用Ribbon还需要去RestTemplate配置类上开启。 Ribbon的核心接口IROLE,用于制定一个负载均衡规则的实现。 它的一些实现类就是一些常用的负载均衡规则。 1. com.netflix.loadbalancer.RoundRobinRule 轮询 2. com.netflix.loadbalancer.RandomRule 随机 3. com.netflix.loadbalancer.RetryRule 先按照轮询的策略获取服务,如果获取服务失败则在指定时间内进行重试,获取可用的服务 4. WeightedResponseTimeRule 对轮询的扩展,响应速度越快的实例选择权重越大,越容易被选择 5. BestAvailableRule 会过滤调由于多次访问故障而处于断路器跳闸状态的服务,然后选择一个并发量最小的服务 6. AvailabilityFilteringRule 先过滤故障实例,再选择并发较小的实例 7. ZoneAvoidanceRule 默认规则,复合判断server所在区域的性能和server的可用性选择服务器 官方说明不能被@ComponentScan注解给扫描到,而@SpringBootApplication启动类注解中是包含了@ComponentScan的,所以不能放在主启动类的包下。 创建配置类。 然后在主启动类下开启自定义规则。 轮询的原理就是通过取模,确定请求的位置,类似于hash的实现。 实现的两个方法。(com.netflix.loadbalancer.RoundRobinRule) 可能以后会学习。 因为有Feign的替代版了,所以这个暂时不考虑,详情请参考OpenFeign。 Feign是一个声明式WebService客户端,使用在服务消费端。 前面使用的是Ribbon+RestTemplate的服务调用方法,利用RestTemplate对http请求进行封装处理,调用其他服务的接口。Feign在此的基础上进一步封装,只需要添加一个注解,即可实现服务调用。 Feign是SpringCloud组件中一个轻量级的RESTful的HTTP服务客户端,Feign内置了Ribbon,用来做客户端负载均衡。 OpenFeign是在Feign的基础上支持了SpringMVC的注解,实现类中做负载均衡并调用其他服务。 引入依赖。 这个依赖是包含了Ribbon依赖的,所以使用其中的负载均衡功能。 编写配置文件。 开启使用。 创建业务服务接口。即通过这个接口,Feign就会调用指定服务的接口。 前端控制器调用业务接口。 总结。 1. 主启动类上开启使用Feign。(@EnableFeignClients) 2. 编写service业务接口类,指定调用的服务提供者。(@FeignClient(\"CLOUD-PAYMENT-PROVIDER\")) 3. 编写的抽象接口就使用服务提供者的接口。 因为是调用服务提供者的接口,所以就可能会出现超时的情况,可用通过配置进行超时控制。 就比如Feign默认的配置超时时间是1秒,即调用的接口1秒之内没有结果回应,Feign客户端就不会继续等待了,直接返回报错。 编写配置类 OpenFeign日志级别。 1. NONE 默认的,不显示任何日志 2. BASIC 仅记录请求方法,URL,响应状态码及执行时间 3. HEADERS 除了BASIC中定义的信息之外,还有请求和响应的头信息 4. FULL 除了HEADERS中定义的信息之外,还有请求和响应的正文及元数据 编写配置类。 设置需要打印日志的接口。 > 服务雪崩 > > 多个微服务之间的调用的时候,假设微服务A调用微服务B和微服务C,微服务B和微服务C又调用其他的微服务,这就是所谓的“扇出”。 > > 如果扇出的链路上某个微服务的调用响应时间过长或者不可用,对微服务A的调用就会占用越来越多的系统资源,进而引起系统崩溃,这就是所谓的雪崩效应。 Hystrix是一个用于处理分布式系统的延迟和容错的开源库,比如在分布式系统里,许多依赖不可避免地会调用失败(超时,异常等),Hystrix就是用于保证不会因为一个依赖出现问题而导致整个服务失败地情况,避免级联故障。 当一个服务发生了故障,无法返回结果,就会通过断路器地故障监控,向调用方返回一个符合预期地备选响应,而不是直接导致整个服务调用的失败。 Hystrix的主要功能。 1. 服务降级 2. 服务熔断 3. 接近实时的监控 - 服务降级 服务的负载过大,但是资源是有限的,根据降级的策略牺牲一些服务或者是功能,保证核心服务的正常执行。 - 服务熔断 当上游服务因为某种原因而调用失败,下游服务为了保证整体服务的可用性,就会不再继续调用失败的上游服务,返回一个设定的结果,快速释放资源。 - 服务限流 服务限制请求的速率,比如服务设定了一个访问阈值,在一段时间内的访问次数超过了阈值,超过的部分就会直接拒绝访问。 > 降级和熔断 > > 降级和熔断的概念很相似,但其实是不一样的。 > > 降级强调的是整体架构的可用性,熔断强调的是当前服务的可用性。 > > 降级的目的在于应对系统自身的故障,而熔断的目的在于应对当前系统依赖的外部系统或者第三方系统的故障。 引入依赖。 编写业务实现类。 编写前端控制器。 > 前提 > > 访问正常请求接口,基本都是秒回信息。 > > 访问超时请求接口,则会等待三秒钟才返回信息。 使用JMeter对超时请求接口进行压力测试。 模拟多线程多个请求访问超时请求接口,自己访问正常请求接口,会发现已经不是秒回信息了,可能会出现超时,停顿的情况。 因为tomcat的默认的工作线程数被打满了,没有多余的线程来分解压力和处理。 这还只是服务提供者的自测,若是还有服务消费者,会极大可能出现请求超时的情况,导致服务消费者的请求不能及时完成,拖死客户端。 正是因为这种情况的出现,所以需要我们进行降级,容错,限流等。 > 解决的问题 > > 1. 服务端出现超时或者宕机了,调用者不能一直卡死等待,需要服务降级 > > 2. 服务端成功返回,但是调用者自己出现故障或又自我要求,自己处理降级 设置自身调用超时时间,不超过超时时间的就可以正常运行,超过了的需要用指定方法进行处理,作服务降级。 主启动类开启服务降级。 配置业务接口的超时设置和超时的处理方式。 配置文件开启支持服务降级。 主启动类启用。 业务类接口处理。 > 一般是调用端配置超时设置,在哪里配置或者两端都配置还要根据具体业务需求。 刚刚演示的是某一个方法的服务降级,若是方法过多,就会导致降级处理的方法也会变多,所以大多数都是会用同一个降级处理方法。 1. 在controller的地方添加降级配置@DefaultProperties 2. 编写全局降级处理方法 3. 给需要降级的接口添加@HystrixCommand注解,不指定降级处理方法就使用控制器全局的配置降级方法。 因为一般不会在controller里进行处理异常情况,所以我们可以直接在业务接口处进行处理降级。 > 注意这两种降级的方法还是有点区别的。 > > 在业务接口的降级处理其实是配置Feign的降级,也就是服务提供端出现问题的处理,在controller的降级处理其实算是在服务消费者的降级处理。 服务熔断是一种保护机制,当扇出链路的某个微服务出错不可用或者响应时间太长,会进行服务的降级,进而熔断该节点微服务的调用,快速返回错误的响应信息,当检测到该节点微服务调用响应正常后,恢复调用链路。 简单的说,就是当一段时间内失败的调用达到指定的阈值后,就会触发熔断机制。 下面配置一下服务端的服务熔断。 在业务接口类配置服务熔断设置。 > 断路器开启之后,请求就不会调用主逻辑了,即不用判断请求正确还是错误,直接调用fallback,直接服务降级。 > > 一段时间(默认是5秒),断路器是半开状态,会让其中一个请求进行转发,如果成功,断路器关闭,若失败,则继续开启 > > 熔断类型。 > > 1. Open。请求不再调用当前服务,直接进行服务降级处理,打开时间达到设置时间,进入半熔断状态。 > 2. Half Open。部分请求根据规则调用当前服务,若是请求成功并且符合规则则认为服务恢复正常,关闭熔断。 > 3. Closed。不对服务进行熔断处理。 HystrixDashboard准实时的调用监控,持续的通过记录所有通过Hystrix发起的请求的执行信息。 引入依赖。 主启动类开启支持。 然后启动就可以访问到页面了。 被监控的服务也要设置一下。 然后在 填写监控的地址。 后续单独提出,这里只需要知道能实现服务降级。 暂不考虑。 Zuul2是Zuul的替代版,但是由于开发组的情况复杂,所以暂不考虑。 SpringCloudGateway新一代的网关,主要当作为服务的入口。 1. 路由(Route) 路由是构建网关的基本模块,由ID,目标URI,一系列的断言和过滤器组成,如果断言为true则匹配该路由 2. 断言(Predicate) 参考了Java8的一个重要的函数接口Predicate,开发人员可以匹配HTTP请求中的所有内容,如果请求与断言相匹配则进行路由 3. 过滤(Filter) 使用过滤器,可以在请求被路由前或者请求之后对请求进行修改 引入依赖。 编写配置文件。 主启动类。 网关的配置主要是在yml配置文件。 > 启动网关服务的时候,出现了一个小错误。 > > 原因是因为多添加了一个web依赖导致的,网关服务是不需要web依赖的,删除即可。 此时网关服务启动了,只要符合断言的路径就会按照服务地址访问。 > http://localhost:9527/payment/** > > 这样的路由就是符合路由的,经过网关转发就会转发到下面的路由。 > > http://localhost:8001/payment/** 我们在配置路由的时候就可以发现,路由地址是写死的,也就是指定了一个微服务,如果服务是集群的,就很麻烦了,所以可以考虑用微服务名来实现动态路由进行转发。 需要添加配置开启使用微服务名进行路由。 然后使用微服务名代替。 断言其实是有很多种的,上述使用的都只是path,即路径符合就返回true,接下来了解一下常用的Predicate。 Path断言表示路径符合断言即为成功。 > 时间的配置可以如下。 > > 比如2021-12-24T11:14:05.346576Z[Etc/UTC] > > 可以通过ZonedDateTime.now()的方法生成。 - After断言代表指定时间之后即为符合断言。(后面接一个时间) - Before断言代表指定时间之前即为符合断言。(后面接一个时间) - Between断言代表指定时间内即为符合断言。(后面接两个时间,配置文件隔开用逗号) Cookie断言代表请求带了指定Cokkie后才符合断言。 Header断言代表请求带了指定请求头后才符合断言。 Host断言代表指定主机符合断言。 Header断言代表请求带了指定请求方法才符合断言。 Query断言代表请求需要带指定参数。 Spring Cloud Gateway内置了多种路由过滤器,由GatewayFilter的工厂类来产生,主要用于添加或修改请求和响应。 自带的过滤器有几十种,所以只看一下一个简单的例子。 自带的太多了,所以主要学习自定义的过滤器。 实现步骤。 1. 实现两个重要接口。GlobalFilter和Ordered。 2. 实现接口的方法。 SpringCloud Config为微服务架构中的微服务提供了集中化的外部配置支持,配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。 SpringCloud Config分为服务端和客户端两部分。 - 服务端也称为分布式配置中心,它是一个独立的微服务应用,用来连接配置服务器并为客户端提供获取配置信息。 - 客户端则是通过指定的配置中心来管理应用资源,以及与业务相关的配置内容,并在启动的时候从配置中心获取和加载配置信息配置服务器默认采用git来存储配置信息,这样就有助于对环境配置进行版本管理,并且可以通过git客户端工具来方便的管理和访问配置内容。 > SrpingCloud Config默认是使用git来存储配置文件,使用的是http/https访问的形式 1. 因为使用的是git来存储配置文件,所以需要提前创建一个github仓库,并提前添加一些配置文件。 2. 服务端主要依赖的引入。 3. 服务端的配置文件编写。 4. 编写服务端的主启动类,开启注解支持。 5. 可以通过URL 就能读取的github仓库里的配置文件了,至此服务端已经完成建立。 1. 引入客户端的主要依赖。 2. 主要的核心就在于配置文件。 - application.yml是用户级别的配置文件 - bootstrap.yml是系统级的配置文件,优先级更高。 - 它会先去加载bootstrap.yml的配置,然后在加载application.yml配置 - 在client模块就需要使用bootstrap.yml 3. 编写主启动类。(不用开启注解。) 4. 测试是否能够读取github上的配置文件。 5. 然后访问这个接口 就能获取到这段配置文本了。 当我们修改了github上的配置文件的内容后,服务端的配置中心读取到是新的配置文件,但是客户端怎么读取,都是之前的配置文件的内容,这就是分布式配置的动态刷新问题。(总不能重启客户端吧,那动态配置的好处就不能体现了) 避免客户端每次都要刷新,就需要解决中国刷新问题。 1. 引入一个重要的依赖。 2. 修改配置文件,暴露监控的端口。 3. 在业务类上面添加一个刷新的注解 4. 每次当github配置文件发生变更时,配置中心会跟着变,此时发送一个POST请求刷新客户端的配置即可生效。 5. 这就成功刷新了客户端的配置内容到最新的版本。 > 从手动刷新这里也能看出来一个问题,那就是手动刷新只能刷新一个服务。 > > 如果有很多个服务,怎样实现动态刷新全部的服务配置文件,还是需要思考的。 > > 这里就可以配合SpringCloud Bus消息总线来实现这个功能。 > > SpringCloud Config大多数都是和SpringCloud Bus配合使用的。 Nacos可以实现服务配置,后续会单独学习。 SpringCloud Bus是用来将分布式系统的节点与轻量级消息系统链接起来的框架,整合了Java的事件处理机制和消息中间件的功能。 Bus目前只支持两种消息代理。 1. RabbitMQ 2. Kafka SpringCloud Bus配合SpringCloud Config使用可以实现配置的动态刷新。","url":"/posts/96a41905/","category":"我的技术学习物语果然有问题","date":"2021.12.17","dateTime":"2021-12-17T00:00:00.000Z"},{"title":"lambda表达式与Stream流","description":"Java8的新特性,优化代码。","content":"Lambda表达式出现主要是为了简化代码,若某一个接口只有一个抽象方法,就能使用Lambda表达式来进行简化这个接口的实现类。 1. Consumer 消费型接口 对T进行操作,不返回结果,方法为 void accept(T t) 2. Supplier 供给型接口 不接收参数,返回类型T的数据,方法为 T get() 3. Function 函数型接口 对类型为T的对象操作,返回R类型的数据,方法为 R apply(T t) 4. Predicate 断定型接口 对类型T的数据进行判断,返回Boolean值,方法为 boolean test(T t) 在lambda体中引用另一个方法,即用另一个方法来实现lambda体。 使用格式 类(或对象):: 方法名 1. 对象::非静态方法 2. 类::静态方法 3. 类::非静态方法 方法引用的方法的形参列表和返回类型要与lambda一样才能使用该方法引用(针对于前两种格式) 主要是第三种格式有些难懂。 相当于lambda引用中创建一个对象,调用了一个构造方法。 Stream流的使用主要分为三个步骤。 1. 创建Stream流。从数据源(集合,数组等)转换成Stream流。 2. 中间操作。对数据源的数据进行处理。 3. 终止操作。执行终止操作,就会执行中间操作的处理,产生结果。 1. 集合获取Stream流的方法 - list.stream()串行 - list.paralleStream() 并行 2. 数组获取Stream流的方法 - 通过Arrays的静态方法stream()得到Stream流Arrays.stream(int[]) 3. 通过Stream.of()来获取Stream流 4. 创建无限流(用于编造数据) - Stream.iterate() - Stream.generate() 1. 筛选与切片 * filter(Predicate p) 从流中排除某些元素,即满足Predicate函数的元素 * limit(n) 截断流,使其元素不超过给定的元素,即筛选出来的元素不超过n * skip(n) 跳过元素,返回一个除了前n个数据的流,若数据源不足n个,则返回空流 * distinct() 通过流生成元素的hashCode和equals方法去除重复的元素 2. 映射 * map(Function f) 接收一个函数作为参数,将元素转换成其他形式或提取信息 * flatMap(Function f) 将一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流 3. 排序 - sorted() 没有参数,自然排序,默认从小到大的排序,如果操作的元素是类,就会抛出异常,需要该类实现Comparable接口 - sorted(Comparator com) 一个Comparator实例,定制排序 1. 匹配与查找 * boolean allMatch(Predicate p) 检查是否所有元素是否匹配该断定函数接口 * boolean anyMatch(Predicate p) 检查是否至少有一个元素匹配该断定函数接口 * boolean noneMatch(Predicate p) 检查是否没有元素匹配该断定函数接口 * findFirst() 返回第一个元素 * findAny() 返回任意一个元素 * count() 返回流中的总个数 * max(Comparator c) 返回流中的最大值 * min(Comparator c) 返回流中的最小值 * forEach(Consumer c) 内部迭代 2. 归约 - reduce(T identity, BinaryOperator bin) 可以将流中元素反复结合起来得到一个值,返回这个T类型的值 比如这个求和的例子list.stream.reduce(0, Integer::sum); - reduce(BinaryOperator bin) 可以将流中元素反复结合起来得到一个值,返回这个Optional 类型的值 3. 收集 collect(Collector c) 将流转换为其他形式的数据源,调用这个Collector接口的方法得到新建数据源 一般使用实现了接口的Collectors的类的方法 常用方法为 * List toList() 将元素收集到创建的List * Set toSet() 将元素收集到创建的Set * Collection toCollection() 将元素收集到创建的Collection * Long counting() 计算流中的个数 * Integer summingInt() 对流中元素的整数属性求和 * Double averagingInt() 求流中的元素Integer属性的平均值 Optional 类是一个容器类,可以报错类型T的值,代表这个值存在。 或者仅仅保存null,表示这个值不存在,可以避免空指针异常 如果值存在,则isPresent()方法返回true,调用get()方法会返回该对象 1. Optional.of(T t) 创建一个实例,t是非空的 2. Optional.isEmpty() 创建一个空的实例 3. Optional.ofNullable(T t) 创建一个实例,t是可以空的 1. boolean isPresent() 判断是否包含对象 2. void ifPresent(Consumer consumer) 如果有值就会执行Consumer接口的实现代码,并且会作为参数传给它 1. T get() 如果调用对象包含值,则返回该值,否则抛异常 2. T orElse(T other) 如果有值则返回,没有返回指定的other值 3. T orElseGet(Supplier other) 如果有值就将其返回,否则返回由Supplier接口实现提供的对象 4. T orElseThrow(Supplier exceptionSupplier) 如果有值就将其返回,否则抛出由Supplier接口实现提供的异常","url":"/posts/8a8aa27b/","category":"我的技术学习物语果然有问题","date":"2021.12.06","dateTime":"2021-12-06T00:00:00.000Z"},{"title":"异常处理","description":"常用的全局异常处理。","content":"这里需要注意的是,自定义异常需要继承RuntimeException(运行时异常)。 > @RestControllerAdvice注解其实是@ControllerAdvice和@ResponseBody的合并。 > > @ControllerAdvice通常配合@ExceptionHandler来捕抓异常信息。 > > @ControllerAdvice可以捕抓到系统抛出的异常,然后使用@ExceptionHandler匹配具体处理异常信息。 有些异常是不会走全局异常处理的,即不会被捕捉到,比如在过滤器中的异常,这种异常是没有经过controller的,所以发生了异常,也不会通过被上述的方式捕捉到。 以下是一个捕捉Token过滤器异常的例子。","url":"/posts/28877bf/","category":"我的技术学习物语果然有问题","date":"2021.10.10","dateTime":"2021-10-10T00:00:00.000Z"},{"title":"分布式session的解决方案","description":"Session主要的目的是会话控制,但是在分布式环境下,Session就会出现一些问题,接下来就来探讨一下会出现的问题以及解决方案。","content":"Session,在计算机领域,被称为“会话控制”。 会话控制,这就提出了两个问题 1. 什么是会话 2. 为什么要控制会话 3. 怎样控制会话 会话按字意来看就是进行对话,其实真正含义就差不多是这个意思。 > 在计算机术语中,会话是指一个终端用户与交互系统进行通讯的过程,比如从输入账户密码进入网上的一个系统到退出系统就是一个会话过程。 也可以理解为两个计算机之间的对话,这就是会话。 一个计算机的网络世界就像是被集体孤立的个人,虽然不能说孤立的个体是毫无作用的,但是不融入集体的个体,是不能发挥出个体的真正意义的,所以每个个体的交流是很重要的。所以在网络世界中,会话也是很重要的。 会话大部分都是建立在HTTP的基础上的,但是HTTP是一个无状态的协议,于是就出现了一个很重要的问题,会话这么多,服务端该怎么区分这些会话是哪个用户的?所以就需要将这些会话进行控制区分。 服务端需要某种机制来将这些会话进行区分,这个机制就是session。 用户通过HTTP与服务端进行会话,服务端为每一个用户生成特定的sessionId来标记该用户,之后每个会话携带着特定sessionId,服务端就能确定该会话属于哪一个用户的了。 控制会话的大致思路就是这样了。 在上述对session的描述中,会发现控制会话的方案是很好的。但是这仅限于单体架构,服务端只有一个服务器在提供服务,该服务存储着所有的sessionId,通过该服务器可以识别出所有被记录的用户。 但是在如今这个大流量的时代,大多时候,单个服务器是不能承担大规模的请求,所以就出现了集群方案,将单个服务器拓展为多个服务器提供服务,减轻单个服务器的压力。 但是从这个图中就会发现一个问题。 假设客户端A与服务端进行了一次会话,第一个请求发送到了服务器A,服务器A为客户端的这次会话生成了一个sessionId,但是客户端A的请求是有可能发送到服务器B的,但是此时的服务器B是没有记录这次会话的,所以也就是没有状态的,这违背了session的初心。其根本原因就在于session是没有共享。 接下来就探讨一下在分布式环境下的session怎样实现共享。 在分布式环境下,一个客户端的请求可能散落在不同的服务器上,但是我们可以发现客户端是唯一,所以将session直接存储在客户端不就可以实现session的共享了吗?这的确是一个方法,一个会话一定是会在同个客户端,这样就实现了session的共享。 那该怎么存储在客户端上呢? 可以借助浏览器的cookie来进行session信息的存储。在客户端向服务端第一次发送请求的时候,服务端生成一个特定的sessionId返回给客户端,浏览器收到了session信息之后,就将该信息存储到cookie中,每次发送请求都带上session信息,服务端就能识别出该会话。在这里服务端只提供生成session和识别seesion的服务,而不存储session信息。 :::note{type=\"warning\"} 缺点: session存储在cookie中,安全隐患很大,很容易被盗取。另一方面,cookie对于数据类型及数据大小存在限制。 ::: 第一种情况,在客户端存储,这种方案已经思考过了,那么接下来可以该在服务端想想方法了。 于是就出现了session复制这种方案。 将服务器A的sessionA给服务器B,服务器B的sessionB给服务器A,这样不就实现了session的共享了吗。 大致思路就是这样,在特定时间,服务器就会去复制其他服务器的session信息或者将自己的信息发送给其他服务器,从而实现session信息同步。 像tomcat等一些web容器就支持session的复制,在同一个局域网内发送该容器的session信息给其他容器。 :::note{type=\"warning\"} 缺点: session需要消耗一定的资源,当集群有点规模,消耗的资源也是不可小觑。 ::: 第一种方法是在客户端,第二种方法是在服务端,接下来就可以考虑请求转发上想方法。 我们只要将同一个客户端的请求都转发到同一个服务器上不就好了吗。 这种想法也是可以行的通的。Nginx也提供了对应的方法。使用Nginx进行负载均衡,可以选择它的ip_hash的方案,将同一个IP的请求转发到相同的服务器,这样该次会话都只会在一个服务器上进行,宏观上就像是单体架构下使用的session。 :::note{type=\"warning\"} 缺点: 降低了集群的可用性,若是单个服务器出现故障,那么存储的session的信息丢失,会话就会出现故障。 ::: 前三种方法在客户端,服务端,和负载均衡下思考的方案,除了这三者之外怎么进行session共享呢? 在计算机领域,没有什么问题是加一层不能解决的。 所以我们可以考虑给系统增加一个数据存储层,然后将seesion存储在该数据存储层上就好了,从而实现session的共享。 :::note{type=\"info\"} 事实上,每一个系统都会存在数据存储层的,只是上述解决思路没有将该数据存储层表示出来。没有表示出来的原因只是因为在session的机制中没有涉及到存储层,所以没有提及。 ::: 这里就提供一个基于Redis的sessioon存储方案。(只要是提供存储数据的都是可以实现的) :::note{type=\"success\"} 这种方法除了降低整个系统的可用性就没有什么很明显的缺点,系统可用性也是可以通过搭建Redis集群来进行提高。其实上述的绑定session的方案和session的方案,总体也是会降低整个系统的可用性,所以就不探讨该缺点。所以这种方案也是最经常使用的方案了。 :::","url":"/posts/86ff1dad/","category":"我的技术学习物语果然有问题","date":"2021.06.10","dateTime":"2021-06-10T00:00:00.000Z"},{"title":"MySQL必知必会","description":"阅读MySQL必知必会的笔记,并记录一下书中的SQL语句,用于加深一下印象。","content":"最好不要使用通配符,检索不需要的列会江都检索和应用程序的性能。 > DISTINCT必须放在列名的前面 > > 不能部分使用DISTINCT,这个关键字应用于所有列而不仅仅是前置它的列,所以除非指定的列都相同,否则所有行都将被检索出来。 > 检索出来的行是从0开始,所以LIMIT 5 表示从第0行开始接下来的五行 > ORDER BY 子句应该保证在FROM子句之后,LIMIT子句要在ORDER BY 子句之后。 > 如果想在多个列上进行降序排序,必须每一个列都要指定DESC关键字 > > ASC关键字其实没多大用,因为默认就是升序排序的,不指定DESC就一般是ASC排序 > WHERE子句的位置应该在ORDER BY子句之前。 | 操作符 | 说明 | | :-----: | :--------------: | | = | 等于 | | <> | 不等于 | | != | 不等于 | | | 大于 | | >= | 大于等于 | | BETWEEN | 在指定两个值之间 | > 单引号用来限定字符串。如果将值与串类型的列进行比较,则需要限定引号。用来与数值列进行比较的值不用引号。 > NULL 无值,她与字段包括0,空字符串或仅仅包括空格不同。 > 用来联结或改变WHERE子句的子句的关键字,被称为逻辑操作符或是操作符。 > AND 用在WHERE子句的关键字,用来指示检索满足所有给定条件的行。 > OR WHERE子句中使用的关键字,用来表示检索匹配任一给定条件的行。 > WHERE可包括AND和OR的组合子句条件,但注意的是,MYSQL会优先处理AND的条件然后在处理OR条件。 > 任何时候使用具有AND和OR操作符的WHERE子句,都应该使用圆括号明确地分组操作符。 > IN操作符用来指定条件返回,范围中地每个条件都可以进行匹配。 > NOT WHERE子句中用来否定后跟条件地关键字。 > WHERE prod_name LIKE '%'也是不能匹配NULL值得,需要注意。","url":"/posts/df083c4d/","category":"读书笔记","date":"2021.06.04","dateTime":"2021-06-04T00:00:00.000Z"},{"title":"漫画算法","description":"记录书中面试算法题的解法,主要是书中思路。","content":"给定一个链表,判断链表中是否有环。 从头节点开始,依次遍历单链表中的每一个节点。没遍历一个新节点,就从头检查新节点之前的所有节点,查看是否相同。若存在相同节点证明链表是有环的。 该算法遍历一遍的同时,内部也在从头遍历一次,所以时间复杂度为O(n^2) 没有创造新的内存空间,空间复杂度为O(1) 创建一个Set集合,遍历链表并将节点加入Set集合,当出现重复的元素,即加入Set集合失败即代表有环出现。 该算法是遍历一遍链表,所以时间复杂度为O(n) 将所有节点加入Set集合存储,空间复杂度也为O(n) 使用两个指针,一个每次前进两个,一个每次前进一个,若是出现两个指针指向一个节点,代表链表有环。因为快指针提前入环,总会追上慢指针。 只用循环一次链表,所以时间复杂度为O(n) 不用创建额外的空间,所以空间复杂度为O(1) 快慢节点重合的时候,在继续前进并记录前进的次数,下次重合,就是快指针(速度是慢指针的两倍)比慢指针多走了一圈,可以理解为前进的次数就是环的长度。 假设链表头节点到入环点的距离是D,从入环点到两个指针首次相遇点为S1,从两个指针首次相遇点到入环点的距离为S2。 设慢指针的移动速度为一个节点,快指针的移动速度为两个节点。 故两个指针首次相遇时,两个指针所走的距离如下 慢指针行走的距离为D + S1 快指针的速度是慢指针的两倍,所以相当于比慢指针多走了N圈,故行走的距离为D + S1 + N * (S1 + S2) 因为快指针的速度是慢指针的两倍,所以快指针的行走距离应该为慢指针的两倍,所以有 2(D + S1) = D + S1 + N * (S1 + S2) 经过整理可以得到 D = (N - 1)(S1 + S2) + S2 也就是说,链表头节点到入环点的的距离相当于从首次相遇点绕环N - 1圈后再回到入环点的距离。 故从头节点出发,与首次相遇点出发,两者均以一个节点的速度,两者相遇点即为入环点。 > 设计一个支持 push ,pop ,top 操作,并能在常数时间内检索到最小元素的栈。 > > - push(x) —— 将元素 x 推入栈中。 > - pop() —— 删除栈顶的元素。 > - top() —— 获取栈顶元素。 > - getMin() —— 检索栈中的最小元素。 这里需要使用到辅助栈来实现,将每次最小的元素都放到辅助栈中,若即入栈的元素比最小元素小,辅助栈中就放入该最小元素,否则就放入之前最小的元素。当栈出栈后,辅助栈也跟着出栈。 > 求出两个正整数的最大公约数。 从较小整数的一半开始遍历到2,首次出现了两个正整数都整除的数,则该数就是两个正整数的最大公约数。 时间复杂度为O(min(a, b)) 这个方法基于一个定理: 两个正整数a和b(a > b),它们的最大公约数等于a除以b的余数c和b之间的最大公约数。 时间复杂度近似为O(log(max(a, b)),当两个正整数很大的时候,a % b的计算性能很差。 两个正整数a和b(a > b),它们的最大公约数等于a - b的差值c和较小数b的最大公约数。 避免了大数取模的计算,但是算法性能不稳定,最坏的时间复杂度为O(max(a, b)) - 当a和b均为偶数时,gcd(a,b) = 2 * gcd(a / 2, b / 2) = 2 * gcd(a >> 1, b >> 1) = gcd(a >> 1, b >> 1) > 1, b); - 当a为奇数,b为偶数时,gcd(a, b) = gcd(a, b / 2) = gcd(a, b >> 1); - 当a和b均为奇数时,先利用更相减损术运算一次,gcd(a, b) = gcd(b, a - b),此时a - b必是偶数,然后进行上面情况的运算。 进行简化之后为 这是更相减损法与位运算的结合方法,算法性能稳定,而且使用了位运算,时间复杂度为O(log(max(a, b))) > 判断一个正整数是否为2的整数次幂 计算出2的整数次幂,依次递增,若是出现了大于该数的2次幂(并没有等于的),就证明该数不是2的整数次幂。 算法的时间复杂度为O(logn)。 每一个2的整数次幂转换为二进制,都是1开头后面都是0的数串。 将该整数次幂减一,就得到二进制全为1的数串。 这两个数取按位与运算,就会出现每一位数都不一样,所以结果为0。 所以不为0的就不是2的整数次幂了。 n & -n可以得到最低位的1的位置,即最低位为1其余全是0的数串,如果是2的整数次幂的话,那么该数串其实表示的就是本身。 > 有一个无序整数型数组,如何求出该数组排序后的任意两个相邻元素的最大差值? 将数组进行快速排序O(nlogn),然后进行遍历O(n),所以总的时间复杂度为O(nlogn) 空间复杂度就是该数组O(n) 使用计数排序,找出新数组最多连续出现0的次数加1,就是最大相邻差了。 当数组的数差值不是很大的情况下,效率很高,但是差值很大的情况,数组的长度会很大。 记录桶内的最大和最小值,统计出每一个桶的最大值,和这个桶右侧非空桶的最小值的差,数值最大的差即为题目所求,故时间复杂度为O(n) > 用栈来模拟一个队列,要求实现队列的两个基本操作:入队和出队。 使用一个栈明显是不能实现队列的,所以需要一个辅助栈。设这两个栈为a和b。 a栈用来存储入队的元素,入队的元素直接压入a栈就好。 b栈用来存储出队的元素,出队的元素就直接推出b栈就好。 当b栈是空的,就将a栈的所有元素出栈压入a栈,这样出栈的顺序就相反了,即符合先进先出了。 > 给出一个整数,从该整数中去掉k个数字,要求剩下的数字形成的新整数尽可能小。应该如何选取被去掉的数字? 从左往右,第一位大于它右边的数,将该数删了就会让整个数值降低。 > 给出两个很大的正整数,要求实现程序求出两个整数之和。 > 很久很久以前,有一位国王拥有5座金矿,每座金矿的黄金储量不同,需要参与挖掘的工人人数也不同。例如又得金矿储量是500kg黄金,需要5个工人来挖掘;有的金矿储量是200kg黄金,需要3个工人来挖掘...... > > 如果参与挖矿的工人的总数是10.每座金矿要么全挖,要么不挖,不能派出一半人挖取一半的金矿。要用程序求出,要想得到尽可能多的黄金,应该选取挖取那几座金矿? 这题就是一道背包问题,根据题意可知这是01背包的问题,有两种状态转移的情况,选或者是不选。 > 在一个无序数组里有99个不重复的正整数,范围从1到100,唯独缺少1个1~100中的整数。如何找出整个缺少的整数。 创建一个哈希表,将1到100这100个数全部存入key中,遍历整个数组,将存在的key都删掉,剩下的key就是缺少的整数。 将数组进行排序,然后逐个寻找。 计算出1~100的和,然后减去数组中元素的和,剩下的就是所缺少的整数了。 > 一个无序数组里有若干个正整数,范围是1~100,其中99个整数都出现了偶数次,只有一个整数出现了奇书次,如何找到这个出现奇数次的整数? 可以将数与数出现的次数当成Key和Value放入哈希表,然后寻找出现次数为1的,和上述哈希表的做法差不多,就不深入了。 这里可以使用异或运算,先了解异或运算的规律。 1. 两个相同的数异或,结果等于0 2. 任何数与0异或,结果等于本身 3. 异或运算符合交换律 故将数组中的数进行异或,偶数次的数异或会变成0,奇数次的数就会留着。","url":"/posts/998d504/","category":"读书笔记","date":"2021.06.03","dateTime":"2021-06-03T00:00:00.000Z"},{"title":"码出高效Java开发手册","description":"记录码出高效Java开发手册的读书笔记,主要是书中一些我觉得很有收获的观点,所以大多是原书内容,小部分是自己的总结。","content":"面向过程编程让计算机有步骤地顺序地做一件事情,是一种过程化地叙事思维。但是在大型软件开发过程中,使用面向过程语言开发,软件维护,软件复用存在着巨大的困难。 面向过程是用来解决一个问题的最好的思想,面向过程最主要的是过程,好的过程就会让一个问题快速正确的获得正确的答案。 但在软件开发方面,会出现很多很多的功能,即出现很多很多的问题需要解决,对于面向对象思想无疑会产生很多问题。 1. 无法复用代码,在不同问题中出现相同的子问题,就需要又去复用之前出现的代码,无疑是很麻烦的。 2. 耦合度高。面向过程的代码不断穿插,就会让软件的耦合度过高,这样只要一个小问题出现了错误,就有可能导致整个大的问题发生错误,这是我们不想看到的。 面向对象思想的想法就是为了解决这样的问题。 > 传统意义上,面向对象有三大特性:封装,继承,多态。本书明确将“抽象”作为面向对象的特性之一,支持面向对象“四大特性”的说法。 > Java之父Gosling设计的Object类,是任何类的默认父类,是对万事万物的抽象,是在哲学方向上的延伸思考,高度概括了事务的自然行为和社会行为。Object还对哲学的三个经典问题进行了隐约的解答。 > > 1. 我是谁? getClass()说明本质上是谁,而toString()是当前我的名片。 > 2. 我从哪里来?Object()构造方法是生产对象的基本方式,clone()是繁殖对象的另一种方式。 > 3. 我到哪里去?finalize()是在对象销毁时触发的方法。 > > Object还映射了社会科学领域的一些问题。 > > 1. 世界是否与你而不同?hashCode()和equals()就是判断与其他元素是否相同的一组方法。 > 2. 与他人如何协调?wait()和notify()是对象间通信与协作的一组方法。 Object的类是抽象的核心体现。他将万物抽象成一个Object,之后每一个类都继承于Object,将Object类当成一个模板,去将事物抽象成一个类。 1. 封装。封装是将一个类中的行为和属性进行的信息控制,决定是否要公开对类行为和属性的控制。外界只要知道调用这个行为方法,就可以实现一些功能,而不用知道如何去内部是怎样实现的。书中有句话说得很好,模块之间的协作只需要忠于接口,忠于功能实现即可。 2. 继承。类将一些复用的行为和属性赋予子类,也就是子类继承了父类,从而复用了父类的代码,也为多态打下基础。 > 继承的成本很低,一个关键字就可以使用别人的方法,所以继承像抗生素一样容易被滥用,我们传递的理念是谨慎使用继承,认清继承滥用的危险性,即方法污染和方法爆炸。 > > 方法污染是指父类具备的行为,通过继承传递给子类,子类并不具备执行此行为的能力,这就是方法污染。(因为父类有些方法不希望子类使用) > > 方法爆炸是指继承树不断扩大,底层类拥有的方法虽然都能执行,但是由于方法众多,其中部分方法并非于当前类功能定位相关,多次继承后达到上百个方法,造成了方法爆炸。 3. 多态。根据运行时不同对象的类型,同一个方法产生不同的运行结果,使同一个行为具有不同的表现形式。 > 抽象类是模板式设计,而接口是契约式设计。 抽象类和接口是对一个事物更高级的抽象,抽象类通常包括抽象方法,实体方法和属性变量,而接口一般只是一组行为,没有具体实现和属性。 抽象类是模板,意义是给子类提供一个抽象的模板,接口是一个契约,继承该接口就要实现里面的所有方法,即遵循这个契约。 > 多态中的override,本书翻译成覆写。如果翻译成重写,那么与重构意思过于接近;如果翻译成覆盖,那么少了“写”这个核心动词。如果父类定义的方法达不到子类的预期,那么子类可以重新实现方法覆盖父类的实现。(实现多态的方式)父类引用执行子类方法时需要注意 > > 1. 无法调用到子类中存在而父类本身不存在的方法。 > 2. 可以调用到子类覆写了父类的方法,这是一种多态的实现。 覆写父类的方法,需要满足以下四个条件。 1. 访问权限不能变小 。 2. 返回类型能够向上转型成父类的返回类型。这里的向上转型必须是严格的继承关系,数据类型基本不存在通过继承向上转型的问题。比如int和Integer,不会自动给装箱,是非兼容返回类型。 3. 异常也要能向上转型成为父类的异常。 4. 方法名,参数类型及个数必须严格一致。 每一个覆写方法最好加上@Override注解,编译器会自动检查覆写方法签名是否一致。 > 在同一个类中,如果多个方法有相同的方法名称,不同的参数类型,参数个数,参数顺序,即为重载。(方法返回值不在考虑范围) JVM在重载方法中,选择合适的目标方法的顺序如下: 1. 精确匹配。 2. 如果是基本数据类型,自动转换成更大表示范围的基本类型。 3. 通过自动拆箱与装箱。 4. 通过子类向上转型继承路线依次匹配。 5. 通过可变参数匹配。 > 父类的公有实例方法与子类的公有实例方法可以存在重载关系。不管继承关系如何复杂,重载在编译时可以根据规则知道调用哪种目标方法。所以重载又称为静态绑定。 > 虽然Java是面向对象编程语言,一切皆是对象,但是为了兼容人类根深蒂固的数据处理习惯,加快常规数据的处理速度,提供了9种基本数据类型,它们都不具备对象的特性,没有属性和行为。 > > 9种数据类型包括:boolean,byte,char,short,int,long,float,double,refvar。 > > refvar是面向对象世界中的引用变量,也叫引用句柄。本书认为它也是一种基本数据类型。 其中的boolean是一个比较特殊的存在。它的值为false或者是true。在计算机的世界,0表示false,1表示true。所以常规思想会认为booealn的大小为1字节或1位。 Java虚拟机描述,虽然定义了Boolean数据类型,但是对它的支持有限,所以在编译时用int数据类型来代替,所以会占用4个字节。但时Boolean数组在编译时会被编译成byte数组,所以数组中Boolean占用1个字节。 refvar无论指向什么,都是占用4个字节的空间。 书的第三章一章书都是在讲代码风格。 对于我这种有一点代码洁癖的人来说,还是很建议去学习一套规范的代码风格的。 这里讲的不是很详细,详细的可以去看一下《阿里巴巴Java开发手册》那本书,一本小册子写了记录了很多的代码规范。 IDEA也有一个插件,用阿里巴巴的代码规范来规范你的代码,多写些规范的代码,利于别人也利于自己。 > 如果某个程序因为不同的硬件平台需要编写多套代码,这是十分令人崩溃的。Java的使命就是一次编写,到处执行。在不同的操作系统,不同的硬件平台上,均可以不用修改代码即可顺畅地执行,如何实现跨平台?有一个声音在天空中回响:计算机工程领域的任何问题都可以通过一个中间层来解决。因此,中间码应运而生,即“字节码”(Bytecode)。 Java之所以会这么流行,离不开它的一次编写,到处执行的跨平台的这个特性。不同平台的Java文件(.java),都会编译产生字节码文件(.class),从字节码文件这一中间层屏蔽了上层操作系统(平台)的差异性,只要安装了Java的环境,都能运行出Java文件,能解决很多平台之间的运行问题。 堆分成了两大块,新生代和老年代(它们之间的占比为1:2)。新生代又分为三个区域Eden区和两个Survivor区(它们占比为8:1:1)。 首先新创建的对象会放在Eden区上,等Eden区满了放不下新创建的对象了,就会进行YGC,将Eden区中和其中一个Survivor区(from区)活着的对象放入另一个一个Survivor区(to区)。以此循环。 每一个对象都会有一个计数器,经历了一次YGC之后,对象的计数器就会加一,当到达了一定阈值,就会进入老年代(Java默认为15)。 新生代进入老年代的两种方法: 1. 对象的计数器到达了阈值,进入老年代。 2. Eden区放不下新创建的对象,进行了YGC之后也放不下,就会提前将该对象晋升为老年代(过早老化)。 方法区是JVM规定的一个区域,不是一个实在的区域,只是一个定义。 Java8之前是用永久代来实现了方法区,Java8之后是用元空间来实现方法区。 永久代包括了运行时常量池(比如String)和一些类元信息(类加载的文件,静态变量等)。 元空间只保存了类元信息,运行时常量池已经放入堆中进行存储。 不同与永久代,元空间在本地内存中分配。 > 虚拟机栈是描述Java方法执行的内存区域,它是线程私有的。栈中的元素用与支持虚拟机进行方法调用,每个方法从开始调用到执行完成的过程,就是栈帧从入栈到出栈的过程。 可以说,栈帧就是一个方法执行过程的具体体现。 栈帧主要包括四个部分。 1. 局部变量表。存放方法参数和局部变量的区域。 2. 操作栈。操作栈是一个初始状态为空的桶式结构栈。在方法执行过程中,会有各种指令往栈中写入和提取信息。 3. 动态连接。每个栈中中包含一个在常量池中对当前方法的引用,目的是支持方法调用过程的动态连接。 4. 方法返回地址。方法执行有两种退出情况。一,正常退出。二,异常退出。无论何种退出情况,都将返回至方法被调用的位置。 > 虚拟机栈主内,本地方法栈主外。这个内外是针对JVM来说的,本地方法栈为Native方法服务的。 > 每个线程在创建后,都会产生自己的程序计数器和栈帧,程序计数器用来存放执行指令的偏移量和行号指示器等,线程执行或恢复都要依赖程序计数器。程序计数器在各个线程之间互不影响,此区域也不会发生内存溢出的异常。 > 1. try代码块 > 监视代码执行过程,一旦发现异常则直接跳转到catch,如果没有catch,就直接跳转到finally。 > 2. catch代码块 > 可选执行的代码块,如果没有任何异常发生则不会执行;如果发现异常则进行处理或向上抛出。 > > 3. finally代码块 > 必选执行代码块,不管是否有异常产生,即使发售鞥OutOfMemoryError也会执行,通常用于处理善后清理工作。如果finally代码块没有执行,则会有三种情况。 > - 没有进入try代码块 > - 进入try代码块,但是代码运行中出现了死循环或死锁状态 > - 进入try代码块,但是执行了System.exit()操作 fail-fast机制是几何世界中比较常见的错误检测机制,通常出现在遍历集合元素的过程中。 java.util下的所有集合类都是fail-fase机制的。 比如在这些集合中,使用foreach遍历元素时进行删除,就会出现异常。 > 需要注意的时,无论是JDK7还是JDK8,ConcurrentHashMap的size()方法都只能返回一个大概数量,无法做到100%精确,因为已经统计过的槽在size()返回最终结果前可能又出现了变化,导致返回大小与实际大小存在些许差异。在多个槽的设计下,如果仅仅是为了统计元素数量而停下所有操作,又会显得因噎废食。因此,ConcurrentHashMap在涉及元素总数的相关更新和计算时,会最大限度地减少锁的使用,以减少线程间地竞争与互相等待。在这个设计思路上,JDK8的ConcurrentHashMap对元素总数的计算又做了进一步的优化,具体表现:在put(),remove()和size()方法中,涉及元素总数的更新和计算,都彻底避免了锁的使用,取而代之的是众多的CAS操作。 > 线程安全问题只在多线程环境下才出现,单线程串行执行不存在此问题。保证高并发场景下的线程安全,可以从以下四个纬度考量 > > 1. 数据单线程内可见。 > 2. 只读对象 > 3. 线程安全类 > 4. 同步与锁机制 > > 线程安全的核心理念就是“要么只读,要么加锁”。 该注意的是线程安全的主体是对象,而不是线程。 一般我们说线程安全的主语都是对象。 > Java并发编程实践中对线程安全的定义 > > 当多个线程访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为都可以获得正确的结果,那这个对象就是线程安全的。 > volatile的英文本已是“挥发,不稳定的”,延申意义为敏感的。当使用volatile修饰变量时,意味着任何对此变量的操作都会在内存中进行,不会产生副本,以保证共享变量的可见性,局部阻止了指令重排的发生。 > > “volatile是轻量级的同步方式”这种说法是错误的。它只是轻量级的线程操作可见方式,并非同步方式,如果是多写场景,一定会产生线程安全问题。 volatile关键字的特性 1. 保证可见性 2. 不保证原子性 3. 禁止指令重排 这本书的前面半部分讲的通俗易懂,讲的很好,但是到后面有几章通过源码来进行讲解部分类与方法,这里就开始接触到部分工具的底层,如果没有一定的基础去看的话会很累,而且也会很繁琐。这些知识点很重要,作者想尽量写全,但是书的篇幅是有限的,所以就会感觉后面讲源码的部分看的体验就不是很好,有些地方也没有更深入的去讲。总的来说还是一本很好的书,适合学习Java的人观看,但是后面的一些知识点需要更加了解的话,就还需要通过其他途径,作者只是给各位读者开个头,了解一下,也是查缺补漏。最后孤尽老师还写了段话送给大家。 > 最后,做一个有技术情怀的人。技术情怀总结成两个关键字:热爱,卓越。热爱是一种源动力,卓越是一种境界。兴趣是最好的老师,也是最好的动力。而热爱是一种信念,即使痛苦,也不会让你背离这份事业和内心的执着。对技术的热爱,让人用于归根究底,勇于坐冷板凳,勇于回馈别人。极致与卓越,似乎是一个意思,即出类拔萃,超出期望。技术情怀提倡我们追求极致式的卓越,把卓越在往前提升。不管一个人如何卓越与优秀,都要学会自我驱动,持续进步,追求个人内心的极致。因为卓越,所以经典,只有这样百尺竿头,才能更进一步。仰望星空的同时,是脚踏实地,这样才能不断地学习和打磨自己。","url":"/posts/b93b977e/","category":"读书笔记","date":"2021.05.30","dateTime":"2021-05-30T00:00:00.000Z"},{"title":"结果类封装","description":"记录一下项目中常用的返回信息的封装类。","content":"首先要封装一个响应的枚举,将一些常见的错误写入,一般状态码需要与前端一起制定,以便前端提示错误信息以及发生错误的处理逻辑。 然后是数据返回的封装类。","url":"/posts/a3d4b987/","category":"我的技术学习物语果然有问题","date":"2021.05.22","dateTime":"2021-05-22T00:00:00.000Z"},{"title":"背包专题","description":"记录一下学习背包问题时的思路和解法","content":"有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 > > 第 i 件物品的体积是 v[i],价值是 w[i]。 > > 求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。 > 输出最大价值。 01背部的特征是每个物品都只有一件,要么选择装进背包要么选择不装进背部。 首先是状态表示,一般都能想到的是二维数组来表示状态dp[i][j],这个应该表示的是从前i个物品中选取,总体积是j的情况下,总价值最大是多少。 那么可以知道这道题的答案就是dp[N][V]了。 然后是状态转移了。 从题目就可以看出选择的方案,或者说是状态转移的方案。 1. 不选择第i件物品,即可以理解为从第i - 1件物品中选择,不选择第i件物品了,背包容量不变。 dp[i][j] = dp[i - 1][j] 2. 选择第i件物品,即可以理解选择了第i - 1件物品之后,从第i - 1件物品中选择,背包容量变为原容量减去第i件物品的体积,这个方案的前提是当前背包容量大于物品的体积。 dp[i][j] = dp[i - 1][j - v[i]] + w[i] 然后是结果,题目要求的是总价值最大,所以将两个方案取最大值就好。 优化dp数组。 这里使用的是二维的dp数组表示状态,但其实可以优化成一维的数组。 仔细观察这两个方程的状态转移方程。 1. dp[i][j] = dp[i - 1][j] 2. dp[i][j] = dp[i - 1][j - v[i]] + w[i] 第一个很好理解,将第i - 1的层j状态转移到第i层,但因为总体积是不变的,即j是不变的,所以这个转移相当于没有意义,所以遍历了i层这个转移就自动成立了。 第二个就会有点麻烦。当我们想要更新当前的状态,那么就需要第i -1 层的[j - v[i]] + w[i]数据来更新,如果我们直接使用d[j] = dp[j - v[i]] + w[i]是不对的。 这个式子其实等价于dp[i][j] = dp[i][j - v[i]] + w[i],与之前的状态转移是不一样的,所以是不对的,要想这个式子与之前的状态转移方程等价,将体积从V到0遍历就可以了。 故完整的代码为 为什么逆序遍历可以让上述两个式子等价呢? 遍历第i层的时候,dp[j-v[i]]会用到之前的状态,这个式子其实等价于dp[i][j-v[i]],在同一层里,用到了之前的状态,而不是上一层i - 1的状态,这就会导致i这个物品是被用到了第二次的,而01背包是每个物品只能用一次的,所以这个式子是不对的,逆序遍历体积容量的话就不会用到被污染的数据,就让式子成立了。(是有点绕,以后理解更深了在来修改一下说法) 还可以进一步优化输入,即便输入边处理数据。 > 有 N 种物品和一个容量是 V 的背包,每种物品都有无限件可用。 > > 第 i 种物品的体积是 vi,价值是 wi。 > > 求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大。 > 输出最大价值。 完全背包与01背包不一样的是完全背包是可以选无限件的。 所以完全背包与01背包分析不一样的就是状态的转移方案。 01背包问题里,是有两种方案的,选一个或者是不选,完全背包就会有很多种方案。 1. 不选第i件物品 dp[i][j] = dp[i - 1][j] 2. 选择k件第i个物品,容量要大于体积。 dp[i][j] = dp[i - 1][j - v[i]] + w[i] 跟01背包差不多,直接遍历所有第i件物品。 这里用到了三重循环,这样的话时间复杂度会很高,所以应该要考虑进行优化。 仔细观察一下这个状态转移方程。 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v] + w, dp[i - 1][j - 2v] + 2w....) 我们求dp[i][j]的最大值也就是求后面这些方案的最大值,我们可以注意到 dp[i][j - v] = max(dp[i - 1][j - v], dp[i - 1][j - 2v] + w).... 所以通过二式我们可以求出一式后面的除了第一项的最大值。 故进行优化之后的状态状态方程为 dp[i][j] = max(dp[i - 1][j], dp[i][j - v] + w) 这样就能省去一重循环,于是变成下面这样。 变成这样会发现和01背包十分相似,所以也可以根据01背包的优化思路进行优化,先将该状态数组优化为一维。 在优化下输入,便输入边处理 ,最终可以为这样。 > 有 N 种物品和一个容量是 V 的背包。 > > 第 i 种物品最多有 si 件,每件体积是 vi,价值是 wi。 > > 求解将哪些物品装入背包,可使物品体积总和不超过背包容量,且价值总和最大。 > 输出最大价值。 多重背包跟完全背包不一样的点是多重背包的每件物品是有个数限制的,不过大体是和完全背包差不多的解题思路。 首先是最暴力的方式,三重循环,多重背包的三重循环相对于完全背包就是为第三个循环加多一个条件就好了。 三重循环的时间复杂度为O(n^3),很大概率会超时,所以要进行优化才行。 其实多重背包可以转换成01背包的问题,只要将背包的个数拆分开来就可以了。 最容易想到的是将n件商品拆分成n个商品,这样将所有商品个数大于1的商品全部拆分,就可以理解为01背包的问题了,选或者是不选。 但是这种方案是行不通的。因为将n件商品拆分成n个,时间复杂度依旧很大,依然很容易超时,所以我们得考虑出另一种拆分方法,怎样拆分能用拆分后得数字表示出0 ~ n呢? 这就用到了一种二进制的拆分方法。 将数字转换成类似二进制的表示方法。 > 比如要拆分9这个数字 > > 我们可以拆分为 1 + 2 + 4 + 2 > > 最后一个数小于2的n次方就使用剩余的数 > > 这样多重背包的一个9件的商品问题就可以拆分为01背包的四个不同的商品的问题 > > 使用这四个数选或者不选两种方案就能遍历出0 ~ 9十种方案 接下来看代码。 - -","url":"/posts/4f2ce235/","category":"我的技术学习物语果然有问题","date":"2021.04.19","dateTime":"2021-04-19T00:00:00.000Z"},{"title":"整合Redis","description":"SpringBoot整合Redis的Demo","content":"Jedis是官网推荐的Java连接工具,类似就是在Java和Redis中增加一层辅助层,辅助你用Java使用Redis。 简单的测试一下使用。 首先创建一个maven项目,导入相关的依赖。 连接使用Redis 事务的使用。 整合就先创建一个SpringBoot的项目,导入SpringData项目的redis依赖。 :::note{type=\"info\"} 在比较新的SpringBoot版本中,放弃了Jedis对redis的直接连接,因为多个线程会出现线程不安全的情况,所以官方已经替换成了lettuce。 lettuce采用netty,实例可以在多个线程中进行共享,减少线程数量,不存在线程不安全的情况。 ::: 在配置文件中,配置Redis的连接。 简单的测试。 上述的测试其实是没有经过序列化的,这是一个很不安全的操作,特别是传输对象的时候,没有序列化就会报错。 先简单的创建一个对象来测试。 :::note{type=\"info\"} 默认是会使用jdk的序列化方式,在后期使用会出现一些麻烦,所以开发中一般会自己定义RedisTemplate的序列化方式,所以就需要自己定义一个RedisTemplate来使用。 ::: 测试。 注解的使用会更加方便的为接口返回的数据添加到缓存里。 这个注解有几个参数。 首先在这个注解中,value或者是cacheNames这个参数是必须的。 最经常用的组合。 condition这个参数是用来定义缓存的条件的,比如下面这个例子。 这个注解和Cacheable作用是一样的,参数也是一样的,不一样的是这个注解是只负责将返回的结果存入缓存,再次查询的时候,是不走缓存的。 这个注解主要是用来清除缓存的。 主要使用的参数是allEntries,让它为true会将缓存清空 1. redis的官方starter 2. fastjson2,用于配置文件中的序列化,当然用其他的也可能可以 3. log4j,用于记录日志,当然不用也可以 4. hutool,这里用于提供sha256Hex加密 借鉴几个开源项目整合的配置文件。","url":"/posts/3cd0c9b6/","category":"我的技术学习物语果然有问题","date":"2021.04.02","dateTime":"2021-04-02T00:00:00.000Z"},{"title":"剑指Offer","description":"剑指Offer上面的题目,记录一下解题的过程","content":"可以直接将数组排序,然后进行循环遍历,就可以找到数组中重复的数字了。 可以将该数组丢到Set集合里去重,若是添加失败就代表该数字重复,直接返回就好了。 跟Set差不多,添加到哈希表之前,先判断一下是否有该键,然后要是有就直接返回。 遍历数组,将每一个数放在与它等值的下标下,因为题目说了数字都在1~n - 1,所以当该下标出现了与它一样的数字,代表这个数字是重复的。 题目详情可以参考 。 这里可以使用上述的哈希和Set集合来进行查找,或者在创建一个数组,然后使用桶排序找出重复的元素。 因为必定会有一个重复的,可以理解为数组中间会出现一个环,所以可以当成寻找链表的环。 还有就是利用分治的思想来解。类似二分查找的思想。 利用数值将数组分成两半,如果一边坑的个数小于数的个数,代表重复的数字就在那半边,所以缩小区间,直到找到。 直接将这个二维数组遍历,暴力破解。 根据递增的单调性,可以从最右上角一个个进行排除,寻找对应的值。可以从右下角向左下角进行遍历(反过来也可以)。 String类里就自带一个替换的方法了,所以可以直接进行替换。 直接遍历字符串,出现了空格就替换,不然就不替换。 要是不能用动态的增加字符串,就只能先遍历一遍字符串,然后判断答案的长度,然后在创建一个新的数组,然后依次放入新数组就好了。 这里最简单的解法就是将链表反转,然后在打印链表了。 这里可以使用类似后序遍历的操作,先递归进去然后添加值,这样就类似栈了,直接从后到前输出。或者这里定义一个栈也可以进行。 其实可以看到,其实从前遍历,然后反向输出就行了,其实并不用一定是正向的数据。 第一次遍历链表,判断数组的个数,然后从后往前赋值就好了。之前的解法也可以改为先进行一次遍历后再赋值,这样就不用使用list集合了,效率太低。 这题主要是要划分区间,划分好左子树和右子树的区间。 前序遍历的区间可以分为三个。根的值,左子树的值,右子树的值。 中序遍历的区间可以分为三个。左子树的值,根的值,右子树的值。 所以可以用前序遍历的第一个值创建节点,然后遍历前序遍历的数组,用中序遍历的数组来判断是否达到根的值。 上面是通过前序遍历和中序遍历去创建一颗二叉树,接下来是通过中序遍历和后序遍历来创建一个二叉树,其实差不多。 题目详情可以参考 这里就是直接找下一个节点就好了。 于是会有两种情况。 1. 当前节点有右子树。那么该节点的下一个节点就是右子树里的最左子节点。 2. 当前节点没有右子树,那就要追溯回原来第一个是其father左儿子的节点。 - 该节点是父节点的左孩子,这样下一个节点就是它的father - 该节点是父孩子的右孩子,这样下一个节点就是该左子树的父节点 这里先来分析一下这两个栈的作用。栈是先进后出的数据结构,而队列是先进先出的,所以无法进行互通,引入第二个栈是用来存储第一个栈中出栈的元素,这样第二个栈的元素就是第一个栈元素的倒序了,直接出栈就是最先进来的元素了。 入队就直接压入第一个栈中就可以了。 主要是要探讨出队的情况。 1. 当第二个栈中还有元素的时候,代表这些元素是最先进入的元素,所以直接出栈就是之前最先入队的元素了。 2. 当第二个栈和第一个栈都没有元素了,那就证明队列为空。 3. 当第二个栈没有元素,第一个栈有元素,那就直接将第一个栈的元素全部出栈压入第二栈,实现倒序。 剑指Offer这题的斐波那契数列是结果取模的,因为返回的是int,除了这个需要注意的,其他的和经常的解法差不多了。 可以考虑直接递归,但一般都会超时。 这里是可以考虑dp数组的迭代解法的,但是这里只是一次性达到答案,不会回头了,所以记录之前的状态并没有什么意思,所以可以创建临时变量保存需要的临时变量就可以了。 可以直接排序在取第一个。 找到第一个不递增的数字那就是最小的数字了。 二分查找最主要的就是划分区间,需要先分析一下怎样确定好区间。 1. 中间的数大于最右边的数,代表期间不会单调递增,直接进入右边的区间 2. 中间的数小于最右边的数,代表期间是单调递增的,直接进入左边的区间 3. 要是中间的数与最右边的数相等,那就缩进一下区间 经典的dfs和回溯。 看看别人的发现判断是否合法不用这么麻烦,还可以优化一下,所以变成下面这样。 从0,0开始,其实只用向右和向下就可以走完全部的格子了,所以可以去掉向左和向上的dfs。 这一题刚开始给我的想法是使用动态规划去解。 搬用题解关于该题的解释。 1. 任何大于1的数都可由2和3相加组成。 2. 因为都能有2和3组成,所以当3的数量越多,乘积越大。当剩余的绳子长度大于等于5,尽可能剪长度为3的绳子。 3. 有一个特例。当剩余的绳子长度等于4,就将绳子剪为两段2。 这题将数据量变大了很多,使用动态规划就会很麻烦,所以用刚刚的贪婪算法,修改一下。 有个方法是可以算出二进制中1的个数。 通过数字与1的与运算,来判断最后一个二进制的数是不是1,是的话与运算会返回1,就这样逐个判断二进制1的个数。 还有一个就是用n & (n - 1)来判断,这样的与运算会消去二进制中最右边的1。 n & (n - 1)还能用来判断是不是2的幂。 这里直接使用相乘的算法会超时,所以用到了快速幂的写法。这里需要注意的点是n为负数的时候,int的负数会比正数多一个,力扣上正好用到了这个边界−2147483648,所以需要用long类型来存储。 这里可以直接查到那个需要删除的节点,然后改变链表的指向就好了。 这题一看题目就是有点像快排的思想,双指针遍历就好了。 这题用快慢指针还是很简单的,先让快指针走N步,然后快慢指针一起走,当快指针都到链表尾部,那么慢指针就是倒数第K个节点了。 这个只要遍历就好了。 递归的解法挺简洁的,但是可能会有点绕。 首先要先找到A中与B节点的头节点相等的点,然后递归判断A与B的左子树与右子树,看是否结构与节点值相等。 转换镜像,那就是将左子树变为右子树,右子树变为左子树就可以了。 这题递归主要是要理清思路。将左子树和右子树传入,然后比较值,在将左子树的左子树和右子树的右子树,右子树的左子树和左子树的右子树放入递归判断就好了。 这题和那题螺旋矩阵差不多,最主要的就是遍历的边界的界定,这还是有点麻烦的。 找到最小元素其实并不难,这题难的地方是调用min,push,pop的时间复杂度都要为O(1)。 使用辅助栈来存取最小的数据,只要出现比辅助栈的栈顶元素还小的数,那就压入辅助栈,这样辅助栈就会是至今为止最小的元素的排行。 这个问题就可以创建一个栈,然后进行模拟压入和弹出就可以了。 如果压入了弹出序列的数,就弹出就好了。 这题就是层序遍历就可以了,要注意的就是确定数组的长度。 这个也是层序遍历,与上一题不一样的是要先确定每层的节点数然后将每层的节点加入到临时链表存储,之后在加入到答案列表。 这个就是要记录一下层数,这里的倒序可以分为两种解法。 1. 倒着加入到列表 2. 加入到列表之后再倒序 两种方法哪个都可以,我就使用了第二种方法。 后序遍历的遍历序列大致可以分成这样[ 左子树 | 右子树 | 根节点 ] 又因为是二叉搜索树,故左子树的所有节点应该比根节点小,右子树的所有节点应该比根节点大 直接进行回溯就可以了。 直接先将链表复制下来,然后逐个给复制随机指针指向就可以了。 链表复制很简单。 到这就会发现,这题的难点是怎样复制随机指针的指向。 这里可以用哈希表存储链表节点,键为原链表节点,值为新链表节点。 所以根据原链表节点的随机指针就能确定新链表的随机指针了。 将原链表和新链表拼接在一起 原节点1 --> 新节点1 --> 原节点2 --> 新节点2 ........... 这样的话,新节点的随机指针指向的前一个节点就是原节点的随机指针指向了。 将随机指针赋值完之后,将这个整合的链表中的新节点提取出来,拆分成一个新的链表就可以得到复制的链表了。 先排序,因为出现的次数超过一半,所以数组中间的数一定是超过一半的数字。 直接排序取前k个数行了。 因为要返回的最小的K个数,并没有说是有序的k个数,所以,快速排序的时候,排到第k个其实就可以停止了。 最简单的方法找出数组的全排序,得到所有数字的可能性,然后比较每个数字的大小就可以了。 不过这会很麻烦,暂时不考虑这种解法。 解法的关键是这个数组该怎么排序。使用普通的大于小于关系当然是不行的,所以需要自定义一个大小关系。 这里就定义了一个关系。要是ab > ba,那就设为a > b。 这里就不多加证明了。 Java还有更简单的排序方法。 这种题目回溯一般会超时,因为会有很多分支,把所有可能都计算出来了,如果题目需要遍历到所有可能,回溯会是一种很好的方法。 回溯减枝就可以想到动态规划了,存储最大的情况。 这里其实可以优化为一维数组的。 这题两重循环的暴力解很大概率会超时,所以就不用暴力解了。 这里最好的方法就是滑动窗口。 使用动态规划,主要是凑成最小的丑数,然后一个个凑到第N个,就是用2,3,5的公倍数从小凑到N。 这题用正常思维就可以解决了,暂时找不到更优的解法,都是先存储出现的次数,然后在遍历找出第一个次数为1的字符。 我这里就是用了哈希来进行存储,用数组也是可以的,因为题目标明了只有小写字母。 超时了。。O(n^2)的确很容易超时。 这个真没想出来。不过这题的确是归并排序的经典题,求出当前数与前面的数或者是后面的数的大小关系的个数的题基本都是归并排序来进行实现的。 归并排序主要分为两个个部分,递归划分,排序合并。 所以在排序合并的时候就能记录出逆序对的个数了。 这题每个节点的数字都不是唯一的,所以不能用普通存储的方式来查找第一个公共节点。 所以需要考虑一下直接遍历,唯一的问题就是,这两个链表不一定是等长的。所以我们需要想办法弄成等长的。 直接循环一遍即可。 因为数组本身就是排好序的,所以很容易联想到二分查找。查找到第一个小于目标数字的数,然后循环找出有多少个目标数字就可以了。 数组本身是递增的,直接递增,就能直接查找到缺少的数字。 求和然后逐个减去数组中的数字,这样就能找出缺少的数字了。 数组有序,那就是二分查找。 最主要的问题是查找什么。 若是每个数字都不缺少,那n这个数字应该会在数组的n的下标的位置。 要是有个数字缺少了,数组就会乱序,所以我们只要找到第一个乱序的数字,即为答案。 首先看到这题就想到之前写的找出唯一一个不是两个数的数字,使用异或很快就解决了问题。 不过这里的数组有两个这样的数,所以就无法直接异或得到答案,需要进行一些处理。 直接截出这两段字符串然后换位置就可以了。 遍历字符串一个个加入到结果字符中也是可以的。 这题是动态规划问题,状态转移方程有点类似多重背包。 dp[i][j] += dp[i - 1][j - k] * dp[1][k] 首先确定答案的约束。 1. 抽到的五张牌是不是连续的。 2. 抽到的五张牌是不重复的。 3. 大小王可以换为任意一张牌,可以存在重复的0 这里可以找出一定的规律,抽到的五张牌中最大的减去最小的小于5就可以说明这五张牌是重复的了。 直接按照题意进行转圈删除,最后一个剩下没被删除的就是答案了。 这题就算典序的约瑟夫环的问题。 约瑟夫环有一个递推公式。 F(n,m) = (f(n - 1,m) + m) % n F(n,m)表示的是n个人报数,报到m的人会被杀掉,最终胜利者的编号,也就是这题的答案。 这题是经典的动态规划题,不过这一题只交易一次。所以只需要找到一个最小的数买进,最大的数卖出就行了。 这题题目是不难的,但是题目的要求让这题变难了,不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。 这里运用到了&&短路与的特性,判断了第一个子式后如果是false就不会进行判断第二个子式了。 不用加减乘除,那就肯定是位运算了。然后就只能看题解了。 ^表示两个数无进位的求和,比如16 + 4,无进位求和就是等于10的,相当于进位没有了。 &表示两个数进位的个数,比如6 + 4 ,答案是等于1的,因为进了一位,需要在左移一位才能等于10。 这题主要是除了当前元素其他元素都相乘,其实就算数左边的元素的乘积与右边元素的乘积的乘积。 这题主要总结节点的情况,该题的节点应该是分为三种的。 1. p和q都在左子树 2. p和q都在右子树 3. p和q一个在左子树,一个在右子树(这种情况的节点就算二叉树的最近公共祖先) 了解了状态这题应该就不难了。 这题的分析跟上面的情况一样,只是判断子树的情况不太一样。","url":"/posts/dd921d98/","category":"我的技术学习物语果然有问题","date":"2021.03.19","dateTime":"2021-03-19T00:00:00.000Z"},{"title":"Redis","description":"学习Redis的笔记","content":"先来看看百度百科对NoSQL的描述。 > NoSQL,泛指非关系型的数据库。随着互联网web2.0网站的兴起,传统的关系数据库在处理web2.0网站,特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心,出现了很多难以克服的问题,而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战,特别是大数据应用难题。 NoSQL维基百科称其为Not Only SQL,在当今的大数据年代,仅仅是关系型数据库已经不能满足当前一些流量较大的Web应用,所以NoSQL就应运而生,就是用来解决数据量较大的问题。 NoSQL可以分成四个大类。 1. 键值存储数据库 2. 列存储数据库 3. 文档型数据库 4. 图形数据库 这里我就用百度百科上的表格,来简单了解一下这四个分类。 | 分类 | Examples举例 | 典型应用场景 | 数据模型 | 优点 | 缺点 | | :---------------: | :---------------------------------------------------: | :----------------------------------------------------------: | :---------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: | | 键值存储数据库 | Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB | 内容缓存,主要用于处理大量数据的高访问负载,也用于一些日志系统等等。 | Key 指向 Value 的键值对,通常用hash table来实现 | 查找速度快 | 数据无结构化,通常只被当作字符串或者二进制数据 | | 列存储数据库 | Cassandra, HBase, Riak | 分布式的文件系统 | 以列簇式存储,将同一列数据存在一起 | 查找速度快,可扩展性强,更容易进行分布式扩展 | 功能相对局限 | | 文档型数据库 | CouchDB, MongoDb | Web应用(与Key-Value类似,Value是结构化的,不同的是数据库能够了解Value的内容) | Key-Value对应的键值对,Value为结构化数据 | 数据结构要求不严格,表结构可变,不需要像关系型数据库一样需要预先定义表结构 | 查询性能不高,而且缺乏统一的查询语法。 | | 图形(Graph)数据库 | Neo4J, InfoGrid, Infinite Graph | 社交网络,推荐系统等。专注于构建关系图谱 | 图结构 | 利用图结构相关算法。比如最短路径寻址,N度关系查找等 | 很多时候需要对整个图做计算才能得出需要的信息,而且这种结构不太好做分布式的集群方案。 | 这次学习的就是键值存储数据库中的Redis。 Redis是Remote Dictionary Server 的缩写,翻译为远程字典调用,是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。 - 官网 - Github windows的只需要下载他们提供的压缩包使用就好了。 打开服务后就能看到服务的信息,默认端口为6379 接下来来确认一下服务是否真的开启了,打开客户端,使用ping命令来测试,出现PONG表示已经连接到了Redis的服务。 :::note{type=\"info\"} windows的版本活跃度很低,而且官网也不推荐使用windows,所以还是尽量使用Linux,之后的使用我也是使用Linux来测试。 ::: 去到redis的github就能下载到压缩包使用。 因为Redis是使用C/C++写的,所以要想使用,还是需要先安装一下C/C++的环境。 > 要是make命令时出现了很多的error,大概率就是因为redis6版本是需要gcc版本是5以上的才行,所以需要先升级gcc的版本,这里是升级到了9。 Redis默认会安装到/usr/local/bin的目录里。 Redis不是默认启动的,为了方便学习,要设置成默认启动的,所以去修改redis.conf这个文件。 启动Redis的服务。 关闭Redis的服务 Redis的目录下还会有一个命令redis-benchmark。 这个命令是官方自带的性能测试的命令,用来测试Redis的一些基础命令读写的速度,以下是命令的参数。 | 参数选项 | 描述 | 默认值 | | :------: | :----------------------------------------: | :-------: | | -h | 指定服务器主机名 | 127.0.0.1 | | -p | 指定服务器端口 | 6379 | | -s | 指定服务器 socket | | | -c | 指定并发连接数 | 50 | | -n | 指定请求数 | 10000 | | -d | 以字节的形式指定 SET/GET 值的数据大小 | 2 | | -k | 1=keep alive 0=reconnect | 1 | | -r | SET/GET/INCR 使用随机 key, SADD 使用随机值 | | | -P | 通过管道传输 请求 | 1 | | -q | 强制退出 redis。仅显示 query/sec 值 | | | --csv | 以 CSV 格式输出 | | | -l | 生成循环,永久执行测试 | | | -t | 仅运行以逗号分隔的测试命令列表 | | | -I | Idle 模式。仅打开 N 个 idle 连接并等待。 | | Redis支持的数据类型有很多,官网也写的很清楚了。 > Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. :::note{type=\"info\"} String一般使用是用来计数,比如用户的访问次数,热点文章的点击数,转发数等。 ::: :::note{type=\"info\"} List一般用来发布与订阅或者说消息队列、慢查询等场景。 ::: :::note{type=\"info\"} Set的使用场景一般为,需要存放的数据不能重复以及需要获取多个数据源交集和并集等场景 ::: :::note{type=\"info\"} Hash一般是用来进行对象的存储 ::: :::note{type=\"info\"} Zset一般使用在那些需要排序的场景。比如礼物排行榜,弹幕消息等。 ::: :::note{type=\"info\"} 一般用来用户签到,统计活跃的用户和用户在线情况。 ::: 对Redis的数据类型进行一个小的总结。 Redis的数据类型其实大概分为两类。 - 五大数据类型 1. String 2. Set 3. Hash 4. List 5. Zset - 三个特殊的数据类型 1. geospatial 2. hyperloglog 3. bitmaps - Redis的事务其实就是一组命令的队列 - Redis事务没有隔离级别的概念 - 一次性,顺序性,排他性 - Redis的单条命令存在原子性,但是事务是多条命令的集合,所以事务不具备原子性 - Redis的事务分为三个阶段 1. 开启事务 2. 命令入队 3. 执行事务 - 在开启事务后,输入的命令会进入队列,但是没有直接执行,要等所有命令入队后,发出执行命令才会一次性,依次执行 :::note{type=\"warning\"} 1. 若是事务中存在错误的命令,那么整个事务的命令都不会被执行 2. 若是事务中只是命令语法有问题,那么该命令会抛出异常,但是其他命令会正常执行 ::: 首先了解悲观锁和乐观锁这两个概念。 - 悲观锁 悲观锁,顾名思义,什么时候都很悲观,每次访问公共数据,都会觉得别人会进行修改,所以每次获取该数据的时候,都会对数据加锁 - 乐观锁 乐观锁,顾名思义,什么时候都很乐观,每次访问公共数据,都觉得别人不会进行修改,所以每次都不会去上锁,只有在更新该数据后会判断一下使用期间其他线程有没有修改该数据。可以使用版本号来实现。每次更新数据后,判断该数据的版本号是否发生变更,发生了变更,就会导致修改失效,若是没有就会修改成功并修改版本号。 存储在内存中的数据,一旦机器出现问题,那么内存中的数据就会丢失,所以为了尽量避免这个问题,Redis提供了两种持久化的方法,接下来来了解一下这两种持久化的方式。 RDB持久化机制是将某个时刻的数据快照写入磁盘,也就是将某个时刻的数据保存下来,等到Redis服务启动,就会自动加载这个快照文件进行数据恢复。 - save命令(不建议使用) save是一个同步的命令,也就是说执行save命令,会让Redis的服务器发生阻塞,直到RDB持久化完成,其他命令才能正常进行。 - bgsave命令 bgsave是一个异步的命令,执行bgsave命令,Redis会fork一个子进程来进行RDB持久化,只有fork时才会阻塞,其他时间Redis正常运行。 - 满足配置文件中save配置的文件,默认配置如下,可以自己配置 - 执行flushall命令清空数据库时,触发持久化 - 执行shutdown命令等手段退出Redis时,触发持久化 从配置文件可以看到配置文件的默认路径和默认名。 AOF持久化全称Append Only File,当我们执行的改变数据的操作时就会将该命令追加到一个AOF文件的末尾,当Redis服务重新启动的时候,就会重新执行AOF文件内的命令,用来同步数据。 :::note{type=\"info\"} AOF不是默认的持久化方式,故默认关闭的,需要去配置文件手动开启。 ::: - always 每次有新的修改数据的命令,就会将缓冲区内的命令同步追加到AOF文件,十分安全,但是效率低 - everysec 默认的策略,每秒将缓冲区内的命令同步追加到AOF文件,但是无法做到实时持久化,还是会可能丢失一秒的数据 - no 交给操作系统来决定什么时候去同步追加数据 当命令不断被追加到AOF文件内,文件会越来越大,这对使用来说很不好,所以Redis提供了一个AOF的重写机制来解决这个问题,将AOF文件内的命令优化,重写为可以恢复到当前数据的最小指令集,从而减少文件的大小,达到压缩AOF文件的目的。 触发流程如下。 手动输入bgrewriteaof命令触发重写机制。 自动触发就需要自行修改配置文件内AOF重写的配置。 之前有提到过设置过期时间,那么就会有一个问题,为什么我们要多此一举去设置一个过期时间呢? 简而言之那就是,内存有限。 如果所有的Key都存在内存,数据量一大就会内存溢出了。 还有一个原因是用户希望存一个有过期时间的Key,就比如在一些场景下,过期Key就会显示很方便。Token的状态登陆或者是验证码的使用,都可以在Redis存储一个过期时间从而达到过期了就无法使用的目的。 不适用过期时间又想要实现这个功能,那就只能查询数据库获得记录,然后在判断是否过期,那也会有点麻烦。 Redis 通过一个叫做过期字典(可以看作是hash表)来保存数据过期的时间。过期字典的键指向Redis数据库中的某个key(键),过期字典的值是一个long long类型的整数,这个整数保存了key所指向的数据库键的过期时间(毫秒精度的UNIX时间戳)。 1. 定期删除 每隔一段时间就会抽取一批Key来进行过期检查,过期了就进行删除。 2. 惰性删除 每次从数据库获取Key时会判断该Key是否过期,要是过期了就会进行删除,没有过期就会返回数据给用户。 3. 定时删除 在设置key的过期时间的同时,为该key创建一个定时器,让定时器在key的过期时间来临时,对key进行删除。 Redis默认使用的就是定期删除和惰性删除的配合。 刚才有提到过过期Key,从Redis的过期Key删除策略中可以看出这些删除策略并不能将每一个过期的Key都删掉,所以在数据量大的时候又加上过期的Key,就会出现内存满了的情况,那这种时候就需要淘汰掉一些内存数据了。 Redis提供有8种淘汰的策略。 1. **volatile-lru**:淘汰掉设置过期时间的数据集里最近最少使用的数据 2. **volatile-ttl**:淘汰掉设置过期时间的数据集里的将要过期的数据 3. **volatile-random**:随机选择设置过期时间的数据集里的数据来进行淘汰 4. **volatile-lfu**:淘汰掉设置过期时间的数据集里最不经常使用的数据 5. **allkeys-lru**:移除空间里最近最少使用的 key(这个是最常用的) 6. **allkeys-random**:从空间中任意选择数据来进行淘汰 7. **allkeys-lfu**:移除空间里最不经常使用的数据 8. **no-eviction**:不允许淘汰数据,当内存满了之后在进行新数据的写入就会报错 发布订阅是一种消息通信模式。 发送者发送消息,订阅者接受发送者的消息。 接下来进行一个简单的测试。 1. 订阅一个频道,这里订阅yww这个频道 2. 在打开一个Redis的客户端,然后往yww频道发送两条消息 3. 在订阅频道的订阅者的客户端就能接收到频道的消息了 以下是一些常用的API 当数据量过大的时候,服务器的压力就会提高,为了解决这个问题,Redis提供了主从复制,读写分离的方案,因为大部分的压力是读操作,所以可以搭建一个Redis集群(最低要求三台,一主二从),主节点负责写操作,从节点用来提供读的服务,这样就能减少服务器的压力了。 当然还可以有以下这种情况 节点是既可以当主节点,又可以当子节点的。 Redis的主从复制表示只有主节点能进行写操作,从节点是不能进行写操作的,只能进行读操作,主节点的数据会同步到子节点,达到整个集群的数据一致。 上边说到的同步方式根据是否是全量来分为全量同步和增量同步。 - 全量同步 全量同步的数据复制一般只会发生在slave从节点连接主节点的时候,这时从节点会将主节点中的所有数据都复制到从节点中,从而从节点连接主节点后数据通同步。 期间发生的具体步骤如下。 1. 从节点连接主节点后,向主节点发出SYNC命令 2. 主节点收到SYNC命令后,开始执行BGSAVE生成RDB文件,因为是异步的操作,所以主节点继续处理命令,并将被执行的命令放入缓冲区 3. 生成RDB文件后,就会向从节点发送快照文件 4. 从节点收到主节点发送的RDB文件后,就会放弃原来存在的旧数据,然后载入RDB文件同步数据 5. 触发增量同步 这样主节点的数据旧全量同步复制到了从节点上。 - 增量同步 除了首次从节点的全量同步,一般数据的同步都是使用增量同步的方式 1. 主节点将缓冲区中的命令发送给从节点 2. 从节点接收到命令请求,就会执行这些命令,完成部分写命令带来的数据同步 这里使用同一个服务器,不同端口搭建的Redis集群进行学习。 当然你有多台服务器可以使用不同服务器来搭建集群来学习。 再不然可以直接开三个容器来搭建Redis集群来学习。 首先是了解一个基本的命令。 创建三个配置文件,用来开启三个服务。 然后配置这三个文件。 然后是建立主从联系,这里使用6379的服务当成主节点,建立联系有两种方法。 - 在从节点中使用命令连接主机,这是简单的连接,要是从节点服务关闭了,之后重启旧连接不到主节点了,可以说是一次性的 - 使用配置设置,这种情况,从节点服务重启后就会继续连接主机 这里连接6379当成主节点。 然后在主机设置的数据,可以在从机中获取数据。 通过配置连接的子节点出现故障,重启服务后,因为配置连接的缘故那还是子节点,所以子节点出现故障的情况很简单。 :::note{type=\"info\"} 要是这个子节点有子节点,那么主机故障后,子节点的role依旧是salve,所以还是不能进行写操作。 ::: 接下来重点了解一下主节点出现故障的情况。 当主节点出现故障后,它的子节点身份是不会变的,当主节点的服务重新启动后,集群依旧存在。 当我们不清楚主节点何时恢复,总不能一直不进行写操作,所以就需要重新推出一个主节点。 这是手动配置主节点,这其实还是挺麻烦的,所以为了解决这个问题,Redis从2.8的版本后就提供了哨兵模式这个方案。 哨兵模式其实就是自动推选主节点的一种方案。 先来简单了解一下哨兵模式。 哨兵是一个独立的进程,在Redis的命令中也能看到它redis-sentinel。 该进程通过向各个节点发送命令,通过节点返回的信息来监控节点的使用情况。 当主节点宕机了,哨兵向主节点发送命令却得不到返回信息,过段时间哨兵确认主节点宕机后,就会随机给从节点随机投票,获得投票的节点就会当选为主节点,然后通过发布订阅模式通知其他的从节点修改配置,让它们切换主节点对象,从而实现集群正常服务。 那要是哨兵宕机了怎么办呢?这样的设置还是会出现问题。所以哨兵不能只有一台,哨兵也要形成一个集群(最好三个起步),于是最终的解决方案就如下图。 多个哨兵进行监控,当有一个哨兵检测到主节点宕机,并不会马上切换,因为有可能是哨兵的问题,所以哨兵只会主观认为主节点宕机(这种情况叫主观下线)。 当一定个数(在哨兵的配置文件可以配置)的哨兵都认为主节点宕机后,那大概率就不是哨兵的问题了,那么哨兵之前就会对剩余的从节点投票,投票结束后,随机一个哨兵进行failover操作(这种情况叫客观下线)。 failover又称故障转移,它会从从节点中挑选一个作为Redis集群中的新的主节点。 1. 选择票数高的从节点当为主节点,若是不存在(同票的情况),就继续判断。 2. 选择主从复制,同步数据最完整的节点成为主节点,若是不存在就继续判断。 3. 选择启动最早的子节点当为新的主节点。 对选出来的主节点执行slaveof no one将身份转换成主节点,然后向其他的从节点发送订阅模式通知,各个哨兵就会让他们的节点切换主节点的对象为新的主节点。最后更新之前宕掉的节点的身份为从节点,当宕机恢复后,就自动成为该集群的从节点。 哨兵的启动需要先配置哨兵启动的配置文件sentinel.conf。 - - - - - - -","url":"/posts/bae4ff13/","category":"我的技术学习物语果然有问题","date":"2021.02.15","dateTime":"2021-02-15T00:00:00.000Z"},{"title":"常用的工具类","description":"记录一下开发中经常使用的工具类。","content":"总结记录一下在开发中经常使用到的一些工具类。 用户的密码一般都会进行加密后在存储到数据库当中,所以一般用到MD5这种加密算法。 这种加密算法最大的特点就是不可逆,只能加密不能解密。 这是挺简单的一种加密算法了,之后还可以考虑加盐和哈希散列,进行更复杂的加密手段。 对于MySQL的主键问题,一般都需要使用自增的主键。但是只是从1自增就会因为分库分表产生主键相同的情况。 所以这次使用雪花算法生成一个分布式全局唯一ID 首先要知道雪花算法生成的ID是怎么样的。 分布式ID一般都是Long类型,所以会有64位。 - 第一部分是一个bit位,是一个标识部分,在java中由于long的最高位是符号位,正数是0,负数是1,一般生成的ID为正数,所以固定为0 - 第二部分是时间戳,该部分占41bit,这个是毫秒级的时间 - 第三部分是工作机器ID,占10bit - 第四部分是序列号,占12bit,支持同一毫秒内同一个节点可以生成4096个ID 参考于: 这个工具类主要是用于获取请求的IP地址。 > hutool里也有很多断言的工具类,但是抛出的异常不是自己定义的,所以为了指定抛出的异常,需要自己在定义一个断言工具类。 > 如果需要添加其他的属性筛选,只需要继承该封装对象即可。","url":"/posts/b0ab3ebd/","category":"我的技术学习物语果然有问题","date":"2021.02.03","dateTime":"2021-02-03T00:00:00.000Z"},{"title":"Shiro","description":"Apache Shiro(发音为“ shee-roh”,日语为“ castle”)是一种功能强大且易于使用的Java安全框架,它执行身份验证,授权,加密和会话管理,可用于保护任何应用程序的安全-从命令行应用程序,移动应用程序到最大的Web和企业应用程序。","content":"网上最流行的两个Java安全框架就是Shiro和spring security。spring security功能更加强大,而Shiro是更加简单。这次就先来学习一下Shiro。首先我们来看看官网上对Shiro的描述。 > **Apache Shiro™** is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro’s easy-to-understand API, you can quickly and easily secure any application – from the smallest mobile applications to the largest web and enterprise applications. > > Apache Shiro是一个功能强大且易于使用的Java安全框架,用于执行身份验证,授权,加密和会话管理。 使用Shiro易于理解的API,您可以快速轻松地保护任何应用程序-从最小的移动应用程序到最大的Web和企业应用程序。 在官网中的参考文档可以看到Shiro的框架架构图和一些解释。 - Subject Subject表示需要认证的数据,可以理解为登陆的用户,一般有一个用户表示身份的信息和验证身份的密码,表示身份的信息一定要由唯一性。 - Security Manager Security Manager是Shiro框架的核心,该对象会协调其内部的安全组件。 - Realm 可以以称为域,充当Shiro和程序安全数据的桥梁,也就是匹配的数据,用来确定Subject登陆是否能够成功。 > 下面这张就是更加详细的架构图。 1. 上面的部分其实就是上图的Subject,可以Shiro是可以支持不同语言的服务的。 2. 中间蓝色的就是框架的核心Security Manager。 - Authenticator(认证) 用来负责认证用户登陆是否成功。当用户尝试登陆时,会通过Authenticator去与单个或多个的Realms去验证该用户是否为合法用户。 - Authenticator(授权) Authenticator是用来确定用户在应用程序中的访问控制。即表示该用户经过认证后,在程序中被允许做什么事情。 - Session Manager 用来创建和管理用户Session的生命周期,管理会话。**SessionDAO**算是实现会话管理操作的接口。 - Cache Manager 用来管理缓存,如果每次执行操作都要去认证授权,那会大幅降低效率,加入了缓存,那就可以不用每次都进行认证和授权了。 3. Cryptography 翻译为密码术或者称密码学。其实就是用来加密和解密的。 4. 下面的部分就为Realms。可以看到可以支持多种方式来验证用户的合法性。 从上面的架构图的各部分的功能可以了解了用户认证的过程。 1. Subject从应用程序过来寻求认证。 2. Shiro将Subject交给Security Manager去管理。 3. 然后就会交给Authenticator去认证,Authenticator又会从Realms去获取安全数据与Subject去比较,确认Subject的合法性。 现在就来简单的实现一下这个认证的流程。 首先是创建一个简单的Maven项目,并导入依赖。 在resources文件夹下创建shiro.ini配置文件。 这里就是用户的数据,用户名为yww,密码为1141。 然后就是实现了。 现在修改一下登陆用户的信息。 发现了这个UnknownAccountException异常,表示找不到该用户,即没有该用户。 在修改一下登陆用户的信息。 会发现另一个异常IncorrectCredentialsException,表示认证不通过,一般就是密码不正确。 常见的就是这两个异常了,现在完善一下认证的程序。 导入依赖后,创建Realms的实现类,继承AuthorizingRealm,并重写其中的两个方法。 认证过程主要是doGetAuthenticationInfo这个方法,上面的授权方法先不重写。 然后是测试类。 这里就使用到了三种加密方法,md5,salt和hash散列,具体是怎么加密的就不详细了解了,大概知道就好了。 1. MD5信息摘要算法,一种被广泛使用的密码散列函数,可以产生出一个128位(16字节)的散列值,用于确保信息传输完整一致。 2. salt就是使用随机的字符串加到密码后进行md5加密,加的位置不知道也会让解密困难。 3. Hash算法可以将一个数据转换为一个标志,这个标志和源数据的每一个字节都有十分紧密的关系。Hash算法还具有一个特点,就是很难找到逆向规律。 下面简单的测试下加密方法。 接下来就来测试一下如何使用加密。 首先也是先创建自定义的realms。 1. 解决MD5加密,先创建一个hash凭证匹配器,在将该匹配器给realms。 2. salt的处理,在匹配的时候加上salt就好。 3. hash散列的处理,设置匹配器的时候加上散列的次数。 > 这里涉及到权限字符串,大概了解一下字符串的写法和格式。 > > 资源标识符:操作:资源类型 > > 可以使用*号代表所有 > > admin:create:* > > 这个权限代表当前角色对admin中所有资源由创建的权限 > > admin:*:01 > > 这个权限代表当前角色对admin中01用户存在所有权限 - 官网 - shiro视频","url":"/posts/c0010af8/","category":"我的技术学习物语果然有问题","date":"2021.01.25","dateTime":"2021-01-25T00:00:00.000Z"},{"title":"单例模式","description":"单例模式是设计模式中十分经典的一个模式。","content":"单例模式是一个很简单的设计模式,当然这里的简单说的是理解起来很简单,其实单例模式中有很多细节值得我们去深究。 单例模式顾名思义就是只有一个实例。 每一个单例的类都只会存在一个实例,需要使用到该类时,就需要使用该实例,不得在创建另一个实例对象。 为什么会需要单例模式呢?每次使用类的时候就直接创建对象就好了,何必这么麻烦。 的确在大多数使用类的情况下,单例是没有必要的。但是在某些情况下单例还是很有必要的。 比如需要重复用到的类,就会不断重复创建实例,这个实例完全可以复用,但是还是重新创建了,这样是十分浪费系统资源和性能的。 再比如数据库的连接,如果每次使用都需要连接一次,使用完在断开连接,要是这样的开销完全大于一直连接,那为什么不一直连接直到程序结束呢? 所以单例模式在一些情况下显得十分必要。 单例模式实现的方式有很多种,大多都是围绕两个核心的问题来变化的。 1. 何时生成实例,也就是是否是懒加载 2. 是否线程安全 接下来就围绕这两个问题进行探讨。 首先是最简单的一种单例模式的实现方法。 这种方式很简单,这也就是网上提到的饿汉式的单例模式。 现在回到刚刚那两个核心问题来看看这个饿汉式的单例模式。 1. 这是线程安全的 2. 不是懒加载的 这种方式简单,其实就简答在一开始就创建了对象,所以就是线程安全的,多个对象用getInstance方法,都是调用同一个对象,不会出现线程安全的问题。 懒汉式其实就是使用了懒加载的。现在来看看最简单的一种写法。 因为使用了懒加载,即直到要使用该类了才会创建实例,但是就是因为懒加载,所以出现了线程安全的问题。 这其实不难理解,单个线程该类不会出现任何的问题,但是在多线程环境下,当多个线程同时进入到判断语句,此时都是null,那就会导致多个线程会创建多个实例,那就不是只有一个实例了,这就出现了线程不安全的问题。 于是为了实现线程安全就可以改成下面这样。 直接在getInstance方法上增加synchronized关键字,就能保证只有一个方法进入到该线程,从而就能保证线程的安全。 上面的线程安全的懒汉式已经解决了之前提到的两个问题,懒加载和线程安全。 但是在方法上增加synchronized,会显得加锁粒度太重,我们只需要在创建对象的时候加锁就好了,何必在方法上加锁呢?所以就能再次优化。 但仔细思考之后,就会发现这段代码虽然降低了加锁粒度,但是并没有保证线程安全,因为也是存在有多个线程同时通过了判断语句,每次封锁就只能封锁住创建的顺序而已,并不能保证只创建一个实例。为了解决这个问题,我们可以在为这段代码增加一个判断语句。 这就是双检锁的单例模式了,这段代码看上去已经很完美了,但是这其实并没有实现线程安全。 因为instance = new Singleton();这个创建对象的语句并不是原子性的操作,这个语句在底层其实分成了三步。 1. 分配实例的内存地址 2. 在该内存地址初始化实例对象 3. 将instance的地址指向这个内存地址。 之前我们学习多线程的时候有提到过指令重排。这三个指令经过优化可能会重排,会导致执行出现以下几种顺序 - 123,正常顺序 - 132,结果与正常顺序一样的顺序 这个不正常的顺序在单线程虽然结果与正常顺序一样,但是在多线就会出现一些线程不安全的问题。 比如存在两个线程A和B调用了getInstance方法,就会出现这种情况。当线程A进入到同步代码块,并通过了第二个判断语句,进入到创建实例的阶段,经过指令重排,执行132这个顺序,当执行完3时,B也到了第一个判断语句,此时instance != null,所以就会直接返回instance,但是线程A还没执行初始化对象,所以这个内存地址其实还是没有被使用的,这样线程B拿到的实例就会是没有被初始化的空的内存地址。 解决这个问题也很简单,之前有提到过volatile是可以禁止指令重排的,所以为该实例加上volatile关键字就好了,所以代码如下。 这样即实现了懒加载,又实现了线程安全,而且封锁的粒度还小。 这种方法就一个缺点,写起来很麻烦,下面探讨一下更简单的写法。 这种单例模式就使用到了静态内部类了,它是可以实现懒加载和线程安全的。因为静态内部类在调用的时候才会加载,也就会在调用到的时候才会创建对象,从而实现懒加载。静态内部类在类加载机制中也会实现线程安全,所以这种方法是比较简单的实现这两个问题的。 上面提到的方法其实都还存在一个问题,可以被反射机制所破坏。 下面我就使用双检索的方式创建一个单例,看看反射机制是否能破环该单例模式。 内存地址并不一样,这并不是同一个对象,所以可以看出反射机制是能够破坏上面的方法的。这种情况基本都是人为破坏的,所以不怎么需要考虑,不过实在要解决也是有方法的,那就是使用枚举。 因为枚举是可以防止反射的,所以使用枚举可以防止别人使用反射,不过这样就和饿汉式差不多了,所以并不怎么推荐使用。 因为反射破坏基本都是人为因素,所以不怎么需要考虑,所以单例模式一般使用双检锁或者是静态内部类的方法就好,如果懒加载并不是必须的,可以考虑使用饿汉式的单例模式。 :::note{type=\"info\"} 单例模式的使用需要经过认真思考,滥用单例模式就是造成内存泄漏的原因之一,所以要在项目中使用单例模式,就需要确定该实例一直存在的开销是否要比使用完就销毁的开销要大。 :::","url":"/posts/f1601c3e/","category":"我的技术学习物语果然有问题","date":"2021.01.23","dateTime":"2021-01-23T00:00:00.000Z"},{"title":"前后端分离demo","description":"简单的体验一下前后端分离。","content":"当下前后端分离的趋势很明显,的确这也是很有必要的。前后端分离让前端专注于前端,后端专注于后端,而不是哪一方都要学习前后端。学习过JSP的都知道,前后端之前都是套模板,这会让项目很繁琐,而且也提高了项目的耦合性,不利于二次开发,所以现在来通过一个简单的demo来简单的体验一下前后端分离。 - Vue - SprtingBoot - Mybatis-plus 这里的数据我就使用Mybatis-plus官方提供样例的数据了。 > 前端就随便展示一下好了。 1. 创建一个Vue的项目 2. 在项目的views的文件夹下编写test.vue页面用来展示数据 > 前端开始主要注重页面,所以先用假数据。 3. 编写路由,在router的文件下编写index.js文件 4. 在页面上添加路由跳转,编写App.vue 5. 运行vue项目,查看 是否出现假数据,出现则为成功 1. 首先先创建一个SpringBoot的项目,我的版本是2.4.2。 2. 然后在pom.xml导入依赖 3. 创建一个实体类,该类在pojo的包下 4. 创建一个Mapper接口,该接口在Mapper的包下 5. 配置SpringBoot,这里使用的配置文件是application.yaml 6. 扫描注册Mapper接口 7. 查询测试 8. 得到结果 由此可以看到查询结果没有什么问题,然后就可以写接口返回数据了。 9. 编写接口,该接口在Controller的包下 访问 即可查询到查询返回的数据。 1. 在vue项目里添加axios插件,用来请求接口 2. 修改test.vue里的数据 3. 在后端部分增加一个工具类,用于解决跨域问题(因为是不同端口的请求),该类在config包下 4. 然后访问前端项目的页面 ,就能看到后端查询并返回的数据了 这次是一个简单的demo,实际项目还要复杂很多,这个demo虽然简单,但是也是能让你简单了解一下前后端分离的开发流程。","url":"/posts/ee7e4b9/","category":"我的技术学习物语果然有问题","date":"2021.01.20","dateTime":"2021-01-20T00:00:00.000Z"},{"title":"synchronized","description":"synchronized是Java提供的一个关键字,是一种同步锁。","content":"首先要知道synchronized实现同步的基础为Java中每一个对象都可以作为锁,synchronized一般的使用方法有以下三个。 1. 在普通方法上加synchronized,为方法的对象加锁。 2. 在静态方法上加synchronized,为该方法的类模板加锁。 3. 同步方法块,为给定对象加锁。 每一个线程执行到同步块或者是同步方法(对共享内存进行访问的程序片段称为临界区),就会去申请获得锁。当同步的操作执行完或者是抛出异常时就会把该锁给释放掉。 之前的volatile文章有提过,volatile是不保证原子性的,现在就用synchronized来保证那个例子的原子性。 由此可以看见测试了很多次,答案都是20000,从而用synchronized可以保证了这个例子的原子性。下面我用图来简单讲解一下为什么synchronized能够保持这个例子的原子性。 介绍synchronized的原理之前先了解一个重要的概念,Monitor。 Monitor又称监视器,是一种同步机制,synchronized就是通过这个机制来实现方法或者代码块的同步的。 > 实际上任何一个Java对象都可以作为Monitor机制的monitor object,每一个Object的类都在底层实现了ObjectMonitor模式(这是底层用C来实现的),我们一般看不到,只要知道每一个Object类的对象都可以作为monitor对象 同步代码块会在代码块开始位置插入一条monitorenter在代码块结尾插入一条monitorexit,用这两条指令来实现Monitor机制。 同步方法是通过一个ACC_SYNCHRONIZED标志来确定,执行方法时判断有无该标志位,然后会隐式调用上面两条指令。 起初在没有线程执行到临界区时,monitor的大概情况是这样子的。 当有一个线程进入临界区,Monitor中的Owner就会指向该线程。 此时要是有其他线程也执行到了临界区的范围,就会进入Enter Set,即将线程的状态转变为阻塞状态,故Enter Set也可以称为阻塞队列。 当Owner的线程1离开了临界区就会出现三种情况。 1. 线程1因某些原因发生了wait等待,Owner恢复为null,并进入Wait set,然后阻塞队列中的线程开始竞争Owner的位置。(这里假设线程2竞争到了) 2. 线程1正常离开临界区,Owner恢复为null,线程1之后不再进入临界区,阻塞队列中的线程就会开始竞争Owner的位置。(这里假设线程2竞争到了) 3. 线程1正常离开临界区,Owner恢复为null,线程1之后还会进入临界区,那线程1就会与阻塞队列中的线程竞争Owner的位置。(这里假设线程2竞争到了) :::note{type=\"info\"} Monitor是synchronized实现线程同步的原理(当初只有重量级锁,锁的优化靠其他的机制)。 从图中也可以看出为什么wait这些方法要放在synchronized中使用,因为都需要借助到Monitor的机制来进行实现。 ::: Java对象头是存储对象的一些基础信息的集合。 | 长度 | 内容 | 说明 | | :---: | :--------------------: | :--------------------------------------: | | 32bit | Mark Word | 存储对象的hashCode或锁信息等 | | 32bit | Class Metadata Address | 存储到对象类型数据的指针 | | 32bit | Arraylength | 数组的长度(要是对象不是数组则没有该项) | 这里就不详细探讨后面两个了,这里的重点是Mark Word,现在我们来看看这里面具体存储了什么。 锁状态 25bit 4bit 1bit 2bit 23bit 2bit 是否是偏向锁 锁的标志位 无锁 对象的hashCode 分代年龄 0 01 偏向锁 线程ID Epoch 对象分代年龄 1 01 轻量级锁 指向栈中锁记录的指针 00 重量级锁 指向互斥量(重量级锁)的指针 10 GC标志 空 11 在JDK1.6之前,synchronized只是一个重量级的锁,当JDK1.6进行更新之后,引入了偏向锁和轻量级锁的概念,所以锁的状态变成了以上的四种。 偏向锁是JDK1.6之后引进的,HotSpot作者发现大多数情况锁不仅存在多线程竞争,而且总是由同一线程多次获得。如果是之前,该线程每次都要获得锁,这样代价也未免太大了一点,所以为了优化这种情况,就出现了偏向锁。 偏向锁,顾名思义,偏爱某个线程的锁。当一个线程访问同步块并获取锁,会在对象头和栈帧中的锁记录里存储偏向的线程ID。以后该线程再次来获取锁,就只需测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁就好了,不必再次进行CAS来操作加锁和解锁。 >1. 偏向锁在Java6中是默认开启的,但是要在应用程序启动几秒之后才会激活,也就是说是有延迟的,有必要也可以通过设置参数来设置延迟 > -XX:BiasedLockingStartupDelay=0 >2. 当不希望使用偏向锁,也可以通过设置参数来关闭,默认进入轻量级锁 > -XX:-UseBiasedLocking=false - Java并发编程的艺术 - https://juejin.cn/post/6844903640197513230#heading-6 - https://segmentfault.com/a/1190000016417017","url":"/posts/edea11bc/","category":"我的技术学习物语果然有问题","date":"2021.01.11","dateTime":"2021-01-11T00:00:00.000Z"},{"title":"2020年度总结","description":"2020年度总结","content":"刚刚结束了地狱级别难度的期末考试,终于有时间来写这篇总结(不是真的想鸽)。 为什么之前没有写? 那是因为自己真的没什么可以说的(其实是太混了,虽然现在也很混)。 2020年一开头就不太平,爆发了疫情。新冠的爆发让我被迫在家呆了好几个月,我到现在都记得刚刚爆发时的情景,第一次感觉到生命是如此的脆弱。 不仅如此,新冠的爆发也让我看到了很多魔幻的事情,网上的事情我就不说了,大家懂的都懂,说说我碰上的。 稍微了解我的都知道我家是开药店的,疫情的爆发我相对很多人都更有体会,全镇都勒令关门禁止营业,除了药店,因为还要提供一些药物和口罩。虽说我们这边没有病例,可依旧是一件冒风险的事情。即使这样还会有人向政府举报我们家高价卖口罩(经过政府调查其实并没有),真的是让人心寒。 只能说医疗行业真的不容易。这其实也是为什么全家都叫我学医我还是选择学了计算机的原因(虽然最后进了数学院,有点遗憾)。 到现在疫情都还没有完全结束,总有死灰复燃的苗头,不过还好已经好转很多了,相信一切都会好起来的。 PC端我就只玩一款游戏,那就是LOL。这款游戏从我小学六年级一直陪伴我到现在,想想也是玩了好多年了。 不过今年玩的也少很多了,一部分是因为学习上的压力,另一方面就是网络风气。LOL的风气懂得都懂,其实每个游戏都这样,不过这游戏玩家多,现象超级明显,对新人极不友好。 移动端我就玩的还算多了,毕竟比较方便。 不过也只是玩了两款,那就是明日方舟和公主连结。 不过现在方舟也不玩了,虽然是一个好游戏,但是随着我学习上压力的递增,我也没有这么多时间来去通关了(想到第一次的危机合约,能玩上一天),到后面就都是抄作业了,时间久了就感受不到方舟的乐趣了,我也没有精力一起玩两款游戏,于是我就卸了(所以也没有截图了)。 说到公主连结就精神了,这游戏更加休闲,纯属一个养花瓶游戏,每天十分钟完成日常就可以了,十分适合我这些懒得玩的人,而且角色多好看啊(看看这个万圣忍,这不可爱吗?)。 这游戏最大的内容就是公会战(虽然公会战总是在摸鱼,但有时间还是会很努力的打的),因此我还认识了很多的志同道合的朋友,十分感谢各位的陪伴。 因为精力总不花在专业学习上,导致学分绩也就排在中游。(老混子了) 身为数学院的学子没学好数学还是挺惭愧的,以后有空研究深度学习了在认真看一下。(老师也都是研究深度学习的,开发在数学院地位低下hh) 这方面其实也没什么说的了,直接看github吧(不要问什么有两段时间空了,在家是真的无法学习,以后要好好改正了)。 20年也没什么成就,花了挺多时间在这个博客上了。 我从大一下学期就接触了hexo,也就那时候就搭建好了这个博客,当时还是用的是next主题,什么都没整明白。 不过虽然搭建好了,但是没怎么管理,文章也就没怎么写,当时是觉得反正没什么人看,没怎么有动力弄得更好。 今年我就改变了这个想法。毕竟这写的文章不给别人看也是要给自己看的,所以要尽量写好,而且弄得更顺眼。 搭建这个博客的确是很能提高能力的一件事情,当然是尽量完善之后。简单说说搭建这个博客学到了什么。 1. hexo与github pages(coding等) 2. 域名解析,也因此买了自己的域名,并备了案 3. html + css + javascript三件套,算是加深一点印像吧 4. github action等一系列技术 5. 使用CDN来加速自己的网站,怎样进行云存储 6. 很多网络和排错的知识,比如Chrome的F12中的Network。 7. Linux基本命令和使用一些基本的服务器软件,比如什么Nginx等 不得不说开发真的是一步步上云,上云是必然的趋势了。 20年下半年我又重新拾起了书本,因为之前我实在看不下书,一看就困。但是书上会有很多知识比网上的资料要详细(因为又很多书都很经典),只有读书才能学到更多的东西,有很多书还是很有趣的。让我想想我20年看过什么书(当然除去课本)。 - 网络是怎样连接的 - C++ Primer Plus - 鸟哥的私房菜 - 小灰的算法之旅 - Java并发编程艺术 - 大话数据结构 - 哈喽算法 说了这么多其实有些没完全读完,就别如那本C++ Primer Plus,有这本书的都懂,而且我学的Java,有时间在看吧。 毕竟是从这个学期才开始认真好好读点书,所以看起来很少,21年尽量会看多一点的。 啊这 。这个其实也就老样子了,依旧的不健康作息。 特别是前两三周,每天复习到凌晨,以后需要改了。 还有就是运动方面,不是不想跑步,因为疫情,好不容易来到学校前期又太忙后期风吹的我脑袋疼(找借口还是有一手的)。 不行了,真的要好好锻炼了,不然整天都是没精神的。 20年懒散了,21年就必须更加努力才行了。说到努力,其实看到很多网上和现实的大佬,真的是强的人还很努力,对比下自己就完爆了。 的确人不能一直对一件事情保持热情(可能只是我不能吧),所以总会有些时候会丧失对学习的热情,总会颓废几天,不过之后还是要努力学习啊。 想到了DIYgod的签名,写代码是热爱,写到世界充满爱。这可能就是强者吧,越学习越热爱,我什么时候也能这么强。 emm,不说这么多了,21年也希望各位能变得更好吧,毕竟21年对于我们这一届来说还是很重要的,送各位一句话,也是小米的标语,永远相信美好的事情即将发生。","url":"/posts/276e22e/","category":"个人总结","date":"2021.01.08","dateTime":"2021-01-08T00:00:00.000Z"},{"title":"volatile","description":"volatile是Java提供的一个关键字,是一个轻量级的同步机制。","content":"volatile是Java提供的一个关键字,是一种轻量级的同步方式,也可以理解为轻量级的synchronized。 :::note{type=\"error\"} 码出高效Java开发手册中是这样说道。 volatile是轻量级的同步方式,这种说法是错误的。它只是轻量级的线程操作可见方式,并非同步方式,如果是多写场景,一定会产生线程安全问题。 这里的错误就不修改了,以便提醒自己。 ::: Java的内存结构其实说的是JVM的运行时数据区。 > 绿色代表线程私有的内存区域,紫色的代表所有线程共享的内存区域。 Java内存结构在这里就不展开详细说了,这算是JVM的内容了,这里提前主要是提醒一下,不要与下面学习的Java的内存模型混淆,这两个概念说的并不是同一个东西。 JMM,全称为Java Memory Model,Java内存模型。 Java内存模型是一组规范或者说是规则,每个线程执行都要遵循这个规范,是用来解决在线程的通信问题的。 JMM是一种规范,是一个抽象的概念,并不真实存在,内存结构才是真实存在的。 在讲解JMM之前先要理解两个概念,主内存和工作内存。 > 《Java虚拟机规范》试图这样进行定义Java内存模型这个概念。 > > Java内存模型是用来屏蔽各种硬件和操作系统的内存访问的差异,以实现让Java程序在各种平台下都能达到一致的内存访问效果。 主内存是Java运行时在计算机存储数据的地方,是所有线程共享的,同时多个线程对这个主内存进行修改,就会出现很多的问题,这就是并发操作的问题,需要我们去解决。 每个线程都有一个存储数据的地方,用来存储线程需要操作的数据,为什么要这样呢? 因为线程是不能直接对主内存中的数据进行修改的,只能修改线程工作内存中的数据,所以线程修改主内存中的数据时就会将主内存中的数据保存在自己的工作内存,然后在进行操作。 这样就会存在一个问题,每个线程都会对自己的工作内存进行操作,所以每一个线程都无法得知其他线程工作内存中的数据是怎么样的,这就是一个可见性的问题。 以下是JMM对主内存数据操作时会执行的八个操作。(按顺序) - lock 将主内存中的数据变量标识为线程独占状态,即对该变量进行加锁操作,其他线程不能对其操作。 - read 读取主内存中需要修改的变量,即上个经过加锁操作的变量。 - load 将读取到的数据变量载入到线程的工作内存之中。 - use 把工作内存中的变量传输给执行引擎,即对该变量进行操作。 - assign 执行引擎对变量进行操作之后,将得到的变量的值放回工作内存。 - store 将线程工作内存中的变量存储好。 - write 将上述存储的变量写入主内存,实现刷新主内存中的值。 - unlock 将该变量的锁释放,使其能让其他线程进行操作。 :::note{type=\"info\"} Java内存模型的结构大概率是参考了CPU基于高速缓存的存储交互的设计。 为了提高CPU的效率,添加了高速缓存的概念,用于解决处理器总是等待缓慢的内存读写的问题。在Java内存模型中,工作内存其实就像是一层高速缓存。 ::: Java内存模型就是为了解决对共享数据中的可见性,原子性和有序性问题的一组规则。 即JMM的存在就是为了 保证这三个特性,现在具体来看看这三个特性。 可见性刚刚也讲工作内存的时候也是有提到的,这个其实很好理解,每个线程中的工作内存经过修改写回主内存之后,其他线程都可以看见主内存中的值发生变化,从而解决一些缓存不一致的情况。 原子性表示一个操作在执行中是不可以被中断的,有点类似事务的原子性,要么成功完成,要么直接失败。 有序性表示JMM会保证操作是有序执行的。或许有人会感到疑惑,难道程序不都是有序执行的吗? 这就要说到处理器的指令重排了,这涉及到了一些汇编的知识,所以不怎么展开了,大概了解一下。 为了提高CPU的使用率,在程序编译执行的时候,处理器会将指令进行重排优化,一般分为以下三个。 1. 编译器优化的重排 2. 指令并行的重排 3. 内存系统的重排 指令重排使得语句不一定是按从上到下执行的,可能会是乱序执行的,有些语句是存在数据依赖性的才会保持前后顺序。 为什么单线程的时候没有感觉呢?这是因为指令重排不会干扰到单线程执行的结果的,但是在多线程中乱序执行就会出现一些问题,导致得到的结果不一样。 根据上述JMM的三个特性来说说volatile的特点。 1. 保证可见性 2. 不保证原子性 3. 禁止指令重排 下面就仔细说说volatile的特点。 volatile是可以保证可见性的,现在来验证一下volatile的可见性。 这个程序的运行结果可以看到,main线程一直没有结束,一直在while循环里出不来。 因为main线程工作内存中datanum是一开始从主内存中拿到的0,在第二个线程将值改为100并刷新之后,由于main线程没收到通知主内存中的值发生了变化,故一直使用工作内存中的值,故一直会进行循环。 那接下来为这个资源变量增加一个volatile之后看看结果。 发现main线程是正常结束了,故可以知道main线程知道主内存中的值发生了改变,故该资源类对所有线程具有了可见性,故可以知道volatile是可以保证可见性的。 那么问题来了,volatile是怎么保证可见性的。 1. 用volatile修饰的变量在工作内存中被修改之后,就会将该值强制刷新到主内存当中去 2. 每个线程在修改volatile修饰的变量前,都会触发总线嗅探,保证工作内存中的值与主内存一样在进行修改。 :::note{type=\"info\"} 每个处理器通过嗅探总线上的资源类来确保自己工作内存的缓存值是否已经过期,如果过期就会将该缓存行设置为无效,然后重修读取主内存中的自己过期的值进行修改,这就是总线嗅探机制,当高并发多个线程不断进行总线嗅探就会导致总线风暴。(我是这么理解的) ::: 这个其实很好验证,看以下代码。 得到的结果按理说应该是20000,但是执行了很多次出来的结果都不是20000,都是比20000少的。这显而易见,每个线程并不能全部完成自己的任务,从而可知volatile不保证原子性。为什么不保证原子性呢? 首先要知道的一点是,自增或者自减其实并不是一个原子性的操作,我们总觉得它是一个语句所以就把它当成了一个原子性操作,这是不对的,在底层i++是有几个指令组成的,现在来探究一下。 首先写一个简单的自增语句。 对该程序进行javap -c的反汇编得到以下的指令。 于是就可以得到i++的指令。 所以可以看到自增的指令并不是一条,所以就会有可能出现一些情况导致出现错误。 比如存在两个线程A和B。这两个线程都在各自线程的工作内存获取了相同并正确的值,并执行完iinc的自增指令,并将其压入栈中,但是由于存在线程竞争的情况,将其写回主内存时就会出现这种情况,A抢到时间片将自增写回主内存,时间片结束轮到B线程进行写入,可能会出现执行速度过快,导致没有进行嗅探将线程错误的初始值确认为无效,然后也将工作内存中的值写回主内存,于是就出现了丢失修改的错误。 所以说valatile并不能代替锁进行线程的同步,只要不是原子性的操作,就不能保证线程安全,如果需要保证原子性那就需要用到锁了。 指令重排涉及到汇编,结果也会有随机性,只能进行云分析了,先看以下样例。 假设有a,b,x,y四个变量的值为0,然后两个线程对该变量进行修改。 | 线程A | 线程B | | :----: | :----: | | x = a | y = b | | b = 10 | a = 10 | 正常的结果是得到x=0,y=0。 可是由于指令重排的存在,所以在小概率的情况下会出现先执行b=1或者是a=2,然后就会导致x与y的值不为0这种错误的结果。 这时候就可以使用volatile来禁止指令重排,使其顺序进行,从而使结果正确。 那么volatile是怎样禁止指令重排的呢?这就涉及到一个新的概念了,内存屏障。 内存屏障分为四类,如表。 | 屏障类型 | 指令示例 | 说明 | | :-----------------: | :----------------------: | :----------------------------------------------------------: | | LoadLoad Barriers | Load1;LoadLoad;Load2 | 确保Load1数据装载先于Load2及所有后续装载指令的装载 | | StoreStore Barriers | Store1;StoreStore;Store2 | 确保Store1数据对其他处理器可见(刷新到内存)先于Store2及所有后续存储指令的存储 | | LoadStore Barriers | Load1;LoadStore;Store2 | 确保Load1数据装载先于Store2及所有后续存储指令的刷新到内存 | | SroreLoad Barriers | Store1;StoreLoad;Load2 | 确保Store1数据对其他处理器可见(刷新到内存)先于Load2及所有后续装载指令的装载 该指令会使屏障之前所有内存访问指令完成之后才执行该屏障之后的内存访问指令 | 接下来的就是JMM针对编译器制定的volatile重排序规则表。 | 是否能够重排序 | 普通读/写 | volatile读 |volatile写 | | :------------: | :--------: | :--: | :--: | | 普通读/写 | | | NO | | volatile读 | NO | NO | NO | | volatile写 | | NO | NO | 左边为第一个操作,右边为第二个操作。比如第三行第二列的NO就表示,如果第一个操作为volatile读,第二个操作为普通读/写,则编译器不能重排序这两个操作。 - 在每个volatile写操作前面插入一个StoreStore Barriers - 在每个volatile写操作后面插入一个StoreLoad Barriers - 在每个volatile读操作后面插入一个LoadLoad Barriers - 在每个volatile读操作后面插入一个LoadStore Barriers - Java并发编程的艺术 - 并发编程网 - 字节码指令","url":"/posts/fe4c9cb6/","category":"我的技术学习物语果然有问题","date":"2021.01.08","dateTime":"2021-01-08T00:00:00.000Z"},{"title":"初识JUC编程","description":"初识JUC编程。","content":"JUC是java.util.concurrent包的缩写,这个包是Java的并发编程的工具类,所以JUC编程可以理解为Java的并发编程。 1. 程序是一组计算机能识别和执行的指令,只是一个静态的概念。 2. 进程是操作系统资源分配的基本单位,可以理解为一个程序的运行就为一个进程,它是一个动态的实体。 3. 线程可以理解为进程之内为了完成某一个任务的线路,一个进程为了完成任务,可能就会将该任务拆分为很多子任务,并开辟多个线程来完成这些子任务,从而加快完成总任务的速度。 1. 继承Thread类,重写run()方法,调用start()方法 2. 实现Runnable接口,重写run()方法,创建Thread实例,调用其中的start()方法。 3. 实现Calleble接口 1. 串行很好理解,每个任务都会排队执行,上一个任务没有结束,下一个任务就无法开始。 2. 并发就是不用等待上一个任务执行完毕,下一个任务就能开始执行,每个任务交替执行,形成每个任务同时进行的假象。 3. 并行就是任务同时进行,而不是像并发一样交替执行。 4. 简单理解为并发就是交替做一件事,并行就是同时做不同的事 。 5. 即使是单核的CPU也能进行多线程的操作,但是做不到并行。 即使是单核的CPU也是支持多线程执行的,CPU通过给每个线程分配CPU时间片来实现这个机制,这个时间片非常短,所以我们觉得多个线程是一起执行的,但其实是CPU在不断的切换线程执行。 在切换线程前会保存这个线程任务的状态,然后加载下个线程任务的状态,这个过程就是一次上下文切换。 刚刚提到了上下文切换,可以知道并发其实并不一定会比串行的速度快,因为并发会消耗一部分时间在上下文切换上,所以当并发执行的操作不超过百万次时,速度会比串行执行操作要慢。 从Java的Thread类中就可以看到Java进程的全部状态了。 首先来看个简单的例子。 从上面这个例子就会出现两种不正常的情况。 1. 先买到了第n张票之后才买到第n-1张票 2. 出现负数的票 因为多线程难以统一资源所以会出现的这些异常情况,这是我们不想看到的。处理并发的有效的手段就是加锁,所以我们需要用加锁来解决这个问题。 这里使用了synchronized来对买票的方法进行加锁,可以解决一些简单的并发问题。 synchronized分为三种使用情况。 1. 在普通方法上使用synchronized关键字,锁住的是实例对象,每个实例都各自有自己的锁,互不干扰。 2. 在静态方法上使用synchronized关键字,锁住的是类,即每个实例对象共用这个锁。 3. 同步方法块,锁的对象不定,看个人行为。 也可以不用synchronized来加锁,这里就来讲讲第二种方式。 这里就只学习Lock类的ReentrantLock这个实现类。 先探究一下这个实现类的构造方法。 由此可以看出,不加参数使用该实现类,这个锁就是非公平锁,加了true的参数,就是公平锁。 >简单的解释一下公平锁与非公平锁。 > >1. 公平锁,表示先来先服务,按照申请锁的顺序去获得锁,每个申请锁的线程都会形成一个队列,一个个来获得锁。 >2. 非公平锁,表示每个线程都可以去申请获得锁,获取不到就等待,获取得到就可以获得锁。 > >很多情况默认都是是非公平锁,synchronized也算是非公平锁,谁先抢到,谁就进行。 现在就用该实现类来解决一下上面买票的问题。 这样就可以进行简单的加锁来解决一些线程出现的问题。 1. synchronized是一个关键字,是JVM层面的,而ReentrantLock是一个来实现类,是API层面的。 2. synchronized是自动加锁和释放锁的,而ReentrantLock是手动加锁的,所以也需要手动释放锁。 3. synchronized的锁是不可中断的,除非是临界区内的代码出现异常或者是正常结束释放锁,而ReentrantLock的锁是可以中断的,可以使用trylock方法设置超时方法。 4. synchronized是非公平锁,而ReentrantLock默认是非公平锁,但是可以通过构造方法设置成公平锁。 5. synchronized的线程阻塞后是只能随机唤醒进程,而ReentrantLock通过Condition类可以精准唤醒被绑定的线程。 我们计划,当商品数量为1的时候,消费者进行消费,当商品数量为0的时候,生产者进行生产。 所以这会涉及到线程之间的通信,商品数量为0的时候消费者就会进入等待,并通知生成者进入就绪状态。商品数量为1的时候生成者就会进入等待,并通知消费者进入就绪状态 这个代码还会有一个虚假唤醒的问题,当线程数增加到了两个以上,就会出现一些异常情况,比如票数会到达0与1之外的范围,这是因为使用if来进行判断等待状态,只会判断一次,所以可能会出现两个线程都判断成功的情况,所以必须要使用while来进行判断,这样可以防止虚假唤醒的问题。 这里的Lock接口是没办法实现线程等待和唤醒的,所以就使用了一个Condition类的await方法和signal方法来代替wait和notifyall方法。 读写锁,这个类其实和上面两个加锁方法差不多,该锁可以将封锁粒度减少一点。读写锁其实就是之前学到的排他锁和共享锁。 线程对一个资源加上排它锁,表示只允许该线程进行读写资源,不允许其他线程读写,直到该线程释放了排它锁。 线程对一个资源加上共享锁,表示该线程可以对该资源进行读操作,但不能修改资源,其他的线程可以对该资源加共享锁,但不能加排它锁进行修改该资源,直到所有线程释放了对该资源的共享锁才能为该资源加排它锁进行修改。 经常使用的一些集合类在并发操作下很多都是不安全的,多个线程进行写入操作就会出现并发修改异常ConcurrentModificationException。所以现在来探讨一下解决的方案。 1. 使用Vector实现类,这个实现类是线程安全的,为什么安全可以看一下它的add方法,它是使用了synchronized关键字的。 2. 使用Collections工具类将Arraylist转换成安全的实现类。 3. 使用CopyOnWriteArrayList实现类。 HashSet也和ArrayList一样不安全,所以需要进行一些操作。 1. 使用Collections工具类将HashSet转换成安全的实现类。 2. 使用CopyOnWriteArrayList实现类。 1. 使用Collections工具类将HashMap转换成安全的实现类。 2. 使用ConcurrentHashMap实现类。 Callable是第三种开启线程的方式,但是线程的开启都是通过Thread类的start方法来开启的,而Callable的实现类是无法传入Thread类中的,所以需要借用中间类来实现。 > 其中的FutureTask是实现了RunnableFuture,而RunnableFuture接口继承了Runnable,其实借用FutureTask类打开线程本质就是接用Runnable来开启线程的。 这是一个减法计数器,可以使一个线程等很多线程执行完毕后在执行。 这是一个加法计数器,可以使很多线程到达一个目的地后在执行线程。 一个计数信号量。 阻塞队列顾名思义就是会阻塞的队列,是队列的子类,其类为BlockingQueue,数组的实现方式是ArrayBlockingQueue和链表的实现方式是LinkedBlockingQueue。 > 这里可以看出这三个方法都是调用了下面不抛出异常的三个方法,加以修饰让其抛出异常而已。 由此可以看出这三个方法都是用到了锁的,使得上面抛出异常的三个方法也是加锁了的。 | 方法 | 有返回值抛出异常 | 有返回值不抛出异常 | 阻塞等待 | 超时等待 | | :----------: | :--------------: | :----------------: | :------: | :-----------: | | 入队 | add | offer | put | 带参数的offer | | 出队 | remove | poll | take | 带参数的poll | | 返回队首元素 | element | peek | - | - | BlockingQueue还有一个实现类为同步队列SynchronousQueue,这个队列只能容纳一个元素,当元素满了再入队就会等待,当元素空了再出队也会等待,类似于上述的阻塞等待,但是只能容纳一个元素。 1. 创建线程池的方法 > 阿里巴巴编程规范不建议用这种方式开启线程池,因为可能会因为创建线程过多或者请求队列的线程过多而产生OOM,所以建议使用原生的ThreadPoolExecutor来开辟。 2. 使用线程池里的线程 3. 使用完记得关闭线程池 七大参数其实就是ThreadPoolExecutor的参数,先看一下构造方法。 | 参数 | 含义 | | :-------------------------------: | :----------------------------------------------------------: | | int corePoolSize | 核心线程数 | | int maximumPoolSize | 最大并发的线程数,只有阻塞队列满了才会开启更多的线程直到最大并发数 | | long keepAliveTime | 超时等候时间,时间到了就会释放线程 | | TimeUnit unit | 设置时间长度,与上一个参数搭配 | | BlockingQueue workQueue | 阻塞队列 | | ThreadFactory threadFactory | 线程工厂,一般固定 | | RejectedExecutionHandler handler | 拒绝策略,即线程数多到使阻塞队列满了而且最大线程数不够用了才执行的策略 | 拒绝策略共有四个,都是当线程数大于最大并发数加阻塞队列容量的时候,才会采取的策略。 1. AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。 这是线程池默认的拒绝策略,在类中也可以看到。 2. CallerRunsPolicy 调用任务的run()方法绕过线程池直接执行。 3. DiscardPolicy 丢弃任务,但是不会抛出异常,这是不推荐使用的拒绝策略。 4. DiscardOldestPolicy 抛弃队列中等待最久的任务,然后把当前任务加入队列中。 1. CPU密集型 CPU有几核就设置为多少个线程。 2. IO密集型 根据具体情况确定,若有15个任务,那最大并发线程数可以设置为大于15,比如设置为30","url":"/posts/195c9969/","category":"我的技术学习物语果然有问题","date":"2021.01.02","dateTime":"2021-01-02T00:00:00.000Z"},{"title":"CMS垃圾回收器","description":"CMS的垃圾回收器有很多讲究,所以特地拿出来探讨一下。","content":"- CMS GC是HotSpot虚拟机第一款真正意义上的并发收集器,第一次实现了垃圾收集线程与用户线程同时工作 - CMS GC的特点是尽可能减少STW时间,即低延迟,Parallel是吞吐量优先 - CMS采用标记-清除算法和Stop The World机制,在空间碎片化严重的时候也会使用一次标记-压缩算法来整理空间 CMS的工作流程大致分为七个步骤。 1. 初始标记阶段 2. 并发标记阶段 3. 预清理阶段 4. 可被终止的预清理阶段 5. 重新标记阶段 6. 并发清除阶段 7. 并发重置 这个阶段主要的工作就是标记出GC Roots能直接关联的对象,这里可分为两部分。 - 标记老年代所有的GC Roots对象 - 标记年轻代中活着的对象引用到老年代的对象 这个阶段因为涉及到了GC Roots的确定,所以会发生STW,为了减短STW时间,这个阶段的标记只是初始标记,之后还会继续标记。 由初始标记阶段标记到的对象开始寻找所有存活的对象,这个阶段是并发执行的,用户线程与标记线程同时进行,不会发生STW。 因为此时是用户线程和标记是并发执行的,所以有可能会出现一些情况,会导致有些对象会漏标。比如 1. 年轻代的对象变成老年代对象 2. 直接在老年代分配对象 3. 老年代的对象进行引用的更新 除了这些常见的情况,还会有一些特殊情况,所以这个阶段的标记是不完整的,还需要后面标记。 为了提高后面的重新标记的效率,该阶段还会把上述漏标的对象所在的Card标识为Dirty,后续重新标记的时候就只需要查看这些标记为Dirty的对象。 :::note{type=\"warning\"} 这个阶段会发生Concurrent Mode Failure。之后还会讲到。 ::: 这个阶段就是用来处理上个阶段标识为Dirty的对象,也是并发发生的,并找到引用标识为Dirty的对象的存活对象进行标记,最后清除Dirty标识。 这个阶段相当于提前做一些下个阶段的工作,尽可能的减少STW,还会处理一些Dirty的对象,这个阶段是并发的。 这个阶段默认持续的时间是5秒,即时间超过5秒,就会终止这个阶段,或者当eden区使用内存值小于CMSScheduleRemarkEdenPenetration,默认50%时,也会退出这个阶段。 可终止的预处理阶段就是为了减少重新标记阶段的时间,当在可终止的预处理阶段时碰上了yound GC的时候,就会大大减少下个阶段的STW,因为重新标记阶段是扫描整个堆的,所以碰上了yound GC就会减少扫描年轻代的压力。 这个阶段是CMS最后的标记阶段,所以这个阶段的主要任务就是标记所有老年代的存活对象。 这个阶段的主要任务如下: 1. 扫描GC Roots的引用链,确定老年代存活对象 2. 扫描整个年轻代,查找是否有年轻代对象引用了老年代 3. 处理所有之前遗留下来的Dirty的对象 因为这个阶段需要确定所有老年代的存活对象,所以不能在并发处理了,不然又会有其他引用变化导致标记不全,所以这个阶段是会发生STW的,而且这个停顿时间是整个CMS垃圾回收里时间最长的一个。 清除那些“死了”的对象,因为这个阶段是标记-清除算法中的清除阶段,不涉及移动对象,所以是并发执行的。 因为这个阶段是并发的,有可能也会产生垃圾,但是这次GC的标记阶段已经过去了,所以就只能下次GC的时候清理了。 因为CMS是标记-清除算法,所以这个阶段也会产生一些内存碎片。 这个阶段会重置CMS的一些数据结构,为下次GC做准备。 虽然CMS会扫描到年轻代的对象,但是扫描年轻代的对象只是为了确定老年代中的对象是否真正死亡或者存活(是否被引用),CMS只会处理老年代的死亡对象,所以注意和Full GC进行区分。 尽管CMS是并发回收,但是也涉及到可达性分析算法,所以一定会发生STW,只是CMS将部分标记的过程与用户线程并行,尽可能地减短了STW的时间。 CMS发生STW的阶段只有两个,初始标记阶段和重新标记阶段,主要的停顿时间是重新标记阶段,因为这里是要确定老年代所有的存活对象,扫描了整个堆。 CMS尽量做到低延迟,但因此丢弃了部分吞吐量,适合用在一些服务器上。 因为CMS采用的是标记-清除算法,所以垃圾收集结束后就会产生大量内存碎片。内存碎片过多会给大对象分配带来很大的麻烦,往往会出现老年代还有很多的剩余空间,但就是无法找到足够大的连续空间来分配大对象的内存,从而不得不提前触发一次Full GC。所以CMS需要设当的进行内存整理,而不是轻易的进行Full GC,可以搭配两个参数进行优化。 - -XX:+UseCMSCompactAtFullCollection(默认是开启的,JDK9后删除) - -XX:CMSFullGCsBeforeCompaction=n(JDK9后删除) 详细介绍可以参考下面的参数讲解。 因为CMS是并发回收的,所以用户线程也是会有可能在GC的过程中消耗内存,年轻代会在一些情况下就会将部分年轻代存活的对象放入老年代,而此时老年代没有足够的空间,此时就会出现Concurrent Mode Failure。 为了解决整个问题CMS一般都会设置一个阈值,当堆内存使用率到达一定阈值的时候,就会开始初始标记阶段,而不是堆内存快不够用的时候发生GC。将GC的时间提前,尽量减少Concurrent Mode Failure的出现。 此时的虚拟机就会触发STW启动Serial Old GC来重新进行老年代的垃圾回收,这样停顿时间会更长。这时候Serial Old GC也会因此进行一次碎片整理,解决标记-清除出现的内存碎片化严重的情况。 在进行Minor GC的时候,Survivor空间不足,只能将年轻代的一些对象放入老年代,此时老年代没有足够内存空间存放这些对象,又或者是内存碎片严重,找不到足够的连续的空间存放对象,与Concurrent Mode Failure是有点类似的。 - -XX:UseConcMarkSweepGC 指定CMS为老年代的垃圾收集器,开启这个参数设置之后,就会使用ParNew为新生代垃圾回收器,CMS为老年代的垃圾回收器,Serial Old为后备回收器的组合方案。 - -XX:CMSInitiatingOccupancyFraction=n 使用这个参数表示,当老年代的内存使用达到n%的时候就开始回收。JDK5以前的版本默认n是68,JDK6之后默认是92。 在内存使用增长慢的时候,可以设置大一点的阈值,这样可以减少GC的触发频率,如果增长快,可以设置低一点,避免频繁使用老年代串行收集器。 > 这个参数设置的好,则可以减少Full GC的触发频率,有效解决Concurrent Mode Failure的问题。 - -XX:+UseCMSCompactAtFullCollection(默认是开启的,JDK9后删除) 用于在CMS收集器不得不进行Full GC时开启内存碎片的合并整理过程,由于内存整理必须移动存活的对象,(在Shenandoah和ZGC出现之前)这个操作是无法并发的,所以又会使停顿时间变长,从而解决内存碎片的问题。为了减少内存整理的停顿时间,可以配合下面这个参数来进行控制内存整理触发频率。 - -XX:CMSFullGCsBeforeCompaction=n(JDK9后删除) 设置在执行了n次Full GC之后,就会对内存进行压缩整理,和XX:+UseCMSCompactAtFullCollection参数搭配使用。 > XX:CMSFullGCsBeforeCompaction=n和XX:+UseCMSCompactAtFullCollection参数搭配使用l可以有效解决内存碎片的问题。 - -XX:ParallelGCThreads=n 这个参数是设置ParallelGC的线程数的,CMS默认的启动线程数是(ParallelGCThread+3)/4 - -XX:+CMSScavengeBeforeRemark 在执行remark操作之前先做一次young GC,因为重新标记阶段是会扫描整个堆的,young GC会帮助扫描年轻代,减少重新标记的STW时间。 > 这个参数可以解决remark阶段停顿时间过长的问题。 - - - -","url":"/posts/b020b173/","category":"我的技术学习物语果然有问题","date":"2020.12.13","dateTime":"2020-12-13T00:00:00.000Z"},{"title":"腾讯精选练习50题","description":"LeetCode上的腾讯精选练习50题的专题的刷题笔记。","content":"利用long来进行中转。 回文数,其实跟回文字符串差不多,只是处理不同而已,我这里就直接将数字转换成了字符串然后对比。 也可以直接将字符串反转在和原来的字符串相对比,不过效率第一点。 直接求出反转后的数字,然后比较是否相等。虽然会有溢出的情况,但是会溢出的就不是回文了,所以可以不用考虑溢出的情况,实在要考虑可以直接来个try-catch来捕获异常。 因为这道题可以不用管中间的高度,所以直接嵌套for循环找出最大面积就好了,不过效率很低。明显看出这是O(n^2)的算法,应该算是效率最差的算法了。 这题明显可以使用双指针的方法。不断选取高度最高的值,并且长方形面积尽量大。最坏的时间复杂度为O(n)。 最开始是直接两个for循环的,但是看到了别人的解法,只能流出智商低的类水。 这经典题目了,直接用栈就可以判断了。 这个题因为两个都是有序的连边,所以一个个赋值就可以了。 还有一种递归写法。 这题考虑的是原地修改数组,那就把这个数组当作一个新的数组就好了,碰到不相同的就放到前面。所以就有了这个算法。 看题目就知道,一道典型的全排列的题目,我就用了递归的写法。不过这个写法遇到有重复的数字的时候会有重复的数据,这题没有重复数据所以不需要去重,要是有重复数据可以需要考虑去重。 这题一开始我用的是双指针逼近,但是发现无法确定逼近的条件,所以就放弃了这个想法。 实在没想出。看了下答案,发现不是题难,是我太菜了。 其实这题用动态规划来解是最好的。 首先确定一下状态,那就是子数组的和最大。 然后是状态变化,因为是求子数组的和最大,所以开头是不可能是负的,如果是正的,但是加了后面的负数也是会抵消。 这道题以前写过类似的,可以直接一个个的赋值,这题的难点就是边界的判断,在while循环中很容易就超出数组的边界了,或者是转过头了没刹住,注意好边界条件就不难了。 一看题目,直接递归搜索。 但是当图大的时候,就不行了,直接超时,所以不能直接搜索了,还要优化才行。因为当x或者y等于一的时候,就只有一条路了,所以可以进行优化一下。 但还是超时了,所以直接递归应该是不可行。所以得考虑其他想法了,比如说动态规划。 虽然可以通过了,但是时间和空间的消耗还是挺多的。 看了一下评论区的解法,发现有一个解法就很有想法。那就是用排列组合的方式。 这题的本质就是斐波那契数列。 首先就是dp数组。 直接递归,不需要存储状态。 这题的思路就是遍历数组,遇到新的元素,就把这个元素加到所有子集里,形成新的子集。 直接就把这两个数组合并,然后在排一次序就好了。这应该是最简单,也是最花时间的算法。 可以使用类似双指针的方法,选取最大的依次放入数组。 简化之后可以得到。 这题真的不会写了,题目描述的不是很清楚,看的都不是很明白,直接查了维基百科,看懂了格雷码转二进制数的规律之后,就很简单了。 这题直接用异或就好了,因为异或运算符和下面这样的规律。 1. 异或符和交换律 2. n与0异或答案为n 3. 两个相同的数异或答案为0 这题可以先直接遍历,然后判断是否有重复的就好了。 见到一种很有趣的解法。将每一个的节点指向自己,有环就会出现指向自己的节点。 快慢指针。 这题和上面的题其实差不多,只是要返回交接的点。 这题直接就是数据结构了,但是不知道会存多少个数字,所以使用了List来当存储数组。 题目要求常数时间内检索到最小元素,这个其实没算实现,因为这里获取最小数的时间复杂度加到了pop方法上了,而且这个的效率不是很好。 所以有了下面种写法,用链表的方法,每一个链表都存储一个最小值,这样pop的时候也会自动变更最小值。 这题我原本是想用两个指针一个个遍历,可是这两个链表不是等长的,所以找不到那个相交点,用for嵌套for又不符合题目要求,所以没写出来,看到人家的答案才知道,可以把这两个链表连起来,连起来这两个链表就等长了,双指针遍历就行。 这题写了几次了,可以用摩尔投票法来找出大于一半的元素。 还看到有一个写法,因为是多数元素,所以一定是跨过中位数的,所以直接排序,寻找中位数就可以了。 反转链表也算简单,注意要存储一下下一个变量,不然引用方向一变链表断开就找不到之后的值了。 另一种写法。 这道题很简单,直接排序取第K大就好了。 看了下评论,发现用库函数都能被骂,真的是服了,那顺便手写下快排。 一开始是直接暴力破解,两个for循环,发现超时了,所以就想到了先排序,然后一个for循环查看附近的值是否相同。 可以直接用Set去重,判断set集合中的元素与数组元素的个数是否相同就可以得到答案。 改进一下就是加入失败的时候就直接跳出,可以像这么写。 这道题和之前写的那道剑指Offer54是有点相似的,指路------>这里 这里我就不写这么详细了,就简单写两个方法。 这题真的看起来简单,又没怎么简单,想了好几个方法全是超时的,想到是用二进制了,但是还是不懂写只能借鉴别人的方法了,看了之后只能说太强了。 满足n & -n == n就是2的幂。 在二进制下,如果这个数是2的幂,那么它的二进制位上就会只有一个1。比如1是1,2是10,4是100,8是1000。 它的负数,在二进制是补码,所以会在各个位数上取反然后加1,这样就只有左边全为1右边全为0 。比如1是.....1111..1,2是...1110,4是...1100,8是....111000。 所以按位与就会是本身。 满足(1<<30) % n == 0就是2的幂。 1 << 30位是最大的2的幂,对n取余如果等于0就表示n是2的幂。 这道题,emm,描述的就离谱,其实就是给定一个链表的你要删掉的结点,删掉它。 这题不难,只是题目要求时间复杂度为O(n)和不能使用除法。这样的话就只能单个的for循环了,所以就可以考虑从左开始乘到当前树(不包含当前数),然后再加个for循环,再乘右边。这种方法速度很快,但是内存消耗太多,暂时还找不到内存消耗小的方法。 这题有点搞,我大费周章的想了很久,结果看到评论我傻了,这就是一道脑经急转弯。 这就是巴什博弈,先手的话,只要是n%(m+1)==0的时候就是一定会输。反之就一定是赢的。在两个人都是最优解的情况。 简化一下就一行 这个就直接用遍历双指针遍历就好了,不同的就是交换变量的方式而已。 这题就是先用split方法分割字串,然后可以用StringBuffer的字符串反转方法进行反转。 这样效率是很低,字符串这样拼接不好,建议使用StringBuffer。时间和内存消耗效率都很低。 先用split方法分割字串,使用StringBuffer进行拼接; 直接在原数组上进行反转。 在优化一下 另外一个搜索的思路","url":"/posts/32849422/","category":"我的技术学习物语果然有问题","date":"2020.12.12","dateTime":"2020-12-12T00:00:00.000Z"},{"title":"GC垃圾回收机制","description":"Java程序在运行中难免会产生一些垃圾,所以Java就使用了GC垃圾回收机制来自动的进行垃圾回收。","content":"在进行垃圾回收之前,就要先判断出什么是垃圾。 垃圾其实指的是在这次运行程序中没有被任何指针指向的对象,也就是没有被引用机会的对象,因为没有指向也就无法引用,所以这些对象就是要清理的垃圾。 如果垃圾不及时的清理,那么在这次运行程序的过程中就会一直占用部分内存,严重的还会导致内存溢出。 :::note{type=\"info\"} 内存溢出就是指程序运行过程中申请的内存大于系统所能够提供的内存,这就会导致无法申请足够的内存,于是就发生了内存溢出。 ::: 垃圾回收就需要关注哪里产生垃圾,其实垃圾的产生主要在运行时数据区中的方法区和堆。因为栈是用完就会推出的,计数器也不需要回收,所以GC的作用区域就是方法区和堆了。虽然说这两块区域会有GC行为,但正常来说主要的还是堆空间的GC,方法区很少会有GC行为。 垃圾标记阶段就是为一些死的或者活的对象打上标记,用来区分哪些是垃圾,哪些是用的上的对象。判断对象存活的方法一般有两个,引用计数算法和可达性分析算法。 计数算法其实就是为每个对象保存以个整型的引用计数器属性,每当该对象被引用了,改对象的引用计数器就会加1,引用失效了计数器就会减1,只要对象的计数器为0,即表示该对象已经不会被引用了,就会为它做上一个标记。 :::note{type=\"info\"} 引用计数算法是很简单高效的算法,但是对象一多,每个对象的计数器也是一个很大的开销。 而且引用计数算法还有一个很严重的问题,无法处理循环引用的情况,这是很致命的,所以Java的垃圾回收器没有使用这个算法。 ::: 从上图就可以看出对象的引用关系只要形成环形,很大的可能就会出现循环引用的问题,这就会出现内存泄漏的问题。 1. 配置JVM的虚拟机参数,打印JVM的情况。 我是使用IDEA,所以按照IDEA的配置来讲。点击RUN->Edit Configurations->Applacion->VM options。配置以下参数 2. 模拟循环引用的情况。 3. 显示调用的GC之后 4. 分析 可以清楚的看到调用了GC之后,内存的占用率变低了,如果Java使用的是引用计数算法,那么内存是不应该降低的,所以可以知道的是Java不适用引用计算这种算法。 可达性分析算法又称根搜索算法,追踪性垃圾收集。该算法可以有效的解决计数算法中的循环引用的问题,防止内存泄漏的发生。 GC Roots根集合,是一组必须活跃的引用。可达性分析算法的思路就是以GC Roots为起始点,从上至下的搜索被根对象引用的对象,查看对象是否可达。 搜索的路径被称为引用链。 存活的对象都应该是直接或者被间接引用到的,即都是可达的。 1. 虚拟机栈中引用的对象 2. 本地方法栈内引用的对象 3. 方法区中静态属性引用的对象 4. 方法区常量引用的对象 5. Java虚拟机内部的引用 6. 所有被同步锁synchronized持有的对象 7. 除了固定的GC Roots集合外,根据用户选用的垃圾收集器以及当前回收的内存区域不同,还可以有其他对象临时加入,比如分代收集和局部回收。 finalization机制称为对象终止机制,这个机制允许开发人员在对象销毁之前可以自定义逻辑代码。 即垃圾回收之前,总会先调用这个对象的finalize方法,这个方法可以被子类重写,通常用于在对象被回收时进行资源释放。 由于finalize方法的存在,虚拟机的对象一般处于三种可能的状态。 1. 可触及的,即可达的。 2. 可复活的。不可触及的对象有可能会在finalize方法中复活。 3. 不可触及的。因为finalize方法只调用一次,当finalize方法被调用对象也没有复活,那就是不可触及的了。 于是虚拟机判断一个对象是否可回收就会有这样的过程。 - 对象不在GC Roots的引用链当中,就会被第一次标记。 - 对象没有重写finalize方法,或者finalize方法已被调用,则被判定为不可触及的。 - 对象重写了finalize方法,且没被执行,那该对象就会进入Finalizer线程触发其finalize方法,然后进行第二次标记。 - 要是该对象的finalize方法进入了引用链,即复活了,就会被移除回收的集合,finalize方法只能执行一次,之后再进入回收的集合就会直接变成不可触及。 当垃圾被标记之后,就要开始进行清除阶段了。 当堆的有效内存被耗尽的时候,就会停止整个程序,进行标记和清除这两个工作。 - 标记:Collector从引用根节点遍历,标记所有被引用的对象,即在对象的Header中标记为可达的对象。 - 清除:Collector对堆内存进行全部遍历,发现没有标记的就会将其回收。 这种方法效率不高,而且进行GC的时候会停止整个程序,清理垃圾后也会产生内存碎片。 :::note{type=\"info\"} 内存碎片表示在内存中散乱的存放着一些对象。当有新的对象需要被加载的时候,可能就会没有足够的连续的内存空间给新的对象,所以即使总的空闲空间是足够的,也不能没有空间存放这个新的对象。 ::: 这里的清除不是表示直接删除该对象,其实这些对象还是存放在内存中,只是会将这部分对象所在的内存加入到空闲列表中,加载新的对象时候,就会将其覆盖掉。 将活着的内存空间分为两块(设两块区域为A和B),每次只用一块(设第一次使用的是A),垃圾回收的时候将A中存活的对象复制到B区域当中,然后清除A中所有的对象。当下次B要进行垃圾回收了就复制到A,清除B中所有对象。交换使用。 这种方法复制到新区域的对象就会是连续的内存空间,就不会产生内存碎片的问题,但缺点也很明显,减少了总体的内存空间,因为分成两半了,而且当需要复制的存活对象很多时候,就会占用很多内存和浪费很多时间。 - 标记:Collector从引用根节点遍历,标记所有被引用的对象,即在对象的Header中标记为可达的对象。 - 整理:标记完了之后就会将所有存活的对象整理在内存中的位置,使其连续排放。 标记-整理算法其实就像是在标记-清除算法后进行一次内存碎片的整理,只是少了清除的遍历,不过因为内存地址变了,有些引用的地址也会变,所以会存在一些风险。 | | Mark-Sweep | Copying | Mark-Compect | | :------------: | :------------------: | :----------------: | :--------------: | | 速度 | 中等 | 最快 | 最慢 | | 空间开销 | 少,但是会有内存碎片 | 大,需要两倍的空间 | 少,没有内存碎片 | | 是否要移动对象 | 否 | 是 | 是 | - 年轻代 年轻代的对象生命周期短,回收频繁,所以使用复制算法是比较好的,复制算法的内存问题可以通过hotspot中的两个survivor的设计得到缓解。 - 老年代 老年代的对象生命周期长,所以一般是使用标记-清除或者是标记-清除和标记-整理混合使用。 - 几乎所有的垃圾回收器都会区分新生代和老年代。 如果等到内存空间不够然后一次性的进行垃圾回收,就会出现程序停止的问题,所以增量收集算法就是让垃圾收集的进程和应用程序的进程交替使用,每次只收集一片区域的内存空间。 分区算法和增量收集算法其实差不多,分区算法就是将堆空间分割成多个小块的内存,每次合理回收若干个小的区间,从而减少一次CG产生的停顿时间。 - 使用System.gc()或者是Runtime.getRuntime().gc()就可以显示触发Full GC,同时回收老年代和新生代,尝试释放被丢弃对象占用的内存。 - 调用该方法会附带一个免责声明,即会触发Full GC,但是不知道会什么时候触发。 - 内存溢出其实不太容易出现,如果当应用程序占用的内存增长速度异常,超过了垃圾回收提供的空闲内存,那就会可能出现内存溢出。 - 内存溢出之前其实都会进行一次独占式的Full GC,回收大量内存,若果此时内存还是不够用,就会出现内存溢出的情况。 - Javadoc对OOM的理解是,没有空闲内存并且垃圾收集器也无法提供更多内存,就会报OOM。 出现的原因可能有以下原因: 1. Java虚拟机的堆内存设置不够 2. 代码创建大量对象,而且长时间不能被垃圾收集器收集。 - 严格来讲,对象不会被程序用到了,但是GC又回收不掉这些对象的情况,叫内存泄漏。 - 宽松一点来讲,一些不当操作导致对象的生命周期变得很长甚至导致OOM,也可以叫做内存泄漏。 - 内存泄漏不会立刻引起程序崩溃,但是发生内存泄漏之后,就有可能不断泄漏,然后就可能会出现OOM,即内存溢出的情况,然后导致程序崩溃。 - 注意,循环引用是针对引用计数算法的内存泄漏,Java不使用引用计数算法,所以这种不算是内存泄漏。 一些内存泄漏的例子: 1. 单例模式 单例的生命周期和应用程序一样长,所以当单例引用了外部对象时候,这个外部对象即一直是可达的了,这就会导致内存泄漏的产生。 2. 一些提供close方法的对象未关闭导致的内存泄漏 比如说数据库连接,网络连接和IO的连接操作,需要手动关闭,不然就会出现内存泄漏。 Stop The World简称STW,指GC事件发生的过程中会产生应用程序的停顿,停顿时整个应用程序线程都会被暂停,这个停顿就是STW。 比如可达性分析算法。可达性分析算法中的GC Roots的是可能会随着程序的而不断更新的,所以当进行枚举GC Roots的时候,会导致Java执行线程停顿。 所有的GC都会有STW的情况发生,不能避免,只能尽量减少STW的时间 事实上,发生GC的时间点并不是随机的,意思就是GC伴随的STW的不是随机某个时间点发生的,只有某一些特殊的位置才会停下来GC,这些位置就称作安全点。但是如何在GC发生的时候,检查到所有的线程都跑到最近的安全点然后开始停顿呢? - 抢先式中断(目前没有虚拟机采用了) 中断所有线程,如果还有线程不在安全点就恢复该线程使其运行到最近的安全点。 - 主动式中断 设置一个中断标志,各个线程运行到安全点的时候主动轮询这个标志,如果中断标志为真,就将该线程中断挂起。 讲述安全点的时候,默认把所有进程认为都在运行着,可是如果有某个进程处于睡眠或者阻塞的时候,还没到安全点就挂着了,这种时候还会一直等到该进程进入安全点吗?这种时候就需要设置安全区域来解决了。 安全区域是指在一段片段中,对象的引用关系不会发生变化,在这个区域中的任何位置开始GC都是安全的。这其实很好理解,对象的引用关系不发生变化的时候,GC Roots是不会发生变化的,可达性分析算法也就不会受到影响,所以在这段区域中停顿是不会对GC产生影响的。安全区域其实也意味着,这段区域都是安全点。 所以线程执行的时候要发生GC的就会是这样的: 1. 当线程进入安全区域的时候,就会标识该线程进入安全区域,如果要发生GC了,就会忽略该线程的情况,该发生就发生,该等就等。 2. 当线程离开安全区域的时候,会检查JVM的GC是否已经完成,完成了该线程就继续运行,否则线程就会等待可以离开安全区域的信号为止。 引用分为四种,按照引用类型的强度递减为强引用,软引用,弱引用和虚引用。 强引用是最经常用到的,平时的引用关系的建立很多都是强引用类型的,就比如Object obj = new Object()这种引用关系的建立就是强引用。强引用的关系存在的时候,就会被可达性分析算法标识为可触及的,所以就不会被垃圾收集器回收。 - 强引用-不回收,即使要发生OOM了也不会进行回收。 - 建立了强引用可以直接访问目标对象。 - 强引用是导致内存泄漏的一个主要原因。 软引用就是弱一点的强引用。在系统即将发生OOM的时候,垃圾回收器就会进行第二次回收(第一次是那些不可达的对象),把这些被软引用关系的对象清除掉,要是清除掉之后还是没有足够内存,才会发生OOM。 - 软引用-内存不足即回收。用来使用在一些虽然有用,但是不是必需的对象上。 - 软引用通常实现缓存方面上 - 建立软引用可以通过使用SoftReference的类来实现。 弱引用的关系在建立了之后就只能活到下一次的垃圾回收,因为GC发生的时候,即使内存足够也会把弱引用的对象全部回收掉。 - 弱引用-发现即回收。 - GC回收的时候,会通过算法检查软引用是否要回收,而弱引用对象被检查到会直接被回收。 - 弱引用也是主要用在缓存方面 - 建立弱引用可以通过使用WeakReference的类来实现。 虚引用关系是否存在对对象的生存不构成影响,也无法通过虚引用来实例化一个对象,该引用的目的只是为了在被虚引用的对象要被垃圾回收的时候会收到一个系统通知。 - 虚引用-对象回收跟踪。 - 虚引用相当于没有引用,也获取不到对象。 - 虚引用必须和引用队列搭配使用,因为当对象被发现是虚引用的时候,就会在垃圾回收之后,将该虚引用加入到引用队列当中,用来通知程序。 - 建立虚引用可以通过使用PhantomReference的类来实现。 - 垃圾回收器可以由不同厂商,不同版本的JVM来实现。 - 按照线程数来分类,可以分为串行垃圾回收器和并行垃圾回收器。 - 按照工作模式来分类,可以分为并发式垃圾回收器和独占式垃圾回收器。 - 按照碎片处理方式来分类,可以分为压缩式垃圾回收器和非压缩式垃圾回收器。 - 按照工作的内存区间来分类,可以分为年轻代垃圾回收器和老年代垃圾回收器。 - 吞吐量:运行用户代码的时间占总运行时间的比例。 - 垃圾收集开销:吞吐量的补数,垃圾收集所用的时间占总运行时间的比例。 - 暂停时间:执行垃圾回收的时候,工作线程被暂停的时间。 - 收集频率。收集操作发生的频率。 - 内存占用:Java堆区所占用的内存大小。 - 快速:一个对象从诞生到被回收的时间。 - 新生代收集器: Serial,ParNew,Parallel,Scavenge - 老年代收集器:Serial Old,Parallel Old,CMS - 整堆收集器:G1 - JDK8中默认使用的是Parallel和Parallel Old的组合,JDK9中默认使用G1 :::note{type=\"info\"} 1. 红色的虚线表示的这两个组合在JDK8已起用,JDK9已移除 2. 绿色的虚线表示的这个组合在JDK14中已经弃用 3. CMS GC的虚线表示在JDK14中已经删掉了这个垃圾回收器。 ::: - Serial收集器是属于串行的垃圾回收器 - Serial收集器采用复制算法,串行回收,Stop The World机制的方式执行内存回收 - Serial收集器是收集年轻代的,也提供了收集老年代的收集器,Serial Old - Serial Old收集器采用标记-压缩算法,串行回收,Stop The World机制的方式执行内存回收 - Serial Old是运行在Client模式下默认的老年代垃圾回收器 - Serial Old在Server模式下有两个用途 1. 与新生代的Parallel Scavenge配合使用 2. 作为老年代CMS收集器的后备垃圾收集方案 - 可以设置参数使用Serial收集器,老年代也会默认使用Serial Old > 现在CPU发展很快,串行的收集器体验不好,特别是对现在高流量的信息时代,所以一般Java Web中不会采用串行垃圾收集器。 - ParNew 是一款并行的垃圾收集器,可以说是Serial GC的多线程版本 - ParNew GC只处理新生代 - ParNew GC采用了复制算法和Stop The World机制,相对Serial GC来说只是暂停时间更短而已 - 很多的运行在Server模式下的JVM会采用ParNew GC为默认垃圾回收器 - 不考虑版本的话,ParNew GC可以搭配CMS GC或者是Serial GC使用 - 对于新生代回收次数频繁,所以使用ParNew GC并行可以提高效率,老年代回收少,使用串行垃圾回收器可以节省资源 - 设置参数使用ParNew GC > 前面有提到一点就是在JDK9版本中,Serial Old GC不可以与ParNewGC搭配了,在之后CMS也会删除,所以ParNew GC也快到了被移除的阶段了,所以不怎么建议使用了。 - Parallel与ParNew都是并行的,两者性能相差不大 - Parallel Scavenge GC 采用复制算法和Stop The World机制 - Parallel Scavenge GC 与ParNew GC不同的是Parallel收集器目标是达到一个可控制的吞吐量,也被称为吞吐量优先的垃圾回收器,自适应调节策略两者也有很大不同。 - 因为Parallel Scavenge GC是以吞吐量为优先的,所以老年代的收集器就不适合用串行的了,所以在JDK1.6的时候提供了Parallel Old GC用来替换Serial Old GC - Parallel Old GC采用标记-整理算法,同样基于并行回收和Stop The World。 - 参数设置 详情可以查看这篇文章","url":"/posts/202acec1/","category":"我的技术学习物语果然有问题","date":"2020.12.07","dateTime":"2020-12-07T00:00:00.000Z"},{"title":"初识JVM","description":"初步认识学习JVM。","content":"认识JVM之前就先了解下面三个相近的概念。 - JDK 英文名称为Java Development Kit。Java开发工具包,开发Java程序经常会使用它。 - JRE 英文名称为Java Runtime Environment。Java运行环境,主要包括JVM和一些类库,保证Java程序运行的最小环境。 - JVM 英文名称为Java Virtual Machine。Java虚拟机,具体是干什么的,之后在说。 通过概念就能看出来它们之间的关系,如下图。 更加详细的信息可以参考这个图。 JVM在我们的计算机当中是位于什么位置的呢?可以参考一下下图。 Java之所以那么火,这么多人使用,其中一个重要的原因就是Java有一个特性,一次编译,到处运行。Java可以实现跨平台运行,这使得开发者在不同平台上都可以运行自己的Java程序,方便了开发者的部署。那么Java是怎么实现跨平台的特性的呢? 这就关系到Java虚拟机了。我们在IDE编写好自己的Java程序之后,就会有一个扩展名为.java的源代码文件。 然后我们可以通过一个简单的命令来编译Java这个源代码文件。 Java程序的编译不是直接编译为计算机可以看懂的序列,而是编译成为了一个扩展名为.class的字节码文件。这个字节码文件通过Java虚拟机的翻译,才能变成计算机看得懂的序列,计算机才能成功运行这个Java程序。 到这应该就知道为什么Java可以实现跨平台了。Java的字节码文件不管放在哪个系统,只要系统安装有JVM,就能将字节码文件翻译成机器看得懂的语言,机器就能执行出程序。系统不同的只是会导致虚拟机不同,但不会影响字节码文件。","url":"/posts/c1baee3f/","category":"我的技术学习物语果然有问题","date":"2020.12.04","dateTime":"2020-12-04T00:00:00.000Z"},{"title":"SpringBoot整合Druid","description":"SpringBoot整合使用Druid.","content":"Druid是的一个阿里巴巴的开源项目,它是一个数据库连接池的实现。Druid能够提供强大的监控和扩展功能。这次就用SpringBoot来整合Druid。 > 配置好之后访问 就可以看到Druid为我们提供的用于监控的web界面。","url":"/posts/f2e39350/","category":"我的技术学习物语果然有问题","date":"2020.11.25","dateTime":"2020-11-25T00:00:00.000Z"},{"title":"SpringBoot使用JDBC","description":"SpringBoot用jdbcTemplate来来进行JDBC操作。","content":"在SpringBoot中简单的使用JDBC,用jdbcTemplate简单的操作数据的增删改查,大型一点的项目建议使用Mybatis。 :::note{type=\"info\"} spring帮我们封装好了JDBC的操作,并做好了模板,就是上述的JdbcTemplate。 JdbcTemplate的几个常用方法。 1. execute(),用于执行任何SQL语句。 2. update(),用于执行新增,修改删除等语句。 3. batchUpdate(),用于执行批处理的语句。 4. query(),用于执行查询语句。 5. call(),用于执行存储过程和函数相关的语句。 :::","url":"/posts/a8057909/","category":"我的技术学习物语果然有问题","date":"2020.11.25","dateTime":"2020-11-25T00:00:00.000Z"},{"title":"SpringBoot使用Mybatis","description":"用SpringBoot整合Mybatis,并简单的使用","content":"Mybatis是现在十分流行的数据持久化框架,这次就来用SpringBoot来整合使用Mybatis。","url":"/posts/e67586ad/","category":"我的技术学习物语果然有问题","date":"2020.11.25","dateTime":"2020-11-25T00:00:00.000Z"},{"title":"HashMap","description":"HashMap是经常用到的一个集合,很有必要进行深入了解。","content":"HashMap是Map经常使用的一个实现类,也是我们经常用到的一个集合,所以很有必要去了解一下。JDK8相对JDK7优化了不少,结构也改变了,所以这里就分开来学习了。 :::note{type=\"info\"} 因为我英语不是特别好,所以有些源码的文档注释是机翻的,所以有些文档注释读起来怪怪的,只能理解一下大概意思。 ::: :::note{type=\"info\"} 从构造方法来看,HashMap(int initialCapacity, float loadFactor)这个方法才是主体。接下来就来分析一下这个构造方法。 ::: 构造方法看完了,现在来看看HashMap的数据结构。JDK7的HashMap是以数组为主,链表为辅的结构。大概结构如下。 :::note{type=\"info\"} 每个链表被称为哈希表的桶,每个节点都存储了一对键值对。 ::: 这里就看出,每个节点就是哈希表的最小组成单位了,现在就来看一下这个节点类。JDK7时的节点类叫Entry。 由此可以看出每个Entry都存储了四个值,一对键值对,一个hash,和一个next值。next指向链表的下一个节点,而hash则用来判断该节点放在数组哪一个位置。 创建了哈希表之后,就可以用put方法来存放键值对,现在就来看看put方法的源码。 put方法有很多门道,现在我们就来一步步解析。 首先就是判断这个哈希表是不是一个空表。如果是就会调用inflateTable(threshold);这个方法,不是就进行下一步。我们去看看这个方法。 这个方法就是用来创建数组的,通过roundUpToPowerOf2方法来确定最小的能大于需要长度toSize的二次幂,是有点绕,那现在去看看这个方法。 寻找到最小的二次幂之后,重新计算阈值,然后用最小的2次幂来创建一个新的数组,最后用initHashSeedAsNeeded来初始化哈希掩码值。 判断传入的key是不是null值,如果是就返回putForNullKey(value),不然就下一步。现在来看看这个方法。 这步是最重要的一步,找到插入的位置然后将键值对插入到hashmap中。 首先就是调用hash方法来计算传入的key的哈希值。 得到哈希值之后,就会调用indexFor方法来计算出应该插入的位置。 计算出具体插入的位置之后就开始插入了,这里就是用了一个for循环遍历。 至此put的流程就结束了,到这里其实还是有问题。用indexFor这个方法来求数组的位置,刚刚也分析了这个方法,就是异或求余,那么就会有以下的问题,hash差为一定的倍数的时候,求余出来的下标就会是一样的,这个问题就是经常提到的哈希冲突。 为了解决哈希冲突这个问题,就引进了链表,也就是之前说的加入到桶中,这就是为什么哈希表底层是用数组和链表构成的了。下面讲讲大概是怎么用到链表的。 :::note{type=\"info\"} 图中只是为了演示大概解决的过程,实现可以参考下面的createEntry方法和扩容中的transfer方法。由于哈希的计算会使数据尽量平均,而且扩容的时候又会重新计算下标,在数组长度较小的时候哈希冲突的发生的概率是很小的。 ::: 假设键值对3计算出来的i是3,就会被放到数组的第四个位置,直接放入。 假设键值对4计算出来的i是2,就会放到数组的第三个位置,但是这个位置已经有键值对1了,这种情况就会用到链表,头插到该链表。 但是如果是这种情况,就无法通过数组来寻找到键值对4了,所以还会变化一下指针的指向,最后就会变成这样。 在上面put的第三步不难看到,在一个桶里只要有key相同,就覆盖,没有就使用addEntry这个方法加入到桶里。不难看出这个方法发生的情况,数组指定位置没有该元素或者是发生哈希冲突时就会用到这个方法,现在来看看这个方法。 刚刚看到addEntry中用resize方法来扩容,现在就来看看这个方法是怎么扩容的。先看看这个方法的源码。 resize方法是挺好理解的了,只有这个迁移函数有点讲究。 :::note{type=\"info\"} 下面例子简化了长度,和一些细节,因为这样转移是很小几率的,只是为了展示转移方法的大概实现。 ::: :::note{type=\"info\"} transfer方法和之前的createEntry方法,表明了1.7的哈希表为什么是头插的。因为头插,哈希表还会出现一些问题,之后还会提到。 ::: get方法就没有put需要考虑到这么多情况了了,所以简单很多。 首先就是判断key值是不是为null,如果是null就调用getForNullKey。 这两句也挺好理解的,用getEntry方法来获取键值对,然后返回value。 :::note{type=\"success\"} JDK8优化了不少,但与JDK7在很多部分是一样的,所以我着重去分析一下不一样的地方。 ::: 可以看出只有两个比较特殊的地方,那就是tableSizeFor和putMapEntries这两个方法了。 JDK8的底层进行了一些优化,主体依旧是数组,链表为辅,但是链表过长会导致hashmap的查询效率变低 因为链表的查询操作的时间复杂度为O(n),所以在JDK8中引入了红黑树。 当链表达到树化阈值的时候,就会转变为红黑树 因为红黑树的查询操作的时间复杂度为O(log(n)),所以可以提高查询桶里节点的效率","url":"/posts/3d614825/","category":"我的技术学习物语果然有问题","date":"2020.11.20","dateTime":"2020-11-20T00:00:00.000Z"},{"title":"树","description":"刷Leetcode关于树的题的笔记。","content":"迭代会麻烦一点,主要先记住中序遍历的特点,先遍历左子树,在遍历当前节点,在遍历右子树。 所以当该节点有左子树的时候就先进入到左边。 二叉搜索树中序遍历是有序的,所以可以先全部遍历,在判断是否有序。 上面的解法一其实可以看出是浪费了一些时间了的,其实可以直接在后一个值小于前一个值的时候就停下来的。 这种方法也很好,直接划个边界给给子树递归,判断是否出边界。不过注意的是,设置边界的最大值的时候,不能用Integer.MAX_VALUE和Integer.MIN_VALUE,因为有样例正好是Integer.MAX_VALUE和Integer.MIN_VALUE,所以只能取大一点的long。 相同的树,首先要判断当前节点是否相同。不相同直接返回false。 然后递归判断两棵树的左子树和右子树,判断一下他们的左子树是否相同和右子树是否相同即可。 1. 判断当前节点是否是一样的 2. 将左子树的左子树和右子树的右子树丢入递归判断,将左子树的右子树和右子树的左子树丢入递归判断,结果取并 使用双栈。 使用队列进行层次遍历,然后判断是否回文。 主要是判断一下是在哪一层,然后分层处理就可以了。 二叉树的层序遍历的迭代可以借组队列来进行存储节点。 1. 首先判断根节点是不是空,不是则值加一 2. 递归判断左子树与右子树,取最大值 优化之后: 假设根的前序遍历的在中序遍历中的位置为K,那么在中序遍历中,1到K-1都是该根的左子树,K+1到最后是该根的右子树。 与上一题差不多,只是有一点点不一样而已。 . 从低向上层次遍历,其实就是先层次遍历然后反转就好了。 首先,判断左右两个子树的高度的绝对值不超过1,就要用到计算二叉树的最大深度了,递归获得深度,左右子树深度差的绝对值小于等于1就返回真,然后遍历左子树和右子树就好了。 这个和上面算法差不多,这个算法是修改了最大深度的求法,不符和条件的就返回-1的深度,要是有-1深度返回代表不符合条件。 求最小深度,就与求最大深度相反就好,只是不能让空子树参与计算,不然一直返回0。 这题是判断路径总和是否等于给定值,不能从下到上的计算节点值,因为情况多会无法相加,所以只能从上到下的相减,看是否等于0。 这题就是根据二叉搜索树的特性,中序遍历会是从小到大,然后找到第K个就好了。 上面的方法是最暴力的解法,还可以进行优化。根据二叉搜索树的左子树会比根节点小,右子树会比根节点大,就可以找到第K小的元素。 这题通过遍历就可以找到需要删除的节点,这题的难点是怎样删除找到的节点。 确认了需要删除的节点后,就要先找到该节点右子树最小的值,用该值代替删除的节点,因为这样就不会破环二叉搜索树的结构了。(也可以寻找左子树的最大值) 这题主要的问题是没理解题目到底在讲什么,看了答案才知道其实是将树从下到上,从右到左累加,然后将该值赋值给当前节点。 1. 判断root是否为空结点 2. 将数据存入List 3. 递归前序遍历各个结点 这道题难的就是结果的存储了,因为经常写的前序遍历都是直接输出结果的,存储的化就要全局的List了。 1. 先判断root是否为空结点 2. 将root结点压入栈 3. 当栈不为空,将栈中数据存入List,将当前结点的孩子压入栈 这题主要的难点就是怎样判断该节点的子树和其他节点的子树是否一样。 可以考虑到的是将该节点的子树和根作为一个字符串,如果其他字符串与其一样,就判断为这是重复的子树节点。 直接中序遍历然后把节点赋给结果子树的右子树就好了。 暴力递归破解。 因为中序遍历是从小到大的,所以还可以优化一下。 我的第一想法就是直接全部遍历,排序然后找到第k大的节点,虽然效率不这么好,但是也是一种方法。 因为给的树是二叉搜索树,所以应该想到二叉搜索树的中序遍历就是有序的,所以可以省去排序的时间。 中序遍历毕竟是要遍历整个树,所以效率也只是比暴力破解好了一点点而已,要想节约时间,那就只搜索到第K大的结点就停止就好了,所以就用到了二叉搜索树的性质。(若它的左子树不空,则左子树上所有结点的值均小于它的根结点根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值。)通过中序遍历,找到第K个结点就可以了。 首先就是这个链表的插入,如果使用尾插就需要在声明一个头节点的数组存储头节点,所以我用了头插法,不过要注意顺序,先将右子树的值插入链表再将左子树的值插入链表,这样就能符和题目的顺序了。还有就是链表数组的长度,第一个解法我就直接再加个函数求取树的最大深度了,套用第104题就行。 这种解法速度还是很快的,只是消耗的内存有点多,可能题目就打算消耗多的内存。还有一种思路就是使用层次遍历,其实也差不多。也看了一下其他解法,不过很多的解法消耗的内存有点多,然后看到一些内存消耗低的解法,发现寻找深度的代码还可以优化,然后又优化了一些细节。","url":"/posts/7b216a3b/","category":"我的技术学习物语果然有问题","date":"2020.11.18","dateTime":"2020-11-18T00:00:00.000Z"},{"title":"Mybatis-plus","description":"顾名思义,Mybatis-plus就是Mybatis的加强版,能帮助你更简便的使用Mybatis。","content":"MyBatis-Plus(简称 MP)是一个 MyBatis的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。 - 官网地址 :::note{type=\"info\"} 参照官网快速开始的样例,官网用的是h2数据库,我这里用的是Mysql。 ::: 1. 创建数据库schema,并执行以下脚本。 2. 添加依赖 主要的依赖。 测试依赖如下。 3. 创建一个实体类 4. 创建Mapper接口 5. 配置数据源和日志 6. 添加扫描Mapper文件的注解 7. 测试类 > 然后就完成了。这的确比mybatis简单了不少。 > > mybatis大概流程是导入依赖,定义实体类,定义mapper接口,创建绑定mapper接口的xml配置文件,配置数据源并绑定mybatis的配置文件和实体类,然后才能使用。现在简单了很多。 主键生成策略有很多,不过主要学习一下这个雪花算法。 首先来做个插入的测试。 这个测试是没有设置主键id的值的,来看一下主键的生成。 插入成功之后看到数据是这样的。 这么一长串的id是什么东西呢,我们在官网看到主键有个注释@TableId,点进去看看源码。 这里就可以看到主键是可以可无的,下面是默认的主键生成策略,我们在点IdType进去看看有什么策略。 在这里就看到当主键为空的时候,会有一个默认的生成策略ASSIGN_ID,这个策略的默认实现算法是雪花算法。 官网已经将上述方法已经总结的很好了,我就直接放官方的表了。 | 值 | 描述 | | :---------------: | :----------------------------------------------------------: | | AUTO | 数据库ID自增(需要数据库也要设置为自增) | | NONE | 无状态,该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT) | | INPUT | insert前自行set主键值 | | ASSIGN_ID | 分配ID(主键类型为Number(Long和Integer)或String)(since 3.3.0),使用接口IdentifierGenerator的方法nextId(默认实现类为DefaultIdentifierGenerator雪花算法) | | ASSIGN_UUID | 分配UUID,主键类型为String(since 3.3.0),使用接口IdentifierGenerator的方法nextUUID(默认default方法) | | ~~ID_WORKER~~ | 分布式全局唯一ID 长整型类型(please use ASSIGN_ID) | | ~~UUID~~ | 32位UUID字符串(please use ASSIGN_UUID) | | ~~ID_WORKER_STR~~ | 分布式全局唯一ID 字符串类型(please use ASSIGN_ID) | > 从官网的删除线和源码来看,后面三种是已经不支持使用了的。 > > 默认的生成策略是NONE,相当于INPUT,就是自己设置主键的值,当主键没有设值的时候,默认是使用ASSIGN_ID雪花算法。 首先需要引入依赖。 引擎可以选择其他的,这里就使用velocity。 这里给出一个比较通用的配置。 想要更加自定义的配置可以参考代码生成器的配置文档","url":"/posts/fd1960c6/","category":"我的技术学习物语果然有问题","date":"2020.11.14","dateTime":"2020-11-14T00:00:00.000Z"},{"title":"Linux","description":"学习尚硅谷的教程时候的学习笔记。","content":"| 连接方式 | 连接的网卡 | 能否连接局域网 | 能否连接公网 | | :------: | :------------------: | :------------: | :----------: | | 桥接 | VMnet0(本地真实网卡) | 可以 | 可以 | | NAT | VMnet8 | 不可以 | 可以 | | 仅主机 | VMnet1 | 不可以 | 不可以 | 1. 桥接连接的网卡是随机连接的,要是连接到了没网络的网卡还需要自己设置。 2. 桥接模式下虚拟机相当一台独立的计算机,拥有一个独立的IP地址,与本机在一个局域网内。 3. NAT模式可以帮助虚拟机通过本机所在的网络来访问公网。 4. 仅主机模式会建立一个全封闭的虚拟网络,只有主机能访问 通过命ls -l就能看到一些文件的基本权限,比如下图。 1. 第一位表示的是文件的类型。 - -代表的是普通文件 - d代表是目录 - b代表块设备文件 - c代表字符设备,比如键盘鼠标等等 - s代表套接字文件 - l位链接文件 - p位管道文件 2. 第二到第四位代表文件所有者的权限(user) 3. 第五到第七位代表组群所有者的权限(group) 4. 第八到第十位代表其他人的权限(other) 5. - -代表没用该权限 - r代表可读 - w代表可写 - x代表可执行 6. 后面两个root代表的是文件所有者和群组 每次新建的文件都会有权限,这就是默认权限,umask。对文件来讲默认权限最大为666,对目录来讲是777。 | 插入命令 | 描述 | | :------: | :--------------------: | | i | 在光标所在字符后插入 | | I | 在光标所在字符行尾插入 | | a | 在光标所在字符前插入 | | A | 在光标所在行行首插入 | | o | 在光标下插入新行 | | O | 在光标上插入新行 | 1. 上下左右键 2. HJKL键,h向左,j向下,k向上,l向右 3. gg移动光标到文件头,G移动到文件尾 4. ^移动到行首,&到行尾 5. 进入编辑模式加数字到第几行,比如:3是到第三行 1. x删除一个字母,nx删除n个字母 2. dd删除一行,ndd删除n行 3. 进入编辑模式,:n1,n2d删除n1到n2行 4. 其实删除是放到了剪切板,按p数粘贴到下一行,P是粘贴到上一行 1. yy复制单行,nyy复制n行 2. 按p数粘贴到下一行,P是粘贴到上一行 1. u撤销上一次操作 2. ctrl+r是反撤销 1. r替换光标的字符 2. R进入替换模式,esc退出 | 参数 | 描述 | | :-------------: | :--------------------------: | | :set nu | 显示行号 | | :set nonu | 取消行号 | | :syntax on | 依据语法显示相关颜色帮助 | | :syntax off | 取消颜色帮助 | | :set hlsearch | 设置将查询的字符串高亮,默认 | | :set nohlsearch | 取消设置将查询的字符串高亮 | | :set ruler | 显示右下角状态栏,默认 | | :set noruler | 取消显示右下角状态栏 | | :set showmode | 显示状态显示,默认 | | :set noshowmode | 不显示状态显示 | | :set list | 显示隐藏字符 | | :set nolist | 不显示隐藏字符,默认 | > 在编辑器中输入只是临时的,需要改就需要到家目录下的.vimrc中添加配置,比如添加set nu该用户的编辑器就会显示行号","url":"/posts/53d0684b/","category":"我的技术学习物语果然有问题","date":"2020.11.11","dateTime":"2020-11-11T00:00:00.000Z"},{"title":"记一次容器编排","description":"记一次容器编排。","content":"老师丢了一个spring写的项目给我们部署到服务器上。这次来记录一下部署的过程。 这是一个spring的项目,没用到springboot,只能用tomcat部署了。因为还用到了MySQL连接,所以还需要一个MySQL的容器。知道了需要的容器那就开始行动了。 1. 创建一个项目的文件夹 2. 创建一个放Tomcat配置的文件夹 3. 创建一个放MySQL配置的文件夹 4. 创建一个docker-compose.yml的配置文件 因为这个项目打包出来是war包的,所以我想的就是直接将war包放到Tomcat的webapps里然后运行Tomcat就好了。(以下操作是在webapp文件夹进行) :::note{type=\"warning\"} 注意设置项目中连接mysql的url,ip填写为mysql(其他也行,后面自己改服务名) localhost是指Tomcat容器的IP,因为容器与容器是隔离的,所以会连接不到MySQL容器的IP。 ::: 1. 将改好的项目war包移入服务器的这个文件夹中。 2. 定制Tomcat的镜像,创建一个Dockerfile文件。 这个容器才是这次的重点,因为要导入自己的sql语句,所以需要额外的shell脚本来实现。(以下操作是在database文件夹进行) 1. 将sql文件移入这个文件夹,我的文件名是mathStock.sql。 2. 定制MySQL的镜像,创建一个Dockerfile文件。 3. 创建一个shell脚本用于导入sql文件,我的文件名是setup.sh 编排完之后就可以运行了。 -","url":"/posts/683134ab/","category":"我的技术学习物语果然有问题","date":"2020.11.10","dateTime":"2020-11-10T00:00:00.000Z"},{"title":"Swagger3","description":"Swagger3","content":"学完之前的swagger2之后,发现还有一个新的版本,swagger3,用起来更加的简单,而且是官方的starter。 1. 首先导入依赖 2. 创建swagger配置类。 3. 然后就能访问url 找到文档了。 有很多的配置与swagger2是一样的,就不具体阐述了。 Swagger3还可以使用knife4j来增加Swagger的体验,这个前身是swagger-bootstrap-ui。 官方的文档。 可以根据底层的不同来选择依赖,比如使用OpenAPI3结构的可使用以下版本。 使用后也是访问doc.html就能看到。 knife4j还有增强的特性,可以参考 来开启增强模式。","url":"/posts/35ca0e58/","category":"我的技术学习物语果然有问题","date":"2020.11.03","dateTime":"2020-11-03T00:00:00.000Z"},{"title":"MySQL","description":"MySQL","content":":::note{type=\"info\"} MySQL的关键字是不区分大小写的,这里我全部用大写来记录。 ::: | 类型 | 描述 | 大小 | | :-------: | :----------------------------------------: | :-----: | | tinyint | 很小的一个数据 | 1个字节 | | smallint | 较小的一个数据 | 2个字节 | | mediumint | 中等大小的一个数据 | 3个字节 | | int | 标准大小的数据(整数常用) | 4个字节 | | bigint | 较大的数据 | 8个字节 | | float | 单精度浮点数 | 4个字节 | | double | 双精度浮点数 | 8个字节 | | decimal | 字符串形式的浮点数(用来解决浮点数精度问题) | | | 类型 | 描述 | 大小 | | :------: | :----------------------------: | :-----: | | char | 固定大小的字符串 | 0~255 | | varchar | 可变的字符串,对应Java的String | 0~65535 | | tinytext | 微型文本 | 2^8-1 | | text | 文本串 | 2^16-1 | | 类型 | 描述 | 格式 | | :-------: | :-------------------------: | :-----------------: | | date | 日期 | YYYY-MM-DD | | time | 时间 | HH:mm:ss | | datetime | 常用的时间格式,即date+time | YYYY-MM-DD HH:mm:ss | | timestamp | 1970.1.1到现在时间的毫秒数 | | | year | 年份表示 | | :::note{type=\"info\"} MM与mm分大小写是为了区分月份和分钟。 HH大写是为了表示是24小时制,hh为12小时制。 YYYY表示week-based-year,即只要本周跨年,那这周就算入下一年。 yyyy就表示真实年份。 ::: 未知的数据类型,不建议参与运算。 | 关键字 | 描述 | | :------------------: | :----------------------------: | | NULL | 该数据列可以包含NULL值 | | NOT NULL | 该数据列不允许为NULL值 | | DEFAULT | 为数据列指定默认值 | | PRIMARY KEY | 设数据列为主键 | | AUTO_INCREMENT | 设数据列为自动递增,设用于整数 | | UNSIGNED | 设数据列为无符号 | | CHARACTER SET [name] | 为数据列指定一个字符集 | | COMMENT | 注释 | > 建个表好进行之后的例子 | AND | && | A AND B | | :--: | :--: | :-----: | | OR | \\|\\| | A OR B | | NOT | ! | NOT A | - INNER JOIN 如果表中有至少一个匹配,则返回行。 - RIGHT JOIN 即使左表中没有匹配,也从右表返回所有的行。 假如depart有id=1000而user表中没有id=1000的数据也会查到id=1000数据,只是在user表的列数据为null。 不会查到user表中有而depart表中没有的数据。 - LEFT JOIN 即使右表中没有匹配,也从左表返回所有的行。 假如user有id=1000而depart表中没有id=1000的数据也会查到id=1000数据,只是在depart表的列数据为null。 不会查到depart表中有而user表中没有的数据。 - FULL JOIN 只要其中一个表中存在匹配,则返回行。","url":"/posts/c24675b4/","category":"我的技术学习物语果然有问题","date":"2020.11.01","dateTime":"2020-11-01T00:00:00.000Z"},{"title":"Docker","description":"Docker 是一个开源的应用容器引擎。","content":"去到官方文档 ,选择对应的操作系统安装就可以了。 **我的环境是CentOS 7.8** 出现了docker版本的信息就代表安装成功了。 1. 打开阿里云的官网。 2. 打开容器镜像服务。 3. 点击镜像中心下的镜像加速器。 4. 选择版本就输入命令就可以配置好阿里云的镜像加速了。 :::note{type=\"info\"} 这是阿里云的镜像加速,也可以找其他国内的源,不换源的话拉取镜像会很慢。 ::: :::note{type=\"warning\"} 慎用docker commit。因为这样生成的黑箱镜像会对其他人的维护工作造成很大压力。生成镜像建议使用Dockerfile。 ::: 1. 拉取Tomcat的镜像 2. 启动容器 3. 打开公网ip的5000端口,或者服务器内部的localhost的5000端口就能看到页面了。因为下载的镜像是被处理过的,所以看不到index页面。 4. 进入容器 1. 建一个新的文件夹,然后在里面建一个Dockerfile文件,内容为 2. 然后生成镜像 3. 然后创建容器打开url,就能看到Hello Docker!了。 :::note{type=\"info\"} 注意这个最后这个点,这个是表示指定当前目录为上下文路径,后面有些指令就是从上下文路径开始指引,不一定是Dockerfile的路径,为了方便才让Dockerfile文件与上下文路径一致。 ::: FROM用来指定基础的镜像,即用这个镜像来进行二次开发。 这个指令是必须的,而且必须是第一条。 > Docker中有一个特殊的镜像,那就是scratch,表示一个空白的镜像。 这个指令用来表示作者的信息。 用来执行命令。 :::note{type=\"warning\"} 当有多个命令的时候,尽量在一个RUN指令中完成,而不是使用多个RUN。因为一个指令就是建立一层,多层的结构就会显得十分的臃肿。 ::: 从构建上下文的目录中将一个文件复制到镜像内的目标路径当中。 如果源路径为文件夹,复制的时候不是直接复制该文件夹,而是将文件夹中的内容复制到目标路径。 ADD也是复制,与COPY差不多,但是能干更多的事情,比如复制的文件是tar压缩文件,会帮你自动解压到目标路径。 > ADD有很多复杂的功能,所以只拷贝文件的时候尽量使用COPY,需要自动解压就用ADD。 用来设置工作目录。 工作目录是用来指定整个镜像的,因为每一层都是隔离的,所以不指定工作目录就会出现目录的混乱,即上一层使用了cd进入了新的目录,而下一层一不小心就当成是上一层的目录继续操作。 暴露端口,类似之前的-p参数,声明容器运行时容器提供服务端口。注意仅仅是声明,不会自动进行端口映射。 这里的目录挂载之后就会在运行的时候自动挂载为匿名卷。 设置环境变量。 ENTRYPOINT与CMD差不多,只不过在容器run后面加命令就会自动添加到ENTRYPOINT的参数去。 > 更多详细内容可以参考官网的Dockerfile reference。 打开阿里云的容器镜像服务,创建命名空间和容器镜像,然后参考官方文档就能跟着发布了。 当Docker启动的时候就能看到docker会自主创建一个docker0的网桥。 docker0类似一个路由器,连接着各个容器。当创建一个容器的时候,也会创建一对的veth pair 接口,一个连接容器,一个连接docker0,这样就可以实现容器与docker0的通信和容器与容器的通信了(只限于ip)。这样Docker 就创建了在主机和所有容器之间一个虚拟共享网络。 :::note{type=\"warning\"} 因为docker0的存在,所以默认创建的容器之间是可以通过ip来通信的,即每个容器之间通过docker分配的ip是可以互相ping通,但是不能通过容器名来ping通,因为是没有解析的。 ::: 1. 创建一个新的目录用于DockerCompose 2. 在目录中创建一个app.py 3. 创建一个requirements.txt 4. 建立Dockerfile 5. 创建docker-compose.yml定义服务 6. 然后启动应用程序 7. 打开url 。就能看到计数的开始了。 > 这是官网的入门程序。地址为 。 > 用SpringBoot写上面类似的计数 1. 创建springboot,导入依赖 2. 创建一个请求 3. 配置Springboot的配置文件application.properties 4. 编写Dockerfile 5. 编写docker-compose.yml 6. 然后打包,将生成的Jar包上传到服务器上,然后运行,访问url 就可以看到计数了。 Raft协议,也是一种一致性的算法,具体的算法内容就自行查阅。 要先知道的是managert节点分为三种状态,Leader,Reachable,Unreachable。 现在以Docker集群来进行大概的情况讲解,假设现在swarm的集群有四个节点。 因为只有manager节点能进行管理,所以在只有一个manager节点,三个worker节点的情况下,manager节点出现故障即状态为Unreachable,该集群就无法进行管理,只能等待manager节点的修复。 在这种情况下,其中一个manager节点状态为Unreachable,另一个manager节点也会无法进行管理操作,所以两个manager节点是无法进行很好的管理的。 当故障的manager节点修复好在加入集群,状态就会变成Reachable,而另外的那个就会变成Leader。 这种就是最起码的集群管理。在这种情况下,第一个manager节点出故障了,其他两个是能进行管理操作的,而不是像之前一样无法管理,当挂了两个就不能管理了。所以一个标准的集群式至少需要三个manager节点的,至少有两个manager节点可用,这样才能保证集群的正常运行。 :::note{type=\"info\"} 可以把集群看成是一个整体,因为服务的副本也是接的相同的端口,所以访问哪个节点的ip端口,都可以访问到这个服务。 ::: docker命令一图流。 - https://yeasy.gitbook.io/docker_practice/contributing","url":"/posts/f5f9fa9b/","category":"我的技术学习物语果然有问题","date":"2020.10.27","dateTime":"2020-10-27T00:00:00.000Z"},{"title":"swagger","description":"swagger是一款让你能更好书写API文档的框架。","content":"1. 为你的项目导入两个依赖 2. 创建一个配置类 3. 开启项目,打开url ,就能看到ui界面 1. 因为swagger的实例Bean是Docker,所以用Docker来配置swagger。 2. 配置完成以后就可以打开 看到信息了。 使用Docket的select方法扫描,通过build方法来构建扫描的配置,**用apis方法来配置扫描的位置**,**paths方法来配置接口扫描过滤**。 :::note{type=\"info\"} 使用select配置扫描,用其中的apis方法配置扫描对象,用paths方法来指定扫描的请求 ::: 1. 首先创建一个实体类 2. 然后再control层加入返回实体类的请求就可以看到实体类了。 3. 配置注释 这就是之前导入的依赖,页面ui地址 页面UI地址 页面UI地址 页面UI地址 :::note{type=\"info\"} 更多好看的ui可以去寻找哦。 :::","url":"/posts/bf71eba1/","category":"我的技术学习物语果然有问题","date":"2020.10.26","dateTime":"2020-10-26T00:00:00.000Z"},{"title":"数据结构","description":"有空就复习一下数据结构,看的书是大话数据结构,还是挺有趣的这本书,因为是复习,所以本篇的代码用的是C写的。","content":"数据是描述客观事物的符号,是计算机中可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合。 数据元素是组成数据的,有一定意义的单位,在计算机中通常作为整体处理,也被称为记录。 数据项是数据不可分割的最小单位,若干个数据项可以组成一个数据元素。 数据对象是性质相同的数据元素的组合,是数据的子集。 不同的数据元素之间不是独立的,而是存在特定的关系,这种关系就是结构。 数据结构就是相互之间存在一种或多种特定关系的数据元素的集合。 逻辑结构是指对象中数据元素之间的相互关系。 1. 集合结构 集合结构就是数据元素除了同属于一个集合外没有其他的关系。 2. 线性结构 线性结构中的数据元素之间是一对一的关系。 3. 树形结构 树形结构中的数据元素之间是一对多的层次关系。 4. 图形结构 图形结构中的数据元素之间是多对多的关系。 物理结构是指数据的逻辑结构在计算机中的存储形式。 1. 顺序存储结构 顺序存储结构意思是把数据元素存放在地址连续的存储单元里,其数据间的逻辑关系和物理关系是一致的。 2. 链式存储结构 链式存储结构是把数据元素存放在任意的存储单元里,这组存储单元可以是连续的,也可以是不连续的。 算法是解决特定问题求解步骤的描述,在计算机表现为指令的有限序列,并且每条指令表示一个或多个操作。 1. 输入 2. 输出 3. 有穷性 4. 确定性 5. 可行性 1. 正确性 2. 可读性 3. 健壮性 4. 时间效率高和存储量低 这种方法主要是通过设计好的测试程序和数据,利用计算机计时器对不同算法编制的程序的运行时间进行比较,从而确定算法效率的高低。 这种方法是在计算机程序编制前依据统计方法对算法进行估算。 1. 用常数1取代运行时间中的所有加法常数 2. 在修改后的运行次数函数中,只保留最高阶项。 3. 如果最高阶项存在且不是1,则去除与这个项目相乘的常数。 以下是一些简单的例子。 线性表的顺序存储结构指的是用一段地址连续的存储单元依次存储线性表的数据元素。 1. 判断是否为空表。 2. 判断获取数据的下标是否在数组的范围。 3. 获取数组指定位置的数据。 1. 判断表是否已经满了。 2. 判断插入的位置是否正确。 3. 判断插入的位置是否在表尾,不在表尾就指定位置之后的数据全部后移一位。 4. 将数据插入指定位置,表长加1。 1. 判断表是否为空表 2. 判断删除的位置是否正确。 3. 判断删除的位置是否是最后一位,不是,删除的位置后面的数据全部前移一位。 4. 表长减一。 1. 从头查找,一直找到第i个结点 2. 计数到i就停止,返回数据 3. 没到i链表就结束了,就返回-1 1. 首先遍历到第i-1个结点 2. 然后创建一个结点,next指向第i个结点 3. 第i-1个结点的next指向新创建的结点 1. 首先遍历到第i-1个结点 2. 第i-1个结点的next指向第i个结点的next 3. 释放第i个结点 - 结点拥有的子树数称为结点的度,度为0称为叶结点,树的度是整个树度的最大值 - 树中结点的最大层次称为树的深度或高度 - 如果树中的结点的各个子树看成从左到右是有次序的,就称为有序树,反之为无序树 - 前序遍历 先访问根节点,然后前序遍历左子树,再前序遍历右子树。 - 中序遍历 先中序遍历左子树,然后访问根节点,再中序遍历右子树。 - 后序遍历 先后序遍历左子树,再后序遍历右子树,然后再访问根结点。 - 层序遍历 从上到下,从左到右的顺序访问结点。 1. 输入根节点数据 2. 递归创建左子树,递归创建右子树 1. 判断是否为空结点 2. 打印根节点数据,递归左子树,递归右子树 1. 判断是否为空结点 2. 递归左子树,打印根节点数据,递归右子树 1. 判断是否为空结点 2. 递归左子树,递归右子树,打印根节点数据 - 知道前序遍历的顺序和中序遍历的顺序可以确定一颗二叉树 - 知道中序遍历的顺序和后序遍历的顺序可以确定一颗二叉树 - 知道前序序遍历的顺序和后序遍历的顺序是不可以确定一颗二叉树的","url":"/posts/79666db/","category":"我的技术学习物语果然有问题","date":"2020.10.23","dateTime":"2020-10-23T00:00:00.000Z"},{"title":"YAML基本语法","description":"记录一下Yaml的语法","content":"注意冒号后面的空格是一定要有的,YAML语法对空格是十分敏感的,而且是用空格来控制层级关系,就比如下面这个例子。 这就表示server这个配置有两个子配置,这两个子配置是port和path,它们都在同一个层级,主要是看首字母的列数,子配置的首字母列数是不能在父配置的左边的比如下面的这个列子就是错误。 :::note{type=\"warning\"} YAML对大小写敏感,所以不要弄错大小写。 ::: 1. 值为数字,字符串或者是布尔类型 字符串默认是不用加引号的,也可以加上,单引号包括是换转义特殊字符的,而双引号不会,就比如经常写的\\n换行等字符。 2. 对象和Map 3. 数组","url":"/posts/bc6b6e0d/","category":"我的技术学习物语果然有问题","date":"2020.10.20","dateTime":"2020-10-20T00:00:00.000Z"},{"title":"SpringBoot","description":"学习SpringBoot的笔记","content":"SpringBoot是一个全新开源的轻量级框架。它基于Spring4.0设计,进一步简化了Spring的配置,更加简单的完成整个搭建和开发。 https://martinfowler.com/articles/microservices.html 可以去官网去创建一个springboot的项目(用idea自带创建也是通过官网创建的),配置什么的自己选择,注意要添加一个Spring Web的依赖,不然不能用作Web开发,然后GENERATE下载项目到本地,用idea导入项目就可以了。 在项目自带的Application类的同级目录下(一定要同级目录,不然SpringBoot无法扫描到你写的类)创建包和类,现创建一个Hello的类。 然后通过Application类来运行,然后打开你的 就能看到HelloWorld了。 分析一下我们的第一个SpringBoot程序。 1. 父项目 2. 导入的Spring Web的依赖 :::note{type=\"info\"} spring-boot-starter,SpringBoot的场景启动器。那什么是场景启动器呢?在SpringBoot框架中,开发者已经帮我们模拟了很多个使用SpringBoot的开发场景,并将这些场景需要的依赖和配置全部写入到这些场景启动器当中。比如我们现在是开发web的场景,我们就导入了这个Spring Web的依赖,主要就是这个spring-boot-starter-web的web场景启动器,里面都是我们开发web需要的依赖以及一些配置。 ::: > @SpringBootApplication这个注解标注了这是SpringBoot的主配置类,SpringBoot通过这个主配置类的main方法来启动这个SpringBoot的应用。查看里面的源码就会发现这个注解是由很多注解组成的,下面详细分析一下。 这个注解表示这个类是一个SpringBoot的配置类,点开里面发现还有个**@Configuration**注解,这个注解表示这是个Spring的配置类。 在点开就发现了这个**@Component**,所以发现这个配置类是容器的一个组件。 这个注解告诉了SpringBoot要开启自动配置功能。 **@Import(AutoConfigurationImportSelector.class)**这是导入组件的选择器,会给容器导入很多这个场景所需要的所有组件并配置号这些组件。 **@AutoConfigurationPackage**这个注解表示自动配置包,点进去发现有一个这样的注解 这个注解是Spring的底层注解,@Import指定了AutoConfigurationPackages.Registrar.class这个类给容器导入一些组件。 **所以这个@EnableAutoConfiguration就是将主配置类同目录下的包与类的所有组件扫描到Spring容器里面,这就是为什么一定要在同目录下创建包与类,因为不同目录就不会扫描得到。** 1. static文件夹 保存静态资源的文件夹,比如js,css文件等。 2. templates文件夹 保存模板页面的文件夹,因为SpringBoot默认jar包嵌入式的Tomcat,所以不支持JSP页面,所以需要用到模板引擎来配置页面。 3. application.properties(application.yml) SpringBoot的配置文件(名字是固定的不能修改),因为SpringBoot已经帮我们配置好了很多配置,想要修改这些默认配置就需要在这个配置文件自己修改,这个配置文件由两种形式,properties和yml形式。 > 1. application.properties的格式是 key=value > 子配置就用点,比如service下的port配置就表示为service.port=value > 2. application.yml的格式是 key: value 注意有空格,因为yml文件对空格很敏感, > 具体语法可参照YAML语法,之后就用yaml的这种格式来写配置文件 首先先写个需要注入值的类。 :::note{type=\"info\"} 1. @Component表示这是spring的组件,会被注入到spring的容器中进行管理 2. @ConfigurationProperties(prefix = \"user\")表示绑定配置文件中的user的配置,这样就可以进行值的注入了 ::: 然后导入一个配置文件处理器的依赖(不导入会爆红虽然没影响),可以去配置文件注入值了。 这样就可以成功的将值注入了,可以去测试类进行一下测试。 得到答案 在上述的示例当中,要是总是把注入的值都加进全局的配置文件中就会显得很乱,所以可以新建一个文件在通过@PropertySource标签导入进去也可以实现值的注入,这样application.properties中就可以不用写user的值了,值都写在user.properties即可。 :::note{type=\"info\"} 注意@PropertySource这个标签导入的是properties的文件,yml文件会出问题。 ::: 这个标签是用来导入spring的配置文件到springBoot中的(即xml格式) 这个标签的功能与@ImportResource类似,也是为了导入配置,给容器添加一个组件的。比如写一个配置类。 :::note{type=\"info\"} 1. @Configuration 表示这个类是一个配置类,就像是一个spring的配置文件 2. @Bean 将方法的返回值注入到容器之中,类似spring配置中 注入bean的操作,方法名就是这个bean的id。 ::: 首先就是主要的配置文件application.properties,创建多文档的方式就是按照application-[name].properties的形式命名创建在resources目录下。就比如我创建了一个测试环境的配置,命名为application-dev.properties 这个就很方便了,直接在application.yml中就可以创建多个文档配置了。只要通过---就能将配置文件分成不同的文档配置,通过spring.profiles: [name]这个配置就能为这个文档配置取个名字了。 在主配置文件,即application.properties下增加这个配置,就可以激活相应名字的文档配置文件。 yaml形式也是通过这个配置spring.profiles.active=dev,就能激活相应名字的文档配置文件。 1. 命令行 比如在打了jar包之后,在命令行运行jar包的时候增加配置就能激活指定配置文件生效。 2. 虚拟机参数 修改虚拟机参数也可以修改。 配置文件的优先级由高到低分别为: 1. 项目路径下的config文件夹中的配置文件 2. 项目路径下的配置文件 3. 资源路径下的config文件夹中的配置文件 4. 资源路径下的配置文件 springboot会通过优先级来加载配置文件,要是有不止一个配置文件,springboot也是会全部加载这些配置文件。对于设置了相同的配置,优先级高的配置文件设置的就会覆盖掉优先级低的配置文件的设置。就比如每个配置文件都设置了不同的打开端口,就会以优先级高的配置文件的为准。其他不冲突的配置也是生效的。","url":"/posts/6f2612a2/","category":"我的技术学习物语果然有问题","date":"2020.10.15","dateTime":"2020-10-15T00:00:00.000Z"},{"title":"第十一届蓝桥杯第二次模拟赛","description":"第十一届蓝桥杯第二次模拟赛","content":"第一题没什么难度就是计算,1MB=1024KB,1KB=1024Byte,所以直接计算器,答案为13,107,200 边数最多,那就是有向完全图了,所以根据数据结构的知识,含有n个节点的有向完全图,边数为n*(n-1)。所以答案为4074342。 这明显就是全排序的题目,所以用全排序的算法就可以得出结果。 我一开始看到这填空题才是七个数的全排列,就直接笔算了,全排列后的种数为7!。因为题目里的这七个字母有两个是一样的,所以全排列后除2就可以得到答案2520。 第二种是在网上看到的灵感,就是先实现全排列,然后加入到set集合里去重,最后也可以得到正确答案。 这道题我一开始看的想法就是左括号和右括号看成0和1,然后直接枚举暴力破解,因为第一个肯定是左括号,最后一个肯定是右括号,所以输出了64种,一种种排除几分钟也能得到正确答案14种。 > 这种方法比较蠢,上了几个for循环,我就不放代码了。 在网上找到的一种方法。这其实是卡特兰数的一种应用(可以去百度了解一下) 。 S(n) = S(0)S(n-1) + S(1)S(n-2) + ..... + S(n-1)S(0) 所以就可以直接套公式了。 - 当有0对括号的时候,有1种序列 - 当有1对括号的时候,有1种序列 - 当有2对括号的时候,有2种序列 - 当有3对括号的时候,有5种序列 所以代进去就能得到答案为14,代码如下。 这题也没什么技巧,最大的数据也只有1000000,所以一个for循环加个if判断语句就可以暴力破解了。 凯撒密码从c敲到Java,常见的题,我不是太清楚这个单词的结构,我默认它是一长串连续的字母组成的字符串,没有空格。 这个题目难点就是求出这个数组,我们可以螺旋递增来求出这个数组,然后再输出r行c列的值就好了。","url":"/posts/16bca3f0/","category":"我的技术学习物语果然有问题","date":"2020.10.15","dateTime":"2020-10-15T00:00:00.000Z"},{"title":"SpringMVC执行原理","description":"SpringMVC的执行原理","content":"1. 前端控制器(DispatcherServlet) 前端控制器就是用来处理请求的中心,接收请求和响应结果都是由它控制的,也算是springmvc里的中心枢纽。 2. 处理器映射器(HandlerMapping) 处理器映射器根据请求里的url来查找相应的处理器,即用来寻找处理器的。 3. 处理器(Handler) 处理器是进行业务操作的。 4. 处理器适配器(HandlerAdapter) 会把处理器包装成适配器,这样就可以支持多种类型的处理器,类比笔记本的适配器(适配器模式的应用) 5. 视图解析器(ViewResovler) 即对返回来的视图进行解析,将代码解析成为对应的视图 1. 用户发送请求,即在浏览器上输入url,DispatcherServlet会接收请求。 2. DispatcherServlet收到请求后就会调用HandlerMapping来寻找需要的Handler。 3. HandlerMapping找到Handler后就会返回给DispatcherServlet。 4. 前端控制器DispatcherServlet收到Handler后就会调用HandlerAdapter对Handler进行处理。 5. HandlerAdapter经过适配调用具体的Handler(Controller,也叫后端控制器)。 6. 执行完毕后就会将一个ModelAndView返回给HandlerAdapter。 7. HandlerAdapter将ModelAndView返回给DispatcherServlet。 8. DispatcherServlet将调用ViewReslover来解析这个ModelAndView。 9. ViewReslover解析ModelAndView后返回具体View给DispatcherServlet。 10. DispatcherServlet根据这个view就会渲染出所需要的页面。 11. DispatcherServlet将这个页面返回给用户,用户获取结果。 1. 首先在web.xml里注册的就是DispatcherServlet前端控制器,用户发出的请求(即输入url)先到的是这里。 ::: info 这里DispatcherServlet收到请求就会获取有用的信息,就是将url拆分。 就比如我输入的url,https://localhost:8080/helloSpringmvc/hello 就会拆分为三部分 1. localhost:8080,这是tomcat开放的端口。 2. helloSpringmvc,这个就是访问的你的项目名(可以自己更改),即tomcat的webapps下的helloSpringmvc文件夹。 3. hello,即为控制器的id ,发出请求输入ur就是为了找到这个控制器。 ::: 2. 然后经过关联的配置文件,即resource下的springmvc-servlet.xml。 3. springmvc-servlet.xml先是注册了HandlerMapping处理器映射器和HandlerAdapter处理器适配器,springmvc自动帮你调用这两个组件。 4. 在springmvc-servlet.xml注册的Handler控制器,这样DispatcherServlet就可以通过这里找到这个hello控制器,然后DispatcherServlet将该控制器交给HandlerAdapter进行处理该Handler所包含的业务逻辑,这里就是HelloController类里的业务操作。 5. HelloController中调用了Controller接口,即可以理解这就是mvc架构中Controller层,在这个类进行我们的业务逻辑操作,因为在springmvc中Control层的数据要交给DispatcherServlet处理的,所以返回了一个包装好的ModelAndView,Model存储数据,View存储视图。 6. DispatcherServlet收到包装好的ModelAndView后,通过注册的视图解析器进行解析渲染视图。 ::: info 这里就是对控制器进行拼接,比如hello控制器,加上前缀与后缀就成为了/WEB-INF/jsp/hello.jsp,然后就会在web目录下找到该视图进行跳转。 ::: :::note{type=\"success\"} 结合springmvc中第一个springmvc程序来看。由此可以看出springmvc帮我们做了很多事情,我们只需要配置好那几个重要的组件,然后编写业务逻辑和视图就能完成对于一个控制器的工作。 ::: 1. https://www.cnblogs.com/xiaoxi/p/6164383.html","url":"/posts/7a197da5/","category":"我的技术学习物语果然有问题","date":"2020.09.22","dateTime":"2020-09-22T00:00:00.000Z"},{"title":"IntelliJ IDEA的优化配置","description":"将IDEA配置好可以很大程度的提升你的学习体验。","content":"闲着没事升级了一下我的idea,现在版本为2020.1.3,顺便记录一下idea的配置与优化,方便以后再改。 一个好的主题会让你喜欢上idea,所以可以去换一个喜欢的主题,体验超好。网上有很多去下载就好了,我就不放地址了。 点击下载一般都会下一个jar包,随便找个地方放就好。 然后在idea里的File -> Manage IDE settings -> import settings,把jar包导进去重启就好了。 1. idea主色配置 File -> Settings -> Appearance & Behavior -> Appearance > 这个看个人喜欢了,我用多了还是深色的好。 2. 自动导包 File -> Settings -> Editor -> General -> Auto Import > 这个就不用多说了吧,自动导包还是很方便的。 3. 字体缩放 File -> Settings -> Editor -> General,勾选第一个选项。 > 然后按着CTRL+滑动滚轮就可以控制字体大小了,很好用的。 4. 大小写不敏感 File -> Settings -> Editor -> General -> Code Completion,取消第一个的勾选。 > 这个就会让你在打错大小写的情况下还会提醒你。 5. 设置背景图片 File -> Settings -> Appearance & Behavior -> Appearance 6. 取消自动打开项目 File -> Settings -> Appearance & Behavior -> System Settings,取消第一个勾选 > 取消了之后就不会每次打开idea就会进入到上次关闭的项目了,当然这个看个人喜好。 7. 显示方法分隔线和行号 File -> Settings -> Editor -> General -> Appearance,勾选上选项。 > 这个会让方法与方法之间出现分隔线,左边出现行号。 8. 快捷键更换 File -> Settings -> Keymap > 有些人习惯了Eclipse的快捷键,从这里就可以改成Eclipse的,下面的快捷键也可以自行修改。 9. 设置方法模板 File -> Settings -> Editor -> Live Templates > 方法模板可以在下面设置,不过比较常用的就是psvm和sout生成主方法和输出语句,第一个选项就是输入了sout之后点空格就会生成模板,我比较喜欢空格,自行选择。 10. 类模板的设置 File -> Settings -> Editor -> File and Code Templates -> Class > 这段注释就是生成类自动帮你生成的模板,可以自行修改。 File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven > 第一个是maven所在位置,第二个是maven里的配置文件setting.xml的位置,第三个是maven-repomaven里的仓库文件夹的位置。 用idea就不能少了插件,插件可以让你的体验在上升一个档次哦。 1. 在idea上直接安装 File -> Settings -> Plugins,直接搜索名字就好了。 有时候有些插件会下载很慢,可以直接去官网下载。 2. 官网下载离线插件 官网地址----> 下载之后点这里导入插件就好了。 1. CodeGlance 安装了这个插件就会在idea右侧生成一个代码地图,用过Vscode都应该知道这个的好处。 2. Translation 顾名思义,一个翻译插件,可以帮你在IDE里翻译源码和控制台的一些不会的英文语句,挺方便的。 3. Rainbow Brackets 彩虹括号,让你的每个括号都带上颜色,一对括号一个颜色,好看又能让你快速分辨。还有更多用法可参照官方文档 4. Chinese 其实这个我不用,idea中文插件,用中文没得灵魂。 5. Grep Console 日志配色。 6. Alibaba Java Coding Guidelines 阿里巴巴代码规范,提醒你不规范的地方","url":"/posts/dcaabd92/","category":"我的技术学习物语果然有问题","date":"2020.07.11","dateTime":"2020-07-11T00:00:00.000Z"},{"title":"SpringMVC","description":"SpringMVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架。","content":"Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架,它是Spring的一部分,它和Struts2一样都属于表现层的框架。 > MVC可参考之前的文章 mvc架构 1. 新建一个maven项目,取个名字一路next即可。 2. 添加web的支持 3. 在pom.xml导入依赖 4. 在resources下创建配置springmvc的配置文件,我这里是springmvc-servlet.xml 5. 配置web.xml 6. 在Java文件夹下创建HelloController 7. 然后在WEB-INF的jsp的文件夹下创建hello.jsp文件,显示msg的信息 8. 配置tomcat启动就好 结构的目录为 跳转至该文章。springmvc执行原理 > 与上面的第一个Springmvc程序来对比 1. 首先是sprngmvc的配置程序 > 1. \\ > > 因为之前配置DispatcherServlet的时候配置了拦截方式为“/”,故包括了静态资源,所有springmvc会将静态资源的请求当成是普通的请求,所以会找不到对应的处理器而导致错误。这条语句将把静态资源和非静态资源的请求分开,从而避免错误。 > > 2. \\ > > 这个帮我们注册了很多的类 ,包括之前的BeanNameUrlHandlerMapping和SimpleControllerHandlerAdapter,并告知spring,启用了注解。 2. 然后是Controller类 3. web.xml用之前的就好,再写jsp页面就可以运行了。 ::: success springmvc-servlet.xml和web.xml基本都是不用怎么改变的,除了改一些路径。 ::: 1. **@Controller** 告诉spring该类为一个控制器,并交给spring来托管 2. **@RequestMapping** 在SpringMvc的配置文件下注册了视图解析器,即下面的这段代码,就可以通过视图解析器来进行转发。 :::note{type=\"warning\"} 因为实质是servlet,所以是可以直接使用servlet的方法的,但是不推荐这么使用,过于繁琐。 ::: :::note{type=\"info\"} 前缀的优先级是比视图解析器大的,有前缀的前提下是不经过视图解析器的,建议还是注册视图解析器,转发不用前缀,重定向使用前缀进行。 ::: 1. 通过url相同的参数名获取数据 2. 通过url不相同的参数名获取数据 3. 通过url来获取一个对象 1. 首先创建一个实体类 2. 获取对象 1. 使用ModelAndView 2. 使用Model 3. 使用ModelMap :::note{type=\"info\"} Model其实是一个接口实现类,一定程度上是继承了ModelMap,因为Model的实现也是要用到ModelMap的方法的,而ModelMap继承了LinkedHashMap,所以方法比Model多一些。 ::: 1. 添加jackson-databind的依赖 2. 实体测试类 3. Controller类 :::note{type=\"warning\"} 注意的是新加依赖要刷新project setting里的lib目录,不然没添加会直接500报错 :::","url":"/posts/ae0f95e0/","category":"我的技术学习物语果然有问题","date":"2020.07.07","dateTime":"2020-07-07T00:00:00.000Z"},{"title":"Ngrok内网穿透","description":"Ngrok内网穿透就是让外网也能访问内网IP。","content":"ngrok 是一个反向代理,通过在公共的端点和本地运行的 Web 服务器之间建立一个安全的通道。ngrok 可捕获和分析所有通道上的流量,便于后期分析和重放。 内网穿透意思是能让外网访问到你本地,就比如你在本地运行tomacat等,外网是无法访问到你本地的项目的,当然你部署到服务器上就可以,这篇文章只是为了简化你的操作,而且你应该不会什么测试都部署到服务器,所以就能使用ngrok实现内网穿透。 先去官网注册一个用户,然后登陆。 国内Ngrok的地址:https://www.ngrok.cc/ 这个是免费的,当然你想体验更流畅那就付费呗。 把你的隧道ID输入就好了 然后你就能用赠送的域名访问到你的内网了。 这只是个简单的穿透,不过也挺有用的,能让外网访问到你的本地项目,在一些时候能很方便。你不想用他的域名,应该是可以解析的,解析成你的就好。","url":"/posts/4a19524b/","category":"我的技术学习物语果然有问题","date":"2020.07.03","dateTime":"2020-07-03T00:00:00.000Z"},{"title":"AOP","description":"AOP是spring的另一个核心,是oop的延续。","content":"Spring 是一个轻量级的IOC和AOP的框架,spring的两大核心就是IOC和AOP,IOC我之前写有,那什么是AOP呢?首先先看一下百度的定义。 > 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。 AOP,面向切面编程,这又是一种新的思想。一开始我们接触的是面向过程,比如c语言。然后是面向对象编程oop,一系列的面向对象语言,比如Java。学到后面就发现,面向对象也不能满足人们了,就出现了面向接口编程,但人总是懒得,这又出现了面向切面编程。面向切面顾名思义,把一个程序一刀切就出现了切面。怎么理解呢。就比如我们得业务,实现增删改查,一开始的我们是这样的。 这时候人们想增加一个功能,比如日志,就会变成这样 人们会发现这样会重复写了一段代码,当很多业务方法都需要加上日志这个功能的时候,就会多写很多的代码,为了简便,人们就想到了 增加一个类来实现日志就好了,就比如这样 但是每一个方法都要加多一段代码来调用日志的方法,这样也是很麻烦的,如果要有很多很多的方法,一个一个的加不仅会破环原方法的代码,还会很繁琐。 所以出现了我们面向切面开发的AOP。 > 这样大概就能理解什么是面向切面编程了吧。我们为了实现功能的操作,都可以理解为一条直线,从中切一刀,插入一个功能,该功能还能切入其他的方法,就这样便减少了代码的重复性,也减少了耦合。 通知可以理解为你需要实现个功能,就比如上述例子的日志功能。 连接点就是你可以你可以使用通知功能的地方,就比如增加操作的前后都是可以增加日志功能的,方法前后都是连接点。 切入点就很好理解了吧,上述的日志功能横穿两个方法,交点就是这个通知的切入点,这个交点也是连接点。其实切入点就是连接点,连接点是你能够使用通知的地方,这些地方会有很多,但你不会所有都用,有些地方你就不会去使用通知的功能,你用通知的连接点才是切入点。 切面其实就是通知和切入点的结合,这两者结合就把一个方法切出一个面,所以叫切面。 引入的意思就是把切面用到目标里。比如查询需要引入日志这个通知,就是把查询这个功能也切一刀。 目标其实就是指需要添加通知的对象,就是刚刚所说的那条线。 看到这其实就发现AOP与之前所说的动态代理很像,整个的AOP实现其实都是通过代理来实现的,没了解过动态代理的可以去参考一下我之前的文章。 把切面应用到目标对象来创建新的代理对象的过程。有3种方式,spring采用的是运行时。 刚刚也说到了,AOP其实就是通过动态代理来实现的。spring用代理类包裹切面,把它们织入到Bean中,从而代理类代替原有的类拦截了方法的调用,拦截了方法的调用然后改代理类又实现了一些附带的功能,然后再把方法调用转发给Bean,从而实现了AOP。 怎么拦截就是代理的问题了。动态代理分为两种,一个是基于接口的动态代理,就是JDK的动态代理,另一个便是基于类的代理,就是使用cglib的动态代理。 1. 基于接口的动态代理 目标类和代理类都实现了同一接口,但不同的是代理类能会实现一些附带的功能,目标类只是代理类的一部分,虽然最后都是目标类完成接口的功能,但代理类不同于接口的方法就可以插入到目标类实现接口方法的前后,这就实现了AOP。就像是代理类里有两兄弟,实现了接口的那些方法就是哥哥,而实现了不同于接口方法的其他功能就是弟弟,当人们想要完成接口的方法的时候,弟弟虽然办不到,但是他招待了你(就是意义上的拦截),你以为他是能实现接口的哥哥,便把任务给了他,弟弟答应了又顺带收了你的钱(即附加的功能,比如日志),然后弟弟知道自己不能做这个任务,便让哥哥实现,这就是JDK的动态代理实现AOP的方式。 2. 基于类的动态代理 基于类那就更加好理解了。目标类就像是父亲,而继承了目标类的代理类就是儿子。人们都找儿子去实现接口的功能,但是儿子在完成接口的任务之前或者之后都会做一些其他的事(即附加的功能,比如日志),所以这就是cglib的动态代理实现AOP的方式。 这两篇还是很好理解的,此文就是借鉴两文然后加上我自己的理解写成的。 - https://blog.csdn.net/qukaiwei/article/details/50367761 - https://blog.csdn.net/q982151756/article/details/80513340","url":"/posts/92933cdb/","category":"我的技术学习物语果然有问题","date":"2020.06.30","dateTime":"2020-06-30T00:00:00.000Z"},{"title":"代理模式","description":"代理模式顾名思义就是为一个对象提供一个代理,并让其他对象通过代理对象来控制这个对象。代理模式又分为两种,一种叫静态代理,一种叫动态代理。","content":"代理模式顾名思义就是为一个对象提供一个代理,并让其他对象通过代理对象来控制这个对象。代理模式又分为两种,一种叫静态代理,一种叫动态代理。 1. Isubject 抽象角色,一般使用接口和抽象类,不过抽象类不怎么好用,大多都是接口。 2. RealSubject 真实角色,被代理的角色。 3. Proxy 代理角色,代理真实角色 光用文字描述,会觉得十分的绕,还是用代码来讲解一下吧。首先先模拟一下环境,比如买火车票这件事情。卖火车票这件事情就是一个抽象角色,我们为它创建一个接口。 有买票的人也就会有卖的人,这里是卖票的设为火车站。这样的话火车站就是一个真实角色,为它创建一个类。 那么问题就来了,我们学生需要买票回家,是该怎么买呢?应该不会有多少人去到火车站买票吧。大多都是网上订票吧,就比如使用软件买票,方便也快捷,这个软件就是一个代理角色,代理了火车站卖票。我们也为他创建一个类。一般代理都会有很多特定的作用,即附属一些其他的方法,就比如使用软件卖票会十分方便。 好了,那就模拟一下我们买票的过程吧。比如我们通过软件就能看到火车站在卖票,然后在软件上买票,这样就不用去到火车站在买票了,也就是我们不需要使用真实角色的卖票方法,使用的是代理对象的卖票方法,代理对象就会帮我们去真实对象中调用想要的方法(代理对象有点类似中介)。 上述是我们日常生活中一个小小的例子,可能没能够体会到代理模式的好处,我们来看看项目中的一些简单实现吧,比如经常见到的增删改查操作。首先是业务接口和接口实现类。 这是没有代理角色的情况,我们也可以直接创建userServiceImpl对象调用里面的方法,但是要是之后需要了增加一些业务需求,比如增加一个日志功能,我们常规就是直接修改userServiceImpl类,比如这样 这只是四个增删改查的操作,你都会发现这样很麻烦,要是再加几个功能,或者再加几个操作,难道还要一个个改吗?这时候用代理就能很好的解决这种问题。那我们先创建这个代理类。 > 当然有人会觉得代理也没差多少,也是挺麻烦的,都是需要手动添加很多代码,但代理模式可以更加方便地拓展,比如需要加功能就再添加一个方法,不用总是改接口实现类里的方法,代码一多就能感受到代理模式的方便了,随便改源码不是一个好的习惯。 静态代理大概了解了,就能发现静态代理会有一个很大的问题。当需要代理的类多了,就会发现代理的类也会增多,因为静态代理是一个类绑定一个代理类的,这就很麻烦取管理了,因为代理类的创建就是为了方便,所以动态代理就出现了。动态代理的代理类是动态生成的,我们写好一个工具类就能动态生成很多类的代理类了。 > 动态代理分为两大类。 > > 1. JDK动态代理 > 2. CGLib动态代理 JDK动态代理是Java自带的一种动态代理的方式,核心原理就是通过反射来实现的。首先要实现JDK的动态代理就要先了解一个类和一个接口,直接看文档的说法。 1. Proxy Proxy提供了创建动态代理类和实例的静态方法,它也是由这些方法创建的所有的动态代理类的超类。这里也不深入了解了,只要了解它主要的一个方法,生成动态代理类的方法。 > Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), > new Class [] { Foo.class }, > handler); 2. InvocationHandler 每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时,方法调用将会被编码分派到其调用处理程序的invoke方法。官方说法有点绕,简单来说是这个接口就只有一个invoke方法,这个方法是处理被代理实例即真实角色的,并会返回一个结果。 > public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; 大概了解了这两个类,就可以写一个生成动态代理的工具类吧。(基本固定,可以当作万能的工具类) 写完了代理类就来写测试一下吧,例子就选之前的那个增删改查的接口吧。 当我们需要添加功能的时候,比如添加一个日志的功能,就改写一下工具类就好了。","url":"/posts/7b510e10/","category":"我的技术学习物语果然有问题","date":"2020.06.28","dateTime":"2020-06-28T00:00:00.000Z"},{"title":"环境搭建手册","description":"总结一下环境的配置,比如导入依赖","content":"为了以后更好的做个cv工程师,所以现在总结一下配置。 - **IntelliJ IDEA 2020.2.2** - **Mysql 8.0.18** - **Tomcat 9.03.5** - **maven 3.6.1** - **jdk 1.8** 官方的: 自我优化的,数据库属性自己修改: 1. 在pom.xml里导入依赖 2. 在application.xml里导入aop约束 由于SpringBoot比较特殊,他的配置用的很多,而且大多都是关于整合其他的依赖来使用,所以这里就只是简单的做一个目录,具体的整合细节都移步到文章中好了。 因人而异,此处我使用了阿里脚手架上比较标准的一套配置文件。 指路整合JDBC 指路整合Druid 指路整合Mybatis 指路集成Swagger2 指路集成Swagger3 指路Mybatis-Plus 指路Shiro 指路整合Redis 指路Redis的学习 指路结果类封装 指路异常处理","url":"/posts/419e09e5/","category":"我的技术学习物语果然有问题","date":"2020.06.27","dateTime":"2020-06-27T00:00:00.000Z"},{"title":"Spring5","description":"Spring 是一个轻量级的控制反转(IOC)和面向切面(AOP)的框架","content":" Spring是Java EE编程领域的一个轻量级开源框架,该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建,是为了解决企业级编程开发中的复杂性,实现敏捷开发的应用型框架 。Spring是一个开源容器框架,它集成各类型的工具,通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中,各类型的功能被抽象成一个个的 Bean,这样就可以实现各种功能的管理,包括动态加载和切面编程。 > Spring 就是一个轻量级的控制反转IOC和面向切面AOP的框架。 参考网站: - 官网 - 官方下载地址 - GitHub地址 1. 创建一个maven项目 2. 在pom.xml里导入依赖 3. 创建一个类,比如我的HelloSpring类 4. 在resources资源目录下配置applicationContext.xml 5. 测试类 为创建的对象起别名,即为bean的id起别名 以上面的例子为例 :::note{type=\"success\"} id为bean的标识符,即创建的对象名 class为对象对所对应的类名,注意是全限定名 name为别名,与alias差不多,可以起多个别名 property属性,为str这个参数赋值 ::: 合并xml配置文件。 依赖注入DI,具体说法可参考我之前写的有关IOC的文章 1. 使用无参构造器创建对象 这种是Spring默认的创建对象的方式,在上述的Spring例子当中,HelloSpring的bean创建对象是用的无参构造器,若没有了无参构造器就会报错。 2. 使用有参构造器创建对象 - 下标 - 类型 - 参数名 > 当bean被注册,加载到该配置文件,即使没有用到这个对象,也会生成。 注入到对象中的属性,例如我的这个例子。 1. 基本数据类型和String类型的注入 2. 引用类型的注入 3. 数组的注入 4. List的注入 5. Map的注入 6. Set的注入 7. null注入即空值注入 8. Properties的注入 :::note{type=\"info\"} 注入的时候是通过你创建的set方法注入的,所以创建类的时候要写上set方法,养成习惯get方法也写上,为了更好的测试,就重写toString方法 拓展方式注入 ::: 想要使用这种方法,先得在bean元素上加入p的命名空间,如下 :::note{type=\"info\"} 这种方式的注入是简单类型的注入,引用类型也可以,类似set注入,但能支持注入的类型少。 ::: 类似P命名空间,用前需要在bean元素上加入c的命名空间,如下 :::note{type=\"info\"} 这种方式的是通过构造器注入的,想要注入的属性就要存在这样的有参构造器。注意因为创建对象要用到无参构造器,所以不要漏写。 ::: 单例模式是指每次创建的bean都是同一个,这也是Spring默认的模式,比如 > 单例模式表示bean只会创建一个对象,每次get的都是同一个 原型模式就和单例模式相反,每次get的都不是同一个。 > 原型模式表示每次创建的bean都不是同一个对象 首先为了更好的测试,先创建两个类,之后的例子就从这两个类中测试。 > 自动装配是从bean的autowire属性配置的。 byName的自动装配是从类中寻找具有相同属性的类,然后装配到bean里,比如在User中有Score类创建的对象,而且有set方法,所以可以自动将Score的对象装配到User类里。 :::note{type=\"warning\"} 是按照User类里的Set方法寻找的,比如Score类在bean里注册的id为score,那User类里就要有setScore这个set方法,将set去掉,首字母小写,然后与id对应一致才能找的到,这是byName的自动装配。 ::: :::note{type=\"warning\"} byType是寻找类里属性类型相同的bean,所以不关id的事情了,id都可以省略。弊端就是当一个类注册了两个bean的时候,byType不知道选择哪一个就会报错。 ::: 首先想用注解先要导入context约束和注解的支持,如下 @Autowired注解 这个注解可以放在属性名上,也可以放在set方法上,放在属性名上,连set方法都可以不用写,当然是引用的类里要有set方法。 > @Autowired里面有个属性是required,默认为true,表示不能为空值,可以手动关闭@Autowired(required = falser)。 :::note{type=\"info\"} @Autowired是通过byType模式来寻找的,若是一个类有多个bean才会选择用byName来自动装配。 要是多个bean的id都不符合byName的时候,就需要使用@Qualifier(value=\"id\")来配合使用,value的值为哪个bean的id,就使用哪个bean自动装配。 ::: 想使用注解来进行开发,先要确定好自己的配置。 1. 导入aop的包(之前导入的依赖包含了aop的包),注解使用不了就确定一下有没有aop的包导入 2. 导入context的约束,开启支持注解 3. 还要指定扫描的包,是包里的注解生效,比如例子的包 在xml中注册bean 使用注解来注册bean :::note{type=\"success\"} 使用了@Component注解,会将这个类装配。可以指定id,在没有指定id的时候,这个类的bean的id就是当前类名首字母小写的字符串。 指定id可以这样写到@Component(\"xxx\")。 ::: :::note{type=\"info\"} @Component 的三个衍生注解,在 web 开发中,会按照 mvc 三层架构分层。 - dao 层@Repository - service 层@Service - web 层@Controller 这四个注解功能都是一样的。 ::: :::note{type=\"success\"} 属性注入可以使用@Value(\"\")的注解,当然简单的才会使用注解,复杂一点的注入还是xml配置注解好一点。 ::: 就是之前得用注解实现自动装配 :::note{type=\"success\"} 作用域可以使用@Scope(\"“),里面是模式,常用的就是singleton和prototype,默认也是singleton。 ::: 先看demo吧 1. 用户类 2. Java配置类 3. 测试类 > 一个个分析吧。 > > 用户类没什么区别,主要是Java配置类。 > > @Configuration表示这个类是个配置类,类似于xml。 > > @Bean表示bean的配置。方法名就相当于id。 关于AOP的介绍就放到另一篇文章里。AOP 这里就讲讲spring中AOP的具体实现。 首先要导入依赖,和aop的约束 1. 首先定义好 接口,并创建好真实对象,即接口实现类 2. 定义一个功能类 > method表示目标对象的方法,objects表示参数,target目标对象。实验的例子是使用MethodBeforeAdvice这个接口,即在目标方法调用之前调用的Advice通知。 > > MethodBeforeAdvice 前置通知 > > AfterReturningAdvice 后置通知,有返回值 > > MethodInterceptor 环绕通知 > ThrowsAdvice 异常通知 3. 然后就要在applicationContext.xml里配置了 > 这里来解析一下execution的表达式。* com.chen.pojo.userServiceImpl..* .*(..) > > 1. execution()为表达式主体,里面为表达式 > 2. 第一个 * 表示返回的类型,*表示任意类型的返回值 > 3. 表示需要拦截的包,即真实对象所在的位置 > 4. 包名后面的,,*表示当前包以及子包 > 5. 第二个 * 表示方法,*表示所有方法 > 6. (..)表示方法可以有任意的参数 4. 测试类 > 注意这里的用的是接口而不是实现类。 1. 定义接口和实现类,和上述一样 2. 定义一个通知类 3. 配置xml文件 > 这种方法还是不够好,简单的插入可以使用这种。 使用注解来实现跟自定义类实现其实差不多。 1. 定义接口和实现类,和上述一样 2. 定义通知类 3. 然后把这个类注册到spring里,并开启注解支持 > 开启注解支持还能设置动态代理模式 > > > 值为false表示使用JDK动态代理(默认),为true表示使用cglib动态代理 > 这个xml是可以代替原来Mybatis的配置文件,以后使用可以直接通过import导入就好了。 用Spring事务时先导入约束,如下 spring终于结束了,说实话spring相对Mybatis还是简单很多的,但细节还是挺多的,学了几天,前面又忘了,还是得多看看细节才行。emm,我的笔记也比较水,还有一些细节还没写出来,看得云里雾里得也挺正常,大概就看看复习一下就好了。end。下个框架见。 > 还没写完---","url":"/posts/7f09f5da/","category":"我的技术学习物语果然有问题","date":"2020.06.26","dateTime":"2020-06-26T00:00:00.000Z"},{"title":"IOC","description":"IOC是Spring的核心,想学好Spring就要了解IOC","content":"今天看了Iteye的开涛对IOC的理解,原文地址,对IOC的有了一些理解,所以来记录一下。 IOC全称为Inversion of Control,即为控制反转。IOC并不是一种技术,而是一种设计思想。怎样理解这种思想呢?就先从IOC的名称上看吧。IOC称控制反转,包含了两个重要的词语,控制和反转。理解IOC就可以从这两个词语去理解,是怎样的控制,怎样的反转。 在我们常规的JavaSE的设计思想来看,我们需要用到其他对象来是实现功能的时候,就会在当前类里new出一个对象来进行调用,进而实现自己想要的功能,这就是我们主动地创造了对象来使用。而IOC不一样,IOC思想是别人已经帮你创造好了一个IOC容器,这个IOC容器会帮你创建好你所需要的对象,你不需要自己去new对象,你只需要获取IOC容器中的对象即可。所以这个控制是指,IOC容器控制了对象,控制了你所需要的所有外部资源。 什么是反转,这个问题在对控制的理解里差不多能体会到。我们去创造对象来进行调用,这就是正转,而IOC这种思想就不是这样,它是反转过来的,是IOC容器来控制对象,我们只是接收容器传出来的对象,所以说是反转。 理解了控制和反转两个词语之后,就应该IOC是怎样的思想了。我们也可以举个简单的例子。假如你想要一个书桌来学习,按常规的设计思想来看,你就需要木材与工具,然后在做好这个书卓,然后在学习,这样来讲你是不是就会觉得这种思想在一定程度来说是挺蠢的。按IOC的思想来看,你需要一个书卓,你就只需要去家具店买就好了,家具店已经有做好的书桌给你。这么说应该就能理解了,家具店就像是一个IOC容器,你需要书桌,我就可以提供书桌给你,这就是IOC。 在我们常规的设计思想中,对象中创建对象,就会导致类与类之间的耦合度增高,从而让它们难以控制,而IOC的出现,人们不用自己创建对象,就能降低与类之间的耦合度,让程结构序更加的灵活,更好的测试。 > 耦合就类似钟表,钟表内每个齿轮都有着联系,当一个齿轮坏了,也会影响另一个,进而影响全部。所以类与类之间的耦合度高在一方面来看不算是什么好事,当代码多起来的时候,错一小处就会影响全局。 说到IOC,就不得不说到DI—Dependency Injection,即依赖注入。在了解了IOC之后,DI也就不难理解。有人认为DI是实现IOC的一种方法,其实差不多。依赖注入表示,程序需要依赖IOC容器提供创建的对象,在程序中需要一个对象,IOC容器就会创建好一个对象来注入到程序中,你只要使用这个对象就可以了,至于对象是什么时候创建的,怎样创建的,在哪创建的你都可以不用去管,你只需要使用这个对象去完成你所需要的功能就好了,这就是我理解的DI。 到此,应该对IOC和DI有自己的理解了,下面就通过一个小demo来加深一下理解。在常规的写法,要实现一个功能,会有dao接口,业务层接口和它们的实现类,最后使用业务层的实现类来实现这个功能。 一个功能是不能满足的时候,就会想着增加第二个功能,就需要这样做 当需要的功能多的时候,我们就会很难受,总是修改业务实现类,所以就出现了IOC这种思想来帮组我们解决这种问题。","url":"/posts/183e2cbd/","category":"我的技术学习物语果然有问题","date":"2020.06.23","dateTime":"2020-06-23T00:00:00.000Z"},{"title":"Javase","description":"这是我学习Java时候做的笔记,比较水。","content":"以前都是记笔记,每篇文章都很短而且很乱,现在学完很久了,有些东西都快忘了,最近又刚刚整完主题,所以索性就整理一下前面的文章,顺便整合起来复习一下。 :::note{type=\"success\"} 这是我学习JavaSE的时候记的笔记,文章较长,建议目录直接跳转 ::: 复习前先来看看什么是JavaSE,来看看百度百科是怎么描述的。(大概了解一下就好了) > Java SE(Java Standard Edition,Java 标准版)是Java技术的核心和基础,是Java ME和Java EE编程的基础 [1] 。Java SE是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台的总称。 学习Java的第一件事情就是要先配置好Java所需要的环境,不然运行不了还怎么学习。 JDK是Java语言的软件开发工具包,是整个Java开发的核心,它包含了Java的运行环境和Java工具,所以这个是必须要下载的。 :::note{type=\"info\"} 下载的版本就选Java8好了,不一定最新的就是最好的,当然最新的也可以。至于IDE嘛,喜欢哪个用哪个,我用的就是idea ::: 1. 此电脑,右键,点击“属性”,点击“高级系统设置”,点击“高级”下的环境变量,配置下面三个变量,有就添加变量,没有就新建变量 2. 分别配置好以下三个环境变量 - JAVA_HOME 路径就填JDK的安装路径 - PATH 路径填JDK命令文件的位置,即bin目录的位置 - CLASSPATH 开头输入**“.;”**,然后填lib目录的位置 配置完了之后就去检查一下有没有配置成功吧,以免之后出错。去cmd输入命令java-version,若有版本号出现就证明配置成功了。 时间不允许我写这么多了,所以我就跳过了一些基本知识,之后我在补(如果有机会的话)。 - 操作符 - 变量和常量 - 控制流程语句(for,if,while) > 这些是跟很多编程语言都是一样的,特别是和C,C++,所以我省了 方法也就是C语言里面的函数,也就是一段实现特定效果的语段。main方法就是主方法,程序的入口。 方法重载就在于方法名是一样的,参数列表不一样。 :::note{type=\"warning\"} 重载不是重写,这是两个概念,不要弄混了 ::: 递归的思想就是自己调用自己(套娃),比如下面这个求阶乘的方法。 成天都说Java是面向对象的语言。那什么是面向对象编程呢? > 面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式 大概了解一下就好了,Java是离不开类和对象的,所以之后就会感受到什么是面向对象编程。 类就是一个抽象的概念,对象就是从类里实例化出来的个体。之后的Java学习都要用到。现在就来定义一个简单的类。 上述的i和print()就本别是类属性和类方法。把类当作是一个整体,类属性就相当于是一个部件,类方法相当于部件实现的功能。 > 类属性和方法调用必须通过对象,比如demo类有个test对象,那就是test.i和test.print() 上述类,属性,对象都用public来修饰,public就是一个访问修饰符,访问修饰符是来设定权限的,设定谁才能使用这个类,以下是四种Java的访问权限。 | 访问级别 | 访问修饰符 | 同类 | 同包不同类(不含子类) | 同包子类 | 不同的包(不含子类) | 不同包子类 | | :------: | :--------: | :--: | :--: | :--: | :--: | :------: | | 公开的 | public | **√** | **√** | **√** |**√**| **√** | | 受保护的 | protected | **√** | **√** | **√** || **√** | | 默认的 | 什么都不加 | **√** | **√** | || | | 私有 | private | **√** | | || | 如果一个变量的类型是 类类型,而非基本类型,那么该变量又叫做引用。 听起来很绕,写起来就知道什么意思了。 使用类就要创建这个类的对象。就比如new demo()。但也只是创建对象,无法访问到它,所以就用引用来代表这个对象。 类还有一个很重要的概念就是构造方法,也叫构造器。构造方法使用来创建类的,所以方法名与类名一模一样,没有返回值,如果要实例化对象,就一定会用到构造方法。 > 需要注意的是,系统会默认提供无参的构造方法,所以你能使用new demo()来创建对象,但如果定义了有参的构造方法,无参的就会没了,所以就不能使用new demo()来创建对象,所以养成个好习惯,创建类的时候,顺便写上无参的构造方法。 :::note{type=\"info\"} 关键字extends ::: 子类继承父类的所有方法和属性,Java的继承包括两种: 1. 类的单继承,即只能继承一个父类 2. 接口的多继承,一个类可以实现(继承)多个接口 :::note{type=\"info\"} 关键字就是private,protected,public ::: 封装就是将一个类里的属性和方法包装起来,严格控制访问权限。就比如JavaBean就是一个标准的封装 多态就是同一个行为具有多个不同表现形式或形态的能力。实现多态的三个必要条件有 1. 继承 2. 重写 3. 父类引用指向子类对象 可以先看个简单的例子 this的本质是”创建好的对象的地址“,经常用为当前对象。下面举个例子来说明this的使用方法。 :::note{type=\"warning\"} 使用this关键字来调用重载的构造方法时,可以避免相同的初始化代码,但只能在构造方法中使用,而且须位于构造方法的第一句。 ::: > this不能用于static方法中。因为static方法是属于类的,this是代表对象,具体详情可以参考下面关于static的描述 super可以理解为指向父类对象(离得最近的)的一个指针,使用方法也有三种。 - 子类的构造函数中要调用super(),一定要放在首行,即使不用系统也会自行调用super(),即子类调用自己的构造器时会先调用父类的,先创建一个父类的对象 - super是从子类中调用父类的方法或变量,而this为在同一类中调用其它方法或变量 - 从本质上来讲this是一个指向本对象的指针,而super是一个Java的关键字 数组是一个固定长度的,包含了相同类型数据的容器。 二维数组可以理解为一个数组,这个数组存着几个一维数组,所以Java的数组可以是不规则的。 接口时一个抽象的类型,跟抽象类有着差不多作用,但又不是类,相当于一个模板需要我们去完善,实现功能,所以接口是不能被实例化的,使用它就需要继承它来实现。 抽象类是一种特殊的类,它的作用就是给子类提供了模板,**它不能被实例化**,所以抽象类是被当作父类去继承的。说到抽象类,就先聊聊什么是抽象类。类里有抽象方法的类被叫为抽象类,但要注意抽象类不是一定有抽象方法。 > 定义抽象类就用关键字abstract,将类声明为抽象类 有抽象方法的类被叫为抽象类,那什么是抽象方法呢,就是专门给我们去继承实现的方法。所以抽象方法是必须要被重写的,而且继承了该抽象类就必须重写抽象方法,不然系统会编译出错。 > 抽象方法的定义也是用关键字abstract,抽象方法是必须被重写的,所以它是不需要方法体的。 :::note{type=\"warning\"} 子类继承了抽象类,没重写其抽象方法子类就必须在声明为抽象类,还有的就是构造方法和用static修饰的类方法是不能被声明为抽象方法的。 ::: 大致了解了抽象类和抽象方法就能理解接口是什么了吧。接口时抽象方法的集合,虽然也可以定义变量,但最好不要破坏了接口的特性,全是抽象方法就好了。 > 接口是用关键字interface来定义的,类通过关键字implements去实现接口,而且里面的方法是不能有抽象方法的,继承的类必须重写里面所有的抽象方法。 这是一个简单的例子 在知道了接口之后,就会有个疑问,既然有了抽象类的概念,为什么还要特意设计接口呢?这就要涉及到接口的一个特点了。 > 类是只支持单继承,而接口支持多继承。 人们在写程序的时候发现,在继承了一个类之后,人们就不能继续继承了,有些功能又要重新定义和实现,因为Java不想我们弄得很乱,不能像C++那样可以支持继承多个类,所以设计了接口来解决这种问题。可以通过下面的列子来大概了解接口的魅力。 :::note{type=\"warning\"} 接口的每个方法都会被隐式的指定public abstract来修饰,变量会被隐式的指定 public static final修饰。 JDK8之后,接口也可以有方法体和静态方法了,但怎么说呢,在我看来还是不加的好 ::: - 该方法只能从键盘获取一个字符,而且获取的是char类型的,其他类型的难处理 - 可以获取字符串,但是获得int,float等类型需要转换 在Java中,有个很重要的类-String类,注意S是大写,就是我们所说的字符串类,这使得我们使用字符串十分方便。 :::note{type=\"warning\"} 注意String创建了就是不可改变的。 ::: 既然字符串是不可变的,那为什么会出现下面的操作呢? > 有人会好奇str1为什么还能继续赋值呢。其实说字符串不可变,是说字符串本身不可变,即“hello”等字符串不能改变,str1只是一个引用,继续赋值只是换了一个地址索引,原来的“hello”还是会存在内存中。 都是经常使用的一些方法 异常是导致程序中断的事件,它不是算是错误,错误error是值jvm运行你的Java程序出的问题。 > Exception类是所有异常类的父类 - ArithmeticException 试图除以0异常 - NullpointerException 空指针异常 - ClassCastException 强制转换异常(引用数据类型转换) - ArraylndexOutOfBoundsException 数组索引越界异常 - NumberFormatException 数字格式化异常 这类异常在编译时必须处理,否则无法通过编译 1. 用try-catch-finally来捕获异常 2. throws抛出异常让系统解决 泛型即参数化类型,本质为数据类型的参数化 ,也就是说所操作的数据类型被指定为一个参数的方式传递,类似于方法中的变量参数。可以用在类、接口、方法的创建中,分别简称为泛型类、泛型接口、泛型方法。 首先举一个简单的例子 nbsp;运行后就会发现程序崩溃了,这是因为在ArrayList中加入了Integer和String类型的数据,转换就出现了异常,所以为了解决一些集合内的类型转换的问题,就出现了泛型,泛型的使用可以减少类型转换和转换异常的情况。 1. 泛型只在编译阶段有效,编译后程序会采取去泛型化的措施,泛型是不会进入到运行阶段的 2. 泛型类型在逻辑上可以看成是不同的类型,实际上都是相同的基本类型 泛型有三种使用方式,泛型类,泛型接口,泛型方法。 首先学容器之前还是学习一下Collection接口,毕竟List与Set接口都是继承的Collection的,所以List与Set都有它的方法,别与Collections类弄混了,前者是集合类的上层接口,后者是一个集合框架的帮助类 List是有序,可重复的容器,List接口继承了Collection,因为是有序的,所以List是有索引位置的,因此相对与Collection接口,会有一些 特殊的关于索引位置的方法 - **LinkedList** LinkedList底层用双向链表实现的储存。查询效率低,删减效率高,线程不安全 - **ArrayList** ArrayList底层是用数组实现的储存。查询效率高,增删效率低,线程不安全 - **Vector** Vector底层是用数组实现的List,相关的方法都加了同步检查,故线程安全,效率低 - 当需要线程安全时就用Vector实现类。查找多就用ArrayList实现类,增删多就用LinkList。 - List允许加重复的元素 - List允许存在null元素 - List是有索引位置的 - List是支持泛型的,所以尽量使用List时要加泛型 Map是存储Key与Value的容器,每个key都会对应一个Value值,所以键对象不能重复,如果存放相同的键对象,对应值对象会被新的值对象代替。 - **HashMap** 底层是通过哈希表来实现的。线程不安全,但效率高。允许Key与Value为null。 - **HashTable** 底层实现与HashMap几乎一样,只是方法添加了synchronized来确保线程同步检查。所以线程安全,但效率低,且不允许Key与Value为null。 - **TreeMap** 底层是通过红黑二叉树来实现的。HashMap效率高于TreeMap,需要排序时才会选择使用TreeMap,即按照Key递增的顺序排序,如果是类排序可以考虑使用comparable接口来实现 Set是**无序而且是不可重复的**,与List一样继承Collection接口。即没有索引只能遍历查找,通过equals方法为true的不能放入,即使是NULL也只能有一个。往Set里面加入元素,本质就是把这个元素作为Key加入到内部的Map里,由于Map里的key是不重复的所以Set也不重复 - **HashSet** 底层是采用HashMap实现的,本质是简化版的HashMap,因此查询与增删效率较高。 - **TreeSet** > 因为Set继承与Collection接口,而且没有新增方法,所以方法与Collection是一样的。 迭代器是一种对象,它能够用来遍历标准模板库容器中的部分或全部元素,每个迭代器对象代表容器中的确定的地址。 - 遍历List容器 - 遍历Set容器 - 遍历Map容器 类java.util.Collections提供了对Set,List,Map的辅助方法 - 根据处理数据的类型不同分为:字符流和字节流 - 根据数据流向的不同分为:输入流和输出流 1. **文件字节流**( 数据源为文件) - FileInputStream 通过字节的方式从文件到程序,读取文件 - FileOutputStream 通过字节的方式从程序到文件,写入文件 2. **文件字符流**( 数据源为文件) - FileReader 通过字符的方式从文件到程序 - FileWriter 通过字符的方式从程序到文件 > 处理的是字符数组 char 3. **字节数组流**(数据源为字节数组对象) - ByteArrayInputStream 通过字节的方式从字节数组到程序 - ByteArrayOutputStream 拖过字节的方式从程序到字节数组 :::note{type=\"warning\"} 使用流之后需要释放流,字节数组流不需要释放,系统会自动释放的 在cry - with -resources 工具类里,在抛出异常的try{}后加入流的声明,则会帮你自动释放资源,比如try(is;os;is1;os2){} ::: 1. **字节缓冲流:** - **BufferedInputStream** - **BufferedOutputStream** - 默认是缓存8K,可以自己修改,原理类似于修饰模式。 - 可以提升性能,运输效率,只用关闭外层的流即可,内层会自动关。手动关闭的话要从里往外关闭 2. **字符缓冲流:** - **BufferedReader** readLine() 读取一行文字 - **BufferedWriter** newLine() 换行符 - 不要用父类引用指向子类对象,不然用不了这些新增方法 3. **转换流:** - **InputStreamReader** - **OutputStreamWriter** - 将字节流转为字符流,方便处理(字节流需全文本) - 能为字节流指定字符集 4. **数据流:** - **DataInputStream** - **DataOutputStream** - 保留数据类型,读取的顺序与写出保持一致 - 数据流里放的是InputStream与OutputStream的字节流 5. **对象流:** - **ObjectInputStream** 反序列化 - **ObjectOutputStream** 序列化 - 先写出后读取,读取的顺序与写出的顺序保持一致 - 不是所有的对象都能序列化,必须是实现了Serializable接口 - 方法和数据流差不多,多了writeobject和readObject - 如果不需要序列化某个对象的值,就用transient来修饰类的对象 6. **打印流:** - **PrintfStream** - **PrintWriter** 7. **随机访问:** - **RandomAcessFile** - 两个模式(mode) \"r\"读 \"rw\"读写 8. **合并:** - **SequenceInputStream** - 先用Vector容器来储存输入流,然后用该容器的elements()方法返回SequenceInputStream的参数,从而合成一个流 - 使用基于TCP协议的Socket网络编程 - TCP协议基于请求- 响应模式 - 利用IO流实现数据的传输 - TCP使用的基本流程 - 基于UDP协议的Socket网络编程实现 - 不需要IO流实现数据传输,数据被打包成包裹发送到目的地(注意传输的包裹不要太大) - 用到的两个类: 1. DatagramPacket 2. DatagramSocket - 代码实现 > 笔记丢了,下次在补 :::note{type=\"success\"} 终于整理完了,暂时不写了,如果想到有些漏的,在加上,还有一些其他的知识,我会用单独的文章来写 ::: > 笔记有一些是网上的,所以要是有侵犯到你的权益可以通知我删除。","url":"/posts/85d837e1/","category":"我的技术学习物语果然有问题","date":"2020.06.18","dateTime":"2020-06-18T00:00:00.000Z"},{"title":"博客主题更换","description":"这次将next换成了butterfly,果然我还是喜欢花里胡哨的主题","content":" 前几天,在b站逛逛,突然看到一个花里胡哨的主题---Butterfly,的确还挺好看的,至少比next的好看(个人意见),所以便决定换掉我的next主题。 就因为换个主题,我玩了一天的yml,这些前端的东西,对于我只学了一点点的人来说确看的云里雾里,不过Butterfly作者也很照顾我们这些不懂的人,主题配置文档写的清清楚楚,很多功能就是改个值就能启动,也很方便。(好了吹到这里) 我是菜鸟,玩了两天还是没玩出来,结果还是是照抄小康大佬和 XueXi大佬的(感谢大佬的教程),虽然花里胡哨,但是好看就完事了。 - Butterfly主题 - 小康 - XueXi - Lete","url":"/posts/70b61401/","category":"瞎折腾","date":"2020.06.17","dateTime":"2020-06-17T00:00:00.000Z"},{"title":"Mybatis","description":"Mybatis 是一款优秀的持久层框架,经常用它来整合项目,能很好的管理数据库的操作。","content":" MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。可以参考官网学习Mybatis 1. 创建maven项目,与之前的第一个servlet程序的流程一样 2. 配置环境,在父项目的pom.xml导入依赖,pom.xml如下 3. 在resource目录下编写Mybatis的核心配置文件 4. 编写Mybatis工具类 > 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。从 XML 文件中构建 SqlSessionFactory 的实例非常简单,建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流(InputStream)实例,比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类,它包含一些实用方法,使得从类路径或其它位置加载资源文件更加容易。 5. 定义接口类 6. 编写xml文件(同目录下好管理),**写好xml之后需要到核心配置处加载映射** 7. 调用 1. 使用工具类中的getSqlSession方法获取sqlSession对象 2. 通过sqlSession对象的getMapper方法获得接口的实现 3. 然后通过实现的接口对象来调用方法 4. 关闭sqlSession对象 **增删改都是需要提交事务的** 1. 接口 2. 绑定的xml 3. 测试类 Mybatis配置文件就是resources文件下的mybatis-config.xml。虽然可以改名,官方推荐使用这个名字 > 需要注意的是,这些配置是按顺序的,比如环境配置是不能放在属性配置前面的,不然会报错 > MyBatis 可以配置成适应多种环境,这种机制有助于将 SQL 映射应用于多种数据库之中, 现实情况下有多种理由需要这么做。例如,开发、测试和生产环境需要有不同的配置;或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。 > > **不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。** > > 所以,如果你想连接两个数据库,就需要创建两个 SqlSessionFactory 实例,每个数据库对应一个。而如果是三个数据库,就需要三个实例,依此类推 - 环境的选择,如果没有环境参数就会选择默认环境,即上述default的环境id - 事务管理器的配置 如果你正在使用 Spring + MyBatis,则没有必要配置事务管理器,因为 Spring 模块会使用自带的管理器来覆盖前面的配置。 - 数据源的配置 属性可以在外部进行配置,并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性,也可以在 properties 元素的子元素中设置。 1. 固定的属性可以直接放在外部的配置文件,比如在resources资源目录下创建一个config-properties文件,&可以不用转译 然后在配置文件中调用 2. 也可以动态的调用,比如 在配置文件中 3. 注意的是,外部的优先级较高,在配置文件中properties属性与外部文件的属性冲突时是使用外部文件的属性 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置,意在降低冗余的全限定类名书写。 1. 类 2. 包 > 指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean。在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如在Mybatis会自动扫描路径上的包,在没有注解的情况下,里面的user类的别名就会定义为user 3. 通过注解来起别名 这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。了解几个就行 | **设置名** | **描述** | **有效值** | **默认值** | | :----------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ---------- | | cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true\\|false | true | | lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 | true\\|false | false | | logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J\\|LOG4J\\|LOG4J2JDK_LOGGING\\| COMMONS_LOGGING\\| STDOUT_LOGGING \\|NO_LOGGING | 未设置 | 既然 MyBatis 的行为已经由上述元素配置完了,我们现在就要来定义 SQL 映射语句了。 但首先,我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面,Java 并没有提供一个很好的解决方案,所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用,或完全限定资源定位符(包括 file:/// 形式的 URL),或类名和包名等。 1. 使用相对于类路径的资源引用,推荐使用这种 2. 使用完全限定资源定位符(URL),不推荐 3. 使用映射器接口实现类的完全限定类名 > 1. 接口与Mapper配置文件同名 > 2. 接口和它的Mapper配置文件同包 4. 将包内的映射器接口实现全部注册为映射器 > 1. 接口与Mapper配置文件同名 > 2. 接口和它的Mapper配置文件同包,也可以将它的Mapper配置文件放在resources下创建相同路径的文件夹 理解我们之前讨论过的不同作用域和生命周期类别是至关重要的,因为错误的使用会导致非常严重的并发问题。 - 这个类可以被实例化、使用和丢弃,一旦创建了 SqlSessionFactory,就不再需要它了。 - 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域(也就是局部方法变量)。 - SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。 - 因此 SqlSessionFactory 的最佳作用域是应用作用域。 - 每个线程都应该有它自己的 SqlSession 实例。 - SqlSession 的实例不是线程安全的,因此是不能被共享的,所以它的最佳的作用域是请求或方法作用域。 - 绝对不能将 SqlSession 实例的引用放在一个类的静态域,甚至一个类的实例变量也不行,也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中。 - 如果你现在正在使用一种 Web 框架,考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说,每次收到 HTTP 请求,就可以打开一个 SqlSession,返回一个响应后,就关闭它。 这个关闭操作很重要,为了确保每次都能执行关闭操作,你应该把这个关闭操作放到 finally 块中。 在有些操作里,会因为pojo包里的属性名与数据库的字段名不一样而会达不到应有效果,比如有时候会查不到不同属性名的值,所以就要注意属性名要与字段一致,要是不一样还有一些其他的解决方法。 为你不同的属性名取一个与字段一样的别名,这样就能实现属性名与字段一致,比如属性名为password,字段名为pwd,则为password起一个pwd的别名 resultMap为结果集映射,将你的字段名映射为属性名,便能使属性名与字段一致 Mybatis 通过使用内置的日志工厂提供日志功能。因为Mybatis的设置日志是为设置的,所以需要设置才能看得到 Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件,甚至是套接口服务器、NT的事件记录器、UNIXSyslog守护进程等;我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。 1. 导入依赖 2. 在resouces目录下创建log4j.properties配置文件,并设置配置,网上很多可以去复制 3. 设置日志实现 对于像 BlogMapper 这样的映射器类来说,还有另一种方法来完成语句映射。 它们映射的语句可以不用 XML 来配置,而可以使用 Java 注解来配置。 1. 注解 2. 去核心配置文件处绑定接口 > 使用注解来映射简单语句会使代码显得更加简洁,但对于稍微复杂一点的语句,Java 注解不仅力不从心,还会让你本就复杂的 SQL 语句更加混乱不堪。 因此,如果你需要做一些很复杂的操作,最好用 XML 来映射语句。","url":"/posts/da3e1361/","category":"我的技术学习物语果然有问题","date":"2020.06.08","dateTime":"2020-06-08T00:00:00.000Z"},{"title":"JSP","description":"JSP也算Javaweb的基础,还是有必要学的。","content":" JSP是一门比较老的技术了,在这个前后端分离大火的时代,JSP基本已经被淘汰了,但是JSP还是有学习的必要的,学习了JSP有助于了解JavaWeb,能更好的理解后面所学的框架。 JSP全称为JavaServer Pages,Java服务端页面,是一种动态网页技术,用于实现动态web。JSP部署于网络服务器上,可以响应客户端发送的请求,并根据请求内容动态地生成HTML,XML或其他格式文档的web网页,然后返回给请求者。JSP技术以Java语言作为脚本语言,为用户的HTTP请求提供服务,并能与服务器上的其它Java程序共同处理复杂的业务需求。 JSP页面,比如index.jsp的页面会在tomcat服务器运行的时候会转变成一个Java程序,你可以在idea目录下找到对应的Java程序与字节码文件,点进去看源码会发现,这个Java程序继承了HttpJspBase,而HttpJspBase继承了Sevlet,所以可以看出**JSP本质上就是Servlet**,我们在JSP中用HTML来写,而系统自动用一个Servlet来帮你写出这个JSP,所以Servlet实现了动态Web,从而JSP也实现了动态Web。 > 我的目录地址为C:\\Users\\Yw\\.IntelliJIdea2019.1\\system\\tomcat\\Unnamed_javaweb01\\work\\Catalina\\localhost\\web01_war\\org\\apache\\jsp 1. 首先处理JSP文件 2. 判断请求 3. 其中还内置了一些对象 4. 输出页面前,还多了一些源码 5. 输出页面,比如Index.jsp 6. 所以基本上除了输出页面的代码,也就是我们在JSP上写的HTML的代码是不一样的以外,其他的基本上都是一样的,系统帮我写好了实现HTML同样效果的Servlet 7. 所以可以得出这样JSP实现的流程。首先客户端向服务器发起了一个请求,服务器中的Web容器会接收请求,找到对应的JSP页面,然后系统会自动将JSP页面转化为Java程序,编译得到class文件,然后web容器帮我们处理这样的class文件,也就是Servlet,Web容器就发起响应,所以我们所看到的就是这个Java程序,也就是Servlet > 在JSP中 > > 写HTML的代码,会被转换成out.write(\"\")的形式,例如上面的输出页面 > > 写Java代码,就会是Java的代码 Model,View,Controller。即模型,视图,控制器。 > 实质就是Servlet,大概有三个作用 1. 接收用户的请求 2. 响应交给业务层处理对应代码 3. 视图跳转 > 实质是JSP,也是Servlet,大概有两个作用 1. 展示数据 2. 提供链接发起Servlet请求 > 因为Controller与View都算是Servlet,但为了更好的管理,便规定为Controller写Servlet,View专注于显示界面 早期的架构只有控制器和视图两层,即以下的结构 > 这种架构是在控制器中直接写对用户的操作,例如增删改查,但这样的话,Servlet中就会有很多代码,处理起来十分麻烦,所以便加多了一层Model层 Model其实包括了业务层Service,用户类JavaBean和Dao层 由此可以知道**JSP其实就是Servlet**,所以能实现动态Web,不过因为这种技术是在HTML中嵌入Java的代码,这是一件令人头疼的事情,毕竟这样的话做一个项目就要同时学习前端和后端,所以前后端分离的思想出来之后,JSP就逐渐被淘汰了。","url":"/posts/78b18e67/","category":"我的技术学习物语果然有问题","date":"2020.06.06","dateTime":"2020-06-06T00:00:00.000Z"},{"title":"第一个Servlet程序","description":"简单使用servlet的小demo","content":"1. 创建一个Maven项目,不用选择模板先 2. 导入依赖 3. 创建一个子模块,选择图中的模板 > 接下来配置好maven和setting.xml和maven-repo的路径,大概如图所示 4. 创建好子模块后,更新web.xml 5. 还原配置 在main下创建好java包和resources包,并在右键Mark Director as标记两个包,Java包为Sources Root,resources包为Resources Root类型,成功如图下 6. 在Java包里编写servle程序,若没有添加servlet程序选项可以自行创建类,然后继承HttpServlet接口 7. 编写好后点击右上角的设置,配置好Tomcat服务器的设置 > 添加之后配置好部署,添加子模块的war包,就可以启动Tomcat了","url":"/posts/26bc41e8/","category":"我的技术学习物语果然有问题","date":"2020.06.05","dateTime":"2020-06-05T00:00:00.000Z"},{"title":"简单的Web基础","description":"刚学web就要先了解一些基础。","content":"web应用程序是一个可以提供浏览器访问的程序,一个web服务器应该是由多部份组成的,前端页面,webService功能,和Java程序,等等 静态网站是最初的建站方式,浏览者所看到的每个页面是建站者上传到服务器上的一个 html ( htm )文件,这种网站每增加、删除、修改一个页面,都必须重新对服务器的文件进行一次下载上传。网页内容一经发布到网站服务器上,无论是否有用户访问,每个静态网页的内容都是保存在网站服务器上的,也就是说,静态网页是实实在在保存在服务器上的文件,每个网页都是一个独立的文件 动态web有点类似静态web,但不是那种有图片动,轮播图的那些伪动态,它的资源数据不是一成不变的,就比如是淘宝,不同的人会有不同的推荐 web服务器用来处理用户的请求,然后返回响应。有LLS,Tomcat服务器,我们主要学的就是Tomcat服务器。现在来了解一下Tomcat服务器。 Tomcat是Apache 软件基金会(Apache Software Foundation)的Jakarta 项目中的一个核心项目,由于有了Sun 的参与和支持,最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现。因为Tomcat 技术先进、性能稳定,而且免费,因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可,成为目前比较流行的Web 应用服务器。 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP 程序的首选。对于一个初学者来说,可以这样认为,当在一台机器上配置好Apache 服务器,可利用它响应HTML(标准通用标记语言下的一个应用)页面的访问请求。实际上Tomcat是Apache 服务器的扩展,但运行时它是独立运行的,所以当你运行tomcat 时,它实际上作为一个与Apache 独立的进程单独运行的。 Apache 为HTML页面服务,而Tomcat 实际上运行JSP 页面和Servlet。另外,Tomcat和IIS等Web服务器一样,具有处理HTML页面的功能,另外它还是一个Servlet和JSP容器,独立的Servlet容器是Tomcat的默认模式。不过,Tomcat处理静态HTML的能力不如Apache服务器。 这是百度对Tomcat的描述,其实在现在看来,我们淘汰了JSP这项技术,但Tomcat依旧是十分主流的web服务器。 这就Tomcat所有的文件,大致都可以了解一下,**bin为一些脚本文件,比如启动和关闭的脚本文件,conf为配置文件,lib是一些所需的依赖jar包,logs为日志,webapps用来存放网站**。 - 可以配置启动的端口号 - 可以配置主机名 为什么要改hosts文件,这就涉及到网站是如何进行访问。 1. 首先客户端输入域名发起请求 2. 客户端先会对本机的hosts进行检查,检查是否有这个域名的映射,要是有就会返回这个域名对应的ip地址,然后就可以直接访问相关的web程序,要是没有检查到就会去DNS服务器上寻早该域名对应的ip(这也就是所理解的dns解析域名),找到就返回ip,找不到就访问不了","url":"/posts/afc5caff/","category":"我的技术学习物语果然有问题","date":"2020.06.04","dateTime":"2020-06-04T00:00:00.000Z"},{"title":"关于equels与==","description":"在初学Java的时候,equels与==总是会感觉很混乱,这次特意来总结一下。","content":" 在初学Java的时候,equels与==总是会感觉很混乱,这次特意来总结一下。首先来大致了解一下这两个的意思。 - ==作用是来判断两个对象是不是同一个对象,因为Java只有值传递,所以对于==来说不管是基本的数据类型还是引用的数据类型,其本质比较的都是值,只是引用的数据类型变量的值是对象的地址。所以就会容易搞混 - equals方法也是比较两个对象是否相等。equals方法是Object类中的方法。 基本数据类型不能算做为对象,所以并没有继承有equals的方法,所以只有==的比较 String类型是重写了equals方法的,所以这里会经常弄乱,重写后的equals方法为 为什么两个都是True,这就要关系到字符串常量池了。当进行第一条语句的时候,编译器就会先在字符串常量池寻找有没有\"ab\"这个字符串,若没有就会将这个字符串放入字符串常量池。第二条语句进行的时候,就可以找到\"ab\"这个字符串,就会把字符串常量池里的引用地址给b,所以a与b的字符串是同一个地址的,所以==是true的。在上面的String重写的equals方法可以看出,equals方法是比较内容是否相同,所以第二个也是true。 new String的语句是在堆内存中开辟一块空间用来存放\"ab\"这个字符串,然后在栈中开辟一块a或b的空间放着字符串的对象的引用,所以a,b两个虽然内容相同,但其实是两个对象,所以地址是不一样的,==在引用中比较的就是对象的地址,结果就是false。String的equals方法是比较内容的,内容相同就是true 这个就比较容易理解了,因为equals方法没被重写,所以是比较两个对象是否是同一个对象,==比较两个地址是否是一样,也是比较是否为同一个对象,所以这两者的作用在equals方法没被重写的时候是一样的。 - 在基本数据类型中 ==比较两个值是否相同 - 在引用类型中 - equals方法没被重写 ==与equals方法比较的是两个的地址是否相同 - equals方法被重写,以String类举例 ==比较地址,equals比较方法 首先先看代码 按照所想,在Integer类当中,==是比较两个是否是同一个地址,但上述的运行结果中却出现了一个false,接下来在进行以下测试 > 由此可以看出 > > 1. 第一段代码中,在-128~127的范围中,==的结果是为true,而不在这个范围中,==则为false > 2. 第二段代码中,两个对象不一样,地址不一样,所以==的结果接就是就是false,没有任何异常的地方。 > 3. 直接用Integer类型与Int类型作比较,值相等就为true 最后在寻找过后得到结果 Java对于Integer是有一种缓存机制的,缓存了-128到127之间的数字,有点类似String,所以在第一个例子中,num11与num22其实是共享一个地址的,所以==的结果是true,不在缓存范围外的数字,并不是共享一个地址,所以==的结果就为false","url":"/posts/4447e73e/","category":"我的技术学习物语果然有问题","date":"2020.06.01","dateTime":"2020-06-01T00:00:00.000Z"},{"title":"Markdown","description":"Markdown是一种轻量级的标记语言,能很大程度提高你写作的体验,也能更好的渲染。","content":"- 使用=和-来标记一级和二级标题 - 使用#来标记标题 > *斜体文本* > _斜体文本_ > **粗体文本** > __粗体文本__ > ***粗斜体文本*** > ___粗斜体文本___ - 分割线 > --- - 删除线 > ~~删除线~~ - 下划线 - 脚注 - 有序列表 > - 第一项 > - 第二项 > - 第三项 - 无序列表 > 1. 第一项 > 2. 第二项 > 3. 第三项 > 一级区块 > > 二级区块 > > > > > 三级区块 > 1. 百度 > 2. | 左对齐 | 右对齐 | 居中对齐 | | :----- | -----: | :------: | | 单元格 | 单元格 | 单元格 | | 单元格 | 单元格 | 单元格 | - **流程图** - **UML时序图** - **甘特图** - 转义 > **没有反斜线的星号** > > \\*\\* 正常显示星号 \\*\\* - 公式","url":"/posts/6fc8eab5/","category":"我的技术学习物语果然有问题","date":"2020.05.15","dateTime":"2020-05-15T00:00:00.000Z"},{"title":"Matlab","description":"数学软件,一些简单的操作。","content":"","url":"/posts/dc9cb9f1/","category":"我的技术学习物语果然有问题","date":"2019.12.09","dateTime":"2019-12-09T00:00:00.000Z"},{"title":"git常用命令","description":"Git是目前世界上最先进的分布式版本控制系统,能够很好的帮你管理项目。","content":"- 仅仅时在本地库移动HEAD指针 - 在本地库移动HEAD指针 - 重置暂存区 - 在本地库移动HEAD指针 - 重置暂存区 - 重置工作区","url":"/posts/423abe9e/","category":"我的技术学习物语果然有问题","date":"2019.11.28","dateTime":"2019-11-28T00:00:00.000Z"},{"title":"如何给你的U盘或移动硬盘自定义图标","description":"上网冲浪的时候看到的一个骚操作,记录一下","content":"首先,选好自己想要自定义的图片,将该图片转为32*32的ico文件。关于怎么转换,直接上网搜就好了。 然后新建一个 autorun.inf 文件,并编辑里面的内容为如下 emm,那个icon.ico就是你那个图片转化之后的ico文件,名字是可以修改的,只要autorun.inf的文件内容里也跟着修改就行了,然后将ico的图片和那个 autorun.inf文件放在移动硬或U盘的根目录下面就完工了。如果你是U盘,就拔掉在插入,如果是移动硬盘可能就要重启了。 当你新建好 autorn.inf这个文件后,将它移入U盘,或者直接在U盘下新建 autorn.inf这个文件,可能系统会提示你没有权限执行。这个问题也卡了我好久,对于这个问题你就要赋予U盘所有的权限,即你的用户需要是管理员权限,当你弄好权限后就可以将 autorn.inf这个文件放进U盘了。 不过可能系统还会告诉你你没有权限执行,这里我也是查了好久,最后我查了一下 autorn.inf这个文件,发现该文件的作用是允许在双击磁盘时自动运行指定的某个文件,而且近几年出现了有利用该文件来传播木马和病毒,即木马或病毒可能会因为你的U盘来侵入你的电脑。折腾了一下,也查了一下,就知道了方法。只要你将你电脑的所有安全杀毒关掉,就可以将 autorn.inf这个文件放进去了。 > 这是从某位博主上发现的操作,时代久远,已经找不到原文了","url":"/posts/54d98528/","category":"瞎折腾","date":"2019.11.27","dateTime":"2019-11-27T00:00:00.000Z"},{"title":"HCS","description":"HTML+CSS+JavaScript,前端三件套。以弃。","content":"Hyper Text Markup Language 超文本标记语言 > 由标签构成的语言,标记语言不是编程语言 - HTML文档后缀名为html或htm - 标签可分为围堵标签和自闭和标签。围堵标签就是有开始标签和结束标签,比如 。自闭和标签就是开始标签和结束标签是在一起的,比如 - 标签可以嵌套 - 在开始标签中可以定义属性。属性是由键值对构成的,值需要用引号引出,单引号或双引号都可以 - 标签不区分大小写 - html : html文档的根标签 - head:头标签。用于指定html文档的一些属性。引入外部资源 - title:标题标签 - body:体标签 - html5中定义该文档是html文档 - **表单是用来采集用户输入的数据的,用于和服务器进行交互,使用到的标签有:form** - input:可以通过type属性值,改变元素展示的样式 - select:下拉列表 - testarea:文本域 - label标签:指定输入项的文字描述信息 > Cascading Style Sheets 层叠样式表 > > 层叠表示多个样式可以作用在同一个html元素上,使其同时生效 - 基础选择器 - 扩展选择器 - 文本,文字 - 背景 background - 边框 - 尺寸 - 控制布局 > JavaScript是一门客户端脚本语言 > > JavaScript是在客户端浏览器中运行的,不需要编译,直接就可以被浏览器解析 > > JavaScript = ECMAScript + JavaScript特有特性(BOM+DOM) - 单行 //注释内容 - 多行 /\\*注释内容\\*/ - 原始数据类型 - number 数字。 整数/小数/NaN - string 字符串 \"abc\" \"a\" 'a' - boolean true和false - null 一个对象为空的占位符 - undefined 未定义。即没有给一个变量给初始化值,默认为undefined - 引用数据类型 - Java是强类型的,在定义变量的时候会定义了该变量的类型,开辟的空间只能放该类型的数据 - JavaScript是弱类型的,不定义变量的类型,开辟好的空间可以放任意类型的值 - 定义变量 var 变量名 = 初始值 - 可以使用typeof运算符来得出该变量的类型 - +正号 在JS中,如果运算数不是所要求的类型,js就会进行自动转换,如 string转number,会按字面值转,如果是英文则会转成NaN(一个不是数字的数字)。 boolean转number,true转为1,false转为0 - 比较运算符(> 虽然大致学过一遍,久了又忘记了","url":"/posts/a8fe19e2/","category":"我的技术学习物语果然有问题","date":"2019.11.25","dateTime":"2019-11-25T00:00:00.000Z"},{"title":"反射","description":"反射是十分重要的,是Java框架的灵魂","content":"- 反射指的是可以在运行时加载,使用编译期间完全未知的类 - 程序在运行中。可以动态加载一个只有名称的类。对于任意一个已加载的类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性 - 一个类只有一个Class对象,在加载一次出来的Class对象也是之前的那一个 - 加载完类之后,在堆内存里就会产生一个Class对象,类的整个结构信息会放到对应的Class对象中 > getDeclaredConstructor()这个方法会查找到所有的构造方法,然后通过后面的newInstance()方法来完成实例化,在强转就可以得到类了。如果有参数就输入参数。(注意这个Javabean中最好要有一个无参构造器,不然无参的这个实例化会报错) - setAccessible(),启用和禁用安全检查的开关,true时取消Java访问检查,但并不是true就能访问,false就不能访问 - 禁止安全检查可以提高反射的运行速度 > 这里就可以知道,运用反射调用方法的时间差不多是直接调用方法的时间的10倍,而关闭了访问检查之后就下降到接近5倍的程度","url":"/posts/7af799fd/","category":"我的技术学习物语果然有问题","date":"2019.11.13","dateTime":"2019-11-13T00:00:00.000Z"},{"title":"注解","description":"注解对Java开发还是很重要的,特别是框架里注解可以简化操作","content":"- 可以对程序作出解释,但又不是程序的部分,这一点跟注释差不多 - 可以被程序读取,注解信息处理流程是注解和注释的区别 - @Override 定义在java.lang.Override里,该注解只修饰方法,表示这个方法是重写了超类的方法 - @Deprecated 定义在java.lang.Deprecated里,可修饰方法,属性,类,表示不建议使用这个元素,使用时会出现划线 - @SuppressWarnings() 定义在java.lang.SuppressWarnings里,用来抑制编译时的警告信息,不过要往里加一个参数才能使用,比如\"all\"等 - 元注解是为注解做的注解,如@Target,@Retention,@Documented,@Inherited,位于java,lang,annotation - @Target,用于描述注解的使用范围 - @Retention,表示需要什么级别保存该注释,描述注解的生命周期 - 使用@interface自定义注解,自动继承了java.lang.annotation接口,其中每一个方法就是声明了一个配置参数,如果只有一个参数一般命名为”value“","url":"/posts/a70f4376/","category":"我的技术学习物语果然有问题","date":"2019.11.12","dateTime":"2019-11-12T00:00:00.000Z"},{"title":"JDBC","description":"JDBC是用来规范客户端程序如何来访问数据库的应用程序接口。","content":"去Mysql官网下载即可 因为MySQL命令行操作在用起来十分繁琐,所以需要选择一个数据库的管理工具,方便使用MySQL,推荐使用 navicat 1. 为什么要装驱动 在编程中连接数据库时,必须先装载特定厂商的数据库驱动程序,不同的数据库有不同的装载方法。驱动就是各个数据库厂商实现的Sun公司提出的jdbc接口。即对connection等接口的实现类的jar文件。 2. 下载驱动 首先要先去官网下载好对应版本的jar包,我的就是**mysql-connector-java-8.0.18**,版本要对应,不知道版本的可以使用命令行进去MySQL然后输入命令\\s来查看版本 1. 旧版本的连接(8.0版本之前) 2. **MySQL8.0之后的版本连接数据库时不需要建立SSL连接,需要显示关闭,最后还要设置CST才能连接** :::note{type=\"info\"} localhost是你数据库的主机名,port数据库的端口,database时库名 user和password时用户名和密码,因人而异 连接对象内部其实包含了Socket对象,是一个远程连接,比较耗时 ::: 1. 由createStatement创建,用于发送简单的不带参数的sql语句 一般也不会使用Statement接口,因为会出现sql注入的危险,比如: 1. **execute()** 运行语句,返回是否有结果集,Boolean类型 2. **executeQuery()** 运行select语句,返回ResultSet结果集 3. **executeUpdate()** 运行insert/update/delete操作,返回更新的行数 **继承Statement接口**,由prepareStatement创建,用于发送含有一个或多个输入参数的sql语句,PrepareStatement对象比Statement对象效率更高,而且可以防止SQL注入,推荐使用 **后打开的先关闭,比如resultset-->statment--->connection这样的顺序关闭,不要合在一起关闭哦** - Batch - 对于大量数据的处理,建议使用Statement,因为PreparedStatement的预编译空间有限,数据多时会出现异常 - 还有就是设置为手动提交事务 - 一组要么同时执行成功,要么同时执行失败的SQL语句,事务是数据库操作的一个执行单元 - 事务开始于: - 连接到数据库上,并执行一条DML语句(insert,update或delete) - 前一个事务结束后,又输入另外一条DML语句 - 事务结束于: - 执行了commit或rollback语句 - 执行一条DDL语句,比如create table语句;这种情况下为自动执行了commit语句 - 执行了一条DCL语句,例如grant语句;这种情况下为自动执行commit语句 - 断开于数据库的连接 - 执行了一条DML语句,但语句失败了,这种情况中会为这个无效的DML语句执行rollback语句 - atomicity(原子性) 表示一个事务内的所有操作时一个整体,要么全部成功,要么全部失败 - consistency(一致性) 表示一个事务内一个操作失败时,所有更改的数据都会回到事务执行之前 - isolation(隔离性) 事务查看数据时数据所处的状态,要么是另一事务修改它之前的状态,要么是另一事务修改它之后的状态,不会查看中间状态的数据,具体看下面的事务隔离级别 - durability(持久性) 持久性事务完成之后,修改时永久的 - 读取未提交 - 读取已提交 - 可重复读 - 序列化 - 用于存储大量的文本数据 - 大字段的操作常常是以流的方式来处理的 - MySQL相关的类型 - tinytext 最大长度为255字符的TEXT列(2^8-1) - text 最大长度为65535字符的TEXT序列(2^16-1) - mediumtext 最大长度为16777215字符的TEXT序列(2^24-1) - longtext 最大长度为4294967295字符的TEXT序列(2^32-1) - 用于存储大量的二进制数据 - 与CLOB类似,常常也是以流的方式处理 - MySQL中相关类型 - tinyblob 最大长度为255字符的BLOB列(2^8-1) - blob 最大长度为65535字符的BLOB序列(2^16-1) - mediumblob 最大长度为16777215字符的BLOB序列(2^24-1) - longblob 最大长度为4294967295字符的BLOB序列(2^32-1)","url":"/posts/8fe47ff4/","category":"我的技术学习物语果然有问题","date":"2019.11.06","dateTime":"2019-11-06T00:00:00.000Z"},{"title":"正则表达式","description":"正则表达式时一种强大而灵活的文本处理工具,用于文本的复杂处理","content":"- 正则表达式时一种强大而灵活的文本处理工具,用于文本的复杂处理 - 正则表达式就是描述了一个规则,通过这个规则可以匹配一类字符串 1. **普通字符** 字母,数字,汉字,下划线以及没有特殊定义的标点符号都是普通字符。表达式中的普通字符在匹配一个字符串时,匹配与之相同的一个字符 2. **简单的转义字符** 3. 标准字符集合 4. 自定义字符集合 - 方括号的匹配方式,能够匹配方括号中任意一个字符,比如 - 正则表达式的特殊符号被包含到中括号中则失去特殊意义,除了^,-之外 - 标准字符集合,除小数点外,如果被包含于中括号,自定义字符集合将包括该集合,比如 5. 量词 6. 字符边界 7. 选择符和分组 8. 预搜索(零宽断言) 1. **IGNORECASE** 忽略大小写模式,即匹配时忽略大小写 2. **SINGLELINE** 单行模式,整个文本看作一个字符串 3. **MULTILINE** 每行都是一个字符串,如果需要匹配最开始和结束的位置,可以用\\A和\\Z 在Java中使用正则主要是java.util.regex包地Pattern和Matcher类 1. 正则表达式的编译表示形式 1. 通过解释Pattern对character sequence执行匹配操作的引擎 2.","url":"/posts/2f57a694/","category":"我的技术学习物语果然有问题","date":"2019.11.03","dateTime":"2019-11-03T00:00:00.000Z"},{"title":"static与final","description":"static和final还是会弄乱的,特地整理一下","content":"- static修饰的变量为类的变量,属于类,即所有的该类的实例化对象共同使用该static变量 - static方法中不能访问非static成员 > 这个很容易理解,每个类都只有一份static的资源,还没类还没实例化就有了该static方法,但没有实例化的成员即非静态成员,所以静态方法是不能访问非static成员的 - static的变量和方法或者块都是属于类的,普通变量和方法是属于对象的。 - 用final修饰类,表明中这个类是不能不继承的,类中的变量可以是非final的变量,但所有的方法都会被隐式地指定为final方法 - 使用final修饰方法原因有两个。一,把方法锁定,防止任何继承类重写该方法。二,提高效率。在早期的Java实现版本会将final方法转为内嵌调用,但如果方法过于庞大,可能看不到内嵌的优化效果,新的Java版本已经 不需要final方法来优化 - final不能修饰构造方法 - final修饰变量,即表示该变量被定义为一个常量,该常量被初始化赋值之后就不能修改","url":"/posts/92a59ea9/","category":"我的技术学习物语果然有问题","date":"2019.10.31","dateTime":"2019-10-31T00:00:00.000Z"}],"totalPosts":74}