yww

记一次重写博客

Fri, 24 Apr 2026 00:00:00 +0000

序言

我的博客已经使用butterfly这个主题很长一段时间了，虽然期间做了很多样式微调，但也难免产生了一点审美疲劳，一直想换一个新的风格。恰逢最近挺无聊的，于是重新搭建一套属于自己的博客系统。

其实重写博客的想法，早在两三年前就已经萌生。当时我特别倾向于前后端分离的动态博客，认为这种动态博客更加的灵活。为此我还专门用 SpringBoot3 + Vue3 实现了一版butterfly版本的动态博客与后台管理系统，但在实际体验了一会Halo这种比我写的更完善的博客后，我发现这种动态博客并不完全适合我的使用场景。我只是想设计实现一套系统罢了，就下意识认为这种动态博客更好，却忽略了我的习惯和强行让自己自适应。最终就放弃了继续优化和完善这套方案，也一直使用butterfly至今。

用AI重写博客

过去一年多，自从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

我不喜欢安装过多的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。

自建busuanzi网站计数服务

Sun, 10 Aug 2025 00:00:00 +0000

序言

不蒜子(busuanzi) 是一个广受欢迎的免费网页计数服务，能够轻松实现网站的页面浏览量(PV)和独立访客数(UV)统计。许多基于Hexo的网站都在使用busuanzi来实现访问统计功能，我的博客当前使用的主题是Butterfly，这个主题也是通过集成busuanzi计数器来实现网页计数。

然而，随着使用人数的不断增多，这个由作者为爱发电的免费服务开始出现稳定性问题，访问速度也变得起伏不定。

因此，我决定自己开发一个服务来代替busuanzi，为我的网站提供稳定的计数服务。

技术栈选择

我简单分析了一下，发现busuanzi这个网页计数服务实现起来并不复杂，主要是通过获取访问请求的来源地址来实现PV和UV的计数增长，因此服务的核心就是一个统计接口。

基于这个分析，技术栈的选择也相对明确：

接口开发：由于我最熟悉Java，所以选择使用SpringBoot3和Java17来实现这个接口。（只实现一个接口的话，用SpringBoot感觉有些重，后续有时间可以考虑用Go重写一遍）
数据存储：数据库选择很多，但考虑到服务需要记录的数据主要是网站的PV和UV，对于请求IP等信息并非必须存储，所以我选择使用Redis。Redis对于这类频繁操作的数据处理速度非常快，而且配置好Redis的持久化后，也不怎么需要担心数据丢失问题。如果还是不太放心，可以在增加一个定时任务，定时从Redis中读取数据，存储到关系型数据库当中去，但是我感觉没有必要。

服务分析

前端脚本

为了避免修改Butterfly主题中集成busuanzi的代码（以免在后续主题升级时进行频繁修改），需要让自建服务的接口访问方式和数据显示方式与原版busuanzi完全一致。因此，首先需要分析当前busuanzi的具体工作流程。

访问官网，可以看到官网提示的信息，只需要两行代码即可搞定计数。

本站总访问量次

从这两行代码可以看出，busuanzi通过引入busuanzi.pure.mini.js脚本来修改busuanzi_container_site_pv标签的内容，从而实现计数显示。数据获取流程的核心就在这个脚本中。由于该脚本经过了代码压缩，我使用claude code对其进行了脚本还原，以提高代码可读性。

/** * Busuanzi 不蒜子统计脚本 * 用于网站PV/UV统计显示 */var bszCaller, bszTag;// DOM Ready 功能实现(function() {    var interval,         domReadyCallback,         executeCallbacks,        isReady = false,         readyCallbacks = [];    // 添加ready回调函数    ready = function(callback) {        if (isReady || document.readyState === "interactive" || document.readyState === "complete") {            return callback.call(document);        } else {            readyCallbacks.push(function() {                return callback.call(this);            });        }        return this;    };    // 执行所有等待的回调函数    executeCallbacks = function() {        for (var i = 0, length = readyCallbacks.length; i < length; i++) {            readyCallbacks[i].apply(document);        }        readyCallbacks = [];    };    // DOM准备完成后的处理    domReadyCallback = function() {        if (!isReady) {            isReady = true;            executeCallbacks.call(window);                        // 移除事件监听器            if (document.removeEventListener) {                document.removeEventListener("DOMContentLoaded", domReadyCallback, false);            } else if (document.attachEvent) {                document.detachEvent("onreadystatechange", domReadyCallback);                if (window == window.top) {                    clearInterval(interval);                    interval = null;                }            }        }    };    // 绑定DOM Ready事件    if (document.addEventListener) {        // 现代浏览器        document.addEventListener("DOMContentLoaded", domReadyCallback, false);    } else if (document.attachEvent) {        // IE浏览器兼容        document.attachEvent("onreadystatechange", function() {            if (/loaded|complete/.test(document.readyState)) {                domReadyCallback();            }        });        // IE浏览器特殊处理        if (window == window.top) {            interval = setInterval(function() {                try {                    if (!isReady) {                        document.documentElement.doScroll("left");                    }                } catch (error) {                    return;                }                domReadyCallback();            }, 5);        }    }})();// JSONP 调用器对象bszCaller = {    /**     * 发起JSONP请求获取统计数据     * @param {string} url - 请求URL     * @param {function} callback - 回调函数     */    fetch: function(url, callback) {        // 生成随机回调函数名        var callbackName = "BusuanziCallback_" + Math.floor(Math.random() * 1099511627776);                // 在全局作用域中注册回调函数        window[callbackName] = this.evalCall(callback);                // 替换URL中的回调函数名        url = url.replace("=BusuanziCallback", "=" + callbackName);                // 创建script标签进行JSONP请求        var scriptTag = document.createElement("SCRIPT");        scriptTag.type = "text/javascript";        scriptTag.defer = true;        scriptTag.src = url;        scriptTag.referrerPolicy = "no-referrer-when-downgrade";                // 将script标签添加到head中        document.getElementsByTagName("HEAD")[0].appendChild(scriptTag);    },    /**     * 包装回调函数，添加错误处理     * @param {function} callback - 原始回调函数     * @returns {function} 包装后的回调函数     */    evalCall: function(callback) {        return function(data) {            ready(function() {                try {                    // 执行回调并清理script标签                    callback(data);                    if (scriptTag && scriptTag.parentElement) {                        scriptTag.parentElement.removeChild(scriptTag);                    }                } catch (error) {                    // 出错时隐藏统计显示                    bszTag.hides();                }            });        };    }};// 发起统计数据请求bszCaller.fetch("//busuanzi.ibruce.info/busuanzi?jsonpCallback=BusuanziCallback", function(data) {    // 更新页面统计数据并显示    bszTag.texts(data);    bszTag.shows();});// 页面标签操作对象bszTag = {    // 支持的统计类型    bszs: ["site_pv", "page_pv", "site_uv"],    /**     * 更新页面中的统计数字     * @param {object} data - 包含统计数据的对象     */    texts: function(data) {        this.bszs.map(function(type) {            var element = document.getElementById("busuanzi_value_" + type);            if (element) {                element.innerHTML = data[type];            }        });    },    /**     * 隐藏所有统计容器     */    hides: function() {        this.bszs.map(function(type) {            var container = document.getElementById("busuanzi_container_" + type);            if (container) {                container.style.display = "none";            }        });    },    /**     * 显示所有统计容器     */    shows: function() {        this.bszs.map(function(type) {            var container = document.getElementById("busuanzi_container_" + type);            if (container) {                container.style.display = "inline";            }        });    }};

虽然对JavaScript不是很熟悉，但这个脚本逻辑相对清晰，不难读懂。以下是该脚本的核心工作流程：

等待浏览器DOM准备
DOM准备完成后，发起JSONP请求
解析请求返回的标签数据，如果请求错误，数据异常就隐藏所有统计容器
获取到计数的数据后，更新携带有ID为busuanzi_value_或busuanzi_container_统计标签的数据，然后修改容器的display属性，从而实现容器和内容的显示

JSONP其实就是GET请求，主要是利用
前端开始主要注重页面，所以先用假数据。
编写路由，在router的文件下编写index.js文件
import Vue from 'vue'import VueRouter from 'vue-router'import Home from '../views/Home.vue'Vue.use(VueRouter)const routes = [  {    path: '/',    name: 'Home',    component: Home  },// 添加test的路由  {    path: '/test',    name: 'Test',    component: () => import('../views/test.vue')  },  {    path: '/about',    name: 'About',    // route level code-splitting    // this generates a separate chunk (about.[hash].js) for this route    // which is lazy-loaded when the route is visited.    component: () => import(/* webpackChunkName: "about" */ '../views/About.vue')  }]const router = new VueRouter({  mode: 'history',  base: process.env.BASE_URL,  routes})export default router
在页面上添加路由跳转，编写App.vue
运行vue项目，查看http://localhost:8080/test是否出现假数据，出现则为成功
后端部分
首先先创建一个SpringBoot的项目，我的版本是2.4.2。
然后在pom.xml导入依赖
                            org.springframework.boot            spring-boot-starter-web                                    mysql            mysql-connector-java            runtime                                    org.projectlombok            lombok            true                                    com.baomidou            mybatis-plus-boot-starter            3.4.1                                    org.springframework.boot            spring-boot-starter-test            test        
创建一个实体类，该类在pojo的包下
package com.yww.springboottest.pojo;import lombok.Data;@Datapublic class User {    private Long id;    private String name;    private Integer age;    private String email;}
创建一个Mapper接口，该接口在Mapper的包下
package com.yww.springboottest.Mapper;import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.yww.springboottest.pojo.User;import org.springframework.stereotype.Repository;// 这里只需要基础BaseMapper接口，泛型放入实体类就好了@Repositorypublic interface UserMapper extends BaseMapper {}
配置SpringBoot，这里使用的配置文件是application.yaml
# 配置MySQLspring:  datasource:    username: root    password: password    url: jdbc:mysql://localhost:3306/Company?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC    driver-class-name: com.mysql.cj.jdbc.Driver# 配置日志，以便更好查看结果 mybatis-plus:  configuration:    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl# 端口自定义，注意和Vue的端口分开，Vue使用了8080，这里就使用8081好了server:  port: 8081
扫描注册Mapper接口
package com.yww.springboottest;import org.mybatis.spring.annotation.MapperScan;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication@MapperScan("com.yww.springboottest.Mapper")public class SpringboottestApplication {    public static void main(String[] args) {        SpringApplication.run(SpringboottestApplication.class, args);    }
查询测试
package com.yww.springboottest;import com.yww.springboottest.Mapper.UserMapper;import com.yww.springboottest.pojo.User;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import java.util.List;@SpringBootTestclass SpringboottestApplicationTests {    @Autowired    private UserMapper userMapper;    @Test    public void FindAll() {        List userList = userMapper.selectList(null);        System.out.println(userList);    }}
得到结果
==>  Preparing: SELECT id,name,age,email FROM user==> Parameters: <==    Columns: id, name, age, email<==        Row: 1, Jone, 18, test1@baomidou.com<==        Row: 2, Jack, 20, test2@baomidou.com<==        Row: 3, Tom, 28, test3@baomidou.com<==        Row: 4, Sandy, 21, test4@baomidou.com<==        Row: 5, Billie, 24, test5@baomidou.com<==        Row: 1327829723124920321, lili, 10, sssss<==        Row: 1327839061415620609, lili, 10, sssss<==        Row: 1327839257776095234, yww, 20, 1141950370@qq.com<==      Total: 8
由此可以看到查询结果没有什么问题，然后就可以写接口返回数据了。
编写接口，该接口在Controller的包下
package com.yww.springboottest.Controller;import com.yww.springboottest.Mapper.UserMapper;import com.yww.springboottest.pojo.User;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class UserController {    @Autowired    private UserMapper userMapper;    @GetMapping("/findall")    public List FindAll() {        return userMapper.selectList(null);    }}
访问http://localhost:8081/findall即可查询到查询返回的数据。
前后端交互
在vue项目里添加axios插件，用来请求接口
    vue add axios
修改test.vue里的数据
在后端部分增加一个工具类，用于解决跨域问题（因为是不同端口的请求），该类在config包下
package com.yww.springboottest.config;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.CorsRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configurationpublic class CrosConfig implements WebMvcConfigurer {    @Override    public void addCorsMappings(CorsRegistry registry) {        registry.addMapping("/**")                .allowCredentials(false)                .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")                .allowedOrigins("*");    }}
然后访问前端项目的页面http://localhost:8080/test，就能看到后端查询并返回的数据了
结尾
这次是一个简单的demo，实际项目还要复杂很多，这个demo虽然简单，但是也是能让你简单了解一下前后端分离的开发流程。

synchronized

Mon, 11 Jan 2021 00:00:00 +0000

应用方式

首先要知道synchronized实现同步的基础为Java中每一个对象都可以作为锁，synchronized一般的使用方法有以下三个。

在普通方法上加synchronized，为方法的对象加锁。
在静态方法上加synchronized，为该方法的类模板加锁。
同步方法块，为给定对象加锁。

每一个线程执行到同步块或者是同步方法（对共享内存进行访问的程序片段称为临界区），就会去申请获得锁。当同步的操作执行完或者是抛出异常时就会把该锁给释放掉。

简单应用

之前的volatile文章有提过，volatile是不保证原子性的，现在就用synchronized来保证那个例子的原子性。

package com.yw;import java.util.concurrent.CountDownLatch;public class Test{    public static void main(String[] args) throws InterruptedException {        Data data = new Data();        //用来辅助确保二十个线程全部执行完毕        CountDownLatch countDownLatch = new CountDownLatch(20);        for (int i = 0; i < 20; i++) {            new Thread(() -> {                //设置次数要多，太少结果不明显                for (int j = 0; j < 1000; j++) {                    data.addData();                }                countDownLatch.countDown();            }).start();        }        countDownLatch.await();        System.out.println("当前资源类的值为----->" + data.datanum);    }}class Data {    int datanum = 0;    // 为该方法加锁，锁的是对象    public synchronized void addData() {        datanum++;    }    //与上面等价，锁的是this对象    public  void addData1() {        synchronized(this) {            datanum++;        }    }}

由此可以看见测试了很多次，答案都是20000，从而用synchronized可以保证了这个例子的原子性。下面我用图来简单讲解一下为什么synchronized能够保持这个例子的原子性。

Monitor

介绍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因某些原因发生了wait等待，Owner恢复为null，并进入Wait set,然后阻塞队列中的线程开始竞争Owner的位置。（这里假设线程2竞争到了）
线程1正常离开临界区，Owner恢复为null，线程1之后不再进入临界区，阻塞队列中的线程就会开始竞争Owner的位置。（这里假设线程2竞争到了）
线程1正常离开临界区，Owner恢复为null，线程1之后还会进入临界区，那线程1就会与阻塞队列中的线程竞争Owner的位置。（这里假设线程2竞争到了）

:::note{type="info"}

Monitor是synchronized实现线程同步的原理（当初只有重量级锁，锁的优化靠其他的机制）。从图中也可以看出为什么wait这些方法要放在synchronized中使用，因为都需要借助到Monitor的机制来进行实现。

:::

Java对象头

Java对象头是存储对象的一些基础信息的集合。

长度	内容	说明
32bit	Mark Word	存储对象的hashCode或锁信息等
32bit	Class Metadata Address	存储到对象类型数据的指针
32bit	Arraylength	数组的长度（要是对象不是数组则没有该项）

这里就不详细探讨后面两个了，这里的重点是Mark Word，现在我们来看看这里面具体存储了什么。

锁状态	25bit		4bit	1bit	2bit
锁状态	23bit	2bit	4bit	是否是偏向锁	锁的标志位
无锁	对象的hashCode		分代年龄	0	01
偏向锁	线程ID	Epoch	对象分代年龄	1	01
轻量级锁	指向栈中锁记录的指针				00
重量级锁	指向互斥量（重量级锁）的指针				10
GC标志	空				11

在JDK1.6之前，synchronized只是一个重量级的锁，当JDK1.6进行更新之后，引入了偏向锁和轻量级锁的概念，所以锁的状态变成了以上的四种。

偏向锁

偏向锁是JDK1.6之后引进的，HotSpot作者发现大多数情况锁不仅存在多线程竞争，而且总是由同一线程多次获得。如果是之前，该线程每次都要获得锁，这样代价也未免太大了一点，所以为了优化这种情况，就出现了偏向锁。

偏向锁，顾名思义，偏爱某个线程的锁。当一个线程访问同步块并获取锁，会在对象头和栈帧中的锁记录里存储偏向的线程ID。以后该线程再次来获取锁，就只需测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁就好了，不必再次进行CAS来操作加锁和解锁。

偏向锁在Java6中是默认开启的，但是要在应用程序启动几秒之后才会激活，也就是说是有延迟的，有必要也可以通过设置参数来设置延迟 -XX:BiasedLockingStartupDelay=0
当不希望使用偏向锁，也可以通过设置参数来关闭,默认进入轻量级锁 -XX:-UseBiasedLocking=false

参考资料

2020年度总结

Fri, 08 Jan 2021 00:00:00 +0000

开篇

刚刚结束了地狱级别难度的期末考试，终于有时间来写这篇总结（不是真的想鸽）。

为什么之前没有写？

那是因为自己真的没什么可以说的（其实是太混了，虽然现在也很混）。

疫情

2020年一开头就不太平，爆发了疫情。新冠的爆发让我被迫在家呆了好几个月，我到现在都记得刚刚爆发时的情景，第一次感觉到生命是如此的脆弱。

不仅如此，新冠的爆发也让我看到了很多魔幻的事情，网上的事情我就不说了，大家懂的都懂，说说我碰上的。

稍微了解我的都知道我家是开药店的，疫情的爆发我相对很多人都更有体会，全镇都勒令关门禁止营业，除了药店，因为还要提供一些药物和口罩。虽说我们这边没有病例，可依旧是一件冒风险的事情。即使这样还会有人向政府举报我们家高价卖口罩（经过政府调查其实并没有），真的是让人心寒。

只能说医疗行业真的不容易。这其实也是为什么全家都叫我学医我还是选择学了计算机的原因（虽然最后进了数学院，有点遗憾）。

到现在疫情都还没有完全结束，总有死灰复燃的苗头，不过还好已经好转很多了，相信一切都会好起来的。

游戏

PC端

PC端我就只玩一款游戏，那就是LOL。这款游戏从我小学六年级一直陪伴我到现在，想想也是玩了好多年了。

不过今年玩的也少很多了，一部分是因为学习上的压力，另一方面就是网络风气。LOL的风气懂得都懂，其实每个游戏都这样，不过这游戏玩家多，现象超级明显，对新人极不友好。

移动端

移动端我就玩的还算多了，毕竟比较方便。

不过也只是玩了两款，那就是明日方舟和公主连结。

不过现在方舟也不玩了，虽然是一个好游戏，但是随着我学习上压力的递增，我也没有这么多时间来去通关了（想到第一次的危机合约，能玩上一天），到后面就都是抄作业了，时间久了就感受不到方舟的乐趣了，我也没有精力一起玩两款游戏，于是我就卸了（所以也没有截图了）。

说到公主连结就精神了，这游戏更加休闲，纯属一个养花瓶游戏，每天十分钟完成日常就可以了，十分适合我这些懒得玩的人，而且角色多好看啊（看看这个万圣忍，这不可爱吗？）。

这游戏最大的内容就是公会战（虽然公会战总是在摸鱼，但有时间还是会很努力的打的），因此我还认识了很多的志同道合的朋友，十分感谢各位的陪伴。

学习

专业学习

因为精力总不花在专业学习上，导致学分绩也就排在中游。（老混子了）

身为数学院的学子没学好数学还是挺惭愧的，以后有空研究深度学习了在认真看一下。（老师也都是研究深度学习的，开发在数学院地位低下hh）

开发

这方面其实也没什么说的了，直接看github吧（不要问什么有两段时间空了，在家是真的无法学习，以后要好好改正了）。

20年也没什么成就，花了挺多时间在这个博客上了。

我从大一下学期就接触了hexo，也就那时候就搭建好了这个博客，当时还是用的是next主题，什么都没整明白。

不过虽然搭建好了，但是没怎么管理，文章也就没怎么写，当时是觉得反正没什么人看，没怎么有动力弄得更好。

今年我就改变了这个想法。毕竟这写的文章不给别人看也是要给自己看的，所以要尽量写好，而且弄得更顺眼。

搭建这个博客的确是很能提高能力的一件事情，当然是尽量完善之后。简单说说搭建这个博客学到了什么。

hexo与github pages（coding等）
域名解析，也因此买了自己的域名，并备了案
html + css + javascript三件套，算是加深一点印像吧
github action等一系列技术
使用CDN来加速自己的网站，怎样进行云存储
很多网络和排错的知识，比如Chrome的F12中的Network。
Linux基本命令和使用一些基本的服务器软件，比如什么Nginx等

不得不说开发真的是一步步上云，上云是必然的趋势了。

读书方面

20年下半年我又重新拾起了书本，因为之前我实在看不下书，一看就困。但是书上会有很多知识比网上的资料要详细（因为又很多书都很经典），只有读书才能学到更多的东西，有很多书还是很有趣的。让我想想我20年看过什么书（当然除去课本）。

网络是怎样连接的
C++ Primer Plus
鸟哥的私房菜
小灰的算法之旅
Java并发编程艺术
大话数据结构
哈喽算法

说了这么多其实有些没完全读完，就别如那本C++ Primer Plus，有这本书的都懂，而且我学的Java，有时间在看吧。

毕竟是从这个学期才开始认真好好读点书，所以看起来很少，21年尽量会看多一点的。

身体

啊这。这个其实也就老样子了，依旧的不健康作息。

特别是前两三周，每天复习到凌晨，以后需要改了。

还有就是运动方面，不是不想跑步，因为疫情，好不容易来到学校前期又太忙后期风吹的我脑袋疼（找借口还是有一手的）。

不行了，真的要好好锻炼了，不然整天都是没精神的。

总结

20年懒散了，21年就必须更加努力才行了。说到努力，其实看到很多网上和现实的大佬，真的是强的人还很努力，对比下自己就完爆了。

的确人不能一直对一件事情保持热情（可能只是我不能吧），所以总会有些时候会丧失对学习的热情，总会颓废几天，不过之后还是要努力学习啊。

想到了DIYgod的签名，写代码是热爱，写到世界充满爱。这可能就是强者吧，越学习越热爱，我什么时候也能这么强。

emm,不说这么多了，21年也希望各位能变得更好吧，毕竟21年对于我们这一届来说还是很重要的，送各位一句话，也是小米的标语，永远相信美好的事情即将发生。

volatile

Fri, 08 Jan 2021 00:00:00 +0000

什么是volatile

volatile是Java提供的一个关键字，是一种轻量级的同步方式，也可以理解为轻量级的synchronized。

:::note{type="error"}

码出高效Java开发手册中是这样说道。 volatile是轻量级的同步方式，这种说法是错误的。它只是轻量级的线程操作可见方式，并非同步方式，如果是多写场景，一定会产生线程安全问题。
这里的错误就不修改了，以便提醒自己。

:::

Java内存结构

Java的内存结构其实说的是JVM的运行时数据区。

绿色代表线程私有的内存区域，紫色的代表所有线程共享的内存区域。

Java内存结构在这里就不展开详细说了，这算是JVM的内容了，这里提前主要是提醒一下，不要与下面学习的Java的内存模型混淆，这两个概念说的并不是同一个东西。

JMM

JMM，全称为Java Memory Model，Java内存模型。

Java内存模型是一组规范或者说是规则，每个线程执行都要遵循这个规范，是用来解决在线程的通信问题的。

JMM是一种规范，是一个抽象的概念，并不真实存在，内存结构才是真实存在的。

在讲解JMM之前先要理解两个概念，主内存和工作内存。

《Java虚拟机规范》试图这样进行定义Java内存模型这个概念。
Java内存模型是用来屏蔽各种硬件和操作系统的内存访问的差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。

主内存

主内存是Java运行时在计算机存储数据的地方，是所有线程共享的，同时多个线程对这个主内存进行修改，就会出现很多的问题，这就是并发操作的问题，需要我们去解决。

工作内存

每个线程都有一个存储数据的地方，用来存储线程需要操作的数据，为什么要这样呢？

因为线程是不能直接对主内存中的数据进行修改的，只能修改线程工作内存中的数据，所以线程修改主内存中的数据时就会将主内存中的数据保存在自己的工作内存，然后在进行操作。

这样就会存在一个问题，每个线程都会对自己的工作内存进行操作，所以每一个线程都无法得知其他线程工作内存中的数据是怎么样的，这就是一个可见性的问题。

JMM的抽象结构

以下是JMM对主内存数据操作时会执行的八个操作。（按顺序）

lock将主内存中的数据变量标识为线程独占状态，即对该变量进行加锁操作，其他线程不能对其操作。
read读取主内存中需要修改的变量，即上个经过加锁操作的变量。
load
将读取到的数据变量载入到线程的工作内存之中。
use
把工作内存中的变量传输给执行引擎，即对该变量进行操作。
assign执行引擎对变量进行操作之后，将得到的变量的值放回工作内存。
store将线程工作内存中的变量存储好。
write将上述存储的变量写入主内存，实现刷新主内存中的值。
unlock将该变量的锁释放，使其能让其他线程进行操作。

:::note{type="info"}

Java内存模型的结构大概率是参考了CPU基于高速缓存的存储交互的设计。
为了提高CPU的效率，添加了高速缓存的概念，用于解决处理器总是等待缓慢的内存读写的问题。在Java内存模型中，工作内存其实就像是一层高速缓存。

:::

JMM的三个特性

Java内存模型就是为了解决对共享数据中的可见性，原子性和有序性问题的一组规则。

即JMM的存在就是为了保证这三个特性，现在具体来看看这三个特性。

可见性

可见性刚刚也讲工作内存的时候也是有提到的，这个其实很好理解，每个线程中的工作内存经过修改写回主内存之后，其他线程都可以看见主内存中的值发生变化，从而解决一些缓存不一致的情况。

原子性

原子性表示一个操作在执行中是不可以被中断的，有点类似事务的原子性，要么成功完成，要么直接失败。

有序性

有序性表示JMM会保证操作是有序执行的。或许有人会感到疑惑，难道程序不都是有序执行的吗？

这就要说到处理器的指令重排了，这涉及到了一些汇编的知识，所以不怎么展开了，大概了解一下。

为了提高CPU的使用率，在程序编译执行的时候，处理器会将指令进行重排优化，一般分为以下三个。

编译器优化的重排
指令并行的重排
内存系统的重排

指令重排使得语句不一定是按从上到下执行的，可能会是乱序执行的，有些语句是存在数据依赖性的才会保持前后顺序。

为什么单线程的时候没有感觉呢？这是因为指令重排不会干扰到单线程执行的结果的，但是在多线程中乱序执行就会出现一些问题，导致得到的结果不一样。

volatile的特点

根据上述JMM的三个特性来说说volatile的特点。

保证可见性
不保证原子性
禁止指令重排

下面就仔细说说volatile的特点。

保证可见性

volatile是可以保证可见性的，现在来验证一下volatile的可见性。

package com.yw;import java.util.concurrent.TimeUnit;public class Test{    public static void main(String[] args)  {        Data data = new Data();System.out.println(Thread.currentThread().getName() + "线程开启");        new Thread(() -> {            System.out.println(Thread.currentThread().getName() + "线程开启！");            // 保证main线程已经执行到循环的部分            try {                TimeUnit.SECONDS.sleep(3);            } catch (InterruptedException e) {                e.printStackTrace();            }            data.modifydata();            System.out.println(Thread.currentThread().getName() + "修改了资源值，当前值为" + data.datanum);        },"第二个线程").start();        while(data.datanum == 0) {            // datanum等于0就一直循环        }        System.out.println(Thread.currentThread().getName() + "线程结束");    }}class Data {    int datanum = 0;    public void modifydata() {        this.datanum = 100;    }}

main线程开启第二个线程线程开启！第二个线程修改了资源值，当前值为100

这个程序的运行结果可以看到，main线程一直没有结束，一直在while循环里出不来。

因为main线程工作内存中datanum是一开始从主内存中拿到的0，在第二个线程将值改为100并刷新之后，由于main线程没收到通知主内存中的值发生了变化，故一直使用工作内存中的值，故一直会进行循环。

那接下来为这个资源变量增加一个volatile之后看看结果。

package com.yw;import java.util.concurrent.TimeUnit;public class Test{    public static void main(String[] args)  {        Data data = new Data();System.out.println(Thread.currentThread().getName() + "线程开启");        new Thread(() -> {            System.out.println(Thread.currentThread().getName() + "线程开启！");            try {                TimeUnit.SECONDS.sleep(3);            } catch (InterruptedException e) {                e.printStackTrace();            }            data.modifydata();            System.out.println(Thread.currentThread().getName() + "修改了资源值，当前值为" + data.datanum);        },"第二个线程").start();        while(data.datanum == 0) {            // datanum等于0就一直循环        }        System.out.println(Thread.currentThread().getName() + "线程结束");    }}class Data {    volatile int datanum = 0;    public void modifydata() {        this.datanum = 100;    }}

main线程开启第二个线程线程开启！第二个线程修改了资源值，当前值为100main线程结束

发现main线程是正常结束了，故可以知道main线程知道主内存中的值发生了改变，故该资源类对所有线程具有了可见性，故可以知道volatile是可以保证可见性的。

那么问题来了，volatile是怎么保证可见性的。

用volatile修饰的变量在工作内存中被修改之后，就会将该值强制刷新到主内存当中去
每个线程在修改volatile修饰的变量前，都会触发总线嗅探，保证工作内存中的值与主内存一样在进行修改。

:::note{type="info"}

每个处理器通过嗅探总线上的资源类来确保自己工作内存的缓存值是否已经过期，如果过期就会将该缓存行设置为无效，然后重修读取主内存中的自己过期的值进行修改，这就是总线嗅探机制，当高并发多个线程不断进行总线嗅探就会导致总线风暴。（我是这么理解的）

:::

不保证原子性

这个其实很好验证，看以下代码。

package com.yw;import java.util.concurrent.CountDownLatch;public class Test{    public static void main(String[] args) throws InterruptedException {        Data data = new Data();        //用来辅助确保二十个线程全部执行完毕        CountDownLatch countDownLatch = new CountDownLatch(20);        for (int i = 0; i < 20; i++) {            new Thread(() -> {                //设置次数要多，太少结果不明显                for (int j = 0; j < 1000; j++) {                    data.addData();                }                countDownLatch.countDown();            }).start();        }        countDownLatch.await();        System.out.println("当前资源类的值为----->" + data.datanum);    }}class Data {    volatile int datanum = 0;    public void addData() {        datanum++;    }}

得到的结果按理说应该是20000,但是执行了很多次出来的结果都不是20000，都是比20000少的。这显而易见，每个线程并不能全部完成自己的任务，从而可知volatile不保证原子性。为什么不保证原子性呢？

首先要知道的一点是，自增或者自减其实并不是一个原子性的操作，我们总觉得它是一个语句所以就把它当成了一个原子性操作，这是不对的，在底层i++是有几个指令组成的，现在来探究一下。

首先写一个简单的自增语句。

package com.yw;public class Test{    public static void main(String[] args) throws InterruptedException {        int i = 0;        i++;        System.out.println(i);    }}

对该程序进行javap -c的反汇编得到以下的指令。

Compiled from "Test.java"public class com.yw.Test {  public com.yw.Test();    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."":()V       4: return  public static void main(java.lang.String[]) throws java.lang.InterruptedException;    Code:       0: iconst_0       1: istore_1       2: iinc          1, 1       5: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;       8: iload_1       9: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V      12: return}

于是就可以得到i++的指令。

       1: istore_1//将栈顶int型数值存入第一个本地变量       2: iinc          1, 1//将指定int型变量增加指定值       5: getstatic     #2//获取指定类中的静态域，并将其压入栈顶

所以可以看到自增的指令并不是一条，所以就会有可能出现一些情况导致出现错误。

比如存在两个线程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写

在每个volatile写操作前面插入一个StoreStore Barriers
在每个volatile写操作后面插入一个StoreLoad Barriers

volatile读

在每个volatile读操作后面插入一个LoadLoad Barriers
在每个volatile读操作后面插入一个LoadStore Barriers

参考资料

初识JUC编程

Sat, 02 Jan 2021 00:00:00 +0000

什么是JUC

JUC是java.util.concurrent包的缩写，这个包是Java的并发编程的工具类，所以JUC编程可以理解为Java的并发编程。

一些基本的概念

程序，进程与线程

程序是一组计算机能识别和执行的指令，只是一个静态的概念。
进程是操作系统资源分配的基本单位，可以理解为一个程序的运行就为一个进程，它是一个动态的实体。
线程可以理解为进程之内为了完成某一个任务的线路，一个进程为了完成任务，可能就会将该任务拆分为很多子任务，并开辟多个线程来完成这些子任务，从而加快完成总任务的速度。

开启线程的方式

继承Thread类，重写run()方法，调用start()方法
实现Runnable接口，重写run()方法，创建Thread实例，调用其中的start()方法。
实现Calleble接口

串行，并发和并行

串行很好理解，每个任务都会排队执行，上一个任务没有结束，下一个任务就无法开始。
并发就是不用等待上一个任务执行完毕，下一个任务就能开始执行，每个任务交替执行，形成每个任务同时进行的假象。
并行就是任务同时进行，而不是像并发一样交替执行。
简单理解为并发就是交替做一件事，并行就是同时做不同的事。
即使是单核的CPU也能进行多线程的操作，但是做不到并行。

上下文切换

即使是单核的CPU也是支持多线程执行的，CPU通过给每个线程分配CPU时间片来实现这个机制，这个时间片非常短，所以我们觉得多个线程是一起执行的，但其实是CPU在不断的切换线程执行。

在切换线程前会保存这个线程任务的状态，然后加载下个线程任务的状态，这个过程就是一次上下文切换。

并发是否比串行执行速度快

刚刚提到了上下文切换，可以知道并发其实并不一定会比串行的速度快，因为并发会消耗一部分时间在上下文切换上，所以当并发执行的操作不超过百万次时，速度会比串行执行操作要慢。

Java进程的状态

从Java的Thread类中就可以看到Java进程的全部状态了。

    public enum State {        /**         * Thread state for a thread which has not yet started.         */        NEW,        /**         * Thread state for a runnable thread.  A thread in the runnable         * state is executing in the Java virtual machine but it may         * be waiting for other resources from the operating system         * such as processor.         */        RUNNABLE,        /**         * Thread state for a thread blocked waiting for a monitor lock.         * A thread in the blocked state is waiting for a monitor lock         * to enter a synchronized block/method or         * reenter a synchronized block/method after calling         * {@link Object#wait() Object.wait}.         */        BLOCKED,        /**         * Thread state for a waiting thread.         * A thread is in the waiting state due to calling one of the         * following methods:         *          *   {@link Object#wait() Object.wait} with no timeout
         *   {@link #join() Thread.join} with no timeout
         *   {@link LockSupport#park() LockSupport.park}
         * 
         *         * A thread in the waiting state is waiting for another thread to         * perform a particular action.         *         * For example, a thread that has called Object.wait()         * on an object is waiting for another thread to call         * Object.notify() or Object.notifyAll() on         * that object. A thread that has called Thread.join()         * is waiting for a specified thread to terminate.         */        WAITING,        /**         * Thread state for a waiting thread with a specified waiting time.         * A thread is in the timed waiting state due to calling one of         * the following methods with a specified positive waiting time:         * 
         *   {@link #sleep Thread.sleep}
         *   {@link Object#wait(long) Object.wait} with timeout
         *   {@link #join(long) Thread.join} with timeout
         *   {@link LockSupport#parkNanos LockSupport.parkNanos}
         *   {@link LockSupport#parkUntil LockSupport.parkUntil}
         * 
         */        TIMED_WAITING,        /**         * Thread state for a terminated thread.         * The thread has completed execution.         */        TERMINATED;    }

synchronized

首先来看个简单的例子。

public class Test implements Runnable{    private int ticket = 30;    private boolean flag = true;    public static void main(String[] args) {        Test test = new Test();        new Thread(test,"第一个人").start();        new Thread(test,"第二个人").start();        new Thread(test,"第三个人").start();    }    /**        买票的方法     */    public void buyTicket() {        if(ticket <= 0) {            flag = false;            return;        }        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + "获得了第" + ticket-- + "张票");    }    /**         run方法     */    @Override    public void run() {        while(flag) {            buyTicket();        }    }}

从上面这个例子就会出现两种不正常的情况。

先买到了第n张票之后才买到第n-1张票
出现负数的票

因为多线程难以统一资源所以会出现的这些异常情况，这是我们不想看到的。处理并发的有效的手段就是加锁，所以我们需要用加锁来解决这个问题。

这里使用了synchronized来对买票的方法进行加锁，可以解决一些简单的并发问题。

package com.yw;/** * @ClassName Test * @Descriprtion TODO * @Author yww * @Date 2020/12/27 15:21 * @Version 1.0 **/public class Test implements Runnable{    private int ticket = 30;    private boolean flag = true;    public static void main(String[] args) {        Test test = new Test();        new Thread(test,"第一个人").start();        new Thread(test,"第二个人").start();        new Thread(test,"第三个人").start();    }    /**        买票的方法     */    public synchronized void buyTicket() {        if(ticket <= 0) {            flag = false;            return;        }        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(Thread.currentThread().getName() + "获得了第" + ticket-- + "张票");    }    /**         run方法     */    @Override    public  void run() {        while(flag) {            buyTicket();        }    }}

synchronized分为三种使用情况。

在普通方法上使用synchronized关键字，锁住的是实例对象，每个实例都各自有自己的锁，互不干扰。
在静态方法上使用synchronized关键字，锁住的是类，即每个实例对象共用这个锁。
同步方法块，锁的对象不定，看个人行为。

Lock锁

也可以不用synchronized来加锁，这里就来讲讲第二种方式。

这里就只学习Lock类的ReentrantLock这个实现类。

先探究一下这个实现类的构造方法。

    /**     * Creates an instance of {@code ReentrantLock}.     * This is equivalent to using {@code ReentrantLock(false)}.     */    public ReentrantLock() {        sync = new NonfairSync();    }    /**     * Creates an instance of {@code ReentrantLock} with the     * given fairness policy.     *     * @param fair {@code true} if this lock should use a fair ordering policy     */    public ReentrantLock(boolean fair) {        sync = fair ? new FairSync() : new NonfairSync();    }

由此可以看出，不加参数使用该实现类，这个锁就是非公平锁，加了true的参数，就是公平锁。

简单的解释一下公平锁与非公平锁。
公平锁，表示先来先服务，按照申请锁的顺序去获得锁，每个申请锁的线程都会形成一个队列，一个个来获得锁。
非公平锁，表示每个线程都可以去申请获得锁，获取不到就等待，获取得到就可以获得锁。
很多情况默认都是是非公平锁，synchronized也算是非公平锁，谁先抢到，谁就进行。

现在就用该实现类来解决一下上面买票的问题。

public class Test implements Runnable{    private int ticket = 30;    private boolean flag = true;    Lock lock = new ReentrantLock();    public static void main(String[] args) {        Test test = new Test();        new Thread(test,"第一个人").start();        new Thread(test,"第二个人").start();        new Thread(test,"第三个人").start();    }    /**        买票的方法     */    public  void buyTicket() {        // 加锁        lock.lock();        try {            if(ticket <= 0) {                flag = false;                return;            }            Thread.sleep(100);            System.out.println(Thread.currentThread().getName() + "获得了第" + ticket-- + "张票");        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            // 解锁            lock.unlock();        }    }        /**         run方法     */    @Override    public  void run() {        while(flag) {            buyTicket();        }    }}

这样就可以进行简单的加锁来解决一些线程出现的问题。

synchronized和ReentrantLock区别

synchronized是一个关键字，是JVM层面的，而ReentrantLock是一个来实现类，是API层面的。
synchronized是自动加锁和释放锁的，而ReentrantLock是手动加锁的，所以也需要手动释放锁。
synchronized的锁是不可中断的，除非是临界区内的代码出现异常或者是正常结束释放锁，而ReentrantLock的锁是可以中断的，可以使用trylock方法设置超时方法。
synchronized是非公平锁，而ReentrantLock默认是非公平锁，但是可以通过构造方法设置成公平锁。
synchronized的线程阻塞后是只能随机唤醒进程，而ReentrantLock通过Condition类可以精准唤醒被绑定的线程。

生产者和消费者的问题

synchronzied

我们计划，当商品数量为1的时候，消费者进行消费，当商品数量为0的时候，生产者进行生产。

所以这会涉及到线程之间的通信，商品数量为0的时候消费者就会进入等待，并通知生成者进入就绪状态。商品数量为1的时候生成者就会进入等待，并通知消费者进入就绪状态

public class Test{    public static void main(String[] args) {        Shop shop = new Shop();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.buyShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"消费者").start();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.AddShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"生成者").start();    }}class Shop {    private int shopnum = 1;    public synchronized void buyShop() throws InterruptedException {        if(shopnum == 0) {            this.wait();        }        System.out.println(Thread.currentThread().getName() + shopnum--);        this.notifyAll();    }    public synchronized void AddShop() throws InterruptedException {        if(shopnum == 1) {            this.wait();        }        System.out.println(Thread.currentThread().getName() + shopnum++);        this.notifyAll();    }}

这个代码还会有一个虚假唤醒的问题，当线程数增加到了两个以上，就会出现一些异常情况，比如票数会到达0与1之外的范围，这是因为使用if来进行判断等待状态，只会判断一次，所以可能会出现两个线程都判断成功的情况，所以必须要使用while来进行判断，这样可以防止虚假唤醒的问题。

public class Test{    public static void main(String[] args) {        Shop shop = new Shop();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.buyShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"消费者").start();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.AddShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"生产者").start();    }}class Shop {    private int shopnum = 1;    public synchronized void buyShop() throws InterruptedException {        // 进入等待        while(shopnum == 0) {            this.wait();        }        System.out.println(Thread.currentThread().getName() + shopnum--);        // 通知唤醒        this.notifyAll();    }    public synchronized void AddShop() throws InterruptedException {        // 进入等待        while(shopnum == 1) {            this.wait();        }        // 通知唤醒        System.out.println(Thread.currentThread().getName() + shopnum++);        this.notifyAll();    }}

Lock锁

这里的Lock接口是没办法实现线程等待和唤醒的，所以就使用了一个Condition类的await方法和signal方法来代替wait和notifyall方法。

public class Test{    public static void main(String[] args) {        Shop shop = new Shop();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.buyShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"消费者1").start();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.AddShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"生产者1").start();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.buyShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"消费者2").start();        new Thread(()->{            for (int i = 0; i < 50; i++) {                try {                    shop.AddShop();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        },"生产者2").start();    }}class Shop {    private int shopnum = 1;    Lock lock = new ReentrantLock();    Condition condition = lock.newCondition();    public  void buyShop() throws InterruptedException {        lock.lock();        try {            while(shopnum == 0) {                condition.await();            }            System.out.println(Thread.currentThread().getName() + shopnum--);            condition.signal();        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            lock.unlock();        }    }    public  void AddShop() throws InterruptedException {        lock.lock();        try {            while(shopnum == 1) {                condition.await();            }            System.out.println(Thread.currentThread().getName() + shopnum++);            condition.signal();        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            lock.unlock();        }    }}

读写锁

读写锁，这个类其实和上面两个加锁方法差不多，该锁可以将封锁粒度减少一点。读写锁其实就是之前学到的排他锁和共享锁。

线程对一个资源加上排它锁，表示只允许该线程进行读写资源，不允许其他线程读写，直到该线程释放了排它锁。

线程对一个资源加上共享锁，表示该线程可以对该资源进行读操作，但不能修改资源，其他的线程可以对该资源加共享锁，但不能加排它锁进行修改该资源，直到所有线程释放了对该资源的共享锁才能为该资源加排它锁进行修改。

public class Test{    public static void main(String[] args) {        Mycache mycache = new Mycache();        for(int i = 1; i <= 10; i++) {            final int temp = i;            new Thread(()->{                mycache.put(temp + "",temp + "");            },String.valueOf(i)).start();        }        for(int i = 1; i <= 10; i++) {            final int temp = i;            new Thread(()->{                mycache.get(temp + "");            },String.valueOf(i)).start();        }    }}class Mycache {    private volatile Map map = new HashMap<>();    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();    public void put(String key,String value) {        // 加上排它锁        readWriteLock.writeLock().lock();        try {            System.out.println(Thread.currentThread().getName() + "写入" + key);            map.put(key,value);            System.out.println(Thread.currentThread().getName() + "写入完成");        } catch (Exception e) {            e.printStackTrace();        } finally {            // 释放排它锁            readWriteLock.writeLock().unlock();        }    }    public void get(String key) {        // 加上共享锁        readWriteLock.readLock().lock();        try {            System.out.println(Thread.currentThread().getName() + "读取" + key);            String value = map.get(key);            System.out.println(Thread.currentThread().getName() + "读取完成");        } catch (Exception e) {            e.printStackTrace();        } finally {            // 释放共享锁            readWriteLock.readLock().unlock();        }    }}

集合类

经常使用的一些集合类在并发操作下很多都是不安全的，多个线程进行写入操作就会出现并发修改异常ConcurrentModificationException。所以现在来探讨一下解决的方案。

List

使用Vector实现类，这个实现类是线程安全的，为什么安全可以看一下它的add方法，它是使用了synchronized关键字的。
```
public synchronized boolean add(E e) {    modCount++;    ensureCapacityHelper(elementCount + 1);    elementData[elementCount++] = e;    return true;}
```

使用Collections工具类将Arraylist转换成安全的实现类。

public class Test{    public static void main(String[] args) {        List list = Collections.synchronizedList(new ArrayList<>());        for(int i = 1; i <= 20; i++) {            new Thread(()->{                list.add("1111");                System.out.println(list);            },String.valueOf(i)).start();        }    }}

使用CopyOnWriteArrayList实现类。

public class Test{    public static void main(String[] args) {        List list = new CopyOnWriteArrayList<>();        for(int i = 1; i <= 20; i++) {            new Thread(()->{                list.add("1111");                System.out.println(list);            },String.valueOf(i)).start();        }    }}

Set

HashSet也和ArrayList一样不安全，所以需要进行一些操作。

使用Collections工具类将HashSet转换成安全的实现类。

public class Test{    public static void main(String[] args) {        Set set = Collections.synchronizedSet(new HashSet<>());        for(int i = 1; i <= 20; i++) {            new Thread(()->{                set.add(UUID.randomUUID().toString());                System.out.println(set);            },String.valueOf(i)).start();        }    }}

使用CopyOnWriteArrayList实现类。

public class Test{    public static void main(String[] args) {        Set set = new CopyOnWriteArraySet<>();        for(int i = 1; i <= 20; i++) {            new Thread(()->{                set.add(UUID.randomUUID().toString());                System.out.println(set);            },String.valueOf(i)).start();        }    }}

Map

使用Collections工具类将HashMap转换成安全的实现类。

public class Test{    public static void main(String[] args) {        Map map = Collections.synchronizedMap(new HashMap<>());        for(int i = 1; i <= 20; i++) {            new Thread(()->{                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString());                System.out.println(map);            },String.valueOf(i)).start();        }    }}

使用ConcurrentHashMap实现类。

public class Test{    public static void main(String[] args) {        Map map = new ConcurrentHashMap<>();        for(int i = 1; i <= 20; i++) {            new Thread(()->{                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString());                System.out.println(map);            },String.valueOf(i)).start();        }    }}

Callable

Callable是第三种开启线程的方式，但是线程的开启都是通过Thread类的start方法来开启的，而Callable的实现类是无法传入Thread类中的，所以需要借用中间类来实现。

public class Test{    public static void main(String[] args) throws ExecutionException, InterruptedException {        HelloTest helloTest = new HelloTest();        FutureTask futureTask = new FutureTask(helloTest);        new Thread(futureTask,"线程").start();        // 获取返回值，有缓存，所以会有可能出现线程阻塞        String msg = (String) futureTask.get();        System.out.println(msg);    }}class HelloTest implements Callable{    @Override    public String call() throws Exception {        System.out.println("call方法调用");        return "hello from Callable";    }}

其中的FutureTask是实现了RunnableFuture，而RunnableFuture接口继承了Runnable，其实借用FutureTask类打开线程本质就是接用Runnable来开启线程的。

常用辅助类

CountDownLatch

这是一个减法计数器，可以使一个线程等很多线程执行完毕后在执行。

public class Test{    public static void main(String[] args) throws InterruptedException {        // 计数器初始赋值        CountDownLatch countDownLatch = new CountDownLatch(10);        for(int i = 1; i <= 10; i++) {            new Thread(()->{                System.out.println(Thread.currentThread().getName() + "线程执行");                // 计数器减一                countDownLatch.countDown();            },String.valueOf(i)).start();        }        // 等待计数器为0        countDownLatch.await();        System.out.println("程序结束");    }}

CyclicBarrier

这是一个加法计数器，可以使很多线程到达一个目的地后在执行线程。

public class Test{    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {        // 设置线程数到10执行创建的线程，以下就是线程开到10个才会进行打印线程        CyclicBarrier cyclicBarrier = new CyclicBarrier(10,()->{            System.out.println("所有线程开启成功");        });        for(int i = 1; i <= 10; i++) {            new Thread(()->{                System.out.println(Thread.currentThread().getName() + "线程启动");                try {                    // 线程到10就会通知之前定义的线程                    cyclicBarrier.await();                } catch (InterruptedException e) {                    e.printStackTrace();                } catch (BrokenBarrierException e) {                    e.printStackTrace();                }            },String.valueOf(i)).start();        }    }}

Semaphore

一个计数信号量。

public class Test{    public static void main(String[] args) {        // 指定线程的最高开启数量        Semaphore semaphore = new Semaphore(2);        for(int i = 0; i <= 10; i++) {            new Thread(() ->{                try {                    // 等待Semaphore中线程数少于限制的量，然后开启线程，将该线程计入Semaphore                    semaphore.acquire();                    System.out.println(Thread.currentThread().getName() + "开启了线程");                    try {                        TimeUnit.SECONDS.sleep(2);                    } catch (InterruptedException interruptedException) {                        interruptedException.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName() + "结束了线程");                } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                    // 线程结束，将该线程从Semaphore释放                    semaphore.release();                }            },String.valueOf(i)).start();        }    }}

阻塞队列

阻塞队列顾名思义就是会阻塞的队列，是队列的子类，其类为BlockingQueue,数组的实现方式是ArrayBlockingQueue和链表的实现方式是LinkedBlockingQueue。

有返回值会抛出异常

public class Test{    public static void main(String[] args) {        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);        // 队列满了在用add方法入队就会抛出异常        // java.lang.IllegalStateException: Queue full        arrayBlockingQueue.add("1");        arrayBlockingQueue.add("2");        arrayBlockingQueue.add("3");        arrayBlockingQueue.add("4");        // 返回队首元素        System.out.println(arrayBlockingQueue.element());        // 队列空了再用remove出队就会抛出异常        // java.util.NoSuchElementException        arrayBlockingQueue.remove();        arrayBlockingQueue.remove();        arrayBlockingQueue.remove();        arrayBlockingQueue.remove();    }}

    // add的实现，add是用了父类的实现    public boolean add(E e) {        return super.add(e);    } // 父类实现 public boolean add(E e) {        if (offer(e))            return true;        else            throw new IllegalStateException("Queue full");    } // remove方法的实现    public E remove() {        E x = poll();        if (x != null)            return x;        else            throw new NoSuchElementException();    } // element方法的实现    public E element() {        E x = peek();        if (x != null)            return x;        else            throw new NoSuchElementException();    }

这里可以看出这三个方法都是调用了下面不抛出异常的三个方法，加以修饰让其抛出异常而已。

有返回值不抛出异常

public class Test{    public static void main(String[] args) {        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);        // 用offer入队，满了也不会出异常，会返回false        System.out.println(arrayBlockingQueue.offer("1"));        System.out.println(arrayBlockingQueue.offer("2"));        System.out.println(arrayBlockingQueue.offer("3"));        System.out.println(arrayBlockingQueue.offer("4"));        // 返回队首元素        System.out.println(arrayBlockingQueue.peek());  // 用poll出队，对空会返回null        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll());    }}

 // offer的实现 public boolean offer(E e) {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lock();        try {            if (count == items.length)                return false;            else {                enqueue(e);                return true;            }        } finally {            lock.unlock();        } // poll的实现    public E poll() {        final ReentrantLock lock = this.lock;        lock.lock();        try {            return (count == 0) ? null : dequeue();        } finally {            lock.unlock();        }    }    // peek的实现    public E peek() {        final ReentrantLock lock = this.lock;        lock.lock();        try {            return itemAt(takeIndex); // null when queue is empty        } finally {            lock.unlock();        }    }

由此可以看出这三个方法都是用到了锁的，使得上面抛出异常的三个方法也是加锁了的。

阻塞等待

public class Test{    public static void main(String[] args) throws InterruptedException {        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  // 因为队满了在用put入队，就会一直等待        arrayBlockingQueue.put("1");        arrayBlockingQueue.put("2");        arrayBlockingQueue.put("3");        arrayBlockingQueue.put("4");  // 因为队空了在用take出队，就会一直等待        System.out.println(arrayBlockingQueue.take());        System.out.println(arrayBlockingQueue.take());        System.out.println(arrayBlockingQueue.take());        System.out.println(arrayBlockingQueue.take());    }}

    // put的实现    public void put(E e) throws InterruptedException {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == items.length)                notFull.await();            enqueue(e);        } finally {            lock.unlock();        }    } // take的实现    public E take() throws InterruptedException {        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0)                notEmpty.await();            return dequeue();        } finally {            lock.unlock();        }    }

超时等待

public class Test{    public static void main(String[] args) throws InterruptedException {        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);  // 在队满的时候在入队，可以设置一个时间，时间过了就不等待了        arrayBlockingQueue.offer("1");        arrayBlockingQueue.offer("2");        arrayBlockingQueue.offer("3");        arrayBlockingQueue.offer("4",2, TimeUnit.SECONDS);  // 在队空的时候在出队，可以设置一个时间，时间过了就不等待了        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll());        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));    }}

 // 这是超时等待的offer方法 public boolean offer(E e, long timeout, TimeUnit unit)        throws InterruptedException {        checkNotNull(e);        long nanos = unit.toNanos(timeout);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == items.length) {                if (nanos <= 0)                    return false;                nanos = notFull.awaitNanos(nanos);            }            enqueue(e);            return true;        } finally {            lock.unlock();        }    } // 这是超时等待的poll方法    public E poll(long timeout, TimeUnit unit) throws InterruptedException {        long nanos = unit.toNanos(timeout);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0) {                if (nanos <= 0)                    return null;                nanos = notEmpty.awaitNanos(nanos);            }            return dequeue();        } finally {            lock.unlock();        }    }

总结

方法	有返回值抛出异常	有返回值不抛出异常	阻塞等待	超时等待
入队	add	offer	put	带参数的offer
出队	remove	poll	take	带参数的poll
返回队首元素	element	peek	-	-

同步队列

BlockingQueue还有一个实现类为同步队列SynchronousQueue，这个队列只能容纳一个元素，当元素满了再入队就会等待，当元素空了再出队也会等待，类似于上述的阻塞等待，但是只能容纳一个元素。

public class Test{    public static void main(String[] args)  {        BlockingQueue blockingQueue = new SynchronousQueue<>();        new Thread(()->{            try {                System.out.println(Thread.currentThread().getName() + "put  1");                blockingQueue.put("1");                System.out.println(Thread.currentThread().getName() + "put  2");                blockingQueue.put("2");                System.out.println(Thread.currentThread().getName() + "put  3");                blockingQueue.put("3");            } catch (InterruptedException e) {                e.printStackTrace();            }        },"线程一").start();        new Thread(()->{            try {                TimeUnit.SECONDS.sleep(3);                System.out.println(Thread.currentThread().getName() + "take  1");                System.out.println(blockingQueue.take());                TimeUnit.SECONDS.sleep(3);                System.out.println(Thread.currentThread().getName() + "take  2");                System.out.println(blockingQueue.take());                TimeUnit.SECONDS.sleep(3);                System.out.println(Thread.currentThread().getName() + "take  3");                System.out.println(blockingQueue.take());            } catch (InterruptedException e) {                e.printStackTrace();            }        },"线程二").start();    }}

线程池

四个方法

创建线程池的方法

 // 创建一个单例线程池，即只有一个线程的线程池 ExecutorService pool1 = Executors.newSingleThreadExecutor(); // 创建一个指定线程数的线程池，超出的线程就会在队列等待    ExecutorService pool2 = Executors.newFixedThreadPool(5); // 创建一个可缓存的线程池，多个线程就有多个线程（看CPU）    ExecutorService pool3 = Executors.newCachedThreadPool(); // 创建一个定长的线程池，支持定时以及周期性任务执行 ExecutorService pool4 = Executors.newScheduledThreadPool(5);

// 看一下创建线程的底层实现    public static ExecutorService newSingleThreadExecutor() {        return new FinalizableDelegatedExecutorService            (new ThreadPoolExecutor(1, 1,                                    0L, TimeUnit.MILLISECONDS,                                    new LinkedBlockingQueue()));    }    public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads,                                      0L, TimeUnit.MILLISECONDS,                                      new LinkedBlockingQueue());    }    public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                      60L, TimeUnit.SECONDS,                                      new SynchronousQueue());    }    public ScheduledThreadPoolExecutor(int corePoolSize) {        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,              new DelayedWorkQueue());    }

阿里巴巴编程规范不建议用这种方式开启线程池，因为可能会因为创建线程过多或者请求队列的线程过多而产生OOM，所以建议使用原生的ThreadPoolExecutor来开辟。

使用线程池里的线程

 // 丢入Runnable即可 pool1.execute(); // 比如    pool1.execute(()->{        System.out.println(Thread.currentThread().getName());    });

使用完记得关闭线程池
```
 pool1.shutdown();
```

七大参数

七大参数其实就是ThreadPoolExecutor的参数，先看一下构造方法。

    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue workQueue) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), defaultHandler);    } // 点进this之后，上面只是简化版    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue workQueue,                              ThreadFactory threadFactory,                              RejectedExecutionHandler handler) {        if (corePoolSize < 0 ||            maximumPoolSize <= 0 ||            maximumPoolSize < corePoolSize ||            keepAliveTime < 0)            throw new IllegalArgumentException();        if (workQueue == null || threadFactory == null || handler == null)            throw new NullPointerException();        this.acc = System.getSecurityManager() == null ?                null :                AccessController.getContext();        this.corePoolSize = corePoolSize;        this.maximumPoolSize = maximumPoolSize;        this.workQueue = workQueue;        this.keepAliveTime = unit.toNanos(keepAliveTime);        this.threadFactory = threadFactory;        this.handler = handler;    }

参数	含义
int corePoolSize	核心线程数
int maximumPoolSize	最大并发的线程数，只有阻塞队列满了才会开启更多的线程直到最大并发数
long keepAliveTime	超时等候时间，时间到了就会释放线程
TimeUnit unit	设置时间长度，与上一个参数搭配
BlockingQueue workQueue	阻塞队列
ThreadFactory threadFactory	线程工厂，一般固定
RejectedExecutionHandler handler	拒绝策略，即线程数多到使阻塞队列满了而且最大线程数不够用了才执行的策略

public class Test{    public static void main(String[] args)  {        ExecutorService pool = new ThreadPoolExecutor(                2,                5,                3,                TimeUnit.SECONDS,                new ArrayBlockingQueue<>(5),                Executors.defaultThreadFactory(), // 一般都是这个                new ThreadPoolExecutor.AbortPolicy()        );    }}

四个拒绝策略

拒绝策略共有四个，都是当线程数大于最大并发数加阻塞队列容量的时候，才会采取的策略。

 *  * *  In the default {@link ThreadPoolExecutor.AbortPolicy}, the * handler throws a runtime {@link RejectedExecutionException} upon * rejection. 
 * *  In {@link ThreadPoolExecutor.CallerRunsPolicy}, the thread * that invokes {@code execute} itself runs the task. This provides a * simple feedback control mechanism that will slow down the rate that * new tasks are submitted. 
 * *  In {@link ThreadPoolExecutor.DiscardPolicy}, a task that * cannot be executed is simply dropped.  
 * * In {@link ThreadPoolExecutor.DiscardOldestPolicy}, if the * executor is not shut down, the task at the head of the work queue * is dropped, and then execution is retried (which can fail again, * causing this to be repeated.) 
 * *

AbortPolicy丢弃任务并抛出RejectedExecutionException异常。

    public static class AbortPolicy implements RejectedExecutionHandler {        /**         * Creates an {@code AbortPolicy}.         */        public AbortPolicy() { }        /**         * Always throws RejectedExecutionException.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         * @throws RejectedExecutionException always         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            throw new RejectedExecutionException("Task " + r.toString() +                                                 " rejected from " +                                                 e.toString());        }    }

这是线程池默认的拒绝策略，在类中也可以看到。

    private static final RejectedExecutionHandler defaultHandler =        new AbortPolicy();

CallerRunsPolicy

调用任务的run()方法绕过线程池直接执行。

    public static class CallerRunsPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code CallerRunsPolicy}.         */        public CallerRunsPolicy() { }        /**         * Executes task r in the caller's thread, unless the executor         * has been shut down, in which case the task is discarded.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {                r.run();            }        }    }

DiscardPolicy丢弃任务，但是不会抛出异常，这是不推荐使用的拒绝策略。

    public static class DiscardPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code DiscardPolicy}.         */        public DiscardPolicy() { }        /**         * Does nothing, which has the effect of discarding task r.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {        }    }

DiscardOldestPolicy

抛弃队列中等待最久的任务，然后把当前任务加入队列中。

    public static class DiscardOldestPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code DiscardOldestPolicy} for the given executor.         */        public DiscardOldestPolicy() { }        /**         * Obtains and ignores the next task that the executor         * would otherwise execute, if one is immediately available,         * and then retries execution of task r, unless the executor         * is shut down, in which case task r is instead discarded.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {                e.getQueue().poll();                e.execute(r);            }        }    }

关于最大并发线程数的设置

CPU密集型CPU有几核就设置为多少个线程。

 // 该方法可以返回CPU的核心数 Runtime.getRuntime().availableProcessors();

IO密集型根据具体情况确定，若有15个任务，那最大并发线程数可以设置为大于15，比如设置为30

CMS垃圾回收器

Sun, 13 Dec 2020 00:00:00 +0000

初步了解

CMS GC是HotSpot虚拟机第一款真正意义上的并发收集器，第一次实现了垃圾收集线程与用户线程同时工作
CMS GC的特点是尽可能减少STW时间，即低延迟，Parallel是吞吐量优先
CMS采用标记-清除算法和Stop The World机制，在空间碎片化严重的时候也会使用一次标记-压缩算法来整理空间

工作流程

CMS的工作流程大致分为七个步骤。

初始标记阶段
并发标记阶段
预清理阶段
可被终止的预清理阶段
重新标记阶段
并发清除阶段
并发重置

初始标记阶段

这个阶段主要的工作就是标记出GC Roots能直接关联的对象，这里可分为两部分。

标记老年代所有的GC Roots对象
标记年轻代中活着的对象引用到老年代的对象

这个阶段因为涉及到了GC Roots的确定，所以会发生STW，为了减短STW时间，这个阶段的标记只是初始标记，之后还会继续标记。

并发标记阶段

由初始标记阶段标记到的对象开始寻找所有存活的对象，这个阶段是并发执行的，用户线程与标记线程同时进行，不会发生STW。

因为此时是用户线程和标记是并发执行的，所以有可能会出现一些情况，会导致有些对象会漏标。比如

年轻代的对象变成老年代对象
直接在老年代分配对象
老年代的对象进行引用的更新

除了这些常见的情况，还会有一些特殊情况，所以这个阶段的标记是不完整的，还需要后面标记。

为了提高后面的重新标记的效率，该阶段还会把上述漏标的对象所在的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最后的标记阶段，所以这个阶段的主要任务就是标记所有老年代的存活对象。

这个阶段的主要任务如下：

扫描GC Roots的引用链，确定老年代存活对象
扫描整个年轻代，查找是否有年轻代对象引用了老年代
处理所有之前遗留下来的Dirty的对象

因为这个阶段需要确定所有老年代的存活对象，所以不能在并发处理了，不然又会有其他引用变化导致标记不全，所以这个阶段是会发生STW的，而且这个停顿时间是整个CMS垃圾回收里时间最长的一个。

并发清除阶段

清除那些“死了”的对象，因为这个阶段是标记-清除算法中的清除阶段，不涉及移动对象，所以是并发执行的。

因为这个阶段是并发的，有可能也会产生垃圾，但是这次GC的标记阶段已经过去了，所以就只能下次GC的时候清理了。

因为CMS是标记-清除算法，所以这个阶段也会产生一些内存碎片。

并发重置阶段

这个阶段会重置CMS的一些数据结构，为下次GC做准备。

注意点

CMS不是Full GC

虽然CMS会扫描到年轻代的对象，但是扫描年轻代的对象只是为了确定老年代中的对象是否真正死亡或者存活（是否被引用），CMS只会处理老年代的死亡对象，所以注意和Full GC进行区分。

CMS回收过程会发生STW

尽管CMS是并发回收，但是也涉及到可达性分析算法，所以一定会发生STW，只是CMS将部分标记的过程与用户线程并行，尽可能地减短了STW的时间。

CMS发生STW的阶段只有两个，初始标记阶段和重新标记阶段，主要的停顿时间是重新标记阶段，因为这里是要确定老年代所有的存活对象，扫描了整个堆。

CMS尽量做到低延迟，但因此丢弃了部分吞吐量，适合用在一些服务器上。

内存碎片

因为CMS采用的是标记-清除算法，所以垃圾收集结束后就会产生大量内存碎片。内存碎片过多会给大对象分配带来很大的麻烦，往往会出现老年代还有很多的剩余空间，但就是无法找到足够大的连续空间来分配大对象的内存，从而不得不提前触发一次Full GC。所以CMS需要设当的进行内存整理，而不是轻易的进行Full GC，可以搭配两个参数进行优化。

-XX:+UseCMSCompactAtFullCollection（默认是开启的，JDK9后删除）
-XX:CMSFullGCsBeforeCompaction=n（JDK9后删除）

详细介绍可以参考下面的参数讲解。

Concurrent Mode Failure

因为CMS是并发回收的，所以用户线程也是会有可能在GC的过程中消耗内存，年轻代会在一些情况下就会将部分年轻代存活的对象放入老年代，而此时老年代没有足够的空间，此时就会出现Concurrent Mode Failure。

为了解决整个问题CMS一般都会设置一个阈值，当堆内存使用率到达一定阈值的时候，就会开始初始标记阶段，而不是堆内存快不够用的时候发生GC。将GC的时间提前，尽量减少Concurrent Mode Failure的出现。

此时的虚拟机就会触发STW启动Serial Old GC来重新进行老年代的垃圾回收，这样停顿时间会更长。这时候Serial Old GC也会因此进行一次碎片整理，解决标记-清除出现的内存碎片化严重的情况。

Promotion Failed

在进行Minor GC的时候，Survivor空间不足，只能将年轻代的一些对象放入老年代，此时老年代没有足够内存空间存放这些对象，又或者是内存碎片严重，找不到足够的连续的空间存放对象，与Concurrent Mode Failure是有点类似的。

CMS的参数

-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阶段停顿时间过长的问题。

参考文章

腾讯精选练习50题

Sat, 12 Dec 2020 00:00:00 +0000

7.整数反转

利用long来进行中转。

class Solution {    public int reverse(int x) {        long res = 0;        while (x != 0) {            res = res * 10 + x % 10;            x = x/10;        }        return (int)res == res?(int)res : 0;    }}

9. 回文数

解法一

回文数，其实跟回文字符串差不多，只是处理不同而已，我这里就直接将数字转换成了字符串然后对比。

class Solution {    public boolean isPalindrome(int x) {        if(x < 0) return false;        if (x < 10) return true;        String str = String.valueOf(x);        for(int i = 0; i < str.length()/2; i++) {            if(str.charAt(i) != str.charAt(str.length() - 1 - i))                return false;        }        return true;    }}

也可以直接将字符串反转在和原来的字符串相对比，不过效率第一点。

class Solution {    public boolean isPalindrome(int x) {        if(x < 0) return false;        if (x < 10) return true;        String str = String.valueOf(x);        String rev = new StringBuffer(str).reverse().toString();        if(rev.equals(str))             return true;        else             return false;    }}

解法二

直接求出反转后的数字，然后比较是否相等。虽然会有溢出的情况，但是会溢出的就不是回文了，所以可以不用考虑溢出的情况，实在要考虑可以直接来个try-catch来捕获异常。

class Solution {    public boolean isPalindrome(int x) {        if(x < 0) return false;        int rev = 0;        int p = x;        int temp = 0;        while(p!=0){            temp = p % 10;            rev = rev * 10+temp;            p = p/10;        }        return x == rev;    }}

11. 盛最多水的容器

解法一

因为这道题可以不用管中间的高度，所以直接嵌套for循环找出最大面积就好了，不过效率很低。明显看出这是O(n^2)的算法，应该算是效率最差的算法了。

class Solution {    public int maxArea(int[] height) {        int res = Integer.MIN_VALUE;        for(int i = 0; i < height.length; i++) {            for(int j = i; j  res) res = val;                } else {                    int val = height[i] * (j - i);                    if(val > res) res = val;                }            }        }        return res;    }}

解法二

这题明显可以使用双指针的方法。不断选取高度最高的值，并且长方形面积尽量大。最坏的时间复杂度为O(n)。

class Solution {    public int maxArea(int[] height) {        int i = 0;        int j = height.length - 1;        int res = 0;        while(i < j) {            int val = Math.min(height[i],height[j]) * (j - i);            if (val > res) res = val;            //选择高度更高的逼急            if(height[i] < height[j]) i++;            else j--;         }        return res;    }}

14.最长公共前缀

最开始是直接两个for循环的，但是看到了别人的解法，只能流出智商低的类水。

class Solution {    public String longestCommonPrefix(String[] strs) {        if(strs.length == 0) return "";        String s = strs[0];        for (String str : strs) {            while(!str.startsWith(s)) {                if (s.length() == 0) return "";                s = s.substring(0,s.length() - 1);            }        }        return s;    }}

20.有效的括号

这经典题目了，直接用栈就可以判断了。

class Solution {    public boolean isValid(String s) {        Stack stack = new Stack<>();        for(char c : s.toCharArray()) {            if (c == '(') stack.push(')');            else if (c == '[') stack.push(']');            else if (c == '{') stack.push('}');            else if (stack.isEmpty() || c != stack.pop()) return false;        }        return stack.isEmpty();    }}

21. 合并两个有序的链表

这个题因为两个都是有序的连边，所以一个个赋值就可以了。

class Solution {    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {        ListNode pre = new ListNode();        ListNode res = pre;        while(l1 != null && l2 != null) {                if(l1.val >= l2.val) {                    pre.next = new ListNode(l2.val);                    l2 = l2.next;                } else {                    pre.next = new ListNode(l1.val);                    l1 = l1.next;                }                pre = pre.next;        }        if(l1 == null) {            pre.next = l2;        }        if(l2 == null) {            pre.next = l1;        }        return res.next;    }}

还有一种递归写法。

class Solution {    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {        if(l1 == null) return l2;        if(l2 == null) return l1;        ListNode res;        if(l1.val > l2.val) {            res = l2;            l2 = l2.next;        } else {            res = l1;            l1 = l1.next;        }        res.next = mergeTwoLists(l1,l2);        return res;    }}

26. 删除排序数组中的重复项

这题考虑的是原地修改数组，那就把这个数组当作一个新的数组就好了，碰到不相同的就放到前面。所以就有了这个算法。

class Solution {    public int removeDuplicates(int[] nums) {        if (null == nums || nums.length == 1) return nums.length;        int res = 1;        for(int i = 1;i < nums.length; i++) {            if(nums[i] != nums[i - 1]) {                nums[res] = nums[i];                res++;            }        }        return res;    }}

46.全排列

看题目就知道，一道典型的全排列的题目，我就用了递归的写法。不过这个写法遇到有重复的数字的时候会有重复的数据，这题没有重复数据所以不需要去重，要是有重复数据可以需要考虑去重。

class Solution {    List> res = new ArrayList<>();    public List> permute(int[] nums) {        fun(nums,0);        return res;    }    public void fun(int[] nums,int start) {        if(start == nums.length -1){            List list = new ArrayList<>();            for(int i:nums) list.add(i);            res.add(list);        }        for(int i = start;i < nums.length; i++) {            swap(nums,i,start);            fun(nums,start + 1);            swap(nums,i,start);        }    }    public void swap(int[] nums,int i,int j) {        int temp = nums[i];        nums[i] = nums[j];        nums[j] = temp;    }}

53. 最大子序和

这题一开始我用的是双指针逼近，但是发现无法确定逼近的条件，所以就放弃了这个想法。

实在没想出。看了下答案，发现不是题难，是我太菜了。

其实这题用动态规划来解是最好的。

首先确定一下状态，那就是子数组的和最大。

然后是状态变化，因为是求子数组的和最大，所以开头是不可能是负的，如果是正的，但是加了后面的负数也是会抵消。

class Solution {    public int maxSubArray(int[] nums) {        int res = nums[0];        int sum = 0;        for(int num : nums) {            //状态变化            if(sum > 0) sum += num;            else sum = num;            //保存状态            res = Math.max(res,sum);        }        return res;    }}

59. 螺旋矩阵 II

这道题以前写过类似的，可以直接一个个的赋值，这题的难点就是边界的判断，在while循环中很容易就超出数组的边界了，或者是转过头了没刹住，注意好边界条件就不难了。

class Solution {    public int[][] generateMatrix(int n) {        int[][] res = new int[n][n];        int count = 1;        int x = 0,y = 0;        res[0][0] = 1;        while(count != n*n) {            //  向右移动            while(y + 1 < n && res[x][y + 1] == 0) {                res[x][y + 1] = ++count;                y++;             }            //  向下移动            while(x + 1 < n && res[x + 1][y] == 0) {                res[x + 1][y] = ++count;                x++;             }            //  向左移动            while(y - 1 >= 0 && res[x][y - 1] == 0) {                res[x][y - 1] = ++count;                y--;             }            //  向上移动            while(x - 1 >= 0 && res[x - 1][y] == 0) {                res[x - 1][y] = ++count;                x--;             }        }        return res;    }}

62. 不同路径

一看题目，直接递归搜索。

class Solution {    public int uniquePaths(int m, int n) {        return dfs(m,n);    }    public int dfs(int x,int y) {        if(x == 1 && y == 1) return 1;        if(x == 1) return dfs(x,y - 1);        if(y == 1) return dfs(x -1,y);        return dfs(x - 1,y) + dfs(x,y - 1);    }}

但是当图大的时候，就不行了，直接超时，所以不能直接搜索了，还要优化才行。因为当x或者y等于一的时候，就只有一条路了，所以可以进行优化一下。

class Solution {    public int uniquePaths(int m, int n) {        return dfs(m,n);    }    public int dfs(int x,int y) {        if(x == 1 || y == 1) return 1;        return dfs(x - 1,y) + dfs(x,y - 1);    }}

但还是超时了，所以直接递归应该是不可行。所以得考虑其他想法了，比如说动态规划。

class Solution {    public int uniquePaths(int m, int n) {        int[][] dp = new int[m][n];        for(int i = 0; i < m; i++) {            for(int j = 0; j < n; j++) {                if(i == 0 || j == 0) dp[i][j] = 1;                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];            }        }        return dp[m - 1][n - 1];    }}

虽然可以通过了，但是时间和空间的消耗还是挺多的。

看了一下评论区的解法，发现有一个解法就很有想法。那就是用排列组合的方式。

class Solution {    public int uniquePaths(int m, int n) {       int N = m + n -2;       //因为行列互换答案是一样的，所以直接找最小值使用       int M = Math.min(m-1,n-1);       // 使用int类型就会溢出了，所以要用long类型       long res = 1;       for(int i = 0; i < M; i++) {           //C = N! / (M! + (N -M)!)简化后得到下面这个式子           res = res * (N - i) / (i + 1);       }       return (int)res;    }}

70.爬楼梯

这题的本质就是斐波那契数列。

首先就是dp数组。

class Solution {    public int climbStairs(int n) {        if (n <= 2) return n;        int[] dp = new int[n + 1];        dp[1] = 1;        dp[2] = 2;        for (int i = 3;i < n + 1; i++) {            dp[i] = dp[i - 1] + dp[i - 2];        }        return dp[n];    }}

直接递归，不需要存储状态。

class Solution {    public int climbStairs(int n) {        if (n <= 2) return n;        int a = 1;        int b = 2;        for (int i = 3;i < n + 1; i+=2) {            a = a + b;            b = a + b;        }        if (n % 2 == 0) return b;        else return a;    }}

78. 子集

这题的思路就是遍历数组，遇到新的元素，就把这个元素加到所有子集里，形成新的子集。

class Solution {    public List> subsets(int[] nums) {        List> res = new ArrayList<>();        res.add(new ArrayList<>());        for(int i = 0;i < nums.length; i++) {            int size = res.size();            for(int j = 0; j < size; j++) {                List list = new ArrayList<>(res.get(j));                list.add(nums[i]);                res.add(list);            }        }        return res;    }}

88. 合并两个有序数组

解法一

直接就把这两个数组合并，然后在排一次序就好了。这应该是最简单，也是最花时间的算法。

class Solution {    public void merge(int[] nums1, int m, int[] nums2, int n) {        int re = 0;        for(int i = m; i < m + n; i++) {            nums1[i] = nums2[re];            re++;        }        Arrays.sort(nums1);    }}

解法二

可以使用类似双指针的方法，选取最大的依次放入数组。

class Solution {    public void merge(int[] nums1, int m, int[] nums2, int n) {        int temp = m + n - 1;        int i = m - 1;        int j = n - 1;        while(i >=0 && j >= 0) {            if(nums1[i] < nums2[j]) {                nums1[temp] = nums2[j];                temp--;                j--;            } else{                nums1[temp] = nums1[i];                temp--;                i--;            }        }        while(j >= 0) {            nums1[temp] = nums2[j];            temp--;            j--;        }    }}

简化之后可以得到。

class Solution {    public void merge(int[] nums1, int m, int[] nums2, int n) {        int temp = m + n - 1;        int i = m - 1;        int j = n - 1;        while(i >=0 && j >= 0) {            nums1[temp--] = nums1[i] < nums2[j] ? nums2[j--] : nums1[i--];        }        while(j >= 0) {            nums1[temp--] = nums2[j--];        }    }}

89. 格雷编码

这题真的不会写了，题目描述的不是很清楚，看的都不是很明白，直接查了维基百科，看懂了格雷码转二进制数的规律之后，就很简单了。

由于G(n) = B(n+1) + B(n)故而B(n) = -B(n+1)+ G(n)自高位至低位运算即可，无需考虑借位。例： 格雷码0111，为4位数，故设二进制数自第5位至第1位分别为：0 b3 b2 b1 b0。b3= 0-0 =0b2=b3-1=0-1=1b1=b2-1=1-1=0b0=b1-1=0-1=1因此所转换为之二进制码为0101

class Solution {    public List grayCode(int n) {        List res = new ArrayList<>();        int len = 1<>1);        }        return res;    }}

136. 只出现一次的数字

这题直接用异或就好了，因为异或运算符和下面这样的规律。

异或符和交换律
n与0异或答案为n
两个相同的数异或答案为0

class Solution {    public int singleNumber(int[] nums) {        int res = 0;        for(int i:nums) res ^= i;        return res;    }}

141.环形列表

这题可以先直接遍历，然后判断是否有重复的就好了。

public class Solution {    public boolean hasCycle(ListNode head) {        Set set = new HashSet<>();        ListNode node = head;        while(node != null) {            if (!set.add(node)) return true;            node = node.next;        }        return false;    }}

见到一种很有趣的解法。将每一个的节点指向自己，有环就会出现指向自己的节点。

public class Solution {    public boolean hasCycle(ListNode head) {        if (head == null || head.next == null) return false;        while(head.next != head) {            if (head == null || head.next == null) return false;            ListNode node = head.next;            head.next = head;            head = node;        }        return true;    }}

快慢指针。

public class Solution {    public boolean hasCycle(ListNode head) {        if (head == null || head.next == null) return false;        ListNode slow = head;        ListNode fast = head.next;        while(fast != slow) {            if (fast == null || fast.next == null) return false;            fast = fast.next.next;            slow = slow.next;        }        return true;    }}

142. 环形链表 II

这题和上面的题其实差不多，只是要返回交接的点。

public class Solution {    public ListNode detectCycle(ListNode head) {        if(head == null) return null;        if(head.next == null) return null;        ListNode p1 = head;        ListNode p2 = head;        while(p2.next != null && p2.next.next != null) {                    p1 = p1.next;            p2 = p2.next.next;            if(p1 == p2) {                ListNode res = head;                while(res != p1) {                    p1 = p1.next;                    res = res.next;                }                return res;            }        }        return null;    }}

155. 最小栈

这题直接就是数据结构了，但是不知道会存多少个数字，所以使用了List来当存储数组。

class MinStack {    List res  = new ArrayList<>();    int min = Integer.MAX_VALUE;    public MinStack() {}        public void push(int x) {        res.add(x);        if(min > x) {            min = x;        }    }        public void pop() {        res.remove(res.size() - 1);        min = Integer.MAX_VALUE;        for(int num:res) {            if(num < min) min = num;        }    }        public int top() {        return res.get(res.size() - 1);    }        public int getMin() {        return min;    }}

题目要求常数时间内检索到最小元素，这个其实没算实现，因为这里获取最小数的时间复杂度加到了pop方法上了，而且这个的效率不是很好。

所以有了下面种写法，用链表的方法，每一个链表都存储一个最小值，这样pop的时候也会自动变更最小值。

class MinStack {    private class ListNode{        int min;        int val;        ListNode next;        public ListNode(int val,int min) {            this.val = val;            this.min = min;        }        public ListNode(int val,int min,ListNode next) {            this.val = val;            this.min = min;            this.next = next;        }    }    private ListNode head;    public void push(int x) {        if(head == null) {            head = new ListNode(x,x);        } else {            //使用头插，因为尾插不好pop            head = new ListNode(x,x > head.min?head.min:x,head);        }    }        public void pop() {        head = head.next;    }        public int top() {        return head.val;    }        public int getMin() {        return head.min;    }    public MinStack() {}}

160. 相交链表

这题我原本是想用两个指针一个个遍历，可是这两个链表不是等长的，所以找不到那个相交点，用for嵌套for又不符合题目要求，所以没写出来，看到人家的答案才知道，可以把这两个链表连起来，连起来这两个链表就等长了，双指针遍历就行。

public class Solution {    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {        if(headA == null || headB == null) return null;        ListNode a = headA,b = headB;        while(a != b) {            a = a==null ? headB : a.next;            b = b==null ? headA : b.next;        }        return a;    }}

169. 多数元素

这题写了几次了，可以用摩尔投票法来找出大于一半的元素。

class Solution {    public int majorityElement(int[] nums) {        if (nums.length == 1) return nums[0];        int count = 1,res = nums[0];        for(int i = 1;i < nums.length; i++) {            if(nums[i] == res) count++;            if(nums[i] != res) {                count--;                if(count == 0) res = nums[i + 1];            }        }        return res;    }}

还看到有一个写法，因为是多数元素，所以一定是跨过中位数的，所以直接排序，寻找中位数就可以了。

class Solution {    public int majorityElement(int[] nums) {        Arrays.sort(nums);        return nums[(nums.length/2)];    }}

206. 反转链表

反转链表也算简单，注意要存储一下下一个变量，不然引用方向一变链表断开就找不到之后的值了。

递归写法

class Solution {    public ListNode reverseList(ListNode head) {        return reverse(null,head);    }    private static ListNode reverse(ListNode prev,ListNode curr){        if(curr==null) return prev;        ListNode node = curr.next;        curr.next = prev;        return reverse(curr,node);    }}

另一种写法。

class Solution {    public ListNode reverseList(ListNode head) {        if(head == null) return null;        if (head.next == null) return head;        ListNode last = reverseList(head.next);        head.next.next = head;        head.next = null;        return last;    }}

迭代写法

class Solution {    public ListNode reverseList(ListNode head) {        ListNode prev = null;        ListNode curr = head;        while(curr != null) {            ListNode node = curr.next;            curr.next = prev;            prev = curr;            curr = node;        }        return prev;    }}

215 数组中的第K个最大元素

这道题很简单，直接排序取第K大就好了。

class Solution {    public int findKthLargest(int[] nums, int k) {        Arrays.sort(nums);        return nums[nums.length - k];    }}

看了下评论，发现用库函数都能被骂，真的是服了，那顺便手写下快排。

class Solution {    public int findKthLargest(int[] nums, int k) {        quicksort(nums,0,nums.length - 1);        return nums[nums.length - k];    }    public void quicksort(int[] nums,int left,int right) {        if(left > right) return;        int temp = nums[left];        int i = left;        int j = right;        while(i != j) {            while(nums[j] >= temp && i < j) j--;            while(nums[i] <= temp && i < j) i++;            if(i < j) {                nums[i] ^= nums[j];                nums[j] ^= nums[i];                nums[i] ^= nums[j];            }        }        nums[left] = nums[i];        nums[i] = temp;        quicksort(nums,left,i - 1);        quicksort(nums,i + 1,right);    }}

217. 存在重复元素

解法一

一开始是直接暴力破解，两个for循环，发现超时了，所以就想到了先排序，然后一个for循环查看附近的值是否相同。

class Solution {    public boolean containsDuplicate(int[] nums) {        Arrays.sort(nums);        for(int i = 1; i < nums.length; i++) {            if(nums[i] == nums[i-1]) return true;        }        return false;    }}

解法二

可以直接用Set去重，判断set集合中的元素与数组元素的个数是否相同就可以得到答案。

class Solution {    public boolean containsDuplicate(int[] nums) {        Set set = new HashSet<>();        for(int i:nums) {            set.add(i);        }                return set.size()==nums.length?false:true;    }}

改进一下就是加入失败的时候就直接跳出，可以像这么写。

class Solution {    public boolean containsDuplicate(int[] nums) {        Set set = new HashSet<>();        for(int i:nums) {            if(!set.add(i)) return true;        }        return false;    }}

230. 二叉搜索树中第K小的元素

这道题和之前写的那道剑指Offer54是有点相似的，指路------>这里

这里我就不写这么详细了，就简单写两个方法。

//中序遍历取第k个值class Solution {    List list = new ArrayList<>();    public int kthSmallest(TreeNode root, int k) {        inorder(root);        return list.get(k-1);    }    public void inorder(TreeNode root) {        if(root == null) return;        inorder(root.left);        list.add(root.val);        inorder(root.right);    }}

class Solution {    int res = 0,sum = 0;    public int kthSmallest(TreeNode root, int k) {        inorder(root,k);        return res;    }    public void inorder(TreeNode root,int k) {        if(root.left != null) {        inorder(root.left,k);           }        sum++;        if(sum == k) {            res = root.val;        }        if(root.right != null) {        inorder(root.right,k);         }    }}

231. 2的幂

这题真的看起来简单，又没怎么简单，想了好几个方法全是超时的，想到是用二进制了，但是还是不懂写只能借鉴别人的方法了，看了之后只能说太强了。

解法一

满足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。

所以按位与就会是本身。

class Solution {    public boolean isPowerOfTwo(int n) {    return (n > 0) && (n & -n) == n;    }}

解法二

满足(1<<30) % n == 0就是2的幂。

1 << 30位是最大的2的幂，对n取余如果等于0就表示n是2的幂。

class Solution {    public boolean isPowerOfTwo(int n) {    return (n > 0) && (1 << 30) % n == 0;    }}

236. 二叉树的最近公共祖先

class Solution {    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {        if(root == null || root == p || root == q) return root;        TreeNode left = lowestCommonAncestor(root.left, p, q);        TreeNode right = lowestCommonAncestor(root.right, p, q);        if(left == null) return right;        if(right == null) return left;        return root;    }}

237. 删除链表中的节点

这道题，emm，描述的就离谱，其实就是给定一个链表的你要删掉的结点，删掉它。

class Solution {    public void deleteNode(ListNode node) {        node.val = node.next.val;        node.next = node.next.next;    }}

238. 除自身以外数组的乘积

这题不难，只是题目要求时间复杂度为O(n)和不能使用除法。这样的话就只能单个的for循环了，所以就可以考虑从左开始乘到当前树（不包含当前数），然后再加个for循环，再乘右边。这种方法速度很快，但是内存消耗太多，暂时还找不到内存消耗小的方法。

class Solution {    public int[] productExceptSelf(int[] nums) {        int len = nums.length;        int[] output = new int[len];        int left = 1;        int right = 1;        for(int i =0;i < len; i++) {            output[i] = left;            left = left * nums[i];        }        for(int i = len - 1; i >= 0; i--) {            output[i] = output[i] * right;            right = right * nums[i];        }        return output;    }}

292. Nim 游戏

这题有点搞，我大费周章的想了很久，结果看到评论我傻了，这就是一道脑经急转弯。

这就是巴什博弈，先手的话，只要是n%(m+1)==0的时候就是一定会输。反之就一定是赢的。在两个人都是最优解的情况。

class Solution {    public boolean canWinNim(int n) {        if(n%4==0) {            return false;        }        return true;    }}

简化一下就一行

class Solution {    public boolean canWinNim(int n) {        return n%4!=0;    }}

344. 反转字符串

这个就直接用遍历双指针遍历就好了，不同的就是交换变量的方式而已。

class Solution {    public void reverseString(char[] s) {        int front = 0;        int rear = s.length-1;        while(front < rear) {            s[front] ^= s[rear];            s[rear] ^= s[front];            s[front] ^= s[rear];            front++;            rear--;         }    }}

class Solution {    public void reverseString(char[] s) {        int front = 0;        int rear = s.length-1;        while(front < rear) {            char c = s[front];            s[front] = s[rear];            s[rear] = c;            front++;            rear--;         }    }}

557. 反转字符串中的单词 III

解法一

这题就是先用split方法分割字串，然后可以用StringBuffer的字符串反转方法进行反转。

class Solution {    public String reverseWords(String s) {        String[] arr = s.split(" ");        StringBuffer buffer = new StringBuffer();        for(int i = 0; i < arr.length; i++) {            if(i == arr.length-1) {            arr[i] = new StringBuffer(arr[i]).reverse().toString();            res = res + arr[i];             continue;            }            arr[i] = new StringBuffer(arr[i]).reverse().toString();            res = res + arr[i] + " ";        }        return res;    }}

这样效率是很低，字符串这样拼接不好，建议使用StringBuffer。时间和内存消耗效率都很低。

解法二

先用split方法分割字串，使用StringBuffer进行拼接；

class Solution {    public String reverseWords(String s) {        String[] arr = s.split(" ");        StringBuffer res = new StringBuffer();        for(int i = 0; i < arr.length; i++) {            res.append(new StringBuffer(arr[i]).reverse().toString());            res.append(" ");        }        //trim去除首尾空格        return res.toString().trim();    }}

解法三

直接在原数组上进行反转。

class Solution {    public String reverseWords(String s) {        char[] arr = s.toCharArray();        int front = 0;        int rear = 0;        for(int i = 0;i < s.length(); i++) {            if(arr[i] == ' ') {                rear = i - 1;                while(front < rear) {                    arr[front] ^= arr[rear];                    arr[rear] ^= arr[front];                    arr[front] ^= arr[rear];                    front++;                    rear--;                }                front = i + 1;            }        }        //反转最后一个单词        rear = s.length()-1;        while(front < rear) {                arr[front] ^= arr[rear];                arr[rear] ^= arr[front];                arr[front] ^= arr[rear];                front++;                rear--;            }            return new String(arr);    }}

在优化一下

class Solution {    public String reverseWords(String s) {        char[] arr = s.toCharArray();        int front = 0;        for(int i = 0;i < s.length(); i++) {            if(arr[i] == ' ') {                reverse(arr,front,i - 1);                front = i + 1;            }        }        //反转最后一个单词        reverse(arr,front,s.length()-1);        return new String(arr);    }    public void reverse(char[] arr,int front,int rear){        while(front < rear) {            arr[front] ^= arr[rear];            arr[rear] ^= arr[front];            arr[front] ^= arr[rear];            front++;            rear--;        }    }}

另外一个搜索的思路

class Solution {    public String reverseWords(String s) {        char[] arr = s.toCharArray();        for(int i = 0;i < s.length(); i++) {            if(arr[i] == ' ') {                continue;            }            int front = i;            while(i < s.length() && arr[i]!=' ') {                i++;            }            reverse(arr,front,i - 1);        }        return new String(arr);    }    public void reverse(char[] arr,int front,int rear){        while(front < rear) {            arr[front] ^= arr[rear];            arr[rear] ^= arr[front];            arr[front] ^= arr[rear];            front++;            rear--;        }    }}

GC垃圾回收机制

Mon, 07 Dec 2020 00:00:00 +0000

什么是垃圾

在进行垃圾回收之前，就要先判断出什么是垃圾。

垃圾其实指的是在这次运行程序中没有被任何指针指向的对象，也就是没有被引用机会的对象，因为没有指向也就无法引用，所以这些对象就是要清理的垃圾。

如果垃圾不及时的清理，那么在这次运行程序的过程中就会一直占用部分内存，严重的还会导致内存溢出。

:::note{type="info"}

内存溢出就是指程序运行过程中申请的内存大于系统所能够提供的内存，这就会导致无法申请足够的内存，于是就发生了内存溢出。

:::

哪里需要垃圾回收

垃圾回收就需要关注哪里产生垃圾，其实垃圾的产生主要在运行时数据区中的方法区和堆。因为栈是用完就会推出的，计数器也不需要回收，所以GC的作用区域就是方法区和堆了。虽然说这两块区域会有GC行为，但正常来说主要的还是堆空间的GC，方法区很少会有GC行为。

垃圾回收的算法

垃圾标记阶段

垃圾标记阶段就是为一些死的或者活的对象打上标记，用来区分哪些是垃圾，哪些是用的上的对象。判断对象存活的方法一般有两个，引用计数算法和可达性分析算法。

引用计数算法

计数算法其实就是为每个对象保存以个整型的引用计数器属性，每当该对象被引用了，改对象的引用计数器就会加1，引用失效了计数器就会减1，只要对象的计数器为0，即表示该对象已经不会被引用了，就会为它做上一个标记。

:::note{type="info"}

引用计数算法是很简单高效的算法，但是对象一多，每个对象的计数器也是一个很大的开销。而且引用计数算法还有一个很严重的问题,无法处理循环引用的情况，这是很致命的，所以Java的垃圾回收器没有使用这个算法。

:::

循环引用问题

从上图就可以看出对象的引用关系只要形成环形，很大的可能就会出现循环引用的问题，这就会出现内存泄漏的问题。

分析Java是否使用引用计数算法

配置JVM的虚拟机参数，打印JVM的情况。我是使用IDEA，所以按照IDEA的配置来讲。点击RUN->Edit Configurations->Applacion->VM options。配置以下参数
```
-XX:+PrintGCDetails
```

模拟循环引用的情况。

package com.yw;/** * @ClassName ReferenceCount * @Descriprtion TODO * @Author yww **/public class ReferenceCount {    //    设置引用属性    Object reference = null;    public static void main(String[] args) {        ReferenceCount A = new ReferenceCount();        ReferenceCount B = new ReferenceCount();    //    形成引用环        A.reference = B;        B.reference = A;    //    断开外部引用，A与B形成循环引用        A = null;        B = null;    }}

// 没有显示调用GC的内存情况Heap PSYoungGen      total 38400K, used 3330K [0x00000000d5f80000, 0x00000000d8a00000, 0x0000000100000000)  eden space 33280K, 10% used [0x00000000d5f80000,0x00000000d62c09a8,0x00000000d8000000)  from space 5120K, 0% used [0x00000000d8500000,0x00000000d8500000,0x00000000d8a00000)  to   space 5120K, 0% used [0x00000000d8000000,0x00000000d8000000,0x00000000d8500000) ParOldGen       total 87552K, used 0K [0x0000000081e00000, 0x0000000087380000, 0x00000000d5f80000)  object space 87552K, 0% used [0x0000000081e00000,0x0000000081e00000,0x0000000087380000) Metaspace       used 3141K, capacity 4496K, committed 4864K, reserved 1056768K  class space    used 342K, capacity 388K, committed 512K, reserved 1048576K

显示调用的GC之后

package com.yw;/** * @ClassName ReferenceCount * @Descriprtion TODO * @Author yww **/public class ReferenceCount {    //    设置引用属性    Object reference = null;    public static void main(String[] args) {        ReferenceCount A = new ReferenceCount();        ReferenceCount B = new ReferenceCount();    //    形成引用环        A.reference = B;        B.reference = A;    //    断开外部引用，A与B形成循环引用        A = null;        B = null;    //    显示调用GC        System.gc();    }}

//    使用了GC之后的内存情况[GC (System.gc()) [PSYoungGen: 2664K->776K(38400K)] 2664K->784K(125952K), 0.0012757 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [Full GC (System.gc()) [PSYoungGen: 776K->0K(38400K)] [ParOldGen: 8K->617K(87552K)] 784K->617K(125952K), [Metaspace: 3136K->3136K(1056768K)], 0.0039173 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] Heap PSYoungGen      total 38400K, used 998K [0x00000000d5f80000, 0x00000000d8a00000, 0x0000000100000000)  eden space 33280K, 3% used [0x00000000d5f80000,0x00000000d6079b20,0x00000000d8000000)  from space 5120K, 0% used [0x00000000d8000000,0x00000000d8000000,0x00000000d8500000)  to   space 5120K, 0% used [0x00000000d8500000,0x00000000d8500000,0x00000000d8a00000) ParOldGen       total 87552K, used 617K [0x0000000081e00000, 0x0000000087380000, 0x00000000d5f80000)  object space 87552K, 0% used [0x0000000081e00000,0x0000000081e9a458,0x0000000087380000) Metaspace       used 3148K, capacity 4496K, committed 4864K, reserved 1056768K  class space    used 343K, capacity 388K, committed 512K, reserved 1048576K

分析可以清楚的看到调用了GC之后，内存的占用率变低了，如果Java使用的是引用计数算法，那么内存是不应该降低的，所以可以知道的是Java不适用引用计算这种算法。

可达性分析算法

可达性分析算法又称根搜索算法，追踪性垃圾收集。该算法可以有效的解决计数算法中的循环引用的问题，防止内存泄漏的发生。

GC Roots

GC Roots根集合，是一组必须活跃的引用。可达性分析算法的思路就是以GC Roots为起始点，从上至下的搜索被根对象引用的对象，查看对象是否可达。

搜索的路径被称为引用链。

存活的对象都应该是直接或者被间接引用到的，即都是可达的。

GC Roots可以是哪些

虚拟机栈中引用的对象
本地方法栈内引用的对象
方法区中静态属性引用的对象
方法区常量引用的对象
Java虚拟机内部的引用
所有被同步锁synchronized持有的对象
除了固定的GC Roots集合外，根据用户选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象临时加入，比如分代收集和局部回收。

对象的finalization机制

finalization机制称为对象终止机制，这个机制允许开发人员在对象销毁之前可以自定义逻辑代码。

即垃圾回收之前，总会先调用这个对象的finalize方法，这个方法可以被子类重写，通常用于在对象被回收时进行资源释放。

由于finalize方法的存在，虚拟机的对象一般处于三种可能的状态。

可触及的，即可达的。
可复活的。不可触及的对象有可能会在finalize方法中复活。
不可触及的。因为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方法

使用System.gc()或者是Runtime.getRuntime().gc()就可以显示触发Full GC，同时回收老年代和新生代，尝试释放被丢弃对象占用的内存。
调用该方法会附带一个免责声明，即会触发Full GC，但是不知道会什么时候触发。

内存溢出（OOM）

内存溢出其实不太容易出现，如果当应用程序占用的内存增长速度异常，超过了垃圾回收提供的空闲内存，那就会可能出现内存溢出。
内存溢出之前其实都会进行一次独占式的Full GC,回收大量内存，若果此时内存还是不够用，就会出现内存溢出的情况。
Javadoc对OOM的理解是，没有空闲内存并且垃圾收集器也无法提供更多内存，就会报OOM。

出现的原因可能有以下原因：

Java虚拟机的堆内存设置不够
代码创建大量对象，而且长时间不能被垃圾收集器收集。

内存泄漏（Memory Leak）

严格来讲，对象不会被程序用到了，但是GC又回收不掉这些对象的情况，叫内存泄漏。
宽松一点来讲，一些不当操作导致对象的生命周期变得很长甚至导致OOM，也可以叫做内存泄漏。
内存泄漏不会立刻引起程序崩溃，但是发生内存泄漏之后，就有可能不断泄漏，然后就可能会出现OOM，即内存溢出的情况，然后导致程序崩溃。
注意，循环引用是针对引用计数算法的内存泄漏，Java不使用引用计数算法，所以这种不算是内存泄漏。

一些内存泄漏的例子：

单例模式单例的生命周期和应用程序一样长，所以当单例引用了外部对象时候，这个外部对象即一直是可达的了，这就会导致内存泄漏的产生。
一些提供close方法的对象未关闭导致的内存泄漏比如说数据库连接，网络连接和IO的连接操作，需要手动关闭，不然就会出现内存泄漏。

Stop The World

Stop The World简称STW，指GC事件发生的过程中会产生应用程序的停顿，停顿时整个应用程序线程都会被暂停，这个停顿就是STW。

比如可达性分析算法。可达性分析算法中的GC Roots的是可能会随着程序的而不断更新的，所以当进行枚举GC Roots的时候，会导致Java执行线程停顿。

所有的GC都会有STW的情况发生，不能避免，只能尽量减少STW的时间

安全点

事实上，发生GC的时间点并不是随机的，意思就是GC伴随的STW的不是随机某个时间点发生的，只有某一些特殊的位置才会停下来GC，这些位置就称作安全点。但是如何在GC发生的时候，检查到所有的线程都跑到最近的安全点然后开始停顿呢？

抢先式中断（目前没有虚拟机采用了）中断所有线程，如果还有线程不在安全点就恢复该线程使其运行到最近的安全点。
主动式中断设置一个中断标志，各个线程运行到安全点的时候主动轮询这个标志，如果中断标志为真，就将该线程中断挂起。

安全区域

讲述安全点的时候，默认把所有进程认为都在运行着，可是如果有某个进程处于睡眠或者阻塞的时候，还没到安全点就挂着了，这种时候还会一直等到该进程进入安全点吗？这种时候就需要设置安全区域来解决了。

安全区域是指在一段片段中，对象的引用关系不会发生变化，在这个区域中的任何位置开始GC都是安全的。这其实很好理解，对象的引用关系不发生变化的时候，GC Roots是不会发生变化的，可达性分析算法也就不会受到影响，所以在这段区域中停顿是不会对GC产生影响的。安全区域其实也意味着，这段区域都是安全点。

所以线程执行的时候要发生GC的就会是这样的：

当线程进入安全区域的时候，就会标识该线程进入安全区域，如果要发生GC了，就会忽略该线程的情况，该发生就发生，该等就等。
当线程离开安全区域的时候，会检查JVM的GC是否已经完成，完成了该线程就继续运行，否则线程就会等待可以离开安全区域的信号为止。

引用

引用分为四种，按照引用类型的强度递减为强引用，软引用，弱引用和虚引用。

强引用（StrongReference）

强引用是最经常用到的，平时的引用关系的建立很多都是强引用类型的，就比如Object obj = new Object()这种引用关系的建立就是强引用。强引用的关系存在的时候，就会被可达性分析算法标识为可触及的，所以就不会被垃圾收集器回收。

强引用-不回收，即使要发生OOM了也不会进行回收。
建立了强引用可以直接访问目标对象。
强引用是导致内存泄漏的一个主要原因。

软引用（SoftReference）

软引用就是弱一点的强引用。在系统即将发生OOM的时候，垃圾回收器就会进行第二次回收（第一次是那些不可达的对象），把这些被软引用关系的对象清除掉，要是清除掉之后还是没有足够内存，才会发生OOM。

软引用-内存不足即回收。用来使用在一些虽然有用，但是不是必需的对象上。
软引用通常实现缓存方面上

建立软引用可以通过使用SoftReference的类来实现。

    Object obj = new Object();    SoftReference sr = new SoftReference<>(obj);    obj = null;    // 销毁强引用

弱引用（WeakReference）

弱引用的关系在建立了之后就只能活到下一次的垃圾回收，因为GC发生的时候，即使内存足够也会把弱引用的对象全部回收掉。

弱引用-发现即回收。
GC回收的时候，会通过算法检查软引用是否要回收，而弱引用对象被检查到会直接被回收。
弱引用也是主要用在缓存方面

建立弱引用可以通过使用WeakReference的类来实现。

    Object obj = new Object();    WeakReference wr = new WeakReference<>(obj);    obj = null;    // 销毁强引用

虚引用（PhantomReference）

虚引用关系是否存在对对象的生存不构成影响，也无法通过虚引用来实例化一个对象，该引用的目的只是为了在被虚引用的对象要被垃圾回收的时候会收到一个系统通知。

虚引用-对象回收跟踪。
虚引用相当于没有引用，也获取不到对象。
虚引用必须和引用队列搭配使用，因为当对象被发现是虚引用的时候，就会在垃圾回收之后，将该虚引用加入到引用队列当中，用来通知程序。

建立虚引用可以通过使用PhantomReference的类来实现。

    Object obj = new Object();    ReferenceQueue queue = new ReferenceQueue();    PhantomReference pr = new PhantomReference<>(obj,queue);    obj = null;    // 销毁强引用

垃圾回收器

性能指标

吞吐量：运行用户代码的时间占总运行时间的比例。
垃圾收集开销：吞吐量的补数，垃圾收集所用的时间占总运行时间的比例。
暂停时间：执行垃圾回收的时候，工作线程被暂停的时间。
收集频率。收集操作发生的频率。
内存占用：Java堆区所占用的内存大小。
快速：一个对象从诞生到被回收的时间。

七款经典的收集器

新生代收集器： Serial,ParNew,Parallel,Scavenge
老年代收集器：Serial Old,Parallel Old,CMS
整堆收集器：G1
JDK8中默认使用的是Parallel和Parallel Old的组合，JDK9中默认使用G1

:::note{type="info"}

红色的虚线表示的这两个组合在JDK8已起用，JDK9已移除
1. 绿色的虚线表示的这个组合在JDK14中已经弃用
2. CMS GC的虚线表示在JDK14中已经删掉了这个垃圾回收器。

:::

Serial GC和Serial Old GC

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
```
    -XX:+UseSerialGC
```

现在CPU发展很快，串行的收集器体验不好，特别是对现在高流量的信息时代，所以一般Java Web中不会采用串行垃圾收集器。

ParNew GC

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
```
    -XX:+UseParNewGC
```

前面有提到一点就是在JDK9版本中，Serial Old GC不可以与ParNewGC搭配了，在之后CMS也会删除，所以ParNew GC也快到了被移除的阶段了，所以不怎么建议使用了。

Parallel Scavenge GC 和 Parallel Old 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。

参数设置

// 默认开启一个，另一个也会开启    -XX:+UseParallelGC    -XX:+UseParallelOldGC// 限制并行的线程,默认与CPU核心数量相等    -XX:ParallelGCThreads// 设置STW最大时间    -XX:MaxGCPauseMillis// 设置Parallel Scavenge GC开启自适应调节策略，默认开启    -XX:+UseAdaptiveSizePolicy

CMS GC

详情可以查看这篇文章

G1

初识JVM

Fri, 04 Dec 2020 00:00:00 +0000

什么是JVM

认识JVM之前就先了解下面三个相近的概念。

JDK英文名称为Java Development Kit。Java开发工具包，开发Java程序经常会使用它。
JRE
英文名称为Java Runtime Environment。Java运行环境，主要包括JVM和一些类库，保证Java程序运行的最小环境。
JVM
英文名称为Java Virtual Machine。Java虚拟机,具体是干什么的，之后在说。

通过概念就能看出来它们之间的关系，如下图。

更加详细的信息可以参考这个图。

JVM的位置

JVM在我们的计算机当中是位于什么位置的呢？可以参考一下下图。

一次编译，到处运行

Java之所以那么火，这么多人使用，其中一个重要的原因就是Java有一个特性，一次编译，到处运行。Java可以实现跨平台运行，这使得开发者在不同平台上都可以运行自己的Java程序，方便了开发者的部署。那么Java是怎么实现跨平台的特性的呢？

这就关系到Java虚拟机了。我们在IDE编写好自己的Java程序之后，就会有一个扩展名为.java的源代码文件。

然后我们可以通过一个简单的命令来编译Java这个源代码文件。

javac hello.java

Java程序的编译不是直接编译为计算机可以看懂的序列，而是编译成为了一个扩展名为.class的字节码文件。这个字节码文件通过Java虚拟机的翻译，才能变成计算机看得懂的序列，计算机才能成功运行这个Java程序。

java hello.class

到这应该就知道为什么Java可以实现跨平台了。Java的字节码文件不管放在哪个系统，只要系统安装有JVM，就能将字节码文件翻译成机器看得懂的语言，机器就能执行出程序。系统不同的只是会导致虚拟机不同，但不会影响字节码文件。

JVM的结构体系

SpringBoot整合Druid

Wed, 25 Nov 2020 00:00:00 +0000

简介

Druid是的一个阿里巴巴的开源项目，它是一个数据库连接池的实现。Druid能够提供强大的监控和扩展功能。这次就用SpringBoot来整合Druid。

依赖

                        org.springframework.boot            spring-boot-starter-web                                mysql            mysql-connector-java            runtime                             com.alibaba             druid             1.2.1                    log4j            log4j            1.2.17                                    org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine

配置SpringBoot配置文件

# aplication.yaml使用spring:  datasource:    username: root    password: password    url: jdbc:mysql://localhost:3306/shop?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC    driver-class-name: com.mysql.cj.jdbc.Driver    type: com.alibaba.druid.pool.DruidDataSource#指定Druid为数据源    # Druid的配置    initialSize: 5    minIdle: 5    maxActive: 20    max-wait: 60000    timeBetweenEvictionRunsMillis: 60000    minEvictableIdleTimeMillis: 300000    validationQuery: SELECT 1 FROM DUAL    testWhileIdle: true    testOnBorrow: false    testOnReturn: false    poolPreparedStatements: true    #配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入    filters: stat,wall,log4j    maxPoolPreparedStatementPerConnectionSize: 20    useGlobalDataSourceStat: true    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

编写配置类

package com.yww.config;import com.alibaba.druid.pool.DruidDataSource;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configurationpublic class DruidConfig {    @Bean    @ConfigurationProperties(prefix = "spring.datasource")    public DataSource dataSource(){        return new DruidDataSource();    }}

配置数据源监控

package com.yww.config;import com.alibaba.druid.pool.DruidDataSource;import com.alibaba.druid.support.http.StatViewServlet;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.boot.web.servlet.ServletRegistrationBean;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;import java.util.HashMap;import java.util.Map;@Configurationpublic class DruidConfig {    @Bean    @ConfigurationProperties(prefix = "spring.datasource")    public DataSource dataSource(){        return new DruidDataSource();    }    @Bean    public ServletRegistrationBean statViewServlet() {        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");        Map initParams = new HashMap<>();        initParams.put("loginUsername", "admin"); //后台管理界面的登录账号        initParams.put("loginPassword", "123456"); //后台管理界面的登录密码        bean.setInitParameters(initParams);        return bean;    }}

配置好之后访问http://localhost:8080/druid/login.html就可以看到Druid为我们提供的用于监控的web界面。

配置filter过滤器

package com.yww.config;import com.alibaba.druid.pool.DruidDataSource;import com.alibaba.druid.support.http.StatViewServlet;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.boot.web.servlet.ServletRegistrationBean;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;import java.util.HashMap;import java.util.Map;@Configurationpublic class DruidConfig {    //注入Druid的配置    @Bean    @ConfigurationProperties(prefix = "spring.datasource")    public DataSource dataSource(){        return new DruidDataSource();    }    //配置Druid的监控    @Bean    public ServletRegistrationBean statViewServlet() {        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");        Map initParams = new HashMap<>();        initParams.put("loginUsername", "admin"); //后台管理界面的登录账号        initParams.put("loginPassword", "123456"); //后台管理界面的登录密码        bean.setInitParameters(initParams);        return bean;    }    //配置filter过滤器    @Beanpublic FilterRegistrationBean webStatFilter() {    FilterRegistrationBean bean = new FilterRegistrationBean();    bean.setFilter(new WebStatFilter());    Map initParams = new HashMap<>();    initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*");    bean.setInitParameters(initParams);    //"/*" 表示过滤所有请求    bean.setUrlPatterns(Arrays.asList("/*"));    return bean;}}

SpringBoot使用JDBC

Wed, 25 Nov 2020 00:00:00 +0000

简介

在SpringBoot中简单的使用JDBC,用jdbcTemplate简单的操作数据的增删改查，大型一点的项目建议使用Mybatis。

依赖

                            org.springframework.boot            spring-boot-starter-jdbc                                org.springframework.boot            spring-boot-starter-web                                mysql            mysql-connector-java            runtime                                    org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine

配置springboot配置文件

# 这个是application.yaml版本spring:  datasource:    username: root    password: password    # 可以根据情况来写url    url: jdbc:mysql://localhost:3306/test?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC    driver-class-name: com.mysql.cj.jdbc.Driver

# 这个是application.properties版本spring.datasource.username=rootspring.datasource.password=passwordspring.datasource.url=jdbc:mysql://localhost:3306/test?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTCspring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

简单的CRUD

package com.yww.controller;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RestController;import java.util.List;import java.util.Map;@RestControllerpublic class JdbcController {    @Autowired    JdbcTemplate jdbcTemplate;    @GetMapping("/select")    public List> userList(){        String sql = "SELECT * FROM user";        List> maps = jdbcTemplate.queryForList(sql);        return maps;    }    @GetMapping("/add")    public String addUser(){        String sql = "INSERT INTO USER VALUES(3,'王五')";        jdbcTemplate.update(sql);        return "添加完成";    }    @GetMapping("/update/{id}")    public String updateUser(@PathVariable("id") int id){        String sql = "UPDATE user SET id=4,name='赵六' WHERE id="+id;        jdbcTemplate.update(sql);        return "修改完成";    }    @GetMapping("/delete/{id}")    public String deleteUser(@PathVariable("id") int id){        String sql = "DELETE FROM user WHERE id=?";        jdbcTemplate.update(sql,id);        return "删除成功";    }}

:::note{type="info"}

spring帮我们封装好了JDBC的操作，并做好了模板，就是上述的JdbcTemplate。 JdbcTemplate的几个常用方法。 1. execute()，用于执行任何SQL语句。 2. update()，用于执行新增，修改删除等语句。 3. batchUpdate()，用于执行批处理的语句。 4. query()，用于执行查询语句。 5. call()，用于执行存储过程和函数相关的语句。

:::

SpringBoot使用Mybatis

Wed, 25 Nov 2020 00:00:00 +0000

简介

Mybatis是现在十分流行的数据持久化框架，这次就来用SpringBoot来整合使用Mybatis。

依赖

                      org.mybatis.spring.boot            mybatis-spring-boot-starter            2.1.1                            org.springframework.boot            spring-boot-starter-web                            mysql            mysql-connector-java            runtime                            com.alibaba            druid            1.2.1                            log4j            log4j            1.2.17                              org.projectlombok             lombok                             org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine                                                                                src/main/java                                    **/*.xml                                true                                                        org.springframework.boot                spring-boot-maven-plugin

定义实体类

package com.yww.pojo;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;@Data@NoArgsConstructor@AllArgsConstructorpublic class User {        int ID;        String name;    }

定义Mapper接口

package com.yww.mapper;import com.yww.pojo.User;import org.apache.ibatis.annotations.Mapper;import org.springframework.stereotype.Repository;import java.util.List;@Mapper@Repositorypublic interface UserMapper {        List selectUserList();        User selectUserByID(int ID);        int addUser(User user);        int updateUser(User user);        int deleteUser(int id);    }

创建Mybatis配置文件

                        INSERT INTO user (ID,name) VALUES (#{ID},#{name})                UPDATE user SET name=#{name} WHERE ID = #{ID}                DELETE FROM user WHERE ID=#{ID}

配置SpringBoot配置文件

# application.yml使用# 连接数据库spring:  datasource:    username: root    password: password    url: jdbc:mysql://localhost:3306/test?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC    driver-class-name: com.mysql.cj.jdbc.Driver    type: com.alibaba.druid.pool.DruidDataSource    # Druid的配置    initialSize: 5    minIdle: 5    maxActive: 20    max-wait: 60000    timeBetweenEvictionRunsMillis: 60000    minEvictableIdleTimeMillis: 300000    validationQuery: SELECT 1 FROM DUAL    testWhileIdle: true    testOnBorrow: false    testOnReturn: false    poolPreparedStatements: true    filters: stat,wall,log4j    maxPoolPreparedStatementPerConnectionSize: 20    useGlobalDataSourceStat: true    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500# mybatis设置mybatis:  type-aliases-package: com.yww.pojo#绑定实体类，不然配置文件识别不出User  mapper-locations: classpath:mybatis/mapper/*.xml#绑定mybatis的配置文件

编写controller

package com.yww.controller;import com.yww.mapper.UserMapper;import com.yww.pojo.User;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestControllerpublic class UserController {        @Autowired    private UserMapper userMapper;        @GetMapping("/select")    public List selectUserList(){        List list = userMapper.selectUserList();        return list;    }        @GetMapping("/selectbyid")    public User selectByID(){        User user = userMapper.selectUserByID(1);        return user;    }        @GetMapping("/insert")    public int addUser(){        User user = new User(3, "王五");        return  userMapper.addUser(user);    }        @GetMapping("/update")    public int  updateUser(){        User user = new User(3, "赵六");        return userMapper.updateUser(user);    }        @GetMapping("/delete")    public int  deleteUser(){        return userMapper.deleteUser(3);    }    }

HashMap

Fri, 20 Nov 2020 00:00:00 +0000

简介

HashMap是Map经常使用的一个实现类,也是我们经常用到的一个集合，所以很有必要去了解一下。JDK8相对JDK7优化了不少，结构也改变了，所以这里就分开来学习了。

:::note{type="info"}

因为我英语不是特别好，所以有些源码的文档注释是机翻的，所以有些文档注释读起来怪怪的，只能理解一下大概意思。

:::

JDK7

参数和变量

    /**     * 默认的初始容量，必须是2的幂，默认16     */    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16    /**     * 这是HashMap的最大容量，值为1<<30。要是传入更高的值，就会使用这个最大容量     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * HashMap默认的负载因子     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**     * 当表未膨胀时使用的空表实例     */    static final Entry[] EMPTY_TABLE = {};    /**     *这个表根据需要调整长度大小，长度必须为2的幂     */    transient Entry[] table = (Entry[]) EMPTY_TABLE;    /**     * 键值对的数量     */    transient int size;    /**     * 下一个要调整大小的值，值为容量*负载系数     * 如果table == EMPTY_TABLE,则值为初始容量     * 膨胀时将会创建表格     * @serial     */    int threshold;    /**     * 哈希表的负载因子     * @serial     */    final float loadFactor;    /**     * 已对HashMap进行结构修改的次数结构修改是指更改HashMap中的映射数或     * 以其他方式修改其内部结构（例如，重新哈希）的修改。 此字段用于使HashMap的Collection-view上     * 的迭代器快速失败。（请参见ConcurrentModificationException）。     */    transient int modCount;    /**     * 映射容量的默认阈值，高于该阈值时，字符串键将使用替代哈希。     * 备用哈希可减少由于字符串键的哈希码计算能力较弱而导致的冲突发生率。     *      * 可以通过定义系统属性来覆盖这个值     */    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;  /**     * 与此实例相关联的随机化值，该值应用于键的哈希码，以使哈希冲突更难找到。 如果为0，则禁用备用哈希。     */    transient int hashSeed = 0;    private transient Set> entrySet = null;    // 序列化默认版本号    private static final long serialVersionUID = 362498820763181265L;

构造器

    /**     * 使用默认的容量16和负载因子0.75创建HashMap     */    public HashMap() {        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);    }    /**     * 使用指定容量和默认的负载因子创建HashMap     */    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    /**     * 使用指定容量和指定的负载因子创建HashMap     */    public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        threshold = initialCapacity;        init();    }    /**     * 创建一个大于Map键值对数量的HashMap，然后将键值对加入到HashMap     * 使用默认的负载因子0.75，和足以包含Map键值对数量的容量     */    public HashMap(Map m) {        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);        inflateTable(threshold);        putAllForCreate(m);    }

:::note{type="info"}

从构造方法来看，HashMap(int initialCapacity, float loadFactor)这个方法才是主体。接下来就来分析一下这个构造方法。

:::

    public HashMap(int initialCapacity, float loadFactor) {        //  容量小于0，抛出异常        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);        //  容量大于最大值1<<30，使用最大值当做容量        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        //  负载因子小于等于0或者非数字就抛出异常        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        threshold = initialCapacity;        //  空方法，用来初始化HashMap，有些类里就会有其实现        init();    }

数据结构

构造方法看完了，现在来看看HashMap的数据结构。JDK7的HashMap是以数组为主，链表为辅的结构。大概结构如下。

:::note{type="info"}

每个链表被称为哈希表的桶，每个节点都存储了一对键值对。

:::

这里就看出，每个节点就是哈希表的最小组成单位了，现在就来看一下这个节点类。JDK7时的节点类叫Entry。

    static class Entry implements Map.Entry {        final K key;        V value;        Entry next;        int hash;        /**         * 构造器         */        Entry(int h, K k, V v, Entry n) {            value = v;            next = n;            key = k;            hash = h;        }        //  get和set方法        public final K getKey() {            return key;        }        public final V getValue() {            return value;        }        public final V setValue(V newValue) {            V oldValue = value;            value = newValue;            return oldValue;        }        //  重写equals        public final boolean equals(Object o) {            if (!(o instanceof Map.Entry))                return false;            Map.Entry e = (Map.Entry)o;            Object k1 = getKey();            Object k2 = e.getKey();            if (k1 == k2 || (k1 != null && k1.equals(k2))) {                Object v1 = getValue();                Object v2 = e.getValue();                if (v1 == v2 || (v1 != null && v1.equals(v2)))                    return true;            }            return false;        }        //  重写hashCode方法        public final int hashCode() {            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());        }        //  重写toString方法        public final String toString() {            return getKey() + "=" + getValue();        }        /**        * 在存在key下put，就会用该方法覆盖value值        */        void recordAccess(HashMap m) {        }        /**         * 删除键值对时就会用这个方法         */        void recordRemoval(HashMap m) {        }    }

由此可以看出每个Entry都存储了四个值，一对键值对，一个hash，和一个next值。next指向链表的下一个节点，而hash则用来判断该节点放在数组哪一个位置。

put

创建了哈希表之后，就可以用put方法来存放键值对，现在就来看看put方法的源码。

/** * 将指定值与指定的键相连，如果指定的键原来有值，就会覆盖掉旧的值 * 返回与key关联的先前值；如果没有key的映射关系，则返回null 。 * 返回null可能还表明该映射先前将null与key关联。 */public V put(K key, V value) {    if (table == EMPTY_TABLE) {        inflateTable(threshold);    }    if (key == null)        return putForNullKey(value);    int hash = hash(key);    int i = indexFor(hash, table.length);    for (Entry e = table[i]; e != null; e = e.next) {        Object k;        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {            V oldValue = e.value;            e.value = value;            e.recordAccess(this);            return oldValue;        }    }    modCount++;    addEntry(hash, key, value, i);    return null;}

put方法有很多门道，现在我们就来一步步解析。

第一步

    if (table == EMPTY_TABLE) {        inflateTable(threshold);    }

首先就是判断这个哈希表是不是一个空表。如果是就会调用inflateTable(threshold);这个方法，不是就进行下一步。我们去看看这个方法。

    private void inflateTable(int toSize) {        // 计算出传入比传入容量大的最小的二次幂        int capacity = roundUpToPowerOf2(toSize);        //  重新计算阈值 threshold = 容量 * 负载因子        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);        //  用最小的2次幂来创建一个新的数组        table = new Entry[capacity];        //  初始化哈希掩码值，将初始化推迟到我们真正需要它之前。        initHashSeedAsNeeded(capacity);    }

这个方法就是用来创建数组的，通过roundUpToPowerOf2方法来确定最小的能大于需要长度toSize的二次幂，是有点绕，那现在去看看这个方法。

    private static int roundUpToPowerOf2(int number) {        //  1.如果这个需要的长度大于最大值，就用最大值来创建数组        //  2.需要的长度小于1就用1当数组的长度，大于1就用highestOneBit方法来确定长度。        return number >= MAXIMUM_CAPACITY                ? MAXIMUM_CAPACITY                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;    }    //  这个方法就是用来确定最小的二次幂    public static int highestOneBit(int i) {        // HD, Figure 3-1        i |= (i >>  1);        i |= (i >>  2);        i |= (i >>  4);        i |= (i >>  8);        i |= (i >> 16);        return i - (i >>> 1);    }

寻找到最小的二次幂之后，重新计算阈值，然后用最小的2次幂来创建一个新的数组，最后用initHashSeedAsNeeded来初始化哈希掩码值。

第二步

    if (key == null)        return putForNullKey(value);

判断传入的key是不是null值，如果是就返回putForNullKey(value)，不然就下一步。现在来看看这个方法。

    private V putForNullKey(V value) {        /**         *  遍历table[0]的链表，若有key==null，就用新的value覆盖原来的         *  然后返回被覆盖的value，所以table[0]就只会有一个元素         */        for (Entry e = table[0]; e != null; e = e.next) {            if (e.key == null) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }        modCount++;       /**         *  要是没有key==null的键，就调用addEntry方法，将空键和值放入table[0]         *  第一次table[0]是没有元素的，所以才能到这里添加空键和值         */        addEntry(0, null, value, 0);        return null;    }

第三步*

        int hash = hash(key);        int i = indexFor(hash, table.length);        for (Entry e = table[i]; e != null; e = e.next) {            Object k;            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                V oldValue = e.value;                e.value = value;                e.recordAccess(this);                return oldValue;            }        }

这步是最重要的一步，找到插入的位置然后将键值对插入到hashmap中。首先就是调用hash方法来计算传入的key的哈希值。

    /**     * 检索对象哈希码，并将补充哈希函数应用于结果哈希，以防止质量差的哈希函数。     * 这很关键，只有HashMap使用2的幂的哈希表，不然哈希表在低位无差异时会遇到冲突。     * 注意：空键始终映射到哈希0，因此索引为0。     */    final int hash(Object k) {        int h = hashSeed;        //  若哈希值不为0而且不是String类型，就返回一个哈希值        if (0 != h && k instanceof String) {            return sun.misc.Hashing.stringHash32((String) k);        }        // 异或        h ^= k.hashCode();        // 此函数可确保在每个位位置仅相差恒定倍数的hashCode具有一定数量的冲突（在默认的加载因子下约为8）。        h ^= (h >>> 20) ^ (h >>> 12);        return h ^ (h >>> 7) ^ (h >>> 4);    }

得到哈希值之后，就会调用indexFor方法来计算出应该插入的位置。

    /**     * 返回计算出来的索引     */    static int indexFor(int h, int length) {        // assert Integer.bitCount(length) == 1 : "长度必须为2的非零次幂";        // h & (length-1)表示hash值与数组长度求余，使用位移运算可以提高效率        // 为什么必须是2的非零次幂，之后还会提到        return h & (length-1);    }

计算出具体插入的位置之后就开始插入了，这里就是用了一个for循环遍历。

    //  遍历table[i]这个桶里是否存在这个key值，若有就将原来的value覆盖，并返回原来的value    for (Entry e = table[i]; e != null; e = e.next) {        Object k;        //  如果哈希值相同，并且key值也相同，就进行替换        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {            V oldValue = e.value;            e.value = value;            e.recordAccess(this);            return oldValue;        }    }    modCount++;    //  如果桶里不存在这个key值就将这对键值对加入到桶中    addEntry(hash, key, value, i);    //  第一次加入到桶就返回null值    return null;

至此put的流程就结束了，到这里其实还是有问题。用indexFor这个方法来求数组的位置，刚刚也分析了这个方法，就是异或求余，那么就会有以下的问题，hash差为一定的倍数的时候，求余出来的下标就会是一样的，这个问题就是经常提到的哈希冲突。为了解决哈希冲突这个问题，就引进了链表，也就是之前说的加入到桶中，这就是为什么哈希表底层是用数组和链表构成的了。下面讲讲大概是怎么用到链表的。

:::note{type="info"}

图中只是为了演示大概解决的过程，实现可以参考下面的createEntry方法和扩容中的transfer方法。由于哈希的计算会使数据尽量平均，而且扩容的时候又会重新计算下标，在数组长度较小的时候哈希冲突的发生的概率是很小的。

:::

假设键值对3计算出来的i是3，就会被放到数组的第四个位置，直接放入。

假设键值对4计算出来的i是2，就会放到数组的第三个位置，但是这个位置已经有键值对1了，这种情况就会用到链表，头插到该链表。

但是如果是这种情况，就无法通过数组来寻找到键值对4了，所以还会变化一下指针的指向，最后就会变成这样。

addEntry

在上面put的第三步不难看到，在一个桶里只要有key相同，就覆盖，没有就使用addEntry这个方法加入到桶里。不难看出这个方法发生的情况，数组指定位置没有该元素或者是发生哈希冲突时就会用到这个方法，现在来看看这个方法。

    /**     * 将具有指定键，值和哈希码的Entry添加到指定存储桶     * 如果有必要，该方法也会负责调整表的大小     */    void addEntry(int hash, K key, V value, int bucketIndex) {        //  如果当前数组长度大于阈值，并且该桶不是空的就执行下面语句        if ((size >= threshold) && (null != table[bucketIndex])) {            //  扩容到原来长度的两倍            resize(2 * table.length);            //  key等于空，hash赋值为0，不然用hash方法获取哈希            hash = (null != key) ? hash(key) : 0;            //  因为扩容了，所以需要重新计算存储位置            bucketIndex = indexFor(hash, table.length);        }        //  创建Entry加入到桶里        createEntry(hash, key, value, bucketIndex);    }    /**     * 与addEntry类似，不同之处在于，在创建条目作为Map构造或“伪构造”（克隆，反序列化）的一部分时使用此版本。     * 此版本无需担心调整表的大小。     * 子类重写此方法，以更改HashMap（Map），克隆和readObject的行为。     */    void createEntry(int hash, K key, V value, int bucketIndex) {        Entry e = table[bucketIndex];        //  这条语句就说明了哈希表链表的插入是头插的        table[bucketIndex] = new Entry<>(hash, key, value, e);        size++;    }

扩容

刚刚看到addEntry中用resize方法来扩容，现在就来看看这个方法是怎么扩容的。先看看这个方法的源码。

    /**     * 将此映射的内容重新映射到容量更大的新数组中。     * 当此映射中的键数达到其阈值时，将自动调用此方法。     * 如果当前容量为MAXIMUM_CAPACITY，则此方法不会调整地图的大小，而是将阈值设置为Integer.MAX_VALUE。     * 这具有防止将来通话的效果。     *     * @param 新容量必须是2的幂，而且是大于当前容量。     *        除非当前容量是MAXIMUM_CAPACITY，这种情况就无关紧要。     */    void resize(int newCapacity) {        //  获取旧的数组和size的大小，判断是不是大于MAXIMUM_CAPACITY。        Entry[] oldTable = table;        int oldCapacity = oldTable.length;        if (oldCapacity == MAXIMUM_CAPACITY) {            threshold = Integer.MAX_VALUE;            return;        }        //  创建新的数组        Entry[] newTable = new Entry[newCapacity];        //  数据迁移，将原来数组的键值对放入新数组        transfer(newTable, initHashSeedAsNeeded(newCapacity));        table = newTable;        //重新设置阈值，等于新长度*负载因子或者MAXIMUM_CAPACITY + 1        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);    }

resize方法是挺好理解的了，只有这个迁移函数有点讲究。

    /**     * 将所有桶从当前表转移到newTable     */    void transfer(Entry[] newTable, boolean rehash) {        int newCapacity = newTable.length;        //  遍历数组        for (Entry e : table) {            //  遍历桶            while(null != e) {                //  保存e的下一个节点，因为之后链表会断开                Entry next = e.next;                //  重新计算e的hash和下标                if (rehash) {                    e.hash = null == e.key ? 0 : hash(e.key);                }                int i = indexFor(e.hash, newCapacity);                //  后面这三句可以参考以下图示。                //  这条语句是挺奇怪的，之后也会导致一些问题出现，之后在说                e.next = newTable[i];                //  节点放到桶里                newTable[i] = e;                //  继续处理原来链表中的下一个节点                e = next;            }        }    }

:::note{type="info"}

下面例子简化了长度，和一些细节，因为这样转移是很小几率的，只是为了展示转移方法的大概实现。

:::

:::note{type="info"}

transfer方法和之前的createEntry方法，表明了1.7的哈希表为什么是头插的。因为头插，哈希表还会出现一些问题，之后还会提到。

:::

get

get方法就没有put需要考虑到这么多情况了了，所以简单很多。

    /**     * 返回指定键所映射到的null如果此映射不包含键的映射关系，则返回null 。     * 更正式地讲，如果此映射包含从键k到值v的映射，     * 使得(key==null ? k==null : key.equals(k)) ，则此方法返回v     * 否则返回null 。（最多可以有一个这样的映射。）     * 返回值null不一定表示该映射不包含该键的映射。 映射也可能将键显式映射为null 。     * containsKey操作可用于区分这两种情况     */    public V get(Object key) {        if (key == null)            return getForNullKey();        Entry entry = getEntry(key);        return null == entry ? null : entry.getValue();    }

第一步

        if (key == null)            return getForNullKey();

首先就是判断key值是不是为null，如果是null就调用getForNullKey。

    /**     * get以查找空键。 空键映射到索引0。     * 为了在两个最常用的操作（获取和放置）中提高性能，此空情况被拆分为单独的方法，但在其他条件中并入了条件。     */    private V getForNullKey() {        //  要是数组没有值就返回null        if (size == 0) {            return null;        }        //  遍历table[0]的桶，寻找key==null的value值，并返回        for (Entry e = table[0]; e != null; e = e.next) {            if (e.key == null)                return e.value;        }        //  桶里没有就返回null        return null;    }

第二步

        Entry entry = getEntry(key);        //  entry为null，就返回null，不然就返回value        return null == entry ? null : entry.getValue();

这两句也挺好理解的，用getEntry方法来获取键值对，然后返回value。

    /**     * 返回与HashMap中的指定键关联的条目。 如果HashMap不包含该键的映射，则返回null     */    final Entry getEntry(Object key) {        //  数组为空返回null        if (size == 0) {            return null;        }        //  计算key的哈希值        int hash = (key == null) ? 0 : hash(key);        //  先通过哈希计算下标，然后遍历下标所在的桶，找到就返回entry，没找到就返回null        for (Entry e = table[indexFor(hash, table.length)];             e != null;             e = e.next) {            Object k;            if (e.hash == hash &&                ((k = e.key) == key || (key != null && key.equals(k))))                return e;        }        return null;    }

JDK8

:::note{type="success"}

JDK8优化了不少，但与JDK7在很多部分是一样的，所以我着重去分析一下不一样的地方。

:::

参数和变量

    //  相同的参数或者变量    private static final long serialVersionUID = 362498820763181265L;    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;    static final int MAXIMUM_CAPACITY = 1 << 30;    static final float DEFAULT_LOAD_FACTOR = 0.75f;    transient int size;    transient int modCount;    final float loadFactor;    int threshold;    //  JDK7独有的    static final Entry[] EMPTY_TABLE = {};    transient Entry[] table = (Entry[]) EMPTY_TABLE;    static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;    transient int hashSeed = 0;    private transient Set> entrySet = null;    //  JDK8独有的    transient Node[] table;    transient Set> entrySet;    static final int TREEIFY_THRESHOLD = 8;    static final int UNTREEIFY_THRESHOLD = 6;    static final int MIN_TREEIFY_CAPACITY = 64;

    /**     * 该表在首次使用时初始化，并根据需要调整大小。     * 分配时，长度始终是2的幂。（在某些操作中，我们还允许长度为零，以允许使用当前不需要的引导机制。）     */    transient Node[] table;    /**     * 保存缓存的entrySet（）。 注意，AbstractMap字段用于keySet（）和values（）     */    transient Set> entrySet;    //  链表的树化阈值，即链表长度大于8就会有可能转换成红黑树    static final int TREEIFY_THRESHOLD = 8;    //  链表的还原阈值，即红黑树的节点小于6就换转换成链表    static final int UNTREEIFY_THRESHOLD = 6;    //  最小树形化阈值，数组长度大于64才会转换成红黑树    static final int MIN_TREEIFY_CAPACITY = 64;

构造器

    public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR; // 其他字段默认    }    public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }    public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " +                                               initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " +                                               loadFactor);        this.loadFactor = loadFactor;        //  上面与JDK7的一样，不一样的就是这句和省略了init初始化方法        this.threshold = tableSizeFor(initialCapacity);    }    /**     * 与JDK7的实现有些不一样，但作用是一样的     */    public HashMap(Map m) {        this.loadFactor = DEFAULT_LOAD_FACTOR;        putMapEntries(m, false);    }

可以看出只有两个比较特殊的地方，那就是tableSizeFor和putMapEntries这两个方法了。

    /**     * 返回大于指定值的最小二次幂，作用类似highestOneBit方法     * 用来代替JDK7中的roundUpToPowerOf2方法     */    static final int tableSizeFor(int cap) {        int n = cap - 1;        n |= n >>> 1;        n |= n >>> 2;        n |= n >>> 4;        n |= n >>> 8;        n |= n >>> 16;        //  可认为将JDK7中roundUpToPowerOf2和highestOneBit方法合并了        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;    }    /**     * 实现Map.putAll和Map构造函数。     * 将map中的元素加入到HashMap中去。     */    final void putMapEntries(Map m, boolean evict) {        int s = m.size();        if (s > 0) {            if (table == null) { // pre-size                float ft = ((float)s / loadFactor) + 1.0F;                int t = ((ft < (float)MAXIMUM_CAPACITY) ?                         (int)ft : MAXIMUM_CAPACITY);                if (t > threshold)                    threshold = tableSizeFor(t);            }            else if (s > threshold)                resize();            for (Map.Entry e : m.entrySet()) {                K key = e.getKey();                V value = e.getValue();                putVal(hash(key), key, value, false, evict);            }        }    }

数据结构

JDK8的底层进行了一些优化，主体依旧是数组，链表为辅，但是链表过长会导致hashmap的查询效率变低因为链表的查询操作的时间复杂度为O(n)，所以在JDK8中引入了红黑树。当链表达到树化阈值的时候，就会转变为红黑树因为红黑树的查询操作的时间复杂度为O(log(n))，所以可以提高查询桶里节点的效率

树

Wed, 18 Nov 2020 00:00:00 +0000

94. 二叉树的中序遍历

递归

class Solution {    List res = new ArrayList<>();    public List inorderTraversal(TreeNode root) {        if (root == null) return res;        fnc(root);        return res;    }    public void fnc(TreeNode node) {        if (node == null) return;        fnc(node.left);        res.add(node.val);        fnc(node.right);    }}

迭代

迭代会麻烦一点，主要先记住中序遍历的特点，先遍历左子树，在遍历当前节点，在遍历右子树。

所以当该节点有左子树的时候就先进入到左边。

class Solution {    public List inorderTraversal(TreeNode root) {        List res = new ArrayList<>();        if (root == null) return res;        Stack stack = new Stack<>();        while(!stack.isEmpty() || root != null) {            // 一直寻找左节点while (root != null) {                stack.push(root);                root = root.left;            }            root = stack.pop();            // 处理左子树的当前节点，进入右子树            res.add(root.val);            root = root.right;}        return res;    }}

98. 验证二叉搜索树

解法一

二叉搜索树中序遍历是有序的，所以可以先全部遍历，在判断是否有序。

class Solution {    List list = new ArrayList<>();    public boolean isValidBST(TreeNode root) {        isvailbst(root);        for(int i = 1;i < list.size(); i++) {            if(list.get(i) <= list.get(i - 1)) return false;        }        return true;    }    public void isvailbst(TreeNode root) {        if(root == null) return;        isvailbst(root.left);        list.add(root.val);        isvailbst(root.right);    }}

解法二

上面的解法一其实可以看出是浪费了一些时间了的，其实可以直接在后一个值小于前一个值的时候就停下来的。

class Solution {    long pre = Long.MIN_VALUE;    public boolean isValidBST(TreeNode root) {        if(root != null) {            if(!isValidBST(root.left)) return false;            if(root.val <= pre) return false;            pre = root.val;            if(!isValidBST(root.right)) return false;        }        return true;    }}

解法三

这种方法也很好，直接划个边界给给子树递归，判断是否出边界。不过注意的是，设置边界的最大值的时候，不能用Integer.MAX_VALUE和Integer.MIN_VALUE，因为有样例正好是Integer.MAX_VALUE和Integer.MIN_VALUE，所以只能取大一点的long。

class Solution {    public boolean isValidBST(TreeNode root) {        return vailbst(root,Long.MIN_VALUE,Long.MAX_VALUE);    }    public static boolean vailbst(TreeNode root,long min,long max) {        if(root == null) return true;        if(root.val <= min || root.val >= max) {            return false;        }        return vailbst(root.left,min,root.val) && vailbst(root.right,root.val,max);    }}

100.相同的树

相同的树，首先要判断当前节点是否相同。不相同直接返回false。

然后递归判断两棵树的左子树和右子树，判断一下他们的左子树是否相同和右子树是否相同即可。

class Solution {public boolean isSameTree(TreeNode p, TreeNode q) {        if (p == null && q == null) {            return true;        }        if (p == null || q == null) {            return false;        }        if (p.val != q.val) {            return false;        }        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);    }}

101.对称二叉树

递归

判断当前节点是否是一样的
将左子树的左子树和右子树的右子树丢入递归判断，将左子树的右子树和右子树的左子树丢入递归判断，结果取并

class Solution {    public boolean isSymmetric(TreeNode root) {        if (root == null) {            return true;        }        return issymmetric(root.left, root.right);    }    public boolean issymmetric(TreeNode left,TreeNode right) {        if (left == null && right == null) {            return true;        }        if (left == null || right == null) {            return false;        }        if (left.val != right.val) {            return false;        }        return issymmetric(left.left,right.right) && issymmetric(right.left,left.right);    }}

迭代

使用双栈。

class Solution {   public boolean isSymmetric(TreeNode root) {        if (root == null) {            return true;        }        Stack left = new Stack<>();        Stack right = new Stack<>();        left.push(root.left);        right.push(root.right);        while (!left.isEmpty() && !right.isEmpty()) {            TreeNode t1 = left.pop();            TreeNode t2 = right.pop();            if (t1 == null && t2 == null) {                continue;            }            if (t1 == null || t2 == null) {                return false;            }            if (t1.val != t2.val) {                return false;            }            left.push(t1.left);            right.push(t2.right);            left.push(t1.right);            right.push(t2.left);        }        return true;    }}

层次遍历

使用队列进行层次遍历，然后判断是否回文。

102. 二叉树的层序遍历

递归解法

主要是判断一下是在哪一层，然后分层处理就可以了。

class Solution {    List> res = new ArrayList<>();    public List> levelOrder(TreeNode root) {        levelorder(root,0);        return res;    }        public void levelorder(TreeNode node,int k) {        if (node == null) return;        // 没有当前层        if (res.size() <= k) {            res.add(new ArrayList());        }        // 将节点放入k层的List中        res.get(k).add(node.val);        // 递归处理        levelorder(node.left,k+1);        levelorder(node.right,k+1);    }}

迭代解法

二叉树的层序遍历的迭代可以借组队列来进行存储节点。

class Solution {    public List> levelOrder(TreeNode root) {        List> res = new ArrayList<>();        if (root == null) return res;        Deque deque = new LinkedList<>();        deque.offer(root);        while (!deque.isEmpty()) {            // 统计当前层的节点个数            int count = deque.size();            List list = new ArrayList<>(count);            while (count-- > 0) {                TreeNode node = deque.poll();                list.add(node.val);                // 先加入左节点在加入右节点，z                if (node.left != null) deque.offer(node.left);                if (node.right != null) deque.offer(node.right);            }            res.add(list);        }        return res;    }}

104.二叉树的最大深度

首先判断根节点是不是空，不是则值加一
递归判断左子树与右子树，取最大值

class Solution {    public int maxDepth(TreeNode root) {        int res = 0;        if (root == null) {            return res;        } else {            res ++;        }        return res + Math.max(maxDepth(root.left), maxDepth(root.right));    }}

优化之后：

    public int maxDepth(TreeNode root) {        if (root == null) return 0;        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;    }

105.从前序与中序遍历序列构造二叉树

假设根的前序遍历的在中序遍历中的位置为K，那么在中序遍历中，1到K-1都是该根的左子树，K+1到最后是该根的右子树。

class Solution {    int pre = 0;    int ino = 0;    public TreeNode buildTree(int[] preorder, int[] inorder) {        return build(preorder,inorder,Integer.MAX_VALUE + 1);    }    // stop表示当前子树根的值，中序遍历到了该值，就表示左子树已经搭建好了    public TreeNode build(int[] preorder,int[] inorder, long stop) {        if (pre == preorder.length) return null;        if (inorder[ino] == stop) {            ino++;            return null;        }        int val = preorder[pre++];        TreeNode root = new TreeNode(val);        root.left = build(preorder,inorder,val);        root.right = build(preorder,inorder,stop);        return root;    }}

106.从中序与后序遍历序列构造二叉树

与上一题差不多，只是有一点点不一样而已。

class Solution {    int ino = 0;    int pos = 0;    public TreeNode buildTree(int[] inorder, int[] postorder) {        pos = postorder.length - 1;        ino = inorder.length - 1;        return build(inorder,postorder,Integer.MIN_VALUE - 1);    }    public TreeNode build(int[] inorder, int[] postorder,long stop) {        if (pos == -1) return null;        if (inorder[ino] == stop) {            ino--;            return null;        }        int val = postorder[pos--];        TreeNode root = new TreeNode(val);        root.right = build(inorder,postorder,val);        root.left = build(inorder,postorder,stop);        return root;    }}

107.二叉树的层次遍历II

从低向上层次遍历，其实就是先层次遍历然后反转就好了。

class Solution {    //定义结果集    List> res = new ArrayList<>();    public List> levelOrderBottom(TreeNode root) {        levelorder(root,0);        //反转list        List> ans = new ArrayList<>();        for(int i = res.size()-1 ; i >= 0; i--) {            ans.add(res.get(i));        }        return ans;    }    public void levelorder(TreeNode node,int k) {        if (node != null) {            if (res.size() <= k) {                res.add(new ArrayList());            }            res.get(k).add(node.val);            levelorder(node.left,k+1);            levelorder(node.right,k+1);        }    }}

110.平衡二叉树

递归一

首先，判断左右两个子树的高度的绝对值不超过1，就要用到计算二叉树的最大深度了，递归获得深度，左右子树深度差的绝对值小于等于1就返回真，然后遍历左子树和右子树就好了。

class Solution {    public boolean isBalanced(TreeNode root) {        //判断是否为空，因为空了就直接停止递归了        //为空就返回真，因为答案要与运算，返回真不会影响        if (root == null) {            return true;        }        //判断是否符合平衡二叉树，用到否定条件        //如果是用小于等于1返回真，那就没有false返回了，答案全是真        if (Math.abs(maxDepth(root.left) - maxDepth(root.right)) > 1) {            return false;        }        //遍历左子树和右子树取与        return isBalanced(root.left) && isBalanced(root.right);    }        //最大深度遍历就直接用104题目的代码了。    public int maxDepth(TreeNode root) {        int res = 0;        if (root == null) {            return res;        } else {            res ++;        }        return res + Math.max(maxDepth(root.left), maxDepth(root.right));    }}

递归二

这个和上面算法差不多，这个算法是修改了最大深度的求法，不符和条件的就返回-1的深度，要是有-1深度返回代表不符合条件。

class Solution {    public boolean isBalanced(TreeNode root) {        return maxDepth(root) >= 0;    }    public static int maxDepth(TreeNode root) {        if (root == null) {            return 0;        }         int leftheight = maxDepth(root.left);        int rightheight = maxDepth(root.right);        //判断左右子树是否平衡        if(leftheight >= 0 && rightheight >= 0 && Math.abs(leftheight - rightheight ) <= 1) {            return Math.max(leftheight,rightheight) + 1;        } else {            return -1;        }    }}

111.二叉树的最小深度

求最小深度，就与求最大深度相反就好，只是不能让空子树参与计算，不然一直返回0。

class Solution {    public int minDepth(TreeNode root) {        if (root == null) {            return 0;        }         if (root.left == null && root.right !=null) {            return 1 + minDepth(root.right);         }        if (root.left != null && root.right == null) {            return 1 + minDepth(root.left);         }        return 1 + Math.min(minDepth(root.left),minDepth(root.right));            }}

112.路径总和

这题是判断路径总和是否等于给定值，不能从下到上的计算节点值，因为情况多会无法相加，所以只能从上到下的相减，看是否等于0。

class Solution {    public boolean hasPathSum(TreeNode root, int sum) {        if (root == null) {            return false;        }        //如果是叶子节点，就直接计算是否符合         if (root.left == null && root.right == null) {            return sum - root.val == 0;        }        return hasPathSum(root.left,sum - root.val) || hasPathSum(root.right,sum - root.val);    }    }

230.二叉搜索树中第K小的元素

这题就是根据二叉搜索树的特性，中序遍历会是从小到大，然后找到第K个就好了。

class Solution {    int res = 0;    int rank = 0;    public int kthSmallest(TreeNode root, int k) {        small(root,k);        return res;    }    public void small(TreeNode root,int k) {        if (root == null) return;        small(root.left,k);        rank++;        if (k == rank) {            res = root.val;            return;        }        small(root.right,k);    }}

上面的方法是最暴力的解法，还可以进行优化。根据二叉搜索树的左子树会比根节点小，右子树会比根节点大，就可以找到第K小的元素。

class Solution {        public int kthSmallest(TreeNode root, int k) {        int left = sumTree(root.left);        if (left + 1 == k) return root.val;        else if (k <= left) return kthSmallest(root.left, k);        else return kthSmallest(root.right, k - left - 1);    }    public int sumTree(TreeNode root) {        if (root == null) return 0;        return sumTree(root.left) + sumTree(root.right) + 1;    }}

450.删除二叉搜索树中的节点

这题通过遍历就可以找到需要删除的节点，这题的难点是怎样删除找到的节点。

确认了需要删除的节点后，就要先找到该节点右子树最小的值，用该值代替删除的节点，因为这样就不会破环二叉搜索树的结构了。（也可以寻找左子树的最大值）

class Solution {    public TreeNode deleteNode(TreeNode root, int key) {        if (root == null) return null;        if (root.val == key) {            if (root.left == null) return root.right;            if (root.right == null) return root.left;            // 寻找节点右子树的最小值            TreeNode node = root.right;            while (node.left != null) node = node.left;            // 将节点的左子树赋值给最小值的左子树完成删除            node.left = root.left;            return root.right;        } else if (key > root.val) {            root.right = deleteNode(root.right,key);            } else {                root.left = deleteNode(root.left,key);            }        return root;    }}

538. 把二叉搜索树转换为累加树

这题主要的问题是没理解题目到底在讲什么，看了答案才知道其实是将树从下到上，从右到左累加，然后将该值赋值给当前节点。

class Solution {    int sum = 0;    public TreeNode convertBST(TreeNode root) {        if (root == null) return null;        convertBST(root.right);        // 将累加结果赋值给当前节点，并记录累加        root.val = root.val + sum;        sum = root.val;        convertBST(root.left);        return root;    }}

589.N叉树的前序遍历

递归

判断root是否为空结点
将数据存入List
递归前序遍历各个结点

这道题难的就是结果的存储了，因为经常写的前序遍历都是直接输出结果的，存储的化就要全局的List了。

public class Solution {    List res = new ArrayList<>();    public List preorder(Node root) {        if (root == null) {            return res;        }        res.add(root.val);        for(Node node : root.children){            preorder(node);        }        return res;    }}

非递归

先判断root是否为空结点
将root结点压入栈
当栈不为空，将栈中数据存入List，将当前结点的孩子压入栈

public class Solution {    public List preorder(Node root) {        List list = new ArrayList<>();        if (root == null) return list;        Stack stack = new Stack<>();        stack.push(root);        while(!stack.isEmpty()) {            Node node = stack.pop();            list.add(node.val);            for (int i = node.children.size() - 1; i >= 0; i--) {                stack.push(node.children.get(i));            }        }        return list;    }}

652.寻找重复的子树

这题主要的难点就是怎样判断该节点的子树和其他节点的子树是否一样。

可以考虑到的是将该节点的子树和根作为一个字符串，如果其他字符串与其一样，就判断为这是重复的子树节点。

class Solution {// 用来去重    HashMap map = new HashMap<>(16);    List res = new ArrayList<>();         public List findDuplicateSubtrees(TreeNode root) {        traverse(root);        return res;    }    public String traverse(TreeNode root) {        if(root == null) {            return "#";        }        String left = traverse(root.left);        String right = traverse(root.right);        String str = left + "+" + right + "+" + root.val;        int freq = map.getOrDefault(str,0);        // 不重复将值加入到List中        if (freq == 1) res.add(root);        map.put(str,freq + 1);        return str;    }}

897.递增顺序查找树

直接中序遍历然后把节点赋给结果子树的右子树就好了。

class Solution {    //head用来记录根节点，因为res要递归右子树    TreeNode head = new TreeNode();    TreeNode res = right;    public TreeNode increasingBST(TreeNode root) {        if (root == null) {            return null;        }        increasingBST(root.left);        //将当前节点赋值给res的右子树，然后再进入右子树，左子树为空        res.right = root;        root.left=null;        res = res.right;        increasingBST(root.right);        return head.right;    }}

938.二叉搜索树的范围和

暴力递归破解。

class Solution {    int sum = 0;    public int rangeSumBST(TreeNode root, int low, int high) {        range(root,low,high);        return sum;    }    public void range(TreeNode root,int low,int high) {        if (root == null) return;        range(root.left,low,high);        if (root.val >= low && root.val <= high) sum += root.val;        range(root.right,low,high);    }}

因为中序遍历是从小到大的，所以还可以优化一下。

965.单值二叉树

class Solution {    public boolean isUnivalTree(TreeNode root) {        return isTree(root,root.val);    }    public boolean isTree(TreeNode root,int val) {        if (root == null) return true;        if (root.val != val) return false;        return isTree(root.left,root.val) && isTree(root.right,root.val);    }}

从根到叶的二进制数之和

class Solution {    int sum = 0;    public int sumRootToLeaf(TreeNode root) {        return sumroottoleaf(root,sum);    }    public int sumroottoleaf(TreeNode root,int sum) {        // 防止左右子树有一个是NULL的情况        if(root == null) {            return 0;        }        //左移一位再加值        sum = sum*2 + root.val;        if(root.left == null && root.right == null){            return sum;        }        //递归        return sumroottoleaf(root.left,sum) + sumroottoleaf(root.right,sum);    }}

剑指 Offer 54. 二叉搜索树的第k大节点

暴力破解

我的第一想法就是直接全部遍历，排序然后找到第k大的节点，虽然效率不这么好，但是也是一种方法。

class Solution {    List arr = new ArrayList<>();    public int kthLargest(TreeNode root, int k) {        largest(root);        Collections.sort(arr);        return arr.get(arr.size()-k);    }    public  void largest(TreeNode root) {        if (root == null) {            return;        }        arr.add(root.val);        largest(root.left);        largest(root.right);    }}

中序遍历

因为给的树是二叉搜索树，所以应该想到二叉搜索树的中序遍历就是有序的，所以可以省去排序的时间。

class Solution {    List arr = new ArrayList<>();    public int kthLargest(TreeNode root, int k) {        largest(root);        return arr.get(arr.size()-k);    }    public  void largest(TreeNode root) {        if (root == null) {            return;        }        largest(root.left);        arr.add(root.val);        largest(root.right);    }}

直接寻找第k大的结点

中序遍历毕竟是要遍历整个树，所以效率也只是比暴力破解好了一点点而已，要想节约时间，那就只搜索到第K大的结点就停止就好了，所以就用到了二叉搜索树的性质。（若它的左子树不空，则左子树上所有结点的值均小于它的根结点根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值。）通过中序遍历，找到第K个结点就可以了。

class Solution {    int sum = 0,res = 0;    public int kthLargest(TreeNode root, int k) {        largest(root,k);        return res;    }    public void largest(TreeNode root,int k) {        if (root.right != null) {            largest(root.right,k);        }        sum++;        if(sum == k) {            res =  root.val;            return;        }        if (root.left != null) {            largest(root.left,k);        }    }}

面试题 04.03. 特定深度节点链表

首先就是这个链表的插入，如果使用尾插就需要在声明一个头节点的数组存储头节点，所以我用了头插法，不过要注意顺序，先将右子树的值插入链表再将左子树的值插入链表，这样就能符和题目的顺序了。还有就是链表数组的长度，第一个解法我就直接再加个函数求取树的最大深度了，套用第104题就行。

class Solution {    public ListNode[] listOfDepth(TreeNode tree) {        int n = maxDepth(tree);        ListNode[] res = new ListNode[n];        listofdepth(tree,0,res);        return res;    }    public int maxDepth(TreeNode root) {        int res = 0;        if (root == null) {            return res;        } else {            res ++;        }        return res + Math.max(maxDepth(root.left), maxDepth(root.right));    }    public void listofdepth(TreeNode tree,int t,ListNode[] res) {        if(tree == null) {            return;        }        ListNode node = new ListNode();        node.val = tree.val;        node.next = null;        listofdepth(tree.right,t+1,res);        node.next = res[t];        res[t] = node;        listofdepth(tree.left,t+1,res);    }}

这种解法速度还是很快的，只是消耗的内存有点多，可能题目就打算消耗多的内存。还有一种思路就是使用层次遍历，其实也差不多。也看了一下其他解法，不过很多的解法消耗的内存有点多，然后看到一些内存消耗低的解法，发现寻找深度的代码还可以优化，然后又优化了一些细节。

class Solution {    public ListNode[] listOfDepth(TreeNode tree) {        int depth = maxDepth(tree);        ListNode[] list = new ListNode[depth];        if (tree == null) return list;        listofdepth(tree,0,list);        return list;    }    public int maxDepth(TreeNode node) {        if (node == null) return 0;        return Math.max(maxDepth(node.left),maxDepth(node.right)) + 1;    }    public void listofdepth(TreeNode root,int k,ListNode[] list) {        if (root == null) return;        ListNode node = new ListNode(root.val);        node.next = list[k];        list[k] = node;        listofdepth(root.right,k + 1,list);        listofdepth(root.left,k + 1,list);    }}

Mybatis-plus

Sat, 14 Nov 2020 00:00:00 +0000

简介

MyBatis-Plus（简称 MP）是一个 MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

官网地址

快速开始

:::note{type="info"}

参照官网快速开始的样例，官网用的是h2数据库，我这里用的是Mysql。

:::

创建数据库schema，并执行以下脚本。

DROP TABLE IF EXISTS user;CREATE TABLE user(    id BIGINT(20) NOT NULL COMMENT '主键ID',    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',    age INT(11) NULL DEFAULT NULL COMMENT '年龄',    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',    PRIMARY KEY (id));DELETE FROM user;INSERT INTO user (id, name, age, email) VALUES(1, 'Jone', 18, 'test1@baomidou.com'),(2, 'Jack', 20, 'test2@baomidou.com'),(3, 'Tom', 28, 'test3@baomidou.com'),(4, 'Sandy', 21, 'test4@baomidou.com'),(5, 'Billie', 24, 'test5@baomidou.com');

添加依赖

主要的依赖。

    com.baomidou    mybatis-plus-boot-starter    3.4.1

测试依赖如下。

                    org.springframework.boot            spring-boot-starter                                    mysql            mysql-connector-java                                    org.projectlombok            lombok            true                                    com.baomidou            mybatis-plus-boot-starter            3.4.1                                    org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine

创建一个实体类

package com.yw.pojo;import lombok.Data;@Datapublic class User {    private Long id;    private String name;    private Integer age;    private String email;}

创建Mapper接口

package com.yw.Mapper;import com.baomidou.mybatisplus.core.mapper.BaseMapper;import com.yw.pojo.User;import org.springframework.stereotype.Repository;@Repositorypublic interface UserMapper extends BaseMapper {}

配置数据源和日志

# 配置MySQLspring: datasource:  username: root  password: password  url: jdbc:mysql://localhost:3306/schema?userUnicode=true&characterEncoding=utf-8&serverTimezone=UTC  driver-class-name: com.mysql.cj.jdbc.Driver# 配置日志，以便更好查看结果 mybatis-plus:  configuration:   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

添加扫描Mapper文件的注解

package com.yw;import org.mybatis.spring.annotation.MapperScan;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication@MapperScan("com.yw.Mapper")public class DemoApplication {    public static void main(String[] args) {        SpringApplication.run(DemoApplication.class, args);    }}

测试类

package com.yw;import com.yw.Mapper.UserMapper;import com.yw.pojo.User;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import java.util.List;@SpringBootTestclass DemoApplicationTests {    @Autowired    private UserMapper userMapper;    @Test    public void testSelect() {        List userList = userMapper.selectList(null);        System.out.println(userList);    }    }

然后就完成了。这的确比mybatis简单了不少。
mybatis大概流程是导入依赖，定义实体类，定义mapper接口，创建绑定mapper接口的xml配置文件,配置数据源并绑定mybatis的配置文件和实体类，然后才能使用。现在简单了很多。

主键生成策略

雪花算法

主键生成策略有很多，不过主要学习一下这个雪花算法。

首先来做个插入的测试。

package com.yw;import com.yw.Mapper.UserMapper;import com.yw.pojo.User;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;@SpringBootTestclass DemoApplicationTests {        @Autowired    private UserMapper userMapper;    //用的还是官网给的测试数据库    @Test    public void testInsert() {        User user = new User();        user.setAge(20);        user.setEmail("1141950370@qq.com");        user.setName("yww");        userMapper.insert(user);    }}

这个测试是没有设置主键id的值的，来看一下主键的生成。

插入成功之后看到数据是这样的。

这么一长串的id是什么东西呢，我们在官网看到主键有个注释@TableId，点进去看看源码。

package com.baomidou.mybatisplus.annotation;import java.lang.annotation.*;/** * 表主键标识 * * @author hubin * @since 2016-01-23 */@Documented@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})public @interface TableId {    /**     * 字段名（该值可无）     */    String value() default "";    /**     * 主键类型     * {@link IdType}     */    IdType type() default IdType.NONE;}

这里就可以看到主键是可以可无的，下面是默认的主键生成策略，我们在点IdType进去看看有什么策略。

package com.baomidou.mybatisplus.annotation;import lombok.Getter;/** * 生成ID类型枚举类 * * @author hubin * @since 2015-11-10 */@Getterpublic enum IdType {    /**     * 数据库ID自增     * 该类型请确保数据库设置了 ID自增 否则无效
     */    AUTO(0),    /**     * 该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)     */    NONE(1),    /**     * 用户输入ID     * 该类型可以通过自己注册自动填充插件进行填充
     */    INPUT(2),    /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */    /**     * 分配ID (主键类型为number或string）,     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(雪花算法)     *     * @since 3.3.0     */    ASSIGN_ID(3),    /**     * 分配UUID (主键类型为 string)     * 默认实现类 {@link com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator}(UUID.replace("-",""))     */    ASSIGN_UUID(4),    /**     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}     */    @Deprecated    ID_WORKER(3),    /**     * @deprecated 3.3.0 please use {@link #ASSIGN_ID}     */    @Deprecated    ID_WORKER_STR(3),    /**     * @deprecated 3.3.0 please use {@link #ASSIGN_UUID}     */    @Deprecated    UUID(4);    private final int key;    IdType(int key) {        this.key = key;    }}

在这里就看到当主键为空的时候，会有一个默认的生成策略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雪花算法。

代码生成器

首先需要引入依赖。

                            com.baomidou            mybatis-plus-generator            ${mybatis-plus-generator.version}                                    org.apache.velocity            velocity-engine-core            ${velocity.version}

引擎可以选择其他的，这里就使用velocity。

这里给出一个比较通用的配置。

想要更加自定义的配置可以参考代码生成器的配置文档

https://baomidou.com/pages/981406/

import com.baomidou.mybatisplus.annotation.FieldFill;import com.baomidou.mybatisplus.annotation.IdType;import com.baomidou.mybatisplus.generator.FastAutoGenerator;import com.baomidou.mybatisplus.generator.config.DataSourceConfig;import com.baomidou.mybatisplus.generator.config.rules.DateType;import com.baomidou.mybatisplus.generator.fill.Column;import org.jetbrains.annotations.Contract;import org.jetbrains.annotations.NotNull;import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;import org.springframework.core.io.ClassPathResource;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.Properties;/** *  *      MyBatisPlus的代码生成器 * 
 * * @ClassName CodeGenerator * @Author yww * @Date 2022/10/8 16:26 */public class CodeGenerator {    /**     * 获取配置文件application.yml中关于mysql的配置     * @return  数据库配置     */    @NotNull    @Contract(" -> new")    private static DataSourceConfig.Builder getDataSourceConfig() {        // 配置文件为application.yml使用        YamlPropertiesFactoryBean factoryBean = new YamlPropertiesFactoryBean();        factoryBean.setResources(new ClassPathResource("application.yml"));        Properties properties = factoryBean.getObject();        if (properties == null) {            throw new RuntimeException("请确认配置文件是否名为application.yml，是否在resources资源目录下！");        }        String url = (String) properties.get("spring.datasource.url");        String username = (String) properties.get("spring.datasource.username");        String password = (String) properties.get("spring.datasource.password");        if (url == null || url.isEmpty()) {            throw new RuntimeException("mysql的url出错！");        }        if (username == null || username.isEmpty()) {            throw new RuntimeException("mysql的username出错！");        }        if (password == null || password.isEmpty()) {            throw new RuntimeException("mysql的password出错！");        }        return new DataSourceConfig.Builder(url, username, password);    }    /**     * 执行 run     */    public static void main(String[] args)  {        // 项目路径 + /src/main        String path = System.getProperty("user.dir").replaceAll("\\\\","/") + "/src/main";        FastAutoGenerator.create(getDataSourceConfig())            // 全局配置            .globalConfig(builder -> builder                    // 作者名称                    .author("yww")                    // 指定输出目录                    .outputDir(path + "/java")                    // 禁止打开输出目录                    .disableOpenDir()                    // 时间策略                    .dateType(DateType.TIME_PACK)                    // 注释日期                    .commentDate("yyyy-MM-dd")                    // 开启springdoc的注解                    .enableSpringdoc()                    .build()            )            // 包配置            .packageConfig(builder -> builder                    // 父包名                    .parent("com.yww.management")                    .build()            )            // 模板配置            .templateConfig(builder -> builder                    // 禁用所有模板                    //.disable()                    .controller(path + "/resources/templates/controller.java.vm")                    .build())            // 策略配置            .strategyConfig((scanner, builder) -> builder                    // 增加表匹配                    .addInclude(getTables(scanner.apply("请输入表名，如需输入多个表名，可用英文逗号分隔，选择所有表输入all")))                    // controller策略                    .controllerBuilder().enableRestStyle().enableHyphenStyle()                    // entity策略配置                    .entityBuilder().enableLombok()                    .idType(IdType.ASSIGN_ID)                    .enableTableFieldAnnotation()                    .addTableFills(new Column("create_time", FieldFill.INSERT))                    .addTableFills(new Column("update_time", FieldFill.INSERT_UPDATE))                    .build()            )            .execute();    }    /**     * 处理输入all的情况     */    protected static List getTables(String tables) {        return "all".equals(tables) ? Collections.emptyList() : Arrays.asList(tables.split(","));    }}

Linux

Wed, 11 Nov 2020 00:00:00 +0000

虚拟机网络

连接方式	连接的网卡	能否连接局域网	能否连接公网
桥接	VMnet0(本地真实网卡)	可以	可以
NAT	VMnet8	不可以	可以
仅主机	VMnet1	不可以	不可以

桥接连接的网卡是随机连接的，要是连接到了没网络的网卡还需要自己设置。
桥接模式下虚拟机相当一台独立的计算机，拥有一个独立的IP地址，与本机在一个局域网内。
NAT模式可以帮助虚拟机通过本机所在的网络来访问公网。
仅主机模式会建立一个全封闭的虚拟网络，只有主机能访问

目录结构

常用命令

目录命令

ls

# 查看文件夹的信息ls # 查看详细信息ls -l# 查看隐藏目录ls -a # 显示文件大小ls -lh

cd

# 进入目录cd [路径]# 进入家目录cd ~# 进入上一次所在的目录cd -# 进入上一级目录cd ..

mkdir和rmdir

# 创建目录mkdir [目录名]# 删除目录，只能删除空目录rmdir [目录名]# 递归建立目录mkdir -p [目录路径]# 递归删除目录,只能删除空目录rmdir -p [目录路径]

文件操作

touch

# touch创建文件touch [文件名]# 若已有该文件则会修改文件时间

stat

# 查看文件详细信息stat

cat

# 查看文件内容cat [文件名]# 显示行号cat -n [文件名]# 显示所有隐藏符号cat -A [文件名]

more和less

# 分屏显示文件内容more [文件名]# 空格键翻页，回车向下一行，b向上翻页，/字符串就算搜索字符串，q退出# 分行显示文件内容less [文件名]

head和tail

# 显示文件开头n行head -[n] [文件名]# 显示文件末尾n行tail -[n] [文件名]# 监听文件新增内容tail -f [文件名]

文件和目录的命令

rm

# 删除文件或者目录rm [文件名]# 强制删除rm -f# 递归删除rm - r

cp

# 复制文件,不自定义名字就会默认原名cp [文件名] [复制后]# 递归复制，多用于目录cp -r

mv

# 移动或重命名mv [文件名] [移动后]

权限

基本权限

通过命ls -l就能看到一些文件的基本权限，比如下图。

第一位表示的是文件的类型。
- -代表的是普通文件
- d代表是目录
- b代表块设备文件
- c代表字符设备，比如键盘鼠标等等
- s代表套接字文件
- l位链接文件
- p位管道文件
第二到第四位代表文件所有者的权限(user)
第五到第七位代表组群所有者的权限(group)
第八到第十位代表其他人的权限(other)
- -代表没用该权限
- r代表可读
- w代表可写
- x代表可执行
后面两个root代表的是文件所有者和群组

修改权限

chmod

# 增加文件所有者的一个文件的可写权限chmod u+w [文件名]# 删除权限chmod u-w [文件名]# 修改所有者，组和其他用户权限chmod u+w,g+w,o+w [文件名]# 设置权限chmod u=rwx,g=rwx,o=rwx [文件名]

数字权限

# 4代表可读，2代表可写，1代表可执行# 修改文件权限,4+2+1=7,4+1=5chmod 755 [文件名]# 经常使用到的数字权限chmod 644chmod 755chmod 777

chown

## 修改文件的所有者chown [用户] [文件名]## 修改文件的所有者和所有组chown [用户]:[组] [文件名]

chgrp

## 修改文件的所属组chown [组] [文件名]

默认权限

每次新建的文件都会有权限，这就是默认权限，umask。对文件来讲默认权限最大为666，对目录来讲是777。

## 查看当前umask的值umask## 查看当前默认权限umask -S

帮助命令

man

man ls## 查看命令有几个级别man -f what is

info

info ls

help

## help只能获取shell内置命令的帮助,不常用cd --help## 可以用type来判断是不是内置命令type cd

搜索命令

whereis

## 用来搜索系统命令，源文件和帮助文档位置whereis ls

which

## 查找命令，若该命令有别名也会查找别名which ls

locate

## 通过文件名搜索,因为是通过数据库查找，所以新增的需要更新数据库locate [文件名]

find

按照文件名搜索

## 通过文件名搜索find [搜索的路径] -name [文件名]## 不区分大小写的文件名find [搜索的路径] -iname [文件名]## 通过inode查找find [搜索的路径] -inum [inode]

按照文件大小搜索

## 按照文件大小搜索find [搜索的路径] -size [大小]

按照权限搜索

find [搜索的路径] -perm [数字权限]## 三个权限只要有一个比数字权限的大或者等于find [搜索的路径] -perm +[数字权限]## 三个权限每一个都要比数字权限的大或者等于find [搜索的路径] -perm -[数字权限]

grep

## 查找文件中符合条件的字符串grep "ww" [文件名]## 输出行号grep -n## 不区分大小写grep -i## 查找不符合条件的grep -v## 符合的部分高亮grep --color=auto

压缩与解压缩

zip格式

## 压缩zip [压缩后文件名] [原文件]zip test.zip test.txt## 解压缩unzip [压缩文件]

gz格式

## 压缩文件，能压缩目录但不打包gzip [文件名]# 不保留原文件gzip -r [目录]# 会将目录内文件一个个压缩，不压缩目录## 解压缩gzip -d [压缩文件]gunzip [压缩文件]gzip -dr [目录]

bz2格式

## 压缩，不能压缩目录bzip2 [文件名]# 不保留原文件bzip2 -k [文件名]# 保留原文件## 解压缩bzip2 -d [压缩文件]bunzip2 [压缩文件]

tar格式

## 打包,c表示打包，f表示指定文件名，v显示打包过程tar -cvf [文件名.tar] [原文件或目录]## 解压,x表示解打包tar -xvf [tar包]## 压缩包,生成.tar.gz的压缩包gzip [tar包]## 解压缩包gzip -d [tar.gz压缩文件]

tar.gz和tar.bz2

## 压缩,z表示tar.gz格式，j表示tar.bz2tar -zcvf [文件名.tar.gz] [原文件或目录]tar -jcvf [文件名.tar.bz2] [原文件或目录]## 解压缩tar -zxvf [文件名.tar.gz] tar -jxvf [文件名.tar.bz2] ## 解压缩到指定位置tar -zxvf [文件名.tar.gz] -C [路径]tar -jxvf [文件名.tar.bz2] -C [路径]## 只查看不解压，用t参数tar -ztvf [文件名.tar.gz] [原文件或目录]tar -jtvf [文件名.tar.gz] [原文件或目录]

关机和重启

sync

# 数据同步，刷新文件系统的缓存区sync

shutdown

# 现在关机shutdown -h now# 在10点关机shutdown -h 10:00# 现在重启shutdown -r now# 取消关机或重启shutdown -c

reboot

# 现在重启reboot

网络命令

ifconfig

# 查询网卡的信息ifconfig

ping

# ping向一个主机发送ICMP请求ping [IP]# 指定ping的次数ping -c 10 [IP]# 广播ping -b [IP]

netstat

# 查询本机开启的所有端口netstat -tuln# 查看本机开启的所有端口是哪个服务netstat -tulnp# 查看网关netstat -rn

VIM

进入输入模式

插入命令	描述
i	在光标所在字符后插入
I	在光标所在字符行尾插入
a	在光标所在字符前插入
A	在光标所在行行首插入
o	在光标下插入新行
O	在光标上插入新行

编辑模式

# 在命令模式用:进入编辑模式# 保存:w# 退出:q# 强制不保存退出:q!# 强制保存退出:wq!

命令模式

移动光标

上下左右键
HJKL键，h向左，j向下，k向上，l向右
gg移动光标到文件头，G移动到文件尾
^移动到行首，&到行尾
进入编辑模式加数字到第几行，比如:3是到第三行

删除

x删除一个字母，nx删除n个字母
dd删除一行，ndd删除n行
进入编辑模式，:n1,n2d删除n1到n2行
其实删除是放到了剪切板，按p数粘贴到下一行，P是粘贴到上一行

复制

yy复制单行，nyy复制n行
按p数粘贴到下一行，P是粘贴到上一行

撤销

u撤销上一次操作
ctrl+r是反撤销

替换

r替换光标的字符
R进入替换模式，esc退出

vim配置文件

参数	描述
: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该用户的编辑器就会显示行号

记一次容器编排

Tue, 10 Nov 2020 00:00:00 +0000

前言

老师丢了一个spring写的项目给我们部署到服务器上。这次来记录一下部署的过程。

分析项目

这是一个spring的项目，没用到springboot，只能用tomcat部署了。因为还用到了MySQL连接，所以还需要一个MySQL的容器。知道了需要的容器那就开始行动了。

构建好大概框架

创建一个项目的文件夹
```
    mkdir math    cd math
```
创建一个放Tomcat配置的文件夹
```
    mkdir webapp
```
创建一个放MySQL配置的文件夹
```
    mkdir database
```
创建一个docker-compose.yml的配置文件
```
    touch docker-compose.yml
```

Tomcat容器

因为这个项目打包出来是war包的，所以我想的就是直接将war包放到Tomcat的webapps里然后运行Tomcat就好了。（以下操作是在webapp文件夹进行）

:::note{type="warning"}

注意设置项目中连接mysql的url，ip填写为mysql（其他也行，后面自己改服务名） localhost是指Tomcat容器的IP，因为容器与容器是隔离的，所以会连接不到MySQL容器的IP。

:::

将改好的项目war包移入服务器的这个文件夹中。

定制Tomcat的镜像，创建一个Dockerfile文件。

FROM tomcat:9.0LABEL maintainer = "yww  <1141950370@qq.com>"# 暴露端口EXPOSE 9010# 将war包放入Tomcat容器的webapps文件夹中ADD math.war /usr/local/tomcat/webapps/

MySQL容器

这个容器才是这次的重点，因为要导入自己的sql语句，所以需要额外的shell脚本来实现。（以下操作是在database文件夹进行）

将sql文件移入这个文件夹，我的文件名是mathStock.sql。

定制MySQL的镜像，创建一个Dockerfile文件。

FROM mysql:8.0LABEL maintainer = "yww  <1141950370@qq.com>"# 设置mysql的工作位置ENV WORK_PATH /usr/local/#定义会被容器自动执行的目录和所需文件的环境变量ENV AUTO_RUN_DIR /docker-entrypoint-initdb.dENV SQLFILE mathStock.sqlENV INSTALL_DATA_SHELL setup.sh# 将需要的文件放入容器内COPY ./$SQLFILE $WORK_PATH/COPY ./$INSTALL_DATA_SHELL $AUTO_RUN_DIR/# 给shell脚本和自动执行目录增加可执行的权限RUN chmod a+x $AUTO_RUN_DIR/$INSTALL_DATA_SHELL#设置容器启动时执行的命令CMD ["sh", "/docker-entrypoint-initdb.d/import.sh"]

创建一个shell脚本用于导入sql文件，我的文件名是setup.sh
```
#!/bin/bashmysql -uroot -ppassword <
```

`容器编排docker-compose.yml`

# 版本需要选对，不然报错version: '3'services:# 编排Tomcat容器      webapp:           container_name: webapp           image: webapp           build:               context: ./webapp               dockerfile: Dockerfile           ports:                   - "9010:8080"           depends_on:                   - mysql# 编排MySQL容器      mysql:           container_name: mysql           image: database           build:                context: ./database                 dockerfile: Dockerfile           ports:                   - "3306:3306"            # 挂载数据卷           volumes:                   - "./mysql:/var/lib/mysql"                   - "./my.cnf:/etc/mysql/conf.d/my.cnf"           #设置编码格式           command: [                  '--character-set-server=utf8mb4',                   '--collation-server=utf8mb4_unicode_ci'              ]           #设置初始化密码           environment:                MYSQL_ROOT_PASSWORD: "password"

`运行`

编排完之后就可以运行了。

docker-compose up -d

`参考文章`

https://blog.csdn.net/u011913691/article/details/90665639



Swagger3
Tue, 03 Nov 2020 00:00:00 +0000
前言
学完之前的swagger2之后,发现还有一个新的版本，swagger3，用起来更加的简单，而且是官方的starter。
使用
首先导入依赖
    io.springfox    springfox-boot-starter    3.0.0
创建swagger配置类。
package com.yww.config;import org.springframework.context.annotation.Configuration;@Configurationpublic class swaggerConfig {}
然后就能访问urlhttp://localhost:8088/swagger-ui/找到文档了。
有很多的配置与swagger2是一样的，就不具体阐述了。
增强
Swagger3还可以使用knife4j来增加Swagger的体验，这个前身是swagger-bootstrap-ui。
官方的文档。https://doc.xiaominfo.com/knife4j/documentation/
可以根据底层的不同来选择依赖，比如使用OpenAPI3结构的可使用以下版本。
    com.github.xiaoymin    knife4j-spring-boot-starter        3.0.2
使用后也是访问doc.html就能看到。
knife4j还有增强的特性，可以参考https://doc.xiaominfo.com/knife4j/documentation/enhance.html来开启增强模式。


MySQL
Sun, 01 Nov 2020 00:00:00 +0000
基本概念
连接数据库
-- username 则为自己的用户名，一般为root，password为密码mysql -u[username] -p[password]mysql -u[username] -p-- 断开连接，即退出数据库操作页面exit
:::note{type="info"}
MySQL的关键字是不区分大小写的，这里我全部用大写来记录。
:::
DDL数据定义语言
数据库操作
创建数据库
CREATE DATABASE [数据库名];CREATE DATABASE IF NOT EXISTS [数据库名];
删除数据库
DROP DATABASE [数据库名];DROP DATABASE IF EXISTS [数据库名];
查看数据库
-- 查看所有的数据库SHOW DATABASES;-- 查看创建库使用的语句SHOW CREATE DATABASES [库名];
切换数据库
-- 切换到指定的数据库USE [数据库名];--  数据库名和表名如果是特殊的词，就需要用``来区分
表中的数据类型
数值类型
类型 描述 大小
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 该数据列可以包含NULL值
NOT NULL 该数据列不允许为NULL值
DEFAULT 为数据列指定默认值
PRIMARY KEY 设数据列为主键
AUTO_INCREMENT 设数据列为自动递增，设用于整数
UNSIGNED 设数据列为无符号
CHARACTER SET [name] 为数据列指定一个字符集
COMMENT 注释
表的操作
查看表
-- 进入数据库后查看该数据库所有的表SHOW TABLES [表名];-- 查看创建表使用的语句SHOW CREATE TABLE [表名];
查看表中的信息
-- 查看表中的具体信息，即结构DESCRIBE [表名];DESC [表名];
创建表
CREATE TABLE IF NOT EXISTS `[表名]`(属性)[表类型][设置字符集]-- 例子CREATE TABLE IF NOT EXISTS `user`(`id` INT(5) NOT NULL AUTO_INCREMENT COMMENT 'id号',        `username` VARCHAR(20) NOT NULL COMMENT '用户名',        `password` VARCHAR(20) NOT NULL COMMENT '密码',        `sex` VARCHAR(2) COMMENT '性别',        `birthday` DATETIME DEFAULT NULL COMMENT '生日',        `address` VARCHAR(100) DEFAULT NULL COMMENT '地址',        `email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',        PRIMARY KEY(`id`)    )ENGINE=INNODB DEFAULT CHARSET=utf8
修改表
-- 修改表名ALTER TABLE [旧表名] RENAME AS [新表名];-- 增加表的字段ALTER TABLE [表名] ADD [属性];ALTER TABLE user1 ADD age INT(10) DEFAULT NULL COMMENT '年龄';-- 修改表的约束-- CHANGE可以更改列名和列类型，而MODIFY只能修改列类型-- CHANGE只修改列类型的时候，也要写两个相同的列名-- 所以只修改列类型建议用MODIFYALTER TABLE [表名] CHANGE [旧列名] [新列名] [类型];ALTER TABLE [表名] MODIFY [列名] [类型];-- 删除表的字段ALTER TABLE [表名] DROP [列名];
删除表
DROP TABLE [表名];DROP TABLE IF EXISTS [表名];
添加外键
ALTER TABLE [当前表名] ADD CONSTRAINT `FK_[列名]` FOREIGN KEY([列名]) REFERENCES [对象表名]([列名]);
DML数据操纵语言
INSERT
-- 插入一条数据INSERT INTO [表名]([列名1]，[列名2]，[列名3]) VALUES([值1]，[值2]，[值3]);INSERT INTO [表名] VALUES([值1]，[值2]，[值3]);-- 插入多条语句INSERT INTO [表名]([列名1]，[列名2]，[列名3]) VALUES([值1]，[值2]，[值3]),([值1]，[值2]，[值3]);INSERT INTO [表名] VALUES([值1]，[值2]，[值3]),([值1]，[值2]，[值3]);
UPDATE
-- 条件一般使用WHEREUPDATE [表名] SET [列名]=[值] [条件];UPDATE [表名] SET [列名1]=[值1],[列名2]=[值2] [条件];
DELETE
-- 删除数据DELETE FORM [表名] [条件];-- 清空表中数据TRUNCATE [表名];-- TRUNCATE会让自增计数器清零
DQL数据查询语言
CREATE TABLE IF NOT EXISTS `user`(`id` INT(5) NOT NULL AUTO_INCREMENT COMMENT 'id号',    `username` VARCHAR(20) NOT NULL COMMENT '名字',    `password` VARCHAR(20) NOT NULL COMMENT '密码',    `sex` VARCHAR(2) COMMENT '性别',    `birthday` DATETIME DEFAULT NULL COMMENT '生日',    `address` VARCHAR(100) DEFAULT NULL COMMENT '地址',    `email` VARCHAR(50) DEFAULT NULL COMMENT '邮箱',    PRIMARY KEY(`id`))ENGINE=INNODB DEFAULT CHARSET=utf8
建个表好进行之后的例子
简单的查询
-- 查询表中所有信息SELECT * FROM [表名];SELECT * FROM `user`;-- 查询表中指定信息SELECT [列名1],[列名2] FROM [表名];SELECT `id`,`name` FROM `user`;-- 给结果的字段及表器别名,AS可以省略SELECT [列名1] AS [别名1],[列名2] AS [别名2] FROM [表名] AS [别名3];SELECT `username` AS '用户名',`password` AS '密码' FROM `user` AS '用户表';-- 处理结果的信息，简单的字符串拼接SELECT CONCAT([message],[列名]) FROM [表名];SELECT CONCAT('用户名为',`username`) FROM `user`;
去重
-- 去除同样的数据SELECT DISTINCT `username` FROM `user`;
一些常用连接符
AND && A AND B
OR || A OR B
NOT ! NOT A
LIKE
-- %代表任意字符,_代表一个字符SELECT [列名] FROM [表名] LIKE '[通配符]';-- 查询用户名第一个字陈的人SELECT `username` FROM `user` LIKE '陈%' ;-- 查询用户名第一个字陈且名字中第三个字为明SELECT `username` FROM `user` LIKE '陈_明%' ;
WHERE
-- 查询id为300的用户信息，大于小于同理SELECT * FROM `user` WHERE id=300;-- 查询id在300到400之间的用户信息SELECT * FROM `user` WHERE id>=300 AND id<=400;SELECT * FROM `user` WHERE id BETWEEN 300 AND 400;-- 查询id为300，301，302的用户信息SELECT * FROM `user` WHERE id=300 AND id=301 AND id=302;SELECT * FROM `user` WHERE id IN (300,301,302);-- 查询邮箱为空的用户信息SELECT * FROM `user` WHERE email='';SELECT * FROM `user` WHERE email IS NULL;-- 查询邮箱不为空的用户信息SELECT * FROM `user` WHERE email IS NOT NULL;
JOIN
-- 首先假设有张部门表depart，有id和department两个属性-- 查询用户的id，userrname和department这三个属性,相同的属性需要通过别名来划分-- INNER JOINSELECT s.id,username,departmen FROM student AS s INNER JOIN depart AS d ON s.id=d.id-- RIGHT JOINSELECT s.id,username,departmen FROM student AS s RIGHT JOIN depart AS d ON s.id=d.id-- LEFT JOINSELECT s.id,username,departmen FROM student AS s LEFT JOIN depart AS d ON s.id=d.id-- FULL JOINSELECT s.id,username,departmen FROM student AS s FULL JOIN depart AS d ON s.id=d.id
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只要其中一个表中存在匹配，则返回行。
排序
# ASC升序,DESC降序SELECT * FROM user ORDER BY id ASCSELECT * FROM user ORDER BY id DESC
分页
-- limit n,m-- n代表第一个值的坐标(从0开始)，m代表一页的数据多少-- 查询user表中第一到第五条数据SELECT * FROM user LIMIT 0,5
GROUP BY
# 按一个或多个列对结果集进行分组SELECT birthday,COUNT(*) FROM user GROUP BY birthday# 查出每个生日的用户人数多少
HAVING
# HAVING可以让筛选分组后的各组数据SELECT birthday,COUNT(*) FROM user GROUP BY birthday HAVING SUM(COUNT(*)) > 100# 查出大于100个人的生日是同一天的生日


Docker
Tue, 27 Oct 2020 00:00:00 +0000
官网
https://www.docker.com/
Docker的安装
去到官方文档https://docs.docker.com/get-docker/，选择对应的操作系统安装就可以了。
我的环境是CentOS 7.8
# 下载需要的安装包yum install -y yum-utils# 更新yum软件包的索引yum makecache fast# 安装dockeryum install docker-ce docker-ce-cli containerd.io# 启动dockersystemctl start docker# 建立docker组sudo groupadd docker# 将当前用户加入docker组sudo usermod -aG docker $USER# 查看版本docker version# 查看docker的信息docker info# 查看帮助命令docker --help
出现了docker版本的信息就代表安装成功了。
HelloWrold
#创建hello-world容器docker run hello-world
阿里云镜像加速
打开阿里云的官网。
打开容器镜像服务。
点击镜像中心下的镜像加速器。
选择版本就输入命令就可以配置好阿里云的镜像加速了。
:::note{type="info"}
这是阿里云的镜像加速，也可以找其他国内的源，不换源的话拉取镜像会很慢。
:::
镜像
拉取镜像
# 拉取镜像docker pull [name]# 选取版本下载，不选默认选择最新版本的镜像docker pull [name][:tag]# 示例docker pull mysqldocker pull mysql:5.7
查看镜像
# 查看顶层镜像信息    docker imagesdocker image ls# 可选项    docker images -a, --all# 显示中间层的镜像    docker images -q, --quiet# 只显示镜像的IDdocker images -f since=mongo:3.2, --filter# 显示在mongo:3.2之后建立的镜像docker images -f before=mongo:3.2, --filter# 显示在mongo:3.2之前建立的镜像
查看镜像的历史
docker history [容器名]:[TAG]
搜索镜像
# 命令寻找镜像docker search [name]
删除镜像
# 通过镜像ID删除镜像docker rm [选项] [ID/名字]# 删除多个镜像docker rm [选项] [ID1] [ID2] ...# 删除所有容器docker rm -f $(docker images -aq)# 删除所有镜像名为nginxdocker image rm $(docker image ls -q nginx)# 删除所有在mongo:3.2之前的镜像docker image rm $(docker image ls -q -f before=mongo:3.2)
提交生成镜像
# 将自定义的容器提交成镜像docker commit -m="message" -a="Author" [容器ID] [要生成镜像的名字]:[TAG]docker commit --author "Author" --message "message" [容器ID] [要生成镜像的名字]:[TAG]# 查看镜像就能看到自定义的镜像docker images 
:::note{type="warning"}
慎用docker commit。因为这样生成的黑箱镜像会对其他人的维护工作造成很大压力。生成镜像建议使用Dockerfile。
:::
容器
新建并启动容器
docker run [可选参数] image# 参数docker run --name image# 给容器取名字docker run -d image# 以守护态运行启动，需要一个前台进程，不然会自动停止docker run -p 容器端口 image# 指定端口docker run -p 主机端口:容器端口 imagedocker run -p ip:主机端口:容器端口docker run -P image# 随机指定端口docker run -it image # t表示分配一个伪终端，i表示让容器标准输入打开
退出容器
# 通过命令来退出容器，在一些情况退出容器会使容器停止exit# 容器不停止退出CTRL + P + Q
查看运行的容器
# 查看运行的容器docker ps docker container ls# 查看容器运行的历史docker ps -a# 查看正在运行的容器的容器IDdocker ps -q 
进入容器
# 进入容器开启新终端，从中使用exit不会使容器停止docker exec -it [容器ID] # 进入容器打开正在执行的终端，从中exit退出会使容器停止docker attach [容器ID]
启动容器
# 启动容器docker start [容器ID]docker container start [容器ID]# 重启容器docker container restart [容器ID]
停止容器
# 停止容器docker container stop [容器ID]# 强制停止容器，即杀死容器docker kill [容器ID]
删除容器
# 删除指定ID的容器，不能删除正在运行的容器docker rm  [容器ID]docker container rm [容器ID]# 强制删除治党ID的容器docker rm -f [容器ID]# 删除所有容器docker rm -f $(docker ps -aq)
查看日志
# 显示日志docker logs [容器ID]# 显示所有的日志并带上时间docker logs -tf [容器ID]# 显示指定条数的日志docker logs -tf --tail [numbers] [容器ID]
查看容器信息
# 查看容器信息docker container ls [容器ID]# 查看容器内部的进程信息docker top [容器ID]# 查看容器全部的信息docker inspect [容器ID]
拷贝容器内的文件到主机
# 将容器内的文件拷贝到主机的目录docker cp [容器ID]:[文件路径] [主机路径]
清理所有处于终止状态的容器
docker container prune
部署Tomcat
拉取Tomcat的镜像
    docker pull tomcat
启动容器
# 启动容器        docker run -d --name tomcattest -p 5000:8080 tomcat# 一次性的测试容器    docker run -it --rm tomcat
打开公网ip的5000端口，或者服务器内部的localhost的5000端口就能看到页面了。因为下载的镜像是被处理过的，所以看不到index页面。
进入容器
    docker exec -it tomcattest /bin/bash# 进入到webapps发现没有任何的网站信息，发现是被存储到了webapps.dist里了，所以要想看到index，就需要拷贝过来    cp -r ./webapps.dist/ROOT/ webapps# 然后就能看见index页面了
数据卷
自定义路径挂载
# 将容器内目录挂载到本地目录上docker run  -v [主机目录]:[容器目录]# 例子docker run -it -v /home/test:/home centos
匿名挂载
# 不指定本地目录的挂载docker run -v [容器目录]# 例子docker run -d -P --name nginxtest1 -v /etc/nginx nginx
具名挂载
# 指定卷名不指定本地目录挂载docker run -v [卷名]:[容器目录]# 例子docker run -d -P --name nginxtest2 -v nginx-test:/etc/nginx nginx
查看数据卷信息
# 查看当前数据卷的使用信息docker volume ls # 指定卷名查看数据卷的具体信息,可以看到本地的挂载目录docker volume inspect [卷名]
删除数据卷
docker volume rm [卷名]
删除无主的数据卷
docker volume prune
DockerFile
一个简单的Dockerfile
建一个新的文件夹，然后在里面建一个Dockerfile文件，内容为
FROM nginxRUN echo 'Hello, Docker!
' > /usr/share/nginx/html/index.html
然后生成镜像
    docker build -t nginx:v2 .
然后创建容器打开url，就能看到Hello Docker!了。
构建镜像
docker build [选项] [镜像名]:[TAG] <上下文路径/URL/-># 一般就为docker build  [镜像名]:[TAG] .
:::note{type="info"}
注意这个最后这个点，这个是表示指定当前目录为上下文路径，后面有些指令就是从上下文路径开始指引，不一定是Dockerfile的路径，为了方便才让Dockerfile文件与上下文路径一致。
:::
指令
FROM
FROM用来指定基础的镜像，即用这个镜像来进行二次开发。
这个指令是必须的，而且必须是第一条。
Docker中有一个特殊的镜像，那就是scratch，表示一个空白的镜像。
MAINTAINER
这个指令用来表示作者的信息。
MAINTAINER 
RUN
用来执行命令。
# shell格式RUN echo 'Hello, Docker!
' > /usr/share/nginx/html/index.html# exec格式RUN ["可执行文件", "参数1", "参数2"]
:::note{type="warning"}
当有多个命令的时候，尽量在一个RUN指令中完成，而不是使用多个RUN。因为一个指令就是建立一层，多层的结构就会显得十分的臃肿。
:::
COPY
从构建上下文的目录中将一个文件复制到镜像内的目标路径当中。
COPY  [文件路径] [镜像内目标路径]
如果源路径为文件夹，复制的时候不是直接复制该文件夹，而是将文件夹中的内容复制到目标路径。
ADD
ADD也是复制，与COPY差不多，但是能干更多的事情，比如复制的文件是tar压缩文件，会帮你自动解压到目标路径。
ADD  [文件路径] [镜像内目标路径]
ADD有很多复杂的功能，所以只拷贝文件的时候尽量使用COPY，需要自动解压就用ADD。
WORKDIR
用来设置工作目录。
WORKDIR <工作目录>
工作目录是用来指定整个镜像的，因为每一层都是隔离的，所以不指定工作目录就会出现目录的混乱，即上一层使用了cd进入了新的目录，而下一层一不小心就当成是上一层的目录继续操作。
EXPOSE
暴露端口，类似之前的-p参数，声明容器运行时容器提供服务端口。注意仅仅是声明，不会自动进行端口映射。
VOLUME
VOLUME ["<路径1>", "<路径2>"...]VOLUME <路径>
这里的目录挂载之后就会在运行的时候自动挂载为匿名卷。
ENV
设置环境变量。
CMD
# shell格式CMD <命令># exec格式CMD ["可执行文件", "参数1", "参数2"...]# 例子CMD echo $HOMECMD ["sh","-c","echo $HOME"]
ENTRYPOINT
ENTRYPOINT与CMD差不多，只不过在容器run后面加命令就会自动添加到ENTRYPOINT的参数去。
更多详细内容可以参考官网的Dockerfile reference。
发布镜像
Dockerhub
https://www.docker.com/
# 登陆dockerhubdocker login -u [username] -p [password]# 发布镜像docker push
阿里云镜像
打开阿里云的容器镜像服务，创建命名空间和容器镜像，然后参考官方文档就能跟着发布了。
Docker网络
docker0
当Docker启动的时候就能看到docker会自主创建一个docker0的网桥。
ip a# 查看网络信息 
docker0类似一个路由器，连接着各个容器。当创建一个容器的时候，也会创建一对的veth pair 接口，一个连接容器，一个连接docker0，这样就可以实现容器与docker0的通信和容器与容器的通信了（只限于ip）。这样Docker 就创建了在主机和所有容器之间一个虚拟共享网络。
:::note{type="warning"}
因为docker0的存在，所以默认创建的容器之间是可以通过ip来通信的，即每个容器之间通过docker分配的ip是可以互相ping通，但是不能通过容器名来ping通，因为是没有解析的。
:::
link
# 通过link可以简单的链接网络docker run -d -P --link [需要连接的容器名] [镜像]# --link 其实就是为容器的host增加一条解析记录，所以在该容器就能ping通需要连接的容器名。# 这个只是增加解析，所以是不能反向ping通的
自定义网络
# 之前创建容器的时候，默认是与docker0进行桥接模式,下面两个命令是一样的docker run -d -P --net bridge [镜像]docker run -d -P [镜像]# 在docker0的网络中，每个容器只能通过IP互相ping通，但是不能访问域名即容器名，可以通过--link单向打通
# 自定义网络就修复了docker0的缺陷，容器能通过容器名来ping通# 创建自定义网络,具体ip看情况定docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 [自定义网络名]docker network create -d bridge [自定义网络名]# 创建容器时指定所在网络docker run -d -P --net [自定义网络名] [镜像]
连通网络
# docker0网络下的容器通过容器名是不能Ping通另一个网络的容器的# 需要将容器直接连通另一个网络网卡docker network connect [另一个网络] [容器]# 其实就是将容器加入到另一个网络# 给了一个容器两个ip地址
DockerCompose
下载安装
# 官方文档下载sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose# 从github上下载会十分慢，建议换成国内源sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose# 下载完成后会在/usr/local/bin下面会有二进制文件docker-compose# 将可执行权限应用于二进制文件sudo chmod +x /usr/local/bin/docker-compose
卸载
# 使用curl安装的sudo rm /usr/local/bin/docker-compose# 使用pip安装的pip uninstall docker-compose
Docker Compose入门
创建一个新的目录用于DockerCompose
在目录中创建一个app.py
import timeimport redisfrom flask import Flaskapp = Flask(__name__)cache = redis.Redis(host='redis', port=6379)def get_hit_count():    retries = 5    while True:        try:            return cache.incr('hits')        except redis.exceptions.ConnectionError as exc:            if retries == 0:                raise exc            retries -= 1            time.sleep(0.5)@app.route('/')def hello():    count = get_hit_count()    return 'Hello World! I have been seen {} times.\n'.format(count)
创建一个requirements.txt
flaskredis
建立Dockerfile
FROM python:3.7-alpineWORKDIR /codeENV FLASK_APP=app.pyENV FLASK_RUN_HOST=0.0.0.0RUN apk add --no-cache gcc musl-dev linux-headersCOPY requirements.txt requirements.txtRUN pip install -r requirements.txtEXPOSE 5000COPY . .CMD ["flask", "run"]
创建docker-compose.yml定义服务
version: "3.8"services:  web:    build: .    ports:      - "5000:5000"  redis:    image: "redis:alpine"
然后启动应用程序
docker-compose up
打开urlhttp://localhost:5000。就能看到计数的开始了。
这是官网的入门程序。地址为https://docs.docker.com/compose/gettingstarted/。
常用命令
查看项目中的所有容器
docker-compose ps
启动存在的服务容器
docker-compose start [SERVISE]
重启项目中的服务
docker-compose restart [SERVISE]# 指定重启前停止容器的超时，默认为10秒docker-compose restart -t, --timeout TIMEOUT
停止运行的容器
docker-compose stop [SERVISE]# 停止容器的超时，默认为10秒docker-compose stop -t, --timeout TIMEOUT
删除所有停止的服务容器
docker-compose rm [SERVISE]# 强制删除docker-compose rm -f [SERVISE] docker-compose rm --force [SERVISE] # 删除容器所挂载的数据卷docker-compose rm -v [SERVISE] 
down
# 此命令将会停止 up 命令所启动的容器，并移除网络docker-compose down # 通过--volumes还删除Redis容器使用的数据量：docker-compose down --volumes
up
docker-compose up# -d 在后台运行服务容器。#--no-color 不使用颜色来区分不同的服务的控制台输出。#--no-deps 不启动服务所链接的容器。#--force-recreate 强制重新创建容器，不能与 --no-recreate 同时使用。#--no-recreate 如果容器已经存在了，则不重新创建，不能与 --force-recreate 同时使用。#--no-build 不自动构建缺失的服务镜像。#-t, --timeout TIMEOUT 停止容器时候的超时（默认为 10 秒）。
docker-compose.yml
# 1. 版本，注意版本要匹配不然会报错version: "3.8"# 2. 服务services:  service1:# 服务1的配置  service2:# 服务2的配置# 3. 其他的配置
简单的微服务
用SpringBoot写上面类似的计数
创建springboot，导入依赖
                    org.springframework.boot            spring-boot-starter-data-redis                            org.springframework.boot            spring-boot-starter-web                            org.springframework.boot            spring-boot-starter-test            test                                                org.junit.vintage                    junit-vintage-engine                                    
创建一个请求
package com.yww.controller;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.StringRedisTemplate;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloDocker {    @Autowired    StringRedisTemplate stringRedisTemplate;    @GetMapping("/hello")    public String hello(){        Long views = stringRedisTemplate.opsForValue().increment("views");        return "Hello Docker views:"+views;    }}
配置Springboot的配置文件application.properties
server.port=8080spring.redis.host=redis        # 写服务名相当于域名
编写Dockerfile
FROM java:8COPY *.jar /app.jarCMD ["--server.port=8080"]ENTRYPOINT ["java","-jar","/app.jar"]
编写docker-compose.yml
version: '3.8'services:  demoapp:    build: .    image: demoapp    depends_on:      - redis    ports:    - "8080:8080"  redis:    image: "library/redis:alpine"
然后打包，将生成的Jar包上传到服务器上，然后运行,访问urlip:8080/hello就可以看到计数了。
    docker-compose up
Docker swarm
swarm集群
初始化一个swarm集群
# 初始化一个swarm节点docker swarm init # 要让其他服务器加入，需要配置一个ip,你的Docker主机有多个网卡，就需要指定ipdocker swarm init --advertise--addr [ip]
加入节点
# 获取加入tokendocker swarm join-token managerdocker swarm join-token worker# 获得一串带有token的命令，可以以manager或worker的节点加入swarm
查看节点信息
docker node ls 
离开集群
docker swarm leave
Raft协议
Raft协议，也是一种一致性的算法，具体的算法内容就自行查阅。
要先知道的是managert节点分为三种状态，Leader,Reachable,Unreachable。
现在以Docker集群来进行大概的情况讲解，假设现在swarm的集群有四个节点。
一个manager节点
因为只有manager节点能进行管理，所以在只有一个manager节点，三个worker节点的情况下，manager节点出现故障即状态为Unreachable，该集群就无法进行管理，只能等待manager节点的修复。
两个manager节点
在这种情况下，其中一个manager节点状态为Unreachable，另一个manager节点也会无法进行管理操作，所以两个manager节点是无法进行很好的管理的。
当故障的manager节点修复好在加入集群，状态就会变成Reachable，而另外的那个就会变成Leader。
三个manager节点
这种就是最起码的集群管理。在这种情况下，第一个manager节点出故障了，其他两个是能进行管理操作的，而不是像之前一样无法管理，当挂了两个就不能管理了。所以一个标准的集群式至少需要三个manager节点的，至少有两个manager节点可用，这样才能保证集群的正常运行。
服务
# 创建一个服务,命令类似run,创建的服务会随机分配给集群的节点docker service create [iamge]-p--name# 指定服务的运行方式,replicated模式为只在worker节点运行，global为全部节点docker service create --mode replicated [iamge]docker service create --mode global [iamge]# 查看服务docker service ls docker service ps [服务名]docker service inspect [服务名]# 创建到num个服务的副本，然后随机分布给集群中的节点,也可以回滚docker service update --replicas [num] [服务名]docker service scale [服务名]=[num]# 删除服务docker service rm [服务名]
:::note{type="info"}
可以把集群看成是一个整体，因为服务的副本也是接的相同的端口，所以访问哪个节点的ip端口，都可以访问到这个服务。
:::
附录
docker命令一图流。
参考资料
https://yeasy.gitbook.io/docker_practice/contributing


swagger
Mon, 26 Oct 2020 00:00:00 +0000
简单的集成swagger
为你的项目导入两个依赖
           io.springfox       springfox-swagger2       2.9.2               io.springfox       springfox-swagger-ui    
创建一个配置类
package com.yww.config;import org.springframework.context.annotation.Configuration;import springfox.documentation.swagger2.annotations.EnableSwagger2;@Configuration@EnableSwagger2        //开启swagger2public class SwaggConfig {}
开启项目，打开urlhttp://localhost:8080/swagger-ui.html，就能看到ui界面
配置文档信息
因为swagger的实例Bean是Docker，所以用Docker来配置swagger。
package com.yww.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import springfox.documentation.service.ApiInfo;import springfox.documentation.service.Contact;import springfox.documentation.spi.DocumentationType;import springfox.documentation.spring.web.plugins.Docket;import springfox.documentation.swagger2.annotations.EnableSwagger2;import java.util.ArrayList;@Configuration@EnableSwagger2public class SwaggConfig {    @Bean    public Docket docket(){        //调用apiInfo方法来传入信息        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());    }    //自定义apiInfo方法实现自定义信息配置    private ApiInfo apiInfo(){        //创建一个contact对象以便输入        Contact contact = new Contact("yw", "localhost:8080/", "1141950370@qq.com");        return new ApiInfo(                "Yw的swagger文档",                   //标题                "永远相信美好的事情即将发生",        //描述                "v1.0",                            //版本号                "urn:tos",                        //termsOfServiceUrl                contact,                        //contact对象                "Apacher 2.0",                    //许可信息                "http://www.apache.org/licenses/LINCENSE-2.0 ",        //许可信息的链接                new ArrayList());    }}
配置完成以后就可以打开http://localhost:8080/swagger-ui.html看到信息了。 
扫描接口的配置
使用Docket的select方法扫描，通过build方法来构建扫描的配置，用apis方法来配置扫描的位置，paths方法来配置接口扫描过滤。
扫描指定的包
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()            //basePackage方法指定扫描的包                .apis(RequestHandlerSelectors.basePackage("com.yww.control"))                .build();    }
扫描全部的包
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()            //any方法扫描全部的包                .apis(RequestHandlerSelectors.any())                .build();    }
不扫描包
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()            //none方法不扫描包                .apis(RequestHandlerSelectors.none())                .build();    }
扫描类上的注解
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()            //withClassAnnotation方法扫描类上带有Controller注解的包                .apis(RequestHandlerSelectors.withClassAnnotation(Controller.class))                .build();    }
扫描方法上的注解
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()            //withMethodAnnotation方法扫描方法上带有GetMapping注解的方法                .apis(RequestHandlerSelectors.withMethodAnnotation(GetMapping.class))                .build();    }
扫描任何请求
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()                .apis(RequestHandlerSelectors.basePackage("com.yww.control"))            //any方法扫描全部请求            .paths(PathSelectors.any())                .build();    }
不扫描请求
@Beanpublic Docket docket(){    return new Docket(DocumentationType.SWAGGER_2)            .apiInfo(apiInfo())            .select()            .apis(RequestHandlerSelectors.basePackage("com.yww.control"))        //none方法不扫描请求        .paths(PathSelectors.none())            .build();}
通过正则来扫描请求
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()                .apis(RequestHandlerSelectors.basePackage("com.yww.control"))            //regex方法通过正则匹配来扫描请求            .paths(PathSelectors.regex(final String pathRegex))                .build();    }
控制路径来扫描请求
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())                .select()                .apis(RequestHandlerSelectors.basePackage("com.yww.control"))            //ant方法通过路径来扫描请求            .paths(PathSelectors.ant("/yw/**"))                .build();    }
:::note{type="info"}
使用select配置扫描，用其中的apis方法配置扫描对象，用paths方法来指定扫描的请求
:::
配置swagger的启动
@Bean    public Docket docket(){        return new Docket(DocumentationType.SWAGGER_2)                .apiInfo(apiInfo())            //使用enable方法来配置swagger是否启动，默认为true                .enable(false)                .select()                .apis(RequestHandlerSelectors.basePackage("com.yww.control"))                .build();    }
配置swagger分组
package com.yww.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import springfox.documentation.spi.DocumentationType;import springfox.documentation.spring.web.plugins.Docket;import springfox.documentation.swagger2.annotations.EnableSwagger2;@Configuration@EnableSwagger2public class SwaggConfig {//通过groupName方法分组，创建不同的api接口页面    @Bean    public Docket docket1(){        return new Docket(DocumentationType.SWAGGER_2)                .groupName("Yw1");    }    @Bean    public Docket docket2(){        return new Docket(DocumentationType.SWAGGER_2)                .groupName("Yw2");    }    }
实体类的配置
首先创建一个实体类
package com.yww.pojo;public class User {    private String name;    private String password;    private String password;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }}
然后再control层加入返回实体类的请求就可以看到实体类了。
package com.yww.control;import com.yww.pojo.User;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RestController;/** * @ClassName UserControl * @Descriprtion TODO * @Author Yw * @Date 2020/10/26 19:46 * @Version 1.0 **/@RestControllerpublic class UserControl {    //通过返回的实体类就能看到User的信息了    @PostMapping("/user")    public User user(){        return new User();    }}
配置注释
//@ApiModel和@ApiModelProperty注释配置注释信息@ApiModel("用户类")public class User {    @ApiModelProperty("用户名")    private String name;    @ApiModelProperty("密码")    private String password;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }}
@RestControllerpublic class UserControl {    @PostMapping("/user")    public User user(){        return new User();    }    //@ApiOperation为一个接口加注释，@ApiParam为参数加注释    @ApiOperation("Hellor控制类")    @GetMapping("/hello")    public String hello(@ApiParam("用户名")String name){        return "Hello"+name;    }}
配置swagger的皮肤
默认的皮肤
      io.springfox      springfox-swagger-ui      2.9.2
这就是之前导入的依赖，页面ui地址http://localhost:8080/swagger-ui.html
bootstrap的UI
   com.github.xiaoymin   swagger-bootstrap-ui   1.9.1
页面UI地址http://localhost:8080/doc.html
Layui-ui
   com.github.caspar-chen   swagger-ui-layer   1.1.3
页面UI地址http://localhost:8080/docs.html
mg-ui
   com.zyplayer   swagger-mg-ui   1.0.6
页面UI地址http://localhost:8080/document.html
:::note{type="info"}
更多好看的ui可以去寻找哦。
:::


数据结构
Fri, 23 Oct 2020 00:00:00 +0000
绪论
数据
数据是描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合。
数据元素
数据元素是组成数据的，有一定意义的单位，在计算机中通常作为整体处理，也被称为记录。
数据项
数据项是数据不可分割的最小单位，若干个数据项可以组成一个数据元素。
数据对象
数据对象是性质相同的数据元素的组合，是数据的子集。
数据结构
不同的数据元素之间不是独立的，而是存在特定的关系，这种关系就是结构。
数据结构就是相互之间存在一种或多种特定关系的数据元素的集合。
逻辑结构
逻辑结构是指对象中数据元素之间的相互关系。
集合结构集合结构就是数据元素除了同属于一个集合外没有其他的关系。
线性结构线性结构中的数据元素之间是一对一的关系。
树形结构树形结构中的数据元素之间是一对多的层次关系。
图形结构图形结构中的数据元素之间是多对多的关系。
物理结构
物理结构是指数据的逻辑结构在计算机中的存储形式。
顺序存储结构顺序存储结构意思是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。
链式存储结构链式存储结构是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。
算法
算法是解决特定问题求解步骤的描述，在计算机表现为指令的有限序列，并且每条指令表示一个或多个操作。
算法的特性
输入
输出
有穷性
确定性
可行性
算法设计的要求
正确性
可读性
健壮性
时间效率高和存储量低
算法效率的度量方法
事后统计方法
这种方法主要是通过设计好的测试程序和数据，利用计算机计时器对不同算法编制的程序的运行时间进行比较，从而确定算法效率的高低。
事前分析估算方法
这种方法是在计算机程序编制前依据统计方法对算法进行估算。
推导大O阶方法
用常数1取代运行时间中的所有加法常数
在修改后的运行次数函数中，只保留最高阶项。
如果最高阶项存在且不是1，则去除与这个项目相乘的常数。
以下是一些简单的例子。
//因为运行次数都只是1次，所以为O(1)int sum = 0;sum = 100*100;
//简单的for循环，循环n次，所以为O(n)int i;for(i = 0; i < n; i++){      // O(1)的语句    }
//count每次与2相乘，故会执行log2n次，O(log2n)int count = 1;while(count < n){        count *= 2;    }
// 两个for循环，每个循环n次，故O(n^2)int i,j;for(i = 0; i < n; i++){      for(j = 0; j < n; j++){          // O(1)的语句      }    }// 两个for循环，一个循环m次一个循环n次，故O(n*m)int i,j;for(i = 0; i < m; i++){      for(j = 0; j < n; j++){          // O(1)的语句      }    }// 两个for循环，一个循环m次，一个每次递减，通过级数之和可得循环了n^2/2+n/2次,故O(n^2)int i,j;for(i = 0; i < n; i++){      for(j = i; j < n; j++){          // O(1)的语句      }    }
线性表
线性表的顺序存储结构
线性表的顺序存储结构指的是用一段地址连续的存储单元依次存储线性表的数据元素。
定义存储的结构
# define MAXSIZE 100// 设置顺序表的最大存储个数typedef int ElemType;//存储数据的类型typedef struct SqList{    ElemType data[MAXSIZE];    int length;//表示顺序表当前长度}SqList;
获取数据
判断是否为空表。
判断获取数据的下标是否在数组的范围。
获取数组指定位置的数据。
// 时间复杂度为O(1)int GetElem(SqList L,int i,ElemType *e){        if(L.length==0)            return -1;        if(i-1 < 0 || i > L.length)            return -1;        *e = L.data[i-1];        return 1;     }// -1表示失败，1表示成功
插入数据
判断表是否已经满了。
判断插入的位置是否正确。
判断插入的位置是否在表尾，不在表尾就指定位置之后的数据全部后移一位。
将数据插入指定位置，表长加1。
// 插入的位置在最后，时间复杂度为O(1)// 插入的位置在最前，时间复杂度为O(n)int ListInsert(SqList *L,int i,ElemType e){        int j;        if(L->length == 0)            return -1;        if(i-1 < 0 || i > L->length + 1)            return -1;        if(i <= L->length){            for(j = L->length-1;j >= i-1;j++){                L->data[j+1] = L->data[j];            }        }        L->data[i-1] = e;        L->length++;        return 1;   }
删除数据
判断表是否为空表
判断删除的位置是否正确。
判断删除的位置是否是最后一位，不是，删除的位置后面的数据全部前移一位。
表长减一。
// 删除的位置在最后，时间复杂度为O(1)// 删除的位置在最前，时间复杂度为O(n)int ListDelete(SqList *L,int i){     if(L->length == 0)            return -1;    if(i - 1 < 0 || i > L->length)            return -1;    if(i < L->length)            for(j = i-1;j <= L->length;j++){                L->data[j] =  L->data[j+1];            }    L->length = -1;    return 1;   }
线性表的链式存储结构
定义存储结构
typedef struct Node {int data;struct Node *next;} Node;
获取数据
从头查找，一直找到第i个结点
计数到i就停止，返回数据
没到i链表就结束了，就返回-1
int getElem(Node *L,int i) {    int j = 1;    Node *pre = L->next;    while (pre!=null && jnext;        j++;    }    if (pre==null || j>i) {return -1;    }    return pre->data;}
插入数据
首先遍历到第i-1个结点
然后创建一个结点，next指向第i个结点
第i-1个结点的next指向新创建的结点
int insert(Node *L,int i,int e) {    int j = 1;    Node *pre = L;    while (pre!=null && jnext;        j++;    }    if(pre==null || j>i) {return -1;    }    Node *p = (Node*)malloc(sizeof(Node));    p->data = e;    p->next = pre->next;    pre->next = p;    return 1;}
删除数据
首先遍历到第i-1个结点
第i-1个结点的next指向第i个结点的next
释放第i个结点
int delete(Node *L,int i) {    int j = 1;    Node *pre = L;    while (pre!=null && jnext;        j++;    }    if(pre==null || j>i) {return -1;    }    Node *p = pre->next;    pre->next = p->next;    free(p);    return 1;}
树
结点拥有的子树数称为结点的度，度为0称为叶结点，树的度是整个树度的最大值
树中结点的最大层次称为树的深度或高度
如果树中的结点的各个子树看成从左到右是有次序的，就称为有序树，反之为无序树
定义二叉树存储结构
typedef struct BiTree{    TElemType data;    struct BiTree *lchild,*rchild;}BiTree;
二叉树的遍历
前序遍历先访问根节点，然后前序遍历左子树，再前序遍历右子树。
中序遍历先中序遍历左子树，然后访问根节点，再中序遍历右子树。
后序遍历先后序遍历左子树，再后序遍历右子树，然后再访问根结点。
层序遍历从上到下，从左到右的顺序访问结点。
创建二叉树
输入根节点数据
递归创建左子树，递归创建右子树
void CreaterBiTree (BiTree *T){    char ch;    scanf("%c",&ch);    if ('#' == ch) {        T = NULL;        return;    } else {        T = (BiTree*) malloc(sizeof(BiTree));        T->data = ch;        CreaterBiTree(T->lchild);        CreaterBiTree(T->rchild);    }}BiTree* CreaterBiTree (){    BiTree * T = (BiTree*) malloc(sizeof(BiTree));    char ch;    scanf("%c",&ch);    if ('#' == ch) {        T = NULL;        return;    } else {        T->data = ch;        T->lchild = CreaterBiTree();        T->rchild = CreaterBiTree();    }}
前序遍历
判断是否为空结点
打印根节点数据，递归左子树，递归右子树
void PreOrderTraverse (BiTree* T){    if(NULL == T){        return;    }    printf("%d",T->data);    PreOrderTraverse(T->lchild);    PreOrderTraverse(T->rchild);}
中序遍历
判断是否为空结点
递归左子树，打印根节点数据，递归右子树
void InOrderTraverse (BiTree* T){    if(NULL == T){        return;    }    InOrderTraverse(T->lchild);    printf("%d",T->data);    InOrderTraverse(T->rchild);}
后序遍历
判断是否为空结点
递归左子树，递归右子树，打印根节点数据
void PostOrderTraverse (BiTree* T){    if(NULL == T){        return;    }    PostOrderTraverse(T->lchild);    PostOrderTraverse(T->rchild);    printf("%d",T->data);}
层次遍历
typedef struct queue {int front,rear;BiTree* data[20];}queue;//初始化队列queue* initqueue() {queue* q = (queue*)malloc(sizeof(queue));q->front = 0;q->rear = 0;}//判断队列是否为空int emptyqueue(queue* q) {if(q->rear==q->front)return 1;elsereturn 0;}//出队bitree* dequeue(queue* q) {return q->data[(q->front)++];}//入队 void inqueue(queue* q,BiTree* root) {if(q->rear==19)return;elseq->data[(q->rear)++]=root;}void levorder(BiTree* root,queue* q) {BiTree *p;p = root;if(p!=NULL)inqueue(q,p);while(!emptyqueue(q)){p = dequeue(q);printf("%d",p->data);if(p->lchild!=NULL)inqueue(q,p->lchild);if(p->rchild!=NULL)inqueue(q,p->rchild); } }
性质
知道前序遍历的顺序和中序遍历的顺序可以确定一颗二叉树
知道中序遍历的顺序和后序遍历的顺序可以确定一颗二叉树
知道前序序遍历的顺序和后序遍历的顺序是不可以确定一颗二叉树的


YAML基本语法
Tue, 20 Oct 2020 00:00:00 +0000
基本语法
Key: value
注意冒号后面的空格是一定要有的，YAML语法对空格是十分敏感的，而且是用空格来控制层级关系，就比如下面这个例子。
server: port: 8081 path: 
这就表示server这个配置有两个子配置，这两个子配置是port和path，它们都在同一个层级，主要是看首字母的列数，子配置的首字母列数是不能在父配置的左边的比如下面的这个列子就是错误。
 server:port: 8081
:::note{type="warning"}
YAML对大小写敏感，所以不要弄错大小写。
:::
值
值为数字，字符串或者是布尔类型
Key: value
字符串默认是不用加引号的，也可以加上，单引号包括是换转义特殊字符的，而双引号不会，就比如经常写的\n换行等字符。
对象和Map
User: Name: student ID: 02
User: {Name: student,ID: 02}
数组
User: - user01 - user02 - user03
User: [user01,user02,user03]


SpringBoot
Thu, 15 Oct 2020 00:00:00 +0000
SpringBoot
SpringBoot是一个全新开源的轻量级框架。它基于Spring4.0设计，进一步简化了Spring的配置，更加简单的完成整个搭建和开发。
微服务架构
https://martinfowler.com/articles/microservices.html
第一个SpringBoot程序
可以去官网去创建一个springboot的项目（用idea自带创建也是通过官网创建的），配置什么的自己选择，注意要添加一个Spring Web的依赖，不然不能用作Web开发，然后GENERATE下载项目到本地，用idea导入项目就可以了。
在项目自带的Application类的同级目录下（一定要同级目录，不然SpringBoot无法扫描到你写的类）创建包和类，现创建一个Hello的类。
@Controller@ResponseBody//将返回的数据写给浏览器，对象就会返回JSON数据//这两个由@RestController替换，因为这两个注解已经被RestController注解包括了。public class Hello {    @GetMapping("/hello")    public String hello(){        return "Hello World!";    }}
然后通过Application类来运行，然后打开你的http://localhost:8080/hello就能看到HelloWorld了。
SpringBoot程序详解
分析一下我们的第一个SpringBoot程序。
Pom.xml
4.0.0org.springframework.bootspring-boot-starter-parent2.3.4.RELEASE com.ywdemo0.0.1-SNAPSHOTdemoMy first springboot demo1.8        org.springframework.bootspring-boot-starter-web org.springframework.bootspring-boot-maven-plugin
父项目
        org.springframework.boot        spring-boot-starter-parent        2.3.4.RELEASE             org.springframework.boot    spring-boot-dependencies    2.3.4.RELEASE
导入的Spring Web的依赖
    org.springframework.boot    spring-boot-starter-web
            4.0.0  org.springframework.boot  spring-boot-starter-web  2.3.4.RELEASE  spring-boot-starter-web  Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container  https://spring.io/projects/spring-boot      Pivotal Software, Inc.    https://spring.io              Apache License, Version 2.0      https://www.apache.org/licenses/LICENSE-2.0                  Pivotal      info@pivotal.io      Pivotal Software, Inc.      https://www.spring.io            scm:git:git://github.com/spring-projects/spring-boot.git    scm:git:ssh://git@github.com/spring-projects/spring-boot.git    https://github.com/spring-projects/spring-boot        GitHub    https://github.com/spring-projects/spring-boot/issues              org.springframework.boot      spring-boot-starter      2.3.4.RELEASE      compile              org.springframework.boot      spring-boot-starter-json      2.3.4.RELEASE      compile              org.springframework.boot      spring-boot-starter-tomcat      2.3.4.RELEASE      compile              org.springframework      spring-web      5.2.9.RELEASE      compile              org.springframework      spring-webmvc      5.2.9.RELEASE      compile      
:::note{type="info"}
spring-boot-starter,SpringBoot的场景启动器。那什么是场景启动器呢？在SpringBoot框架中，开发者已经帮我们模拟了很多个使用SpringBoot的开发场景，并将这些场景需要的依赖和配置全部写入到这些场景启动器当中。比如我们现在是开发web的场景，我们就导入了这个Spring Web的依赖，主要就是这个spring-boot-starter-web的web场景启动器，里面都是我们开发web需要的依赖以及一些配置。
:::
主程序
@SpringBootApplicationpublic class SpringbootApplication {public static void main(String[] args) {SpringApplication.run(SpringbootApplication.class, args);}}
@SpringBootApplication这个注解标注了这是SpringBoot的主配置类，SpringBoot通过这个主配置类的main方法来启动这个SpringBoot的应用。查看里面的源码就会发现这个注解是由很多注解组成的，下面详细分析一下。
@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })public @interface SpringBootApplication {
@SpringBootConfiguration
这个注解表示这个类是一个SpringBoot的配置类，点开里面发现还有个**@Configuration**注解，这个注解表示这是个Spring的配置类。
@Configurationpublic @interface SpringBootConfiguration {
在点开就发现了这个**@Component**，所以发现这个配置类是容器的一个组件。
@Componentpublic @interface Configuration {
@EnableAutoConfiguration
这个注解告诉了SpringBoot要开启自动配置功能。
@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)public @interface EnableAutoConfiguration {
**@Import(AutoConfigurationImportSelector.class)**这是导入组件的选择器，会给容器导入很多这个场景所需要的所有组件并配置号这些组件。
@AutoConfigurationPackage这个注解表示自动配置包，点进去发现有一个这样的注解
@Import(AutoConfigurationPackages.Registrar.class)
这个注解是Spring的底层注解，@Import指定了AutoConfigurationPackages.Registrar.class这个类给容器导入一些组件。
所以这个@EnableAutoConfiguration就是将主配置类同目录下的包与类的所有组件扫描到Spring容器里面，这就是为什么一定要在同目录下创建包与类，因为不同目录就不会扫描得到。
Resource文件夹
static文件夹保存静态资源的文件夹，比如js,css文件等。
templates文件夹保存模板页面的文件夹，因为SpringBoot默认jar包嵌入式的Tomcat，所以不支持JSP页面，所以需要用到模板引擎来配置页面。
application.properties（application.yml）SpringBoot的配置文件（名字是固定的不能修改）,因为SpringBoot已经帮我们配置好了很多配置，想要修改这些默认配置就需要在这个配置文件自己修改，这个配置文件由两种形式，properties和yml形式。
application.properties的格式是    key=value
子配置就用点，比如service下的port配置就表示为service.port=value
application.yml的格式是    key: value    注意有空格，因为yml文件对空格很敏感， 具体语法可参照YAML语法,之后就用yaml的这种格式来写配置文件
配置文件值的注入
首先先写个需要注入值的类。
@Component@ConfigurationProperties(prefix = "user")public class User {    private String name;    private int age;    private Date birth;    private Boolean happy;    private Map family;    private List hobby;    private Dog dog;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public Date getBirth() {        return birth;    }    public void setBirth(Date birth) {        this.birth = birth;    }    public Boolean getHappy() {        return happy;    }    public void setHappy(Boolean happy) {        this.happy = happy;    }    public Map getFamily() {        return family;    }    public void setFamily(Map family) {        this.family = family;    }    public List getHobby() {        return hobby;    }    public void setHobby(List hobby) {        this.hobby = hobby;    }    public Dog getDog() {        return dog;    }    public void setDog(Dog dog) {        this.dog = dog;    }    @Override    public String toString() {        return "User{" +                "name='" + name + '\'' +                ", age=" + age +                ", birth=" + birth +                ", happy=" + happy +                ", hobby=" + hobby +                ", family=" + family +                ", dog=" + dog +                '}';    }}
@Componentpublic class Dog {    private String name;    private int age;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public String toString() {        return "Dog{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}
:::note{type="info"}
@Component表示这是spring的组件，会被注入到spring的容器中进行管理@ConfigurationProperties(prefix = "user")表示绑定配置文件中的user的配置，这样就可以进行值的注入了
:::
然后导入一个配置文件处理器的依赖（不导入会爆红虽然没影响），可以去配置文件注入值了。
org.springframework.bootspring-boot-configuration-processor
这样就可以成功的将值注入了，可以去测试类进行一下测试。
@SpringBootTestclass DemoApplicationTests {@AutowiredUser user;//其实不一定要与配置类中的名称一致，user01也能读取出值@Testvoid contextLoads() {System.out.println(user);}}
 得到答案
User{name='Yw', age=20, birth=Wed Oct 21 00:00:00 CST 2020, happy=true, hobby=[play, game], family={father=yww1, mother=yww2}, dog=Dog{name='wwangwang', age=3}}
导入文件资源
@PropertySource
在上述的示例当中，要是总是把注入的值都加进全局的配置文件中就会显得很乱，所以可以新建一个文件在通过@PropertySource标签导入进去也可以实现值的注入，这样application.properties中就可以不用写user的值了，值都写在user.properties即可。
@Component@ConfigurationProperties(prefix = "user")@PropertySource(value = {"classpath:user.properties"})public class User {
:::note{type="info"}
注意@PropertySource这个标签导入的是properties的文件，yml文件会出问题。
:::
@ImportResource
这个标签是用来导入spring的配置文件到springBoot中的（即xml格式）
@ImportResource(locations = {"classpath:beans.xml"})
@Bean
这个标签的功能与@ImportResource类似，也是为了导入配置，给容器添加一个组件的。比如写一个配置类。
@Configuration//表示这个类是一个配置类，就像是一个spring的配置文件public class Config {    @Bean//将方法的返回值注入到容器之中，类似spring配置中    public Hello hello(){        return new Hello();    }}
:::note{type="info"}
@Configuration 表示这个类是一个配置类，就像是一个spring的配置文件@Bean 将方法的返回值注入到容器之中，类似spring配置中注入bean的操作，方法名就是这个bean的id。
:::
Profile
properties的多文档
首先就是主要的配置文件application.properties，创建多文档的方式就是按照application-[name].properties的形式命名创建在resources目录下。就比如我创建了一个测试环境的配置，命名为application-dev.properties
yaml的多文档
这个就很方便了，直接在application.yml中就可以创建多个文档配置了。只要通过---就能将配置文件分成不同的文档配置，通过spring.profiles: [name]这个配置就能为这个文档配置取个名字了。
server:  port: 8085---server:  port: 8086spring:  profiles: dev---
激活指定的Profile
properties
在主配置文件，即application.properties下增加这个配置，就可以激活相应名字的文档配置文件。
spring.profiles.active=dev
yaml
yaml形式也是通过这个配置spring.profiles.active=dev，就能激活相应名字的文档配置文件。
server:  port: 8085spring:  profiles:    active: dev---server:  port: 8086spring:  profiles: dev
共同的激活方式
命令行比如在打了jar包之后，在命令行运行jar包的时候增加配置就能激活指定配置文件生效。
java -jar ---.jar --spring.profiles.active=dev
虚拟机参数修改虚拟机参数也可以修改。
-Dspring.profiles.active=dev
配置文件的优先级
配置文件的优先级由高到低分别为：
项目路径下的config文件夹中的配置文件
项目路径下的配置文件
资源路径下的config文件夹中的配置文件
资源路径下的配置文件
springboot会通过优先级来加载配置文件，要是有不止一个配置文件，springboot也是会全部加载这些配置文件。对于设置了相同的配置，优先级高的配置文件设置的就会覆盖掉优先级低的配置文件的设置。就比如每个配置文件都设置了不同的打开端口，就会以优先级高的配置文件的为准。其他不冲突的配置也是生效的。


第十一届蓝桥杯第二次模拟赛
Thu, 15 Oct 2020 00:00:00 +0000
12.5MB
【问题描述】在计算机存储中，12.5MB是多少字节？【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
第一题没什么难度就是计算，1MB=1024KB，1KB=1024Byte，所以直接计算器，答案为13,107,200
最多边数
【问题描述】一个包含有2019个结点的有向图，最多包含多少条边？（不允许有重边）【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
边数最多，那就是有向完全图了，所以根据数据结构的知识，含有n个节点的有向完全图，边数为n*(n-1)。所以答案为4074342。
单词重排
【问题描述】将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。请问，总共能排列如多少个不同的单词。【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
这明显就是全排序的题目，所以用全排序的算法就可以得出结果。
解法一
我一开始看到这填空题才是七个数的全排列，就直接笔算了，全排列后的种数为7！。因为题目里的这七个字母有两个是一样的，所以全排列后除2就可以得到答案2520。
解法二
第二种是在网上看到的灵感，就是先实现全排列，然后加入到set集合里去重，最后也可以得到正确答案。
import java.util.HashSet;import java.util.Set;public class Solution {    static char[] arr = "LANQIAO".toCharArray();    static Set res = new HashSet<>();//start表示开始的位置，end表示最后的位置    public static void Permutation(char[] arr,int start,int end){        if (end <= 1) {            return;        }        if (start == end) {            res.add(new String(arr));        }        else{            for (int i = 0; i <= end; i++) {                swapchar(arr,i,start);                Permutation(arr,start+1,end);                swapchar(arr,i,start);            }        }    }    public static void swapchar(char[] arr,int a,int b){        char t = arr[a];        arr[a] = arr[b];        arr[b] = t;    }    public static void main(String[] args) {        Permutation(arr, 0, 6);        System.out.println(res.size());    }}
括号序列
【问题描述】由1对括号，可以组成一种合法括号序列：()。由2对括号，可以组成两种合法括号序列：()()、(())。由4对括号组成的合法括号序列一共有多少种？【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解法一
这道题我一开始看的想法就是左括号和右括号看成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，代码如下。
public class Solution {    public static void main(String[] args) {        System.out.println(Catalan(4));    }    public static int Catalan(int k){        if(k<=1){            return 1;        }        int[] res = new int[k+1];        res[0] = 1;        res[1] = 1;        for (int i = 2; i <= k; i++) {            for (int j = 0; j < i; j++) {                res[i] = res[i] + (res[j] * res[i - j - 1]);            }        }        return res[k];    }}
反倍数
【问题描述】给定三个整数 a, b, c，如果一个整数既不是 a 的整数倍也不是 b 的整数倍还不是 c 的整数倍，则这个数称为反倍数。请问在 1 至 n 中有多少个反倍数。【输入格式】输入的第一行包含一个整数 n。第二行包含三个整数 a, b, c，相邻两个数之间用一个空格分隔。【输出格式】输出一行包含一个整数，表示答案。【样例输入】302 3 6【样例输出】10【样例说明】以下这些数满足要求：1, 5, 7, 11, 13, 17, 19, 23, 25, 29。【评测用例规模与约定】对于 40% 的评测用例，1 <= n <= 10000。对于 80% 的评测用例，1 <= n <= 100000。对于所有评测用例，1 <= n <= 1000000，1 <= a <= n，1 <= b <= n，1 <= c <= n。
这题也没什么技巧，最大的数据也只有1000000，所以一个for循环加个if判断语句就可以暴力破解了。
public class Solution {    public static void main(String[] args) {        int res = 0;        Scanner scanner = new Scanner(System.in);        int n = scanner.nextInt();        int a = scanner.nextInt();        int b = scanner.nextInt();        int c = scanner.nextInt();        for (int i = 1; i <= n; i++) {            if(i%a!=0&&i%b!=0&&i%c!=0) {                res++;            }        }        System.out.println(res);    }}
凯撒加密
【问题描述】给定一个单词，请使用凯撒密码将这个单词加密。凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。即a变为d，b变为e，...，w变为z，x变为a，y变为b，z变为c。例如，lanqiao会变成odqtldr。【输入格式】输入一行，包含一个单词，单词中只包含小写英文字母。【输出格式】输出一行，表示加密后的密文。【样例输入】lanqiao【样例输出】odqtldr【评测用例规模与约定】对于所有评测用例，单词中的字母个数不超过100。
凯撒密码从c敲到Java，常见的题，我不是太清楚这个单词的结构，我默认它是一长串连续的字母组成的字符串，没有空格。
public class Solution {    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        String str = scanner.nextLine();        char[] arr = str.toCharArray();        for(char c:arr) {            if (c == 'x') {                System.out.print('a');            }            if (c == 'y') {                System.out.println('b');            }            if (c == 'z') {                System.out.println('c');            }            System.out.print((char) (c + 3));        }    }}
螺旋
【问题描述】对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整数，我们称填好的表格为一个螺旋矩阵。例如，一个 4 行 5 列的螺旋矩阵如下：1 2 3 4 514 15 16 17 613 20 19 18 712 11 10 9 8【输入格式】输入的第一行包含两个整数 n, m，分别表示螺旋矩阵的行数和列数。第二行包含两个整数 r, c，表示要求的行号和列号。【输出格式】输出一个整数，表示螺旋矩阵中第 r 行第 c 列的元素的值。【样例输入】4 52 2【样例输出】15【评测用例规模与约定】对于 30% 的评测用例，2 <= n, m <= 20。对于 70% 的评测用例，2 <= n, m <= 100。对于所有评测用例，2 <= n, m <= 1000，1 <= r <= n，1 <= c <= m。
这个题目难点就是求出这个数组，我们可以螺旋递增来求出这个数组，然后再输出r行c列的值就好了。
public class Solution {    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        int k = 1,x=0,y = 0;        int n = scanner.nextInt();        int m = scanner.nextInt();        int r = scanner.nextInt();        int c = scanner.nextInt();        int[][] arr = new int[n][m];        arr[0][0] = k;        while(n*m>k){            //向右循环递增            while (y + 1 < m && arr[x][y + 1]==0) {                arr[x][y+1] = ++k;                y++;            }            //向下循环递增            while (x + 1 < n && arr[x+1][y]==0) {                arr[x+1][y] = ++k;                x++;            }            //向左循环递增            while (y-1 >= 0 && arr[x][y-1]==0) {                arr[x][y-1] = ++k;                y--;            }            //向上循环递增            while (x-1 >= 0 && arr[x-1][y]==0) {                arr[x-1][y] = ++k;                x--;            }        }            System.out.println(arr[r-1][c-1]);    }}
摆动序列
通电
植树


SpringMVC执行原理
Tue, 22 Sep 2020 00:00:00 +0000
springmvc的组件
前端控制器（DispatcherServlet）
前端控制器就是用来处理请求的中心，接收请求和响应结果都是由它控制的，也算是springmvc里的中心枢纽。
处理器映射器（HandlerMapping）
处理器映射器根据请求里的url来查找相应的处理器，即用来寻找处理器的。
处理器（Handler）
处理器是进行业务操作的。
处理器适配器（HandlerAdapter）
会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器（适配器模式的应用）
视图解析器（ViewResovler）
即对返回来的视图进行解析，将代码解析成为对应的视图
工作流程
具体分析
用户发送请求，即在浏览器上输入url，DispatcherServlet会接收请求。
DispatcherServlet收到请求后就会调用HandlerMapping来寻找需要的Handler。
HandlerMapping找到Handler后就会返回给DispatcherServlet。
前端控制器DispatcherServlet收到Handler后就会调用HandlerAdapter对Handler进行处理。
HandlerAdapter经过适配调用具体的Handler(Controller，也叫后端控制器)。
执行完毕后就会将一个ModelAndView返回给HandlerAdapter。
HandlerAdapter将ModelAndView返回给DispatcherServlet。
DispatcherServlet将调用ViewReslover来解析这个ModelAndView。
ViewReslover解析ModelAndView后返回具体View给DispatcherServlet。
DispatcherServlet根据这个view就会渲染出所需要的页面。
DispatcherServlet将这个页面返回给用户，用户获取结果。
对于hellospringmvc的详解
首先在web.xml里注册的就是DispatcherServlet前端控制器，用户发出的请求（即输入url）先到的是这里。
::: info这里DispatcherServlet收到请求就会获取有用的信息，就是将url拆分。就比如我输入的url，https://localhost:8080/helloSpringmvc/hello    就会拆分为三部分
localhost:8080，这是tomcat开放的端口。
helloSpringmvc，这个就是访问的你的项目名（可以自己更改），即tomcat的webapps下的helloSpringmvc文件夹。
hello，即为控制器的id ,发出请求输入ur就是为了找到这个控制器。
:::
然后经过关联的配置文件，即resource下的springmvc-servlet.xml。
    springmvc    org.springframework.web.servlet.DispatcherServlet            contextConfigLocation        classpath:springmvc-servlet.xml        1            springmvc        /
springmvc-servlet.xml先是注册了HandlerMapping处理器映射器和HandlerAdapter处理器适配器，springmvc自动帮你调用这两个组件。
    
在springmvc-servlet.xml注册的Handler控制器,这样DispatcherServlet就可以通过这里找到这个hello控制器，然后DispatcherServlet将该控制器交给HandlerAdapter进行处理该Handler所包含的业务逻辑，这里就是HelloController类里的业务操作。
                     
HelloController中调用了Controller接口，即可以理解这就是mvc架构中Controller层，在这个类进行我们的业务逻辑操作，因为在springmvc中Control层的数据要交给DispatcherServlet处理的，所以返回了一个包装好的ModelAndView，Model存储数据，View存储视图。
public class HelloController implements Controller {    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)        throws Exception {                    //创建一个ModelAndView对象                    ModelAndView mv = new ModelAndView();                    //封装所需要的数据到ModelAndView的对象中                    mv.addObject("msg","HelloSpringMVC!");                    //封装要跳转的视图，放在ModelAndView中                    mv.setViewName("hello");     //   /WEB-INF/jsp/hello.jsp                    return mv;            }}
DispatcherServlet收到包装好的ModelAndView后，通过注册的视图解析器进行解析渲染视图。
                                
::: info这里就是对控制器进行拼接，比如hello控制器，加上前缀与后缀就成为了/WEB-INF/jsp/hello.jsp，然后就会在web目录下找到该视图进行跳转。
:::
:::note{type="success"}
结合springmvc中第一个springmvc程序来看。由此可以看出springmvc帮我们做了很多事情，我们只需要配置好那几个重要的组件，然后编写业务逻辑和视图就能完成对于一个控制器的工作。
:::
参考文章
https://www.cnblogs.com/xiaoxi/p/6164383.html


IntelliJ IDEA的优化配置
Sat, 11 Jul 2020 00:00:00 +0000
前言
闲着没事升级了一下我的idea，现在版本为2020.1.3，顺便记录一下idea的配置与优化，方便以后再改。
主题方面
一个好的主题会让你喜欢上idea，所以可以去换一个喜欢的主题，体验超好。网上有很多去下载就好了，我就不放地址了。点击下载一般都会下一个jar包，随便找个地方放就好。
然后在idea里的File -> Manage IDE settings -> import settings,把jar包导进去重启就好了。
设置优化
idea主色配置File -> Settings -> Appearance & Behavior -> Appearance
这个看个人喜欢了，我用多了还是深色的好。
自动导包 File -> Settings -> Editor -> General -> Auto Import 
这个就不用多说了吧，自动导包还是很方便的。
字体缩放File -> Settings -> Editor -> General，勾选第一个选项。
然后按着CTRL+滑动滚轮就可以控制字体大小了，很好用的。
大小写不敏感File -> Settings -> Editor -> General -> Code Completion，取消第一个的勾选。 
这个就会让你在打错大小写的情况下还会提醒你。
设置背景图片File -> Settings -> Appearance & Behavior -> Appearance
取消自动打开项目File -> Settings -> Appearance & Behavior -> System Settings，取消第一个勾选
取消了之后就不会每次打开idea就会进入到上次关闭的项目了，当然这个看个人喜好。
显示方法分隔线和行号File -> Settings -> Editor -> General -> Appearance,勾选上选项。
这个会让方法与方法之间出现分隔线，左边出现行号。
快捷键更换File -> Settings -> Keymap
有些人习惯了Eclipse的快捷键，从这里就可以改成Eclipse的，下面的快捷键也可以自行修改。
设置方法模板File -> Settings -> Editor -> Live Templates
方法模板可以在下面设置，不过比较常用的就是psvm和sout生成主方法和输出语句，第一个选项就是输入了sout之后点空格就会生成模板，我比较喜欢空格，自行选择。
类模板的设置File -> Settings -> Editor -> File and Code Templates -> Class
这段注释就是生成类自动帮你生成的模板，可以自行修改。
Maven环境配置
File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven
第一个是maven所在位置，第二个是maven里的配置文件setting.xml的位置，第三个是maven-repomaven里的仓库文件夹的位置。
插件
用idea就不能少了插件，插件可以让你的体验在上升一个档次哦。
插件安装方法
在idea上直接安装File -> Settings -> Plugins，直接搜索名字就好了。有时候有些插件会下载很慢，可以直接去官网下载。
官网下载离线插件官网地址---->https://plugins.jetbrains.com/
下载之后点这里导入插件就好了。
插件推荐
CodeGlance安装了这个插件就会在idea右侧生成一个代码地图，用过Vscode都应该知道这个的好处。
Translation顾名思义，一个翻译插件，可以帮你在IDE里翻译源码和控制台的一些不会的英文语句，挺方便的。
Rainbow Brackets彩虹括号，让你的每个括号都带上颜色，一对括号一个颜色，好看又能让你快速分辨。还有更多用法可参照官方文档
Chinese
其实这个我不用，idea中文插件，用中文没得灵魂。
Grep Console
日志配色。
Alibaba Java Coding Guidelines阿里巴巴代码规范，提醒你不规范的地方


SpringMVC
Tue, 07 Jul 2020 00:00:00 +0000
什么是SpringMVC
Spring MVC是一个基于MVC架构的用来简化web应用程序开发的应用开发框架，它是Spring的一部分，它和Struts2一样都属于表现层的框架。
MVC可参考之前的文章mvc架构
第一个SpringMVC程序
新建一个maven项目，取个名字一路next即可。
添加web的支持
在pom.xml导入依赖
                          org.springframework            spring-webmvc            5.2.6.RELEASE       
在resources下创建配置springmvc的配置文件，我这里是springmvc-servlet.xml
                                                            
配置web.xml
            springmvc        org.springframework.web.servlet.DispatcherServlet                            contextConfigLocation            classpath:springmvc-servlet.xml                        1                            springmvc        /        
在Java文件夹下创建HelloController
public class HelloController implements Controller {//在idea有两个Controller接口，导入的是org.springframework.web.servlet.mvc下    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)         throws Exception {            //ModelAndView            ModelAndView mv = new ModelAndView();            //封装对象            mv.addObject("msg","HelloSpringMVC!");            //封装要跳转的视图            mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp            return mv;    }}
然后在WEB-INF的jsp的文件夹下创建hello.jsp文件，显示msg的信息
<%@ page contentType="text/html;charset=UTF-8" language="java" %>    Title    ${msg}
配置tomcat启动就好
结构的目录为
执行原理
跳转至该文章。springmvc执行原理
注解的使用
与上面的第一个Springmvc程序来对比
首先是sprngmvc的配置程序
                                         
因为之前配置DispatcherServlet的时候配置了拦截方式为“/”,故包括了静态资源，所有springmvc会将静态资源的请求当成是普通的请求，所以会找不到对应的处理器而导致错误。这条语句将把静态资源和非静态资源的请求分开，从而避免错误。
这个帮我们注册了很多的类 ，包括之前的BeanNameUrlHandlerMapping和SimpleControllerHandlerAdapter，并告知spring，启用了注解。
然后是Controller类
import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;//自动视为一个Controller的类//@RequestMapping("/1")，这里也可以添加路径，这里加上了那下面的路径就是/1/hello了@Controllerpublic class HelloController  {    // 访问的路径    @RequestMapping("/hello")    public String hello(Model model){        model.addAttribute("msg","hello springmvc");        return "hello";        //返回给视图解析器拼接，然后寻找视图    }}
web.xml用之前的就好，再写jsp页面就可以运行了。
::: success
springmvc-servlet.xml和web.xml基本都是不用怎么改变的，除了改一些路径。
:::
简单的标签详解
@Controller告诉spring该类为一个控制器，并交给spring来托管
@RequestMapping
@Controller@RequestMapping("/hello1")public class HelloController  {    //表示获取的路径，放在类上为父级，方法上为子级。全标签是这样@RequestMapping(value="/hello2")    @RequestMapping("/hello2")    //访问路径为http://localhost:8080/项目名/hello1/hello2    public String hello(Model model){        model.addAttribute("msg","hello springmvc");        return "hello";    }            //@PathVariable表示绑定参数，method默认为GET，所以通过get方法就能访问，换成其他方法比如delete就会报错。    @RequestMapping(value="/hello2/{a}/{b}",method = RequestMethod.GET)    //通过访问路径http://localhost:8080/项目名/hello1/hello2/1/2就能获取a和b的值了    public String hello1(@PathVariable int a,@PathVariable int b, Model model){        int c = a + b;        model.addAttribute("msg",c);        return "hello";    }            //通过method参数就会有以下的衍生注解代表不同方法，不同的是衍生注解只能放在方法上    /*    @GetMapping("/hello2/{a}/{b}")    @PostMapping("/hello2/{a}/{b}")    @PutMapping("/hello2/{a}/{b}")    @DeleteMapping("/hello2/{a}/{b}")    @PatchMapping("/hello2/{a}/{b}")    */    @GetMapping("/hello2/{a}/{b}")    public String hello1(@PathVariable int a,@PathVariable int b, Model model){        int c = a + b;        model.addAttribute("msg",c);        return "hello";    }}
关于重定向和转发
使用视图解析器
在SpringMvc的配置文件下注册了视图解析器，即下面的这段代码，就可以通过视图解析器来进行转发。
                    
@Controllerpublic class HelloController  {    @GetMapping("/hello")    public String hello(Model model){        model.addAttribute("msg","Hello World!");        return "hello";        //返回给视图解析器就会拼接成/WEB-INF/jsp/hello.jsp    }}
不使用视图解析器
直接使用servlet的方法
@Controllerpublic class HelloController  {    //转发    @GetMapping("/hello1")    public void hello1(HttpServletRequest request, HttpServletResponse response) throws IOException {        response.getWriter().println("Hello World!");    }    //转发    @GetMapping("/hello2")    public void hello2(HttpServletRequest request, HttpServletResponse response) throws IOException {        response.sendRedirect("index.jsp");    }    //重定向    @GetMapping("/hello3")    public void hello3(HttpServletRequest request, HttpServletResponse response) throws Exception {        request.setAttribute("msg","Hello World!");        request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(request,response);    }}
:::note{type="warning"}
因为实质是servlet，所以是可以直接使用servlet的方法的，但是不推荐这么使用，过于繁琐。
:::
使用前缀
@Controllerpublic class HelloController  {    //forward前缀 转发    @GetMapping("/hello1")    public String hello1(Model model){        model.addAttribute("msg","Hello World!");        return "forward:/WEB-INF/jsp/hello.jsp";    }    //forward前缀 跳转到目标方法    @GetMapping("/hello2")    public String hello2(Model model){        model.addAttribute("msg","Hello World!");        return "forward:/hello1";    }    //redirect前缀 重定向    @GetMapping("/hello3")    public String hello3(Model model){        model.addAttribute("msg","Hello World!");        return "redirect:/index.jsp";    }}
:::note{type="info"}
前缀的优先级是比视图解析器大的，有前缀的前提下是不经过视图解析器的，建议还是注册视图解析器，转发不用前缀，重定向使用前缀进行。
:::
数据处理
获取数据
通过url相同的参数名获取数据
@Controllerpublic class HelloController  {    @GetMapping("/hello1")    //输入http://localhost:8080/项目名/hello?msg01=hello world!    public String hello1(String msg01, Model model){        model.addAttribute("msg",msg01);        return "hello";    }    @GetMapping("/hello2")    //输入http://localhost:8080/项目名/hello?msg01=hello&msg02= world!    public String hello2(String msg01,String msg02,Model model){        model.addAttribute("msg",msg01+msg02);        return "hello";    }}
通过url不相同的参数名获取数据
@Controllerpublic class HelloController  {    @GetMapping("/hello")    //输入http://localhost:8080/项目名/hello?msg0=hello world!    //通过RequestParam标签绑定参数名字可以修改名字，但不能用回原来的参数名来获取了，即只能用msg0来获取    public String hello(@RequestParam("msg0") String msg01, Model model){        model.addAttribute("msg",msg01);        return "hello";    }}
通过url来获取一个对象
首先创建一个实体类
public class user {    String name;    int id;    public user(String name, int id) {        this.name = name;        this.id = id;    }    public String getName() {        return name;    }    public int getId() {        return id;    }    @Override    public String toString() {        return "user{" +                "name='" + name + '\'' +                ", id=" + id +                '}';    }}
获取对象
@Controllerpublic class HelloController  {    @GetMapping("/hello")    //输入http://localhost:8080/项目名/hello?name=he&id=2    //注意的是，输入的参数要与构造器的顺序一样    public String hello(User user, Model model){        model.addAttribute("msg",user);        return "hello";    }}
解析到前端页面
使用ModelAndView
public class HelloController implements Controller {    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {        ModelAndView mv = new ModelAndView();        //封装数据        mv.addObject("msg", "Hello World!");        //封装跳转页面        mv.setViewName("hello");        return mv;    }}
使用Model
@Controllerpublic class HelloController  {    @GetMapping("/hello")    public String hello(Model model){        //封装数据        model.addAttribute("msg","Hello World!");        //返回跳转视图        return "hello";    }}
使用ModelMap
@Controllerpublic class HelloController  {    @GetMapping("/hello")    public String hello(ModelMap modelMap){        modelMap.addAttribute("msg","Hello World!");        return "hello";    }}
:::note{type="info"}
Model其实是一个接口实现类，一定程度上是继承了ModelMap，因为Model的实现也是要用到ModelMap的方法的，而ModelMap继承了LinkedHashMap，所以方法比Model多一些。
:::
Json的处理
添加jackson-databind的依赖
            com.fasterxml.jackson.core            jackson-databind            2.11.0
实体测试类
public class User {    String name;    int id;    public User(String name, int id) {        this.name = name;        this.id = id;    }    public String getName() {        return name;    }    public int getId() {        return id;    }    @Override    public String toString() {        return "user{" +                "name='" + name + '\'' +                ", id=" + id +                '}';    }}
Controller类
@RestController//作用为跳过视图解析器，返回json字符串public class HelloController  {    @RequestMapping("/hello")    public String json() throws JsonProcessingException {        ObjectMapper mapper = new ObjectMapper();        User user = new User("yww", 2);        String res = mapper.writeValueAsString(user);        return res;    }}
:::note{type="warning"}
注意的是新加依赖要刷新project setting里的lib目录，不然没添加会直接500报错
:::


Ngrok内网穿透
Fri, 03 Jul 2020 00:00:00 +0000
什么是Ngrok
ngrok 是一个反向代理，通过在公共的端点和本地运行的 Web 服务器之间建立一个安全的通道。ngrok 可捕获和分析所有通道上的流量，便于后期分析和重放。
有什么用
内网穿透意思是能让外网访问到你本地，就比如你在本地运行tomacat等，外网是无法访问到你本地的项目的，当然你部署到服务器上就可以，这篇文章只是为了简化你的操作，而且你应该不会什么测试都部署到服务器，所以就能使用ngrok实现内网穿透。
注册
先去官网注册一个用户，然后登陆。国内Ngrok的地址：https://www.ngrok.cc/
购买隧道
这个是免费的，当然你想体验更流畅那就付费呗。
使用
把你的隧道ID输入就好了
然后你就能用赠送的域名访问到你的内网了。
后话
这只是个简单的穿透，不过也挺有用的，能让外网访问到你的本地项目，在一些时候能很方便。你不想用他的域名，应该是可以解析的，解析成你的就好。


AOP
Tue, 30 Jun 2020 00:00:00 +0000
什么是AOP
Spring 是一个轻量级的IOC和AOP的框架，spring的两大核心就是IOC和AOP，IOC我之前写有，那什么是AOP呢？首先先看一下百度的定义。
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
面向切面编程
AOP，面向切面编程，这又是一种新的思想。一开始我们接触的是面向过程，比如c语言。然后是面向对象编程oop，一系列的面向对象语言，比如Java。学到后面就发现，面向对象也不能满足人们了，就出现了面向接口编程，但人总是懒得，这又出现了面向切面编程。面向切面顾名思义，把一个程序一刀切就出现了切面。怎么理解呢。就比如我们得业务，实现增删改查，一开始的我们是这样的。
这时候人们想增加一个功能，比如日志，就会变成这样
人们会发现这样会重复写了一段代码，当很多业务方法都需要加上日志这个功能的时候，就会多写很多的代码，为了简便，人们就想到了
增加一个类来实现日志就好了，就比如这样
但是每一个方法都要加多一段代码来调用日志的方法，这样也是很麻烦的，如果要有很多很多的方法，一个一个的加不仅会破环原方法的代码，还会很繁琐。
所以出现了我们面向切面开发的AOP。
这样大概就能理解什么是面向切面编程了吧。我们为了实现功能的操作，都可以理解为一条直线，从中切一刀，插入一个功能，该功能还能切入其他的方法，就这样便减少了代码的重复性，也减少了耦合。
AOP的术语
通知（Advice）
通知可以理解为你需要实现个功能，就比如上述例子的日志功能。
连接点（JoinPoint）
连接点就是你可以你可以使用通知功能的地方，就比如增加操作的前后都是可以增加日志功能的，方法前后都是连接点。
切入点（Pointcut）
切入点就很好理解了吧，上述的日志功能横穿两个方法，交点就是这个通知的切入点，这个交点也是连接点。其实切入点就是连接点，连接点是你能够使用通知的地方，这些地方会有很多，但你不会所有都用，有些地方你就不会去使用通知的功能，你用通知的连接点才是切入点。
切面（Aspect）
切面其实就是通知和切入点的结合，这两者结合就把一个方法切出一个面，所以叫切面。
引入（introduction）
引入的意思就是把切面用到目标里。比如查询需要引入日志这个通知，就是把查询这个功能也切一刀。
目标（target）
目标其实就是指需要添加通知的对象，就是刚刚所说的那条线。
代理(proxy)
看到这其实就发现AOP与之前所说的动态代理很像，整个的AOP实现其实都是通过代理来实现的，没了解过动态代理的可以去参考一下我之前的文章。
织入(weaving)
把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时。
AOP的实现原理
刚刚也说到了，AOP其实就是通过动态代理来实现的。spring用代理类包裹切面，把它们织入到Bean中，从而代理类代替原有的类拦截了方法的调用，拦截了方法的调用然后改代理类又实现了一些附带的功能，然后再把方法调用转发给Bean，从而实现了AOP。
怎么拦截就是代理的问题了。动态代理分为两种，一个是基于接口的动态代理，就是JDK的动态代理，另一个便是基于类的代理，就是使用cglib的动态代理。
基于接口的动态代理目标类和代理类都实现了同一接口，但不同的是代理类能会实现一些附带的功能，目标类只是代理类的一部分，虽然最后都是目标类完成接口的功能，但代理类不同于接口的方法就可以插入到目标类实现接口方法的前后，这就实现了AOP。就像是代理类里有两兄弟，实现了接口的那些方法就是哥哥，而实现了不同于接口方法的其他功能就是弟弟，当人们想要完成接口的方法的时候，弟弟虽然办不到，但是他招待了你（就是意义上的拦截），你以为他是能实现接口的哥哥，便把任务给了他，弟弟答应了又顺带收了你的钱（即附加的功能，比如日志），然后弟弟知道自己不能做这个任务，便让哥哥实现，这就是JDK的动态代理实现AOP的方式。
基于类的动态代理基于类那就更加好理解了。目标类就像是父亲，而继承了目标类的代理类就是儿子。人们都找儿子去实现接口的功能，但是儿子在完成接口的任务之前或者之后都会做一些其他的事（即附加的功能，比如日志），所以这就是cglib的动态代理实现AOP的方式。
参考文章
这两篇还是很好理解的，此文就是借鉴两文然后加上我自己的理解写成的。
https://blog.csdn.net/qukaiwei/article/details/50367761
https://blog.csdn.net/q982151756/article/details/80513340


代理模式
Sun, 28 Jun 2020 00:00:00 +0000
什么是代理模式
代理模式顾名思义就是为一个对象提供一个代理，并让其他对象通过代理对象来控制这个对象。代理模式又分为两种，一种叫静态代理，一种叫动态代理。
静态代理
角色分析
Isubject抽象角色，一般使用接口和抽象类，不过抽象类不怎么好用，大多都是接口。
RealSubject真实角色，被代理的角色。
Proxy代理角色，代理真实角色
代码实现1
光用文字描述，会觉得十分的绕，还是用代码来讲解一下吧。首先先模拟一下环境，比如买火车票这件事情。卖火车票这件事情就是一个抽象角色，我们为它创建一个接口。
public interface buyTickets {    void buytickets();}
有买票的人也就会有卖的人，这里是卖票的设为火车站。这样的话火车站就是一个真实角色，为它创建一个类。
public class Station implements buyTickets {    public void buytickets() {        System.out.println("火车站在卖票");    }}
那么问题就来了，我们学生需要买票回家，是该怎么买呢？应该不会有多少人去到火车站买票吧。大多都是网上订票吧，就比如使用软件买票，方便也快捷，这个软件就是一个代理角色，代理了火车站卖票。我们也为他创建一个类。一般代理都会有很多特定的作用，即附属一些其他的方法，就比如使用软件卖票会十分方便。
public class Software implements buyTickets {    private Station station;    public  Software(){}    public Software(Station station) {        this.station = station;    }    public void buytickets() {        station.buytickets();    }    public void Convenient(){        System.out.println("用软件卖票十分方便");    }}
好了，那就模拟一下我们买票的过程吧。比如我们通过软件就能看到火车站在卖票，然后在软件上买票，这样就不用去到火车站在买票了，也就是我们不需要使用真实角色的卖票方法，使用的是代理对象的卖票方法，代理对象就会帮我们去真实对象中调用想要的方法（代理对象有点类似中介）。
public class test01 {    public static void main(String[] args) {     //首先是一个火车站要卖票        Station station = new Station();     //然后就是软件代理火车站卖票        Software software = new Software(station);        software.buytickets();    }}
代码实现2
上述是我们日常生活中一个小小的例子，可能没能够体会到代理模式的好处，我们来看看项目中的一些简单实现吧，比如经常见到的增删改查操作。首先是业务接口和接口实现类。
public interface userService {    void add();    void delete();    void update();    void select();}
public class userServiceImpl implements userService{    public void add() {        System.out.println("增加了一个用户");    }    public void delete() {        System.out.println("删除了一个用户");    }    public void update() {        System.out.println("修改了一个用户");    }    public void select() {        System.out.println("查询了一个用户");    }}
这是没有代理角色的情况，我们也可以直接创建userServiceImpl对象调用里面的方法，但是要是之后需要了增加一些业务需求，比如增加一个日志功能，我们常规就是直接修改userServiceImpl类，比如这样
public class userServiceImpl implements userService{    public void add() {        System.out.println("使用add方法增加了一个用户");        System.out.println("增加了一个用户");    }    public void delete() {        System.out.println("使用delete方法删除了一个用户");        System.out.println("删除了一个用户");    }    public void update() {        System.out.println("使用update方法修改了一个用户");        System.out.println("修改了一个用户");    }    public void select() {        System.out.println("使用select方法查询了一个用户");        System.out.println("查询了一个用户");    }}
这只是四个增删改查的操作，你都会发现这样很麻烦，要是再加几个功能，或者再加几个操作，难道还要一个个改吗？这时候用代理就能很好的解决这种问题。那我们先创建这个代理类。
public class Proxy  implements userService{    private userServiceImpl userserviceimpl;    public Proxy() {}    public Proxy(userServiceImpl userserviceimpl) {        this.userserviceimpl = userserviceimpl;    }    public void add() {        log("add");        userserviceimpl.add();    }    public void delete() {        log("delete");        userserviceimpl.delete();    }    public void update() {        log("update");        userserviceimpl.update();    }    public void select() {        log("select");        userserviceimpl.select();    }    public void log(String logs){        System.out.println("使用了"+logs+"方法");    }}
public class test01 {    public static void main(String[] args) {        userServiceImpl userserviceimpl = new userServiceImpl();        Proxy proxy = new Proxy(userserviceimpl);        proxy.add();    }}
当然有人会觉得代理也没差多少，也是挺麻烦的，都是需要手动添加很多代码，但代理模式可以更加方便地拓展，比如需要加功能就再添加一个方法，不用总是改接口实现类里的方法，代码一多就能感受到代理模式的方便了，随便改源码不是一个好的习惯。
动态代理
静态代理大概了解了，就能发现静态代理会有一个很大的问题。当需要代理的类多了，就会发现代理的类也会增多，因为静态代理是一个类绑定一个代理类的，这就很麻烦取管理了，因为代理类的创建就是为了方便，所以动态代理就出现了。动态代理的代理类是动态生成的，我们写好一个工具类就能动态生成很多类的代理类了。
动态代理分为两大类。
JDK动态代理
CGLib动态代理
JDK动态代理
JDK动态代理是Java自带的一种动态代理的方式，核心原理就是通过反射来实现的。首先要实现JDK的动态代理就要先了解一个类和一个接口,直接看文档的说法。
ProxyProxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有的动态代理类的超类。这里也不深入了解了，只要了解它主要的一个方法，生成动态代理类的方法。
 Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),                                          new Class[] { Foo.class },                                          handler);
InvocationHandler每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将会被编码分派到其调用处理程序的invoke方法。官方说法有点绕，简单来说是这个接口就只有一个invoke方法,这个方法是处理被代理实例即真实角色的，并会返回一个结果。
public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable;
大概了解了这两个类，就可以写一个生成动态代理的工具类吧。（基本固定，可以当作万能的工具类）
public class ProxyInvocationHandler implements InvocationHandler {    //设置一个被代理的对象    private Object target;    public void setTarget(Object target) {        this.target = target;    }    //生成代理类，文档的写法    public Object getProxy(){        return Proxy.newProxyInstance(this.getClass().getClassLoader(),                                      target.getClass().getInterfaces(),this);    }    //处理要被代理实例，并返回结果    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object result = method.invoke(target, args);        return result;    }}
写完了代理类就来写测试一下吧，例子就选之前的那个增删改查的接口吧。
public class test01 {    public static void main(String[] args) {        //先创建一个真实角色        userServiceImpl userservice = new userServiceImpl();        ProxyInvocationHandler pih = new ProxyInvocationHandler();        //闯入需要代理的角色        pih.setTarget(userservice);        //生成一个代理类        userService proxy = (userService) pih.getProxy();        proxy.add();        proxy.delete();        proxy.select();        proxy.update();    }}
当我们需要添加功能的时候，比如添加一个日志的功能，就改写一下工具类就好了。
public class ProxyInvocationHandler implements InvocationHandler {    //设置一个被代理的对象    private Object target;    public void setTarget(Object target) {        this.target = target;    }    //生成代理类    public Object getProxy(){        return Proxy.newProxyInstance(this.getClass().getClassLoader(),                                      target.getClass().getInterfaces(),this);    }    //处理要被代理实例，并返回结果    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        log(method.getName());        Object result = method.invoke(target, args);        return result;    }    public void log(String msg){        System.out.println("使用了"+msg+"方法");    }}
CGLib动态代理


环境搭建手册
Sat, 27 Jun 2020 00:00:00 +0000
前言
为了以后更好的做个cv工程师，所以现在总结一下配置。
我的环境
IntelliJ IDEA 2020.2.2
Mysql  8.0.18
Tomcat  9.03.5
maven  3.6.1
jdk  1.8
Servlet更新web.xml
Mybatis
pom.xml
                                    mysql            mysql-connector-java            5.1.47                                    org.mybatis            mybatis            3.5.4                                    junit            junit            4.12                                                    src/main/resources                                    **/*.properties                    **/*.xml                                false                                        src/main/java                                    **/*.properties                    **/*.xml                                false                        
resource下的Mybatis配置文件
官方的：
                                                                      
自我优化的，数据库属性自己修改：
                                                                                                                                                                    
Mybaitis工具类
public class Mybatisutils {        private static SqlSessionFactory sqlSessionFactory;        static{            try {                //使用Mybatis第一步：获取sqlSessionFactory对象                String resource = "mybatis-config.xml";//resource下的mybatis-config.xml                InputStream inputStream = Resources.getResourceAsStream(resource);                 sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);            } catch (IOException e) {                e.printStackTrace();            }        }        //通过SqlSessionFactory中获得SqlSession的实例，通过SqlSession使用sql语句        public static SqlSession getSqlSession(){            return sqlSessionFactory.openSession();        }}
业务类的配置文件
Spring
pom.xml
                        org.springframework            spring-webmvc            5.2.6.RELEASE                            junit            junit            4.12        
配置文件
            
p命名空间的导入
       xmlns:p="http://www.springframework.org/schema/p"              xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">
C命名空间的导入
       xmlns:c="http://www.springframework.org/schema/c"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">
用注解装配，导入context约束和注解的支持
                  
AOP的实现
在pom.xml里导入依赖
    org.aspectj    aspectjweaver     1.9.5
在application.xml里导入aop约束
SpringMVC
pom.xml
    4.0.0    org.example    springmvc    1.0-SNAPSHOT                              org.springframework            spring-webmvc            5.2.6.RELEASE                                                   src/main/resources                                    **/*.properties                    **/*.xml                                false                                        src/main/java                                    **/*.properties                    **/*.xml                                false                        
web.xml
                springmvc        org.springframework.web.servlet.DispatcherServlet                            contextConfigLocation            classpath:springmvc-servlet.xml                        1                    springmvc        /                 encoding        org.springframework.web.filter.CharacterEncodingFilter                    encoding            utf-8                        encoding        /*    
springmvc-servlet.xml
                                                                                                                                                                                                                                    
SpringBoot
由于SpringBoot比较特殊，他的配置用的很多，而且大多都是关于整合其他的依赖来使用，所以这里就只是简单的做一个目录，具体的整合细节都移步到文章中好了。
SpringBoot配置Pom.xml
因人而异，此处我使用了阿里脚手架上比较标准的一套配置文件。
4.0.0com.ywwserver0.0.1server阿里的配置配置文件8UTF-8UTF-82.7.3           org.springframework.bootspring-boot-starterorg.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-testtestorg.springframework.bootspring-boot-dependencies${spring-boot.version}pomimportsrc/main/java**/*.xmlfalseorg.apache.maven.pluginsmaven-compiler-plugin3.8.11.81.8UTF-8org.springframework.bootspring-boot-maven-plugin${spring-boot.version}com.yww.blog.BlogApplicationrepackagerepackage    
JDBC
指路整合JDBC
Druid
指路整合Druid
Mybatis
指路整合Mybatis
Swagger
Swagger2
指路集成Swagger2
Swagger3
指路集成Swagger3
Mybatis-Plus
指路Mybatis-Plus
Shiro
指路Shiro
Redis
指路整合Redis
指路Redis的学习
结果类封装
指路结果类封装
异常处理
指路异常处理


Spring5
Fri, 26 Jun 2020 00:00:00 +0000
简介
Spring是Java EE编程领域的一个轻量级开源框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。Spring是一个开源容器框架，它集成各类型的工具，通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。
Spring 就是一个轻量级的控制反转IOC和面向切面AOP的框架。
参考网站：
官网
官方下载地址
GitHub地址
第一个Spring程序
创建一个maven项目
在pom.xml里导入依赖
                    org.springframework            spring-webmvc            5.2.6.RELEASE            
创建一个类，比如我的HelloSpring类
public class HelloSpring {    private String str;    public String getStr(){        return  str;    }    public void setStr(String str){        this.str = str;    }    @Override    public String toString(){        return "{"+"str="+str+"}";    }}
在resources资源目录下配置applicationContext.xml
                        
测试类
public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        HelloSpring hello = context.getBean("hello"，HelloSpring.class);        System.out.println(hello.toString());    }}//得到结果，输出    {str= Hello Spring}
Spring配置
别名
为创建的对象起别名，即为bean的id起别名
Bean
以上面的例子为例
            
:::note{type="success"}
id为bean的标识符，即创建的对象名
class为对象对所对应的类名，注意是全限定名name为别名，与alias差不多，可以起多个别名
property属性，为str这个参数赋值
:::
import
合并xml配置文件。
依赖注入
依赖注入DI，具体说法可参考我之前写的有关IOC的文章
构造器注入
使用无参构造器创建对象这种是Spring默认的创建对象的方式，在上述的Spring例子当中，HelloSpring的bean创建对象是用的无参构造器，若没有了无参构造器就会报错。
使用有参构造器创建对象
下标
            ;                
类型
            ;                
参数名
            ;                
 当bean被注册，加载到该配置文件，即使没有用到这个对象，也会生成。
Set方式注入
注入到对象中的属性，例如我的这个例子。
public class Student {    private String name;    private Address address;    private String[] books;    private List hobbies;    private Map card;    private Set games;    private String ll;    private Properties info;    @Override    public String toString() {        return "Student{" +                "name='" + name + '\'' +                ", address=" + address +                ", books=" + Arrays.toString(books) +                ", hobbies=" + hobbies +                ", card=" + card +                ", games=" + games +                ", ll='" + ll + '\'' +                ", info=" + info +                '}';    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Address getAddress() {        return address;    }    public void setAddress(Address address) {        this.address = address;    }    public String[] getBooks() {        return books;    }    public void setBooks(String[] books) {        this.books = books;    }    public List getHobbies() {        return hobbies;    }    public void setHobbies(List hobbies) {        this.hobbies = hobbies;    }    public Map getCard() {        return card;    }    public void setCard(Map card) {        this.card = card;    }    public Set getGames() {        return games;    }    public void setGames(Set games) {        this.games = games;    }    public String getLl() {        return ll;    }    public void setLl(String ll) {        this.ll = ll;    }    public Properties getInfo() {        return info;    }    public void setInfo(Properties info) {        this.info = info;    }}
基本数据类型和String类型的注入
        
引用类型的注入
             
数组的注入
                                    a                b                c                d                    
List的注入
                                    music                game                    
Map的注入
                                                                                                         
Set的注入
                                     kkk                sss                www                    
null注入即空值注入
                        
Properties的注入
                                111                333                    
:::note{type="info"}
注入的时候是通过你创建的set方法注入的，所以创建类的时候要写上set方法，养成习惯get方法也写上,为了更好的测试，就重写toString方法拓展方式注入
:::
P命名空间的注入
想要使用这种方法，先得在bean元素上加入p的命名空间，如下
:::note{type="info"}
这种方式的注入是简单类型的注入，引用类型也可以,类似set注入，但能支持注入的类型少。
:::
C命名空间注入
类似P命名空间，用前需要在bean元素上加入c的命名空间，如下
:::note{type="info"}
这种方式的是通过构造器注入的，想要注入的属性就要存在这样的有参构造器。注意因为创建对象要用到无参构造器，所以不要漏写。
:::
Bean的作用域（Scope）
单例模式
单例模式是指每次创建的bean都是同一个，这也是Spring默认的模式，比如
                    
//测试类，两个get的对象都是一样的public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        Address address1 =  context.getBean("address",Address.class);        Address address2 =  context.getBean("address",Address.class);        System.out.println(address1.hashCode());        System.out.println(address2.hashCode());    }}
单例模式表示bean只会创建一个对象，每次get的都是同一个
原型模式
原型模式就和单例模式相反，每次get的都不是同一个。
                    
//测试类，两个get的对象都是一样的public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        Address address1 =  context.getBean("address",Address.class);        Address address2 =  context.getBean("address",Address.class);        System.out.println(address1.hashCode());        System.out.println(address2.hashCode());    }}
原型模式表示每次创建的bean都不是同一个对象
Spring的自动装配
首先为了更好的测试，先创建两个类，之后的例子就从这两个类中测试。
public class User {    private String name;     private Score score;        public Score getScore() {        return score1;    }    public void setScore(Score score) {        this.score1 = score;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}
public class Score {     private String name;        public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override    public String toString() {        return "Score{" +                "name='" + name + '\'' +                '}';    }}
自动装配是从bean的autowire属性配置的。
byName的自动装配
byName的自动装配是从类中寻找具有相同属性的类，然后装配到bean里，比如在User中有Score类创建的对象，而且有set方法，所以可以自动将Score的对象装配到User类里。
                                    
public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        User user = context.getBean("user", User.class);        System.out.println(user.getScore());    }}
:::note{type="warning"}
是按照User类里的Set方法寻找的，比如Score类在bean里注册的id为score，那User类里就要有setScore这个set方法，将set去掉，首字母小写，然后与id对应一致才能找的到，这是byName的自动装配。
:::
byTypee的自动装配
                                                
public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        User user = context.getBean("user", User.class);        System.out.println(user.getScore());    }}
:::note{type="warning"}
byType是寻找类里属性类型相同的bean，所以不关id的事情了，id都可以省略。弊端就是当一个类注册了两个bean的时候，byType不知道选择哪一个就会报错。
:::
用注解实现自动装配
首先想用注解先要导入context约束和注解的支持，如下
           
@Autowired注解这个注解可以放在属性名上，也可以放在set方法上，放在属性名上，连set方法都可以不用写，当然是引用的类里要有set方法。
                
public class User {     private String name;     @Autowired     private Score score;        public Score getScore() {        return score1;    }    public void setScore1(Score score) {        this.score1 = score;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}
@Autowired里面有个属性是required，默认为true，表示不能为空值，可以手动关闭@Autowired(required = falser)。
:::note{type="info"}
@Autowired是通过byType模式来寻找的，若是一个类有多个bean才会选择用byName来自动装配。   要是多个bean的id都不符合byName的时候，就需要使用@Qualifier(value="id")来配合使用，value的值为哪个bean的id，就使用哪个bean自动装配。
:::
                                            
使用注解开发
想使用注解来进行开发，先要确定好自己的配置。
导入aop的包（之前导入的依赖包含了aop的包），注解使用不了就确定一下有没有aop的包导入
导入context的约束，开启支持注解
还要指定扫描的包，是包里的注解生效，比如例子的包
注册bean
在xml中注册bean
    
使用注解来注册bean
@Componentpublic class Score {private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override    public String toString() {        return "Score{" +                "name='" + name + '\'' +                '}';    }}
:::note{type="success"}
使用了@Component注解，会将这个类装配。可以指定id,在没有指定id的时候，这个类的bean的id就是当前类名首字母小写的字符串。
指定id可以这样写到@Component("xxx")。
:::
:::note{type="info"}
@Component 的三个衍生注解，在 web 开发中，会按照 mvc 三层架构分层。
dao 层@Repository
service 层@Service
web 层@Controller
这四个注解功能都是一样的。
:::
属性注入
@Componentpublic class Score {    @Value("lll")private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override    public String toString() {        return "Score{" +                "name='" + name + '\'' +                '}';    }}
:::note{type="success"}
属性注入可以使用@Value("")的注解，当然简单的才会使用注解，复杂一点的注入还是xml配置注解好一点。
:::
自动装配
就是之前得用注解实现自动装配
作用域
@Component@Scope("prototype")public class Score {@Value("chen")    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override    public String toString() {        return "Score{" +                "name='" + name + '\'' +                '}';    }}
:::note{type="success"}
作用域可以使用@Scope("“)，里面是模式，常用的就是singleton和prototype，默认也是singleton。
:::
使用Java的方式配置Spring
先看demo吧
用户类
public class User {    @Value("chen")    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}
Java配置类
@Configurationpublic class pojoconfig {    @Bean    public User getUser(){        return new User();    }}
测试类
public class test01 {    public static void main(String[] args) {        ApplicationContext context = new AnnotationConfigApplicationContext(pojoconfig.class);        User user = context.getBean("getUser",User.class);        System.out.println(user.getName());    }}
一个个分析吧。
用户类没什么区别，主要是Java配置类。
@Configuration表示这个类是个配置类，类似于xml。
@Bean表示bean的配置。方法名就相当于id。
AOP
关于AOP的介绍就放到另一篇文章里。AOP
这里就讲讲spring中AOP的具体实现。首先要导入依赖，和aop的约束
     org.aspectj     aspectjweaver     1.9.5   
使用Spring的接口来实现
首先定义好 接口，并创建好真实对象，即接口实现类
public interface userService {    void add();    void delete();    void update();    void select();}
public class userServiceImpl implements userService{    public void add() {        System.out.println("增加了一个用户");    }    public void delete() {        System.out.println("删除了一个用户");    }    public void update() {        System.out.println("修改了一个用户");    }    public void select() {        System.out.println("查询了一个用户");    }}
定义一个功能类
public class log implements MethodBeforeAdvice {    public void before(Method method, Object[] objects, Object target) throws Throwable {        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");    }}
method表示目标对象的方法，objects表示参数,target目标对象。实验的例子是使用MethodBeforeAdvice这个接口，即在目标方法调用之前调用的Advice通知。
MethodBeforeAdvice             前置通知
AfterReturningAdvice             后置通知，有返回值
MethodInterceptor                 环绕通知ThrowsAdvice                         异常通知
然后就要在applicationContext.xml里配置了
                                                    
这里来解析一下execution的表达式。* com.chen.pojo.userServiceImpl..*  .*(..)
execution()为表达式主体，里面为表达式
第一个 * 表示返回的类型，*表示任意类型的返回值
表示需要拦截的包，即真实对象所在的位置
包名后面的,,*表示当前包以及子包
第二个 * 表示方法，*表示所有方法
(..)表示方法可以有任意的参数
测试类
public class test01 {    public static void main(String[] args) {        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");        userService userService = context.getBean("userServiceImpl", userService.class);                userService.add();        userService.delete();        userService.update();        userService.select();    }}
注意这里的用的是接口而不是实现类。
使用自定义类来实现
定义接口和实现类，和上述一样
定义一个通知类
public class log {    public  void before(){        System.out.println("方法执行");    }}
配置xml文件
                                                                                  
这种方法还是不够好，简单的插入可以使用这种。
使用注解来实现
使用注解来实现跟自定义类实现其实差不多。
定义接口和实现类，和上述一样
定义通知类
//定义切面@Aspectpublic class log {    //定义环绕方式，里面是切入点    @Before("execution(* com.chen.pojo.userServiceImpl.*(..))")    public void before(){        System.out.println("方法执行");    }}
然后把这个类注册到spring里，并开启注解支持
                
开启注解支持还能设置动态代理模式
值为false表示使用JDK动态代理（默认），为true表示使用cglib动态代理
Spring与Mybatis整合
导入依赖
    4.0.0    com.chen    spring-study    pom    1.0-SNAPSHOT            spring-01                            junit            junit            4.12                            org.mybatis            mybatis            3.5.4                            mysql            mysql-connector-java            5.1.47                            org.springframework            spring-webmvc            5.2.6.RELEASE                            org.springframework            spring-jdbc            5.1.9.RELEASE                            org.assertj            aspectjweaver            1.9.4                            org.mybatis            mybatis-spring            2.0.2                                                            src/main/resources                                    **/*.properties                    **/*.xml                                true                                        src/main/java                                    **/*.properties                    **/*.xml                                true                        
配置spring的xml
                                                                                                                            
这个xml是可以代替原来Mybatis的配置文件，以后使用可以直接通过import导入就好了。
事务
导入约束
用Spring事务时先导入约束，如下
配置事务通知
                                                 
配置事务切入
                                                                 
后话
spring终于结束了，说实话spring相对Mybatis还是简单很多的，但细节还是挺多的，学了几天，前面又忘了，还是得多看看细节才行。emm，我的笔记也比较水，还有一些细节还没写出来，看得云里雾里得也挺正常，大概就看看复习一下就好了。end。下个框架见。
还没写完---


IOC
Tue, 23 Jun 2020 00:00:00 +0000
前言
今天看了Iteye的开涛对IOC的理解，原文地址，对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
说到IOC,就不得不说到DI—Dependency Injection,即依赖注入。在了解了IOC之后，DI也就不难理解。有人认为DI是实现IOC的一种方法，其实差不多。依赖注入表示，程序需要依赖IOC容器提供创建的对象，在程序中需要一个对象，IOC容器就会创建好一个对象来注入到程序中，你只要使用这个对象就可以了，至于对象是什么时候创建的，怎样创建的，在哪创建的你都可以不用去管，你只需要使用这个对象去完成你所需要的功能就好了，这就是我理解的DI。
一个demo
到此，应该对IOC和DI有自己的理解了，下面就通过一个小demo来加深一下理解。在常规的写法，要实现一个功能，会有dao接口，业务层接口和它们的实现类，最后使用业务层的实现类来实现这个功能。
// Userdaopublic interface UserDao {    void getUser();}//UserDaoImplpublic class UserDaoImpl implements UserDao {    public void getUser() {        System.out.println("实现第一个功能");    }}//UserServicepublic interface UserService {    void getuser();}//UserServiceImppublic class UserServiceImpl implements UserService {    private UserDao userDao = new UserDaoImpl();    public void getuser() {        userDao.getUser();    }}//最后就会获得用户的数据public class test01 {    public static void main(String[] args) {        UserService userService = new UserServiceImpl();            userService.getuser();//实现第一个功能    }}
一个功能是不能满足的时候，就会想着增加第二个功能，就需要这样做
// Userdao public interface UserDao {    void getUser();}//UserDaoImplpublic class UserDaoImpl implements UserDao {    public void getUser() {        System.out.println("实现第一个功能");    }}//UserServicepublic interface UserService {    void getuser();}public class UserDaoImpl2 implements UserDao {    public void getUser() {        System.out.println("实现第二个功能");    }}//UserServiceImp//要想实现第二个功能就要修改业务层，从而改变实现的功能public class UserServiceImpl implements UserService {    private UserDao userDao = new UserDaoImpl2();    public void getuser() {        userDao.getUser();    }}//最后就会获得用户的数据public class test01 {    public static void main(String[] args) {        UserService userService = new UserServiceImpl();            userService.getuser();//实现第二个功能    }}
当需要的功能多的时候，我们就会很难受，总是修改业务实现类，所以就出现了IOC这种思想来帮组我们解决这种问题。
// UserDao public interface UserDao {    void getUser();}//UserDaoImplpublic class UserDaoImpl implements UserDao {    public void getUser() {        System.out.println("获取用户数据");    }}//UserDaoImpl2public class UserDaoImpl2 implements UserDao {    public void getUser() {        System.out.println("第二次获得用户数据");    }}//Service//增加了Set方法来设置获取的对象public interface UserService {    void getuser();    void setUserDao(UserDao userDao);}//ServiceImplpublic class UserServiceImpl implements UserService {    private UserDao userDao;//先设置引用，对象由set方法后期获得    public void setUserDao(UserDao userDao){        this.userDao = userDao;    }    public void getuser() {        userDao.getUser();    }}public class test01 {    public static void main(String[] args) {        UserService userService = new UserServiceImpl();        userService.setUserDao(new UserDaoImpl());        userService.getuser();//实现第一个功能        userService.setUserDao(new UserDaoImpl2());        userService.getuser();//实现第二个功能    }}


Javase
Thu, 18 Jun 2020 00:00:00 +0000
前言
以前都是记笔记，每篇文章都很短而且很乱，现在学完很久了，有些东西都快忘了，最近又刚刚整完主题，所以索性就整理一下前面的文章，顺便整合起来复习一下。
:::note{type="success"}
这是我学习JavaSE的时候记的笔记，文章较长，建议目录直接跳转
:::
什么是JavaSE
复习前先来看看什么是JavaSE，来看看百度百科是怎么描述的。（大概了解一下就好了）
Java SE（Java Standard Edition，Java 标准版）是Java技术的核心和基础，是Java ME和Java EE编程的基础 [1] 。Java SE是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台的总称。
Java环境配置
学习Java的第一件事情就是要先配置好Java所需要的环境，不然运行不了还怎么学习。
下载JDK
JDK是Java语言的软件开发工具包，是整个Java开发的核心，它包含了Java的运行环境和Java工具，所以这个是必须要下载的。
:::note{type="info"}
下载的版本就选Java8好了，不一定最新的就是最好的，当然最新的也可以。至于IDE嘛，喜欢哪个用哪个，我用的就是idea
:::
设置环境变量
此电脑，右键，点击“属性”，点击“高级系统设置”，点击“高级”下的环境变量，配置下面三个变量，有就添加变量，没有就新建变量
分别配置好以下三个环境变量
JAVA_HOME路径就填JDK的安装路径
PATH路径填JDK命令文件的位置，即bin目录的位置
CLASSPATH
开头输入**“.;”**,然后填lib目录的位置
检查是否配置成功
配置完了之后就去检查一下有没有配置成功吧，以免之后出错。去cmd输入命令java-version，若有版本号出现就证明配置成功了。
省略一部分
时间不允许我写这么多了，所以我就跳过了一些基本知识，之后我在补（如果有机会的话）。
操作符
变量和常量
控制流程语句（for,if,while）
这些是跟很多编程语言都是一样的，特别是和C,C++，所以我省了
方法
方法也就是C语言里面的函数，也就是一段实现特定效果的语段。main方法就是主方法，程序的入口。
方法的简单使用
public class Hello {    public static void main(String[] args) {        //方法调用，若方法没加static修饰，就new一个Hello的对象，然后调用这个方法        helloworld();    }//定义，修饰符，返回值加方法名，方法体     static void helloworld(){        System.out.println("Hello World!");    }}
方法重载
方法重载就在于方法名是一样的，参数列表不一样。
:::note{type="warning"}
重载不是重写，这是两个概念，不要弄混了
:::
public class Hello {    public static void main(String[] args) {        helloworld();        helloworld(1);    }    static void helloworld(){        System.out.println("Hello World!");    }    static void helloworld(int i){        System.out.println("Hello World!");    }}
方法递归
递归的思想就是自己调用自己（套娃），比如下面这个求阶乘的方法。
public class Hello {    public static void main(String[] args) {        System.out.println(fnc(5));    }     static int fnc(int i){        int res = i;        if(i>1)         res = res * fnc(i - 1);//套娃        return res;     }}
面向对象
成天都说Java是面向对象的语言。那什么是面向对象编程呢？
面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式
大概了解一下就好了，Java是离不开类和对象的，所以之后就会感受到什么是面向对象编程。
类和对象
类就是一个抽象的概念，对象就是从类里实例化出来的个体。之后的Java学习都要用到。现在就来定义一个简单的类。
//注意一个类文件里面只能有一个public类public class demo{    public int i;    public void print(){        System.out.println(i);    }}
类属性和类方法
上述的i和print()就本别是类属性和类方法。把类当作是一个整体，类属性就相当于是一个部件，类方法相当于部件实现的功能。
类属性和方法调用必须通过对象，比如demo类有个test对象，那就是test.i和test.print()
访问修饰符
上述类，属性，对象都用public来修饰，public就是一个访问修饰符，访问修饰符是来设定权限的，设定谁才能使用这个类，以下是四种Java的访问权限。
访问级别 访问修饰符 同类 同包不同类(不含子类) 同包子类 不同的包(不含子类) 不同包子类
公开的 public √ √ √ √ √
受保护的 protected √ √ √ √
默认的 什么都不加 √ √ 
私有 private √ 
引用
如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。
听起来很绕，写起来就知道什么意思了。
使用类就要创建这个类的对象。就比如new demo()。但也只是创建对象，无法访问到它，所以就用引用来代表这个对象。
//引用了d这个变量来代表新创建的demo对象demo d = new demo();
构造方法
类还有一个很重要的概念就是构造方法，也叫构造器。构造方法使用来创建类的，所以方法名与类名一模一样，没有返回值，如果要实例化对象，就一定会用到构造方法。
public class Hello {    public static void main(String[] args) {    demo d1 = new demo();        demo d2 = new demo(1);    }}class demo{    public int i;    public void print(int i){        System.out.println(i);    }    //无参构造函数    demo(){    i = 2;    }     //有参构造函数（重载）    demo(int t ){       i = t;    }}
需要注意的是，系统会默认提供无参的构造方法，所以你能使用new demo()来创建对象，但如果定义了有参的构造方法，无参的就会没了，所以就不能使用new demo()来创建对象，所以养成个好习惯，创建类的时候，顺便写上无参的构造方法。
Java的三大特性
继承
:::note{type="info"}
关键字extends
:::
子类继承父类的所有方法和属性，Java的继承包括两种：
类的单继承，即只能继承一个父类
接口的多继承，一个类可以实现（继承）多个接口
封装
:::note{type="info"}
关键字就是private,protected,public
:::
封装就是将一个类里的属性和方法包装起来，严格控制访问权限。就比如JavaBean就是一个标准的封装
class demo{        private String name;    private  int id;        public demo(int id, String name) {        this.id = id;        this.name = name;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}
多态
多态就是同一个行为具有多个不同表现形式或形态的能力。实现多态的三个必要条件有
继承
重写
父类引用指向子类对象
可以先看个简单的例子
public class Test {    public static void main(String[] args) {      show(new Cat());  // 以 Cat 对象调用 show 方法      show(new Dog());  // 以 Dog 对象调用 show 方法                      Animal a = new Cat();  // 向上转型        a.eat();               // 调用的是 Cat 的 eat      Cat c = (Cat)a;        // 向下转型        c.work();        // 调用的是 Cat 的 work  }      public static void show(Animal a)  {      a.eat();          // 类型判断        if (a instanceof Cat)  {  // 猫做的事情             Cat c = (Cat)a;              c.work();          } else if (a instanceof Dog) { // 狗做的事情             Dog c = (Dog)a;              c.work();          }      }  }abstract class Animal {      abstract void eat();  }  class Cat extends Animal {      public void eat() {          System.out.println("吃鱼");      }      public void work() {          System.out.println("抓老鼠");      }  }  class Dog extends Animal {      public void eat() {          System.out.println("吃骨头");      }      public void work() {          System.out.println("看家");      }  }
this与super关键字
this
this的本质是”创建好的对象的地址“，经常用为当前对象。下面举个例子来说明this的使用方法。
// 1class A（int a,int b） {this.a = a;           //this.a指的是这个对象中定义的a，与构造器定义的区分this.b = b;}   // 2class A(int a,int b,int c){    this(a,b);           // 引用同个类的构造器，必须放在第一行，不能引用两个    this.c = c;}// 3this.a();//通过this来调用本类的方法
:::note{type="warning"}
使用this关键字来调用重载的构造方法时，可以避免相同的初始化代码，但只能在构造方法中使用，而且须位于构造方法的第一句。
:::
this不能用于static方法中。因为static方法是属于类的，this是代表对象，具体详情可以参考下面关于static的描述
super
super可以理解为指向父类对象（离得最近的）的一个指针，使用方法也有三种。
public class demo {    public  int id;    demo(){        id = 10;    }    public void print(){        System.out.println(id);    }    public static void main(String[] args) {    }}class demo_01 extends demo{    demo_01(){        super();//1.引父类的无参构造方法    }    public void print(){        id = super.id;//2. 调用父类的成员        super.print();//3. 调用父类的方法，跟第二个使用很像    }}
两者对比
子类的构造函数中要调用super()，一定要放在首行，即使不用系统也会自行调用super()，即子类调用自己的构造器时会先调用父类的，先创建一个父类的对象
super是从子类中调用父类的方法或变量，而this为在同一类中调用其它方法或变量
从本质上来讲this是一个指向本对象的指针，而super是一个Java的关键字
数组
数组是一个固定长度的，包含了相同类型数据的容器。
一维数组
数组的声明
// 优先使用这种方法声明datatype[] arr_name;// 这种是C/C++风格的声明，不推荐datatype  arr_name[];
数组的实例
// 优先使用这种方法实例datatype[] arr;//不推荐datatype arr[];
创建数组
//dataType[] arr_name = new dataType[arraysize];int arr = new int[10];
三种初始化方式
// 1.静态初始化   type[]  arr_name={,,,}//2. 默认初始化   type[]  arr_name = new type[int]    //全初始化为默认值，Boolean为false，引用类型为为null//3.动态初始化   //先分配空间，然后一个个初始化
二维数组
二维数组可以理解为一个数组，这个数组存着几个一维数组,所以Java的数组可以是不规则的。
二维数组创建：
type[][] arr_name= new type[int][int];
二维数组的初始化
//1.静态初始化type[][] arr_name ={{},{},{}}//2.动态初始化，可以使数组不规则 arr_name[0]=new type[]{,,,}
接口
接口时一个抽象的类型，跟抽象类有着差不多作用，但又不是类，相当于一个模板需要我们去完善，实现功能，所以接口是不能被实例化的，使用它就需要继承它来实现。
抽象类
抽象类是一种特殊的类，它的作用就是给子类提供了模板，它不能被实例化，所以抽象类是被当作父类去继承的。说到抽象类，就先聊聊什么是抽象类。类里有抽象方法的类被叫为抽象类，但要注意抽象类不是一定有抽象方法。
定义抽象类就用关键字abstract，将类声明为抽象类
抽象方法
有抽象方法的类被叫为抽象类，那什么是抽象方法呢，就是专门给我们去继承实现的方法。所以抽象方法是必须要被重写的，而且继承了该抽象类就必须重写抽象方法，不然系统会编译出错。
抽象方法的定义也是用关键字abstract，抽象方法是必须被重写的，所以它是不需要方法体的。
:::note{type="warning"}
子类继承了抽象类，没重写其抽象方法子类就必须在声明为抽象类，还有的就是构造方法和用static修饰的类方法是不能被声明为抽象方法的。
:::
接口
大致了解了抽象类和抽象方法就能理解接口是什么了吧。接口时抽象方法的集合，虽然也可以定义变量，但最好不要破坏了接口的特性，全是抽象方法就好了。
接口是用关键字interface来定义的，类通过关键字implements去实现接口，而且里面的方法是不能有抽象方法的，继承的类必须重写里面所有的抽象方法。
这是一个简单的例子
public class demo implements demotest {    public static void main(String[] args)  {        demo d = new demo();        d.a();        d.b();    }    public void a() {        System.out.println("aaa");    }    public void b() {        System.out.println("bbb");    }}interface demotest {    void a();    void b();}
接口的多继承
在知道了接口之后，就会有个疑问，既然有了抽象类的概念，为什么还要特意设计接口呢？这就要涉及到接口的一个特点了。
类是只支持单继承，而接口支持多继承。
人们在写程序的时候发现，在继承了一个类之后，人们就不能继续继承了，有些功能又要重新定义和实现，因为Java不想我们弄得很乱，不能像C++那样可以支持继承多个类，所以设计了接口来解决这种问题。可以通过下面的列子来大概了解接口的魅力。
//继承了demoA的方法，又继承了demoB的方法，如果还想添加功能可以再写接口在实现public class demo implements demoA,demoB {    public static void main(String[] args) {        demo d = new demo();        d.a();        d.b();    }    public void a() {        System.out.println("aaa");    }    public void b() {        System.out.println("bbb");    }}interface demoA {    void a();}interface demoB {    void b();}
:::note{type="warning"}
接口的每个方法都会被隐式的指定public abstract来修饰，变量会被隐式的指定 public static final修饰。
JDK8之后，接口也可以有方法体和静态方法了，但怎么说呢，在我看来还是不加的好
:::
Scanner类
import java.util.Scannerpublic class Main {       public static void main(String[] args) {        Scanner sc= new Scanner(System.in);        String str1 = sc.next();//        next方法只读去空格之前的数据，并且指向本行        String str2 = sc.nextLine();//        nextLine方法可以扫描到一行内容并作为一个字符串而被获取到        int i  = sc.nextInt();//        nextInt方法只读取数值    }}
System.in和System.out
该方法只能从键盘获取一个字符，而且获取的是char类型的，其他类型的难处理
import java.io.IOException;public class Main {    public static void main(String[] args)  {        System.out.println("请输入一个字符：");        char c = 0;        try {            c = (char) System.in.read();        } catch (IOException e) {            e.printStackTrace();        }        System.out.println(c);    }}
InputStreamReader和BufferedReader
可以获取字符串，但是获得int,float等类型需要转换
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class Main {    public static void main(String[] args)  {        System.out.println("请输入：");        InputStreamReader is = new InputStreamReader(System.in);        BufferedReader br = new BufferedReader(is);        try {            String msg =br.readLine();            System.out.println(msg);        } catch (IOException e) {            e.printStackTrace();        }    }
String类
在Java中，有个很重要的类-String类，注意S是大写，就是我们所说的字符串类，这使得我们使用字符串十分方便。
String的简单应用
public class demo {    public static void main(String[] args) {        String str1 = "hello";        String str2 = "world!";        System.out.println(str1+str2);        String str3 = str1+str2;        System.out.println(str3);    }}
:::note{type="warning"}
注意String创建了就是不可改变的。
:::
既然字符串是不可变的，那为什么会出现下面的操作呢？
public class demo {    public static void main(String[] args) {        String str1 = "hello";        String str2 = "world!";        String str3 = str1+str2;        System.out.println(str3);        str1 = "hello world!";        System.out.println(str1);    }}
 有人会好奇str1为什么还能继续赋值呢。其实说字符串不可变，是说字符串本身不可变，即“hello”等字符串不能改变，str1只是一个引用，继续赋值只是换了一个地址索引，原来的“hello”还是会存在内存中。
类里经常使用的方法
都是经常使用的一些方法
//返回 char指定索引处的值char charAt(int index) //将此字符串与指定对象进行比较boolean equals(Object anObject) //使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中 byte[] getBytes() //返回指定字符第一次出现的字符串内的索引 int indexOf(int ch)//返回 true如果，且仅当 length()为0 boolean isEmpty()  //返回此字符串的长度int length()  //将此字符串转换为新的字符数组。 char[] toCharArray()  
异常
异常是导致程序中断的事件，它不是算是错误，错误error是值jvm运行你的Java程序出的问题。
Exception类是所有异常类的父类
RuntimeException(运行时异常)
ArithmeticException                                                                 试图除以0异常
NullpointerException                                                               空指针异常
ClassCastException                                                                   强制转换异常（引用数据类型转换）
ArraylndexOutOfBoundsException                                        数组索引越界异常    
NumberFormatException                                                         数字格式化异常
CheckedException(已检查异常)
这类异常在编译时必须处理，否则无法通过编译   
处理异常的方法
用try-catch-finally来捕获异常
public class demo {    public static void main(String[] args) {        try                        //try来捕获异常        {                System.out.println("try");            throw new Exception( );        }        catch(Exception e)        //catch来处理异常        {            System.err.println("catch");            e.printStackTrace( );        }        finally                    //finally是必须执行的语句        {            System.out.println("finally");        }    }}
throws抛出异常让系统解决
public class demo {    public static void main(String[] args) throws Exception {            }}
泛型
泛型即参数化类型，本质为数据类型的参数化 ,也就是说所操作的数据类型被指定为一个参数的方式传递，类似于方法中的变量参数。可以用在类、接口、方法的创建中，分别简称为泛型类、泛型接口、泛型方法。
为什么要使用泛型呢？
首先举一个简单的例子
public class Test {    public static void main(String[] args) {        List arrayList = new ArrayList();        arrayList.add("aaaa");        arrayList.add(100);        for(int i = 0; i< arrayList.size();i++){            String item = (String)arrayList.get(i);            System.out.println("元素是" + item);        }    }}
nbsp;运行后就会发现程序崩溃了，这是因为在ArrayList中加入了Integer和String类型的数据，转换就出现了异常，所以为了解决一些集合内的类型转换的问题，就出现了泛型，泛型的使用可以减少类型转换和转换异常的情况。
泛型的特性
泛型只在编译阶段有效，编译后程序会采取去泛型化的措施，泛型是不会进入到运行阶段的
泛型类型在逻辑上可以看成是不同的类型，实际上都是相同的基本类型
使用方法
泛型有三种使用方式，泛型类，泛型接口，泛型方法。
集合框架
Collection
 首先学容器之前还是学习一下Collection接口，毕竟List与Set接口都是继承的Collection的，所以List与Set都有它的方法，别与Collections类弄混了，前者是集合类的上层接口，后者是一个集合框架的帮助类
//先新建两个CollectionCollection  c1 = new ArrayList<>();Collection  c2 = new ArrayList<>();// size()，返回值是int，返回当前集合元素的个数System.out.println(c1.size());//isEmpty()，返回值是Boolean类型，如果集合是空的就返回true，反之返回falseSystem.out.println(c1.isEmpty());//add()，向集合里加入元素c1.add("student");//remove()，移除集合中的元素，并不是删除c1.remove("student");//clear()，移除所有的元素c1.clear();//toArray()，转换一个Object数组Object[] objs = c1.toArray();//contains()，返回值为Boolean类型，判断元素是否在集合内System.out.println(c1.contains("student"));//containsAll()，返回值为Boolean类型,判断集c1是否包含有c2的所有元素c1.containsAll(c2);//addAll()，将c2的所有元素加入c1中c1.addAll(c2);//removeAll(),移除c1与c2共同的元素(移除c1与c2的交集)c1.removeAll(c2);//retainAll()，只保留c1与c2共同的元素(移除c1与c2非交集的元素)c1.retainAll(c2);
List
概念
List是有序，可重复的容器，List接口继承了Collection,因为是有序的，所以List是有索引位置的，因此相对与Collection接口，会有一些 特殊的关于索引位置的方法
常用实现类
LinkedList
  LinkedList底层用双向链表实现的储存。查询效率低，删减效率高，线程不安全
ArrayList
   ArrayList底层是用数组实现的储存。查询效率高，增删效率低，线程不安全
Vector
   Vector底层是用数组实现的List,相关的方法都加了同步检查，故线程安全,效率低
当需要线程安全时就用Vector实现类。查找多就用ArrayList实现类，增删多就用LinkList。
特殊方法
List list = new ArrayList<>();// List重载了一个add()方法,在指定索引位置插入一个元素list.add(3，"sss");//List重载了一个remove()方法,移除指定索引位置的元素list.remove(3);//set()，将指定索引位置元素改为指定元素list.set(2,"student");//get(),返回指定索引位置的元素System.out.println(list.get(2));//indexOf()，返回指定元素的第一次的索引位置，若没有，返回-1System.out.println(list.indexOf("student"));//lastIndexOf(),返回指定元素的最后一次的索引位置，若没有，返回-1System.out.println(list.lastIndexOf("student"));
一些要点
List允许加重复的元素
List允许存在null元素
List是有索引位置的
List是支持泛型的，所以尽量使用List时要加泛型
Map
概念
Map是存储Key与Value的容器，每个key都会对应一个Value值，所以键对象不能重复,如果存放相同的键对象，对应值对象会被新的值对象代替。
常用实现类
HashMap
底层是通过哈希表来实现的。线程不安全，但效率高。允许Key与Value为null。
HashTable
   底层实现与HashMap几乎一样，只是方法添加了synchronized来确保线程同步检查。所以线程安全，但效率低，且不允许Key与Value为null。
TreeMap
   底层是通过红黑二叉树来实现的。HashMap效率高于TreeMap,需要排序时才会选择使用TreeMap，即按照Key递增的顺序排序，如果是类排序可以考虑使用comparable接口来实现
常用的方法
 Map map1 = new HashMap<>(); Map map2 = new HashMap<>();//put()，存放键值对map1.put(1,"student1");//get()，通过键对象得到对应的值对象map1.get(1);//remove()，删除键对象对应的键值对map1.remove(1);//containsKey()与containsValue()，判断是否包含键对象或值对象是否存在改容器map1.containsKey(1);map1.containsValue("student1");//size()，返回容器中键值对的数量System.out.println(map1.size());//isEmpty(),判断容器是否为空，返回值为Boolean类型System.out.println(map1.isEmpty());//putAll(),将map2所有的键值对存放到map1里map1.putAll(map2);//clear(),清空所有键值对map1.clear();
Set
概念
Set是无序而且是不可重复的，与List一样继承Collection接口。即没有索引只能遍历查找，通过equals方法为true的不能放入，即使是NULL也只能有一个。往Set里面加入元素，本质就是把这个元素作为Key加入到内部的Map里，由于Map里的key是不重复的所以Set也不重复
常用实现类
HashSet
底层是采用HashMap实现的，本质是简化版的HashMap，因此查询与增删效率较高。
TreeSet
常用方法
因为Set继承与Collection接口，而且没有新增方法，所以方法与Collection是一样的。
迭代器
概念
迭代器是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。
使用
遍历List容器
    List list = new ArrayList<>();        list.add("1");        list.add("2");        list.add("3");        list.add("4");        list.add("5");//使用list里的iterator方法返回一个迭代器，使用该迭代器的hasNext方法得到下一个对象，进而遍历容器        for(Iterator iter = list.iterator();iter.hasNext();){            String t = iter.next();            System.out.println(t);        }
遍历Set容器
//遍历Set的方法与遍历List是一样的    Set set = new HashSet<>();        set.add("1");        set.add("2");        set.add("3");        set.add("4");        set.add("5");        for(Iterator iter = set.iterator();iter.hasNext();){            String t = iter.next();            System.out.println(t);        }
遍历Map容器
    Map map = new HashMap<>();        map.put(1, "student1");        map.put(2, "student2");        map.put(3, "student3");//通过Map.entrySet使用iterator遍历key和value        Iterator> it = map.entrySet().iterator();        while (it.hasNext()) {            Map.Entry entry = it.next();            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());        }
容器遍历汇总
List遍历
List list = new ArrayList<>();        list.add("1");        list.add("2");        list.add("3");        list.add("4");        list.add("5");//第一种，用for循环遍历for(int i = 0;i < list.size() ; i++){            System.out.println(list.get(i));        }// 第二种，用迭代器遍历for(Iterator iter = list.iterator();iter.hasNext();){            String t = iter.next();            System.out.println(t);        }//第三种，用增强for循环来遍历for(String s :list){            System.out.println(s);        }//第四种，用foreach遍历list.forEach(item -> {            System.out.println(item);        });//第五种，用list.stream().forEachlist.stream().forEach(item -> {            System.out.println(item);        });//经过测试，第一种是效率最高的，也是最推荐的，接下来是第二种，第三种，第四种，第五种
Set遍历
//Set的遍历与List大同小异,只是没有用索引遍历Set set = new HashSet<>();        set.add("1");        set.add("2");        set.add("3");        set.add("4");        set.add("5");//第一种，用迭代器遍历        for(Iterator iter = set.iterator();iter.hasNext();){            String t = iter.next();            System.out.println(t);        }//第二种，用增强for循环来遍历for(String s :set){            System.out.println(s);        }//第三种，用foreach遍历set.forEach(item -> {             System.out.println(item);        });//第四种，用set.stream().forEach         set.stream().forEach(item -> {                System.out.println(item);            });//效率比较与List的遍历时一样的
Map遍历
//第一种，用增强for循环遍历 for (Integer key : map.keySet()) {            System.out.println("key= "+ key + " and value= " + map.get(key));        }//第二种，通过Map.entrySet使用iterator遍历key和valueIterator> it = map.entrySet().iterator();        while (it.hasNext()) {            Map.Entry entry = it.next();            System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());        }//第三种，这种方法仅遍历，无法在for循环时实现remove等操作        for(Map.Entryentry:map.entrySet()){                System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());            }//第四种，只能获取values，不能获取key        for(String t:map.values()){                    System.out.println("value= "+t);                }//一般使用第一种，但因为第一种方法是二次取值，所以效率会比第二第三种都要低
Collections工具类
概念
类java.util.Collections提供了对Set,List,Map的辅助方法
常用方法
List list = new ArrayList<>();//sort(),对list容器内的元素从小到大排序        Collections.sort(list);//shuffle(),对list容器内的元素随机排序        Collections.shuffle(list);//reverse(),对list容器内的元素逆序排序        Collections.reverse(list);//fill(),用一个指定对象重写容器        Collections.fill(list,"student");//binarySearch(),对于顺序的list容器，采用二分法查找特定对象 Collections.sort(list);        Collections.binarySearch(list, "student");
IO流
IO流的分类
根据处理数据的类型不同分为：字符流和字节流
根据数据流向的不同分为：输入流和输出流
节点流
文件字节流( 数据源为文件)
FileInputStream                   通过字节的方式从文件到程序，读取文件               
FileOutputStream                 通过字节的方式从程序到文件，写入文件
文件字符流( 数据源为文件)
FileReader                            通过字符的方式从文件到程序 
FileWriter                             通过字符的方式从程序到文件
 处理的是字符数组 char
字节数组流(数据源为字节数组对象)
ByteArrayInputStream                通过字节的方式从字节数组到程序    
ByteArrayOutputStream            拖过字节的方式从程序到字节数组
:::note{type="warning"}
使用流之后需要释放流，字节数组流不需要释放，系统会自动释放的
在cry - with -resources 工具类里，在抛出异常的try{}后加入流的声明，则会帮你自动释放资源，比如try(is;os;is1;os2){}
:::
处理流
字节缓冲流：
BufferedInputStream
BufferedOutputStream
默认是缓存8K，可以自己修改，原理类似于修饰模式。
可以提升性能，运输效率，只用关闭外层的流即可，内层会自动关。手动关闭的话要从里往外关闭
字符缓冲流：
BufferedReaderreadLine()        读取一行文字
BufferedWriternewLine()            换行符
不要用父类引用指向子类对象，不然用不了这些新增方法
转换流：
InputStreamReader           
OutputStreamWriter            
将字节流转为字符流，方便处理（字节流需全文本）
能为字节流指定字符集
数据流：
DataInputStream
DataOutputStream
保留数据类型，读取的顺序与写出保持一致
数据流里放的是InputStream与OutputStream的字节流
对象流：
ObjectInputStream               反序列化
ObjectOutputStream            序列化
先写出后读取，读取的顺序与写出的顺序保持一致
不是所有的对象都能序列化，必须是实现了Serializable接口
方法和数据流差不多，多了writeobject和readObject
如果不需要序列化某个对象的值，就用transient来修饰类的对象
打印流：
PrintfStream
PrintWriter
随机访问：
RandomAcessFile
两个模式(mode)
"r"读     "rw"读写
合并：
SequenceInputStream
先用Vector容器来储存输入流，然后用该容器的elements()方法返回SequenceInputStream的参数，从而合成一个流
TCP与UDP的简单实现
TCP
使用基于TCP协议的Socket网络编程
TCP协议基于请求- 响应模式
利用IO流实现数据的传输
TCP使用的基本流程
  import java.io.DataInputStream;  import java.net.ServerSocket;  import java.net.Socket;    /**   * 创建服务器   * 1. 使用ServerSocket创建服务器   需要指定端口   * 2. 阻塞式的等待连接  accept返回一个socket对象   * 3. 输入输出流操作   * 4. 释放资源   *   */  public class TCP_Setver {      public static void main(String[] args) throws Exception{  //        1.          ServerSocket server = new ServerSocket(9999);  //        2.          Socket client = server.accept();          System.out.println("一个客户端建立了连接");  //        3.          DataInputStream dis = new DataInputStream(client.getInputStream());          String data = dis.readUTF();          System.out.println(data);  //        4.          dis.close();        }  }  
  import java.io.DataOutputStream;  import java.net.Socket;    /**   * 创建客户端   * 1. 使用Socket创建客户端   指定服务器的地址和端口   * 2. 输入输出流操作   * 3. 释放资源   */  public class TCP_Client {      public static void main(String[] args) throws Exception {  //        1.          Socket client = new Socket("localhost",9999);  //        2.          DataOutputStream dos =new DataOutputStream(client.getOutputStream());          String data = "hello";          dos.writeUTF(data);          dos.flush();  //        3.          dos.close();          client.close();      }  }
UDP
基于UDP协议的Socket网络编程实现
不需要IO流实现数据传输，数据被打包成包裹发送到目的地（注意传输的包裹不要太大）
用到的两个类： 
DatagramPacket
DatagramSocket
代码实现
import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.InetSocketAddress;      /**    *                      发送端    *    * 1. 使用DatagramSocket(int port)指定端口,创建发送端    * 2. 准备数据(一定要转成字节数组)    * 3. 将字节数组封装成DatagramPacket包裹，需要指定目的地    * 4. 用send(DatagramPacket p)    * 5. 释放资源    */   public class UDP_Client {       public static void main(String[] args) throws Exception{   //        1.           DatagramSocket client = new DatagramSocket(8888);      //        2.  比如发送一段文字           String msg = "你好!";           byte[] datas = msg.getBytes();      //        3.  指定的端口要是接收端创建时指定的端口           DatagramPacket packet = new DatagramPacket(datas,0,datas.length,                   new InetSocketAddress("localhost",6666));      //        4.           client.send(packet);      //        5.           client.close();          }   }   
   import java.net.DatagramPacket;   import java.net.DatagramSocket;      /**    *                 接收端    *   1. 使用DatagramSocket(int port)指定端口,创建接收端    *   2. 准备容器，封装成DatagramPacket包裹，用来接收发送端的包裹    *   3. 用seceive(DatagramPacket p)阻塞式的接收包裹    *   4. 分析数据，比如用getData()和getLengeth()方法    *   5. 释放资源    */   public class UDP_Server {       public static void main(String[] args) throws Exception{   //        1.           DatagramSocket server = new DatagramSocket(6666);      //        2.           byte[] datas = new byte[1024*10];           DatagramPacket packet = new DatagramPacket(datas,0,datas.length);      //        3.           server.receive(packet);      //        4.           byte[] flush = packet.getData();           int len = packet.getLength();           System.out.println(new String(flush,0,flush.length));      //        5.           server.close();       }   }
多线程
笔记丢了，下次在补
:::note{type="success"}
终于整理完了，暂时不写了，如果想到有些漏的，在加上，还有一些其他的知识，我会用单独的文章来写
:::
笔记有一些是网上的，所以要是有侵犯到你的权益可以通知我删除。


博客主题更换
Wed, 17 Jun 2020 00:00:00 +0000
前言
前几天，在b站逛逛，突然看到一个花里胡哨的主题---Butterfly，的确还挺好看的，至少比next的好看（个人意见），所以便决定换掉我的next主题。
Butterfly
就因为换个主题，我玩了一天的yml，这些前端的东西，对于我只学了一点点的人来说确看的云里雾里，不过Butterfly作者也很照顾我们这些不懂的人，主题配置文档写的清清楚楚，很多功能就是改个值就能启动，也很方便。（好了吹到这里）
关于魔改
我是菜鸟，玩了两天还是没玩出来，结果还是是照抄小康大佬和 XueXi大佬的（感谢大佬的教程），虽然花里胡哨，但是好看就完事了。
指路
Butterfly主题
小康
XueXi
Lete


Mybatis
Mon, 08 Jun 2020 00:00:00 +0000
Mybatis简介
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。可以参考官网学习Mybatis
Mybatis简单使用
创建maven项目，与之前的第一个servlet程序的流程一样
配置环境，在父项目的pom.xml导入依赖,pom.xml如下
    4.0.0    com.chen    Mybatis-test    pom    1.0-SNAPSHOT            Mybatis-01                                            mysql            mysql-connector-java            5.1.47                                            org.mybatis            mybatis            3.5.4                                    junit            junit            4.12                                                    src/main/resources                                    **/*.properties                    **/*.xml                                true                                        src/main/java                                    **/*.properties                    **/*.xml                                true                        
在resource目录下编写Mybatis的核心配置文件
                                                                                                                                                                
编写Mybatis工具类
        每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流（InputStream）实例，比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。
//sqlSessionFactory -->sqlSessionpublic class Mybatisutils {        private static SqlSessionFactory sqlSessionFactory;        static{            try {                //使用Mybatis第一步：获取sqlSessionFactory对象                String resource = "org/mybatis/example/mybatis-config.xml";                InputStream inputStream = Resources.getResourceAsStream(resource);                 sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);            } catch (IOException e) {                e.printStackTrace();            }        }        //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。        // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法        //你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。        public static SqlSession getSqlSession(){            return sqlSessionFactory.openSession();        }        }
定义接口类
public interface UserMapper {    List getUserList();    user getUserById(int id);}
编写xml文件(同目录下好管理)，写好xml之后需要到核心配置处加载映射
                        
调用
使用工具类中的getSqlSession方法获取sqlSession对象
通过sqlSession对象的getMapper方法获得接口的实现
然后通过实现的接口对象来调用方法
关闭sqlSession对象
public class UserDaoTest {    @Test    public void test(){//1        SqlSession sqlSession = Mybatisutils.getSqlSession();//2        UserMapper mapper = sqlSession.getMapper(UserMapper.class);    //class对象获得接口信息//3        List userlist = mapper.getUserList();        for(user u:userlist){             System.out.println(u.getId()+"---"+u.getName()+"---"+u.getPwd());        }//4        sqlSession.close();    }    @Test    public void getUserById(){//1        SqlSession sqlSession = Mybatisutils.getSqlSession();//2        UserMapper mapper = sqlSession.getMapper(UserMapper.class);//3        user u = mapper.getUserById(1);         System.out.println(u.getId()+"---"+u.getName()+"---"+u.getPwd());//4        sqlSession.close();    }}
增删改查
增删改都是需要提交事务的
接口
package com.chen.dao;import com.chen.pojo.user;import java.util.List;public interface UserMapper {    List getUserList();    user getUserById(int id);    int addUser(user u);    int updateUser(user u);    int deleteUser(int id);}
绑定的xml
                    insert into mybatis(id,name,pwd) values(#{id},#{name},#{pwd})                update mybatis set name=#{name},pwd=#{pwd} where id=#{id}                delete from mybatis where id = #{id}    
测试类
package com.chen.dao;import com.chen.pojo.user;import com.chen.utils.Mybatisutils;import org.apache.ibatis.session.SqlSession;import org.junit.Test;import java.util.List;public class UserDaoTest {    @Test    public void test(){        //获得sqlSession对象        SqlSession sqlSession = Mybatisutils.getSqlSession();        //执行sql语句        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        List userlist = mapper.getUserList();        for(user u:userlist){            System.out.println(u.getId()+"---"+u.getName()+"---"+u.getPwd());        }        //关闭sqlSession        sqlSession.close();    }        @Test    public void getUserById(){        SqlSession sqlSession = Mybatisutils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        user u = mapper.getUserById(1);        System.out.println(u);        sqlSession.close();    }    //            增删改的的操作都是需要commit提交事务的，不然实现不了        @Test    public void Adduser(){        SqlSession sqlSession = Mybatisutils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        mapper.addUser(new user(4, "liuliu", "4"));        sqlSession.commit();        sqlSession.close();    }    @Test    public void UpdateUser(){        SqlSession sqlSession = Mybatisutils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        mapper.updateUser(new user(4,"六六","5"));        sqlSession.commit();        sqlSession.close();    }        @Test    public void DelteUser(){        SqlSession sqlSession = Mybatisutils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        mapper.deleteUser(4);        sqlSession.commit();        sqlSession.close();    }}
Mybatis的配置详情
Mybatis配置文件就是resources文件下的mybatis-config.xml。虽然可以改名，官方推荐使用这个名字
需要注意的是，这些配置是按顺序的，比如环境配置是不能放在属性配置前面的，不然会报错
环境配置（envirnments）
MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推
                                                                                                                                                                                                                                                         
环境的选择，如果没有环境参数就会选择默认环境，即上述default的环境id
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment);SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, properties);
事务管理器的配置
如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
数据源的配置
属性（properties）
属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。
固定的属性可以直接放在外部的配置文件，比如在resources资源目录下创建一个config-properties文件,&可以不用转译
driver = com.mysql.jdbc.Driverurl = jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTCusername = rootpassword = password
然后在配置文件中调用
                                                                                                                                                    
也可以动态的调用，比如
driver = com.mysql.jdbc.Driverurl = jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
在配置文件中
                                                                                                                                                                    
注意的是，外部的优先级较高，在配置文件中properties属性与外部文件的属性冲突时是使用外部文件的属性
类型别名（typeAliases）
类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。
类
  
包
  
指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean。在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如在Mybatis会自动扫描路径上的包，在没有注解的情况下，里面的user类的别名就会定义为user
通过注解来起别名
@Alias("user")public class user {    }
设置（Settings）
这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。了解几个就行
设置名 描述 有效值 默认值
cacheEnabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 true|false true
lazyLoadingEnabled 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 true|false false
logImpl 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。 SLF4J|LOG4J|LOG4J2JDK_LOGGING|
COMMONS_LOGGING|
STDOUT_LOGGING
|NO_LOGGING 未设置
映射器（mappers）
既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。
使用相对于类路径的资源引用，推荐使用这种
      
使用完全限定资源定位符（URL）,不推荐
      
使用映射器接口实现类的完全限定类名
接口与Mapper配置文件同名
接口和它的Mapper配置文件同包
      
将包内的映射器接口实现全部注册为映射器
接口与Mapper配置文件同名
接口和它的Mapper配置文件同包，也可以将它的Mapper配置文件放在resources下创建相同路径的文件夹
  
作用域（Scope）和生命周期
理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder
这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
SqlSessionFactory
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
因此 SqlSessionFactory 的最佳作用域是应用作用域。
SqlSession
每个线程都应该有它自己的 SqlSession 实例。
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行，也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中。
如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。
属性名与字段不一致
在有些操作里，会因为pojo包里的属性名与数据库的字段名不一样而会达不到应有效果，比如有时候会查不到不同属性名的值，所以就要注意属性名要与字段一致，要是不一样还有一些其他的解决方法。
起别名
为你不同的属性名取一个与字段一样的别名，这样就能实现属性名与字段一致，比如属性名为password,字段名为pwd，则为password起一个pwd的别名
        
ResultMap
resultMap为结果集映射，将你的字段名映射为属性名，便能使属性名与字段一致
                                       
日志
Mybatis 通过使用内置的日志工厂提供日志功能。因为Mybatis的设置日志是为设置的，所以需要设置才能看得到
STDOUT_LOGGING
                
Log4j
Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIXSyslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
导入依赖
                    log4j            log4j            1.2.17        
在resouces目录下创建log4j.properties配置文件，并设置配置，网上很多可以去复制
#将等级为DEBUG的日志信息输出到console和file两个目的地log4j.rootLogger=DEBUG,console,file#控制台输出的相关设置log4j.appender.console=org.apache.log4j.ConsoleAppenderlog4j.appender.console.Target=System.outlog4j.appender.console.Threshold=DEBUGlog4j.appender.console.layout=org.apache.log4j.PatternLayoutlog4j.appender.console.layout.ConversionPattern=[%c]-%m%n#文件输出的相关配置log4j.appender.file=org.apache.log4j.RollingFileAppenderlog4j.appender.file.File=./log/Mybatis.loglog4j.appender.file.MaxFileSize=10mblog4j.appender.file.Threshold=DEBUGlog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}[%c]%m%n#日志输出级别log4j.logger.org.mybatis=DEBUGlog4j.logger.java.sql=DEBUGlog4j.logger.java.sql.Statement=DEBUGlog4j.logger.java.sql.ResultSet=DEBUGlog4j.logger.java.sql.PreparedStatement=DEBUG
设置日志实现
             
注解
对于像 BlogMapper 这样的映射器类来说，还有另一种方法来完成语句映射。 它们映射的语句可以不用 XML 来配置，而可以使用 Java 注解来配置。
注解
public interface UserMapper {    @Select("select * from user")    List getUserList();}
去核心配置文件处绑定接口
    
使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。


JSP
Sat, 06 Jun 2020 00:00:00 +0000
前言
JSP是一门比较老的技术了，在这个前后端分离大火的时代，JSP基本已经被淘汰了，但是JSP还是有学习的必要的，学习了JSP有助于了解JavaWeb，能更好的理解后面所学的框架。
什么是JSP
JSP全称为JavaServer Pages,Java服务端页面，是一种动态网页技术，用于实现动态web。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML,XML或其他格式文档的web网页，然后返回给请求者。JSP技术以Java语言作为脚本语言，为用户的HTTP请求提供服务，并能与服务器上的其它Java程序共同处理复杂的业务需求。
JSP原理
JSP是怎么实现动态web
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
JSP的一些源码分析
首先处理JSP文件
// 初始化  public void _jspInit() {  }//销毁  public void _jspDestroy() {  }//JSPService，处理请求响应  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)      throws java.io.IOException, javax.servlet.ServletException {    if (!javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {      final java.lang.String _jspx_method = request.getMethod();      if ("OPTIONS".equals(_jspx_method)) {        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");        return;      }      if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");        return;      }    }
判断请求
其中还内置了一些对象
    final javax.servlet.jsp.PageContext pageContext;            //页面上下文    javax.servlet.http.HttpSession session = null;                //Session    final javax.servlet.ServletContext application;                //application    final javax.servlet.ServletConfig config;                    //config    javax.servlet.jsp.JspWriter out = null;                        //out    final java.lang.Object page = this;                            //当前页    
输出页面前，还多了一些源码
 response.setContentType("text/html");        //设置响应的页面类型 pageContext = _jspxFactory.getPageContext(this, request, response,                  null, true, 8192, true); _jspx_page_context = pageContext; application = pageContext.getServletContext(); config = pageContext.getServletConfig(); session = pageContext.getSession(); out = pageContext.getOut(); _jspx_out = out;//这些对象可以在JSP页面中直接使用
输出页面，比如Index.jsp
       out.write("\n");      out.write("\n");      out.write("Hello World!
\n");      out.write("\n");      out.write("\n");        
所以基本上除了输出页面的代码，也就是我们在JSP上写的HTML的代码是不一样的以外，其他的基本上都是一样的，系统帮我写好了实现HTML同样效果的Servlet
所以可以得出这样JSP实现的流程。首先客户端向服务器发起了一个请求，服务器中的Web容器会接收请求，找到对应的JSP页面，然后系统会自动将JSP页面转化为Java程序，编译得到class文件，然后web容器帮我们处理这样的class文件，也就是Servlet，Web容器就发起响应，所以我们所看到的就是这个Java程序，也就是Servlet
在JSP中
写HTML的代码，会被转换成out.write("")的形式，例如上面的输出页面
写Java代码，就会是Java的代码
MVC三层架构
MVC
Model,View,Controller。即模型，视图，控制器。 
Controller 控制器
实质就是Servlet，大概有三个作用
接收用户的请求
响应交给业务层处理对应代码
视图跳转
View 视图
实质是JSP，也是Servlet，大概有两个作用
展示数据
提供链接发起Servlet请求
因为Controller与View都算是Servlet，但为了更好的管理，便规定为Controller写Servlet，View专注于显示界面
早期架构
早期的架构只有控制器和视图两层，即以下的结构
这种架构是在控制器中直接写对用户的操作，例如增删改查，但这样的话，Servlet中就会有很多代码，处理起来十分麻烦，所以便加多了一层Model层
Model 模型
Model其实包括了业务层Service，用户类JavaBean和Dao层
在优化下，才出现了如今的MVC三层架构
总结
由此可以知道JSP其实就是Servlet，所以能实现动态Web，不过因为这种技术是在HTML中嵌入Java的代码，这是一件令人头疼的事情，毕竟这样的话做一个项目就要同时学习前端和后端，所以前后端分离的思想出来之后，JSP就逐渐被淘汰了。


第一个Servlet程序
Fri, 05 Jun 2020 00:00:00 +0000
创建一个Maven项目，不用选择模板先
导入依赖
                    javax.servlet            javax.servlet-api            4.0.1            provided                            javax.servlet.jsp            jsp-api            2.1            provided            
创建一个子模块，选择图中的模板
接下来配置好maven和setting.xml和maven-repo的路径，大概如图所示
创建好子模块后，更新web.xml
还原配置
在main下创建好java包和resources包，并在右键Mark Director as标记两个包，Java包为Sources Root,resources包为Resources Root类型，成功如图下
在Java包里编写servle程序，若没有添加servlet程序选项可以自行创建类，然后继承HttpServlet接口
编写好后点击右上角的设置，配置好Tomcat服务器的设置
添加之后配置好部署，添加子模块的war包，就可以启动Tomcat了



简单的Web基础
Thu, 04 Jun 2020 00:00:00 +0000
web应用
web应用程序是一个可以提供浏览器访问的程序，一个web服务器应该是由多部份组成的，前端页面，webService功能，和Java程序，等等
静态web
静态网站是最初的建站方式，浏览者所看到的每个页面是建站者上传到服务器上的一个 html （ htm ）文件，这种网站每增加、删除、修改一个页面，都必须重新对服务器的文件进行一次下载上传。网页内容一经发布到网站服务器上，无论是否有用户访问，每个静态网页的内容都是保存在网站服务器上的，也就是说，静态网页是实实在在保存在服务器上的文件，每个网页都是一个独立的文件
动态web
动态web有点类似静态web，但不是那种有图片动，轮播图的那些伪动态，它的资源数据不是一成不变的，就比如是淘宝，不同的人会有不同的推荐
web服务器
web服务器用来处理用户的请求，然后返回响应。有LLS,Tomcat服务器，我们主要学的就是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文件，这就涉及到网站是如何进行访问。
首先客户端输入域名发起请求
客户端先会对本机的hosts进行检查，检查是否有这个域名的映射，要是有就会返回这个域名对应的ip地址，然后就可以直接访问相关的web程序，要是没有检查到就会去DNS服务器上寻早该域名对应的ip(这也就是所理解的dns解析域名)，找到就返回ip，找不到就访问不了


关于equels与==
Mon, 01 Jun 2020 00:00:00 +0000
前言
在初学Java的时候，equels与==总是会感觉很混乱，这次特意来总结一下。首先来大致了解一下这两个的意思。
==作用是来判断两个对象是不是同一个对象，因为Java只有值传递，所以对于==来说不管是基本的数据类型还是引用的数据类型，其本质比较的都是值，只是引用的数据类型变量的值是对象的地址。所以就会容易搞混
equals方法也是比较两个对象是否相等。equals方法是Object类中的方法。
//这是Object类中的equals方法public boolean equals(Object obj){    return(this == obj);}
在基本数据类型中的比较
基本数据类型不能算做为对象，所以并没有继承有equals的方法，所以只有==的比较
 int num1 = 15;     int num2 = 15;    System.out.println(num1==num2);// 运行结果为true，==判断值是否相等
在引用数据类型中的比较
String类型中的比较
String类型是重写了equals方法的，所以这里会经常弄乱，重写后的equals方法为
 public boolean equals(Object anObject) {        if (this == anObject) {            return true;        }        if (anObject instanceof String) {            String anotherString = (String) anObject;            int n = value.length;            if (n == anotherString.value.length) {                char v1[] = value;                char v2[] = anotherString.value;                int i = 0;                while (n-- != 0) {                    if (v1[i] != v2[i])                            return false;                    i++;                }                return true;            }        }        return false;    }//String类重写的equals方法
不new String的情况
        String a = "ab";        String b = "ab";      System.out.println(a==b);      System.out.println(a.equals(b));//两个结果都是true
为什么两个都是True，这就要关系到字符串常量池了。当进行第一条语句的时候，编译器就会先在字符串常量池寻找有没有"ab"这个字符串，若没有就会将这个字符串放入字符串常量池。第二条语句进行的时候，就可以找到"ab"这个字符串，就会把字符串常量池里的引用地址给b，所以a与b的字符串是同一个地址的，所以==是true的。在上面的String重写的equals方法可以看出，equals方法是比较内容是否相同，所以第二个也是true。
new String的情况
       String a = new String("ab");       String b = new String("ab");     System.out.println(a==b);     System.out.println(a.equals(b));
new String的语句是在堆内存中开辟一块空间用来存放"ab"这个字符串，然后在栈中开辟一块a或b的空间放着字符串的对象的引用，所以a,b两个虽然内容相同，但其实是两个对象，所以地址是不一样的，==在引用中比较的就是对象的地址，结果就是false。String的equals方法是比较内容的，内容相同就是true
不在String中比较
Scanner scanner = new Scanner(System.in);        Scanner scanner2 = new Scanner(System.in);       System.out.println(scanner.equals(scanner2));       //false       System.out.println(scanner==scanner2);   //false        Scanner sc = scanner;       System.out.println(scanner.equals(sc));            //true       System.out.println(scanner==sc);     //true
这个就比较容易理解了，因为equals方法没被重写，所以是比较两个对象是否是同一个对象，==比较两个地址是否是一样，也是比较是否为同一个对象，所以这两者的作用在equals方法没被重写的时候是一样的。
总结
在基本数据类型中
==比较两个值是否相同
在引用类型中
equals方法没被重写==与equals方法比较的是两个的地址是否相同
equals方法被重写，以String类举例
==比较地址，equals比较方法
一个特殊的例子
首先先看代码
Integer num11 = 127;        Integer num22 = 127;      System.out.println(num11 == num22);//true  System.out.println(num11 == 127);//true        Integer num111 = 128;        Integer num222 = 128;      System.out.println(num111 == num222);//false  System.out.println(num111 == 128);//true
按照所想，在Integer类当中，==是比较两个是否是同一个地址，但上述的运行结果中却出现了一个false，接下来在进行以下测试
Integer num11 = new Integer(127);        Integer num22 = new Integer(127);      System.out.println(num11 == num22);//false      System.out.println(num11 == 127);//true        Integer num111 = new Integer(128);        Integer num222 = new Integer(128);      System.out.println(num111 == num222);//false      System.out.println(num111 == 128);//true
由此可以看出
第一段代码中，在-128~127的范围中，==的结果是为true，而不在这个范围中，==则为false
第二段代码中，两个对象不一样，地址不一样，所以==的结果接就是就是false，没有任何异常的地方。
直接用Integer类型与Int类型作比较，值相等就为true
最后在寻找过后得到结果
Java对于Integer是有一种缓存机制的，缓存了-128到127之间的数字，有点类似String，所以在第一个例子中，num11与num22其实是共享一个地址的，所以==的结果是true，不在缓存范围外的数字，并不是共享一个地址，所以==的结果就为false


Markdown
Fri, 15 May 2020 00:00:00 +0000
标题
使用=和-来标记一级和二级标题
一级标题=============二级标题-----------------
使用#来标记标题
# 一级标题## 二级标题### 三级标题#### 四级标题##### 五级标题###### 六级标题// 推荐这种写法
字体
*斜体文本*_斜体文本_**粗体文本**__粗体文本__***粗斜体文本***___粗斜体文本___//效果图如下
斜体文本斜体文本粗体文本粗体文本粗斜体文本粗斜体文本
特定格式
分割线
**** * ******- - -----------//  这些方式都可以代表分隔线，符号只要大于三个，有无空格都可以，效果就像下方这条线
删除线
~~删除线~~
删除线
下划线
下划线就用标签
脚注
//[^脚注]  //[^脚注]:脚注的内容 
列表
有序列表
* 第一项* 第二项* 第三项+ 第一项+ 第二项+ 第三项- 第一项- 第二项- 第三项//三种方式都可以
第一项
第二项
第三项
无序列表
1. 第一项2. 第二项3. 第三项
第一项
第二项
第三项
区块
/*> 一级区块>> 二级区块>>> 三级区块*/
一级区块
二级区块
三级区块
代码块
/*```java(语言，可以不写)```*/// 就是这个框
链接
1. [链接名称](链接地址)2. <链接地址>
百度
http://www.baidu.com
图片
![alt 属性文本](图片地址)![alt 属性文本](图片地址 "可选标题")// 就不插入了,里面的属性文本可以不写，要是会HTML就自己加
表格
| 左对齐 | 右对齐 | 居中对齐 || :-----| ----: | :----: || 单元格 | 单元格 | 单元格 || 单元格 | 单元格 | 单元格 |// 表头与单元格之间用---来分隔  :-----左对齐  ----:右对齐  :----:居中对齐
左对齐 右对齐 居中对齐
单元格 单元格 单元格
单元格 单元格 单元格
图
流程图
UML时序图
甘特图
其他的技巧
转义
Markdown里有很多特定符号不能直接显示，所以要想显示这些符号就要在这些符号前面加上反斜线\`   反引号*   星号_   下划线{}  花括号[]  方括号()  小括号#   井字号+   加号-   减号.   英文句点!   感叹号
没有反斜线的星号
** 正常显示星号 **
公式
使用$$包裹Tex或LaTex格式的数学公式来实现    $$        ------    $$// 不会公式就去学习学习



Matlab
Mon, 09 Dec 2019 00:00:00 +0000
基本操作
%定义变量syms a%清屏clc%清空所有clear
矩阵的操作
%定义矩阵,空格或逗号分隔一行里的元素，分号是分行a = [ ; ; ]%定义元素全为1的矩阵A1 = ones(2,4)%定义元素全为0的矩阵A2 = zeros(3,3)%定义单位矩阵A3 = eye(4)%定义随机数的矩阵A4 = rand(2,3)%定义魔方矩阵，每行每列没对角线的和相等A5 = magic(3)
%求A行列式的值det(A)%求A矩阵的秩(r(A))rank(A)%求A矩阵的迹(tr(A))trace(A)%求A行列式的逆矩阵inv(A)%求A的特征值与特征向量eig(A)%化简矩阵Arref(A)
克莱姆法则求解
% 克莱姆法则求解非齐次线性方程组的解% 判断行列式是否为0，不为0即有唯一解D = det(A)%然后用结果那一列换到行列式里，得D1,D2等x1 = D1/D x2 = D2/D ....% 克莱姆法则求解齐次线性方程组的解% 判断行列式是否为0，不为0即仅有零解，为0则有非零解
求线性方程组得通解
%A为系数矩阵，b为结果juz%先用pinv求x0x0 = pinv(A)*b(先format rat,然后x0 = A\b)%然后求解z = null(A,'r')
数学分析的基本运算
%复合函数z = compose(f,g)%即Z(x)=f(g(x)) %求解反函数gx = finverse(fx)%求数列与函数的极限limit(fx ,x,0)%表示fx这个算式在x->0的情况下的极限值%求导数与偏导数diff(fx,x,1)%表示求f的一阶导数%求不定积分int(y,x)%表示y式的不定积分%求定积分int(fx,x,0,inf)%表示fx在dx的情况下0到无穷大的定积分
雅可比矩阵
% 定义函数矩阵f = [x*y*z; y; x+z];v = [x,y,z];%表示按dx,dy,dz的顺序求解jacobi矩阵R = jacobian(f,v)
求解多项式的根
%比如多项式 x^3-6*x^2-72*x-27 = 0p = [1 -6 72 -27]r = roots(p)
微分方程
%求解微分方程,fx为微分方程或方程组,cond为初始条件或边界条件，name表示变量，默认是tY = dsolve('fx1,fx2...','cond1,cond2...','name')
Matlab作图
作图的基本的操作
% 为图像起标题title('')%为x轴，y轴起标题xlabel('')ylabel('')%创建一个窗口figure%继续在这个窗口画图hold%起标识legend()%加网格线grid on
作图
% 画散点图 scatter(X,Y,S,C)%S是标记面积的大小，S为空则为默认大小，C为RGB值%如scantter(X,Y,S，'r','filled')，用红色来画散点，filled为填充标记% 二维曲线plot(x,y)plot(x,y1,x,y2)plot(x,y,linespec)%linespec为线型，标记，和颜色% rectangle函数作图rectangle('Position',[x,y,w,h])%x，y为矩形左下角坐标，w为宽,h为高rectangle('Position',[x,y,w,h],'Curvature',cur)%加入曲率，cur为标量值，曲率从0-1，故[1 1]创建一个椭圆或者园% 产生网格meshgrid(x,y)%从数组x,y产生网格% 画mesh图和surf图mesh(x,y,z)surf(x,y,z)
动态
%二维彗星图comet(x,y,n)%n表示轨迹尾线的长度，从0到1


git常用命令
Thu, 28 Nov 2019 00:00:00 +0000
本地库操作
git的签名
#用户名和邮件地址又称签名#系统用户级别的签名设置（这个是一定要设置的）git config --global user.name namegit config --global user.email email#仓库级别的签名设置git config user.name name git config user.email email#这两个签名就是范围不同，一个是全局的一个是部分的，当两个签名都存在时，就会使用仓库级别的签名#注意的是，用户名不能是中文的
git的添加和删除
#将操作提交的暂存区git add file#将所有操作都提交到暂存区git add .#将操作从暂存区删除掉git rm --cached file
git提交
#将暂存区中没提交的操作提交到本地版本库git commit file#因为git每次提交都需要写日志来清楚知道修改了什么，所以可以这么写git commit -m"message" (file)#还能这么写,-a表示执行修改或删除的操作都提交到本地库，可以不用add操作git commit -a -m"message"
git状态查看
#查看库中有无修改操作，即有无操作可以add或commitgit status file
查看历史记录
#这些操作都是查看历史版本的，只是显示的方式不同    git log     git log --pretty=oneline    git log --oneline    git reflog #这个方式比较好看出索引和易于前进后退
前进后退
# 基于索引操作git reset --hard "索引值"# 用^来操作git reset --hard Head^^#该操作只能后退，一个^后退一个版本#用~来操作       git reset --hard Head~n#这样表示后退n个版本    
reset三个参数的对比
soft
仅仅时在本地库移动HEAD指针
mixed
在本地库移动HEAD指针
重置暂存区
hard
在本地库移动HEAD指针
重置暂存区
重置工作区
从本地库中删除文件
#用rm命令把文件从工作区删除rm file#此时用status命令可以发现该操作可以添加到暂存区git add file#然后把该操作提交到本地版本库就可以从本地库中删除该文件git commit -m"delete a file"
比较文件差异
#将工作区中的文件和暂存区进行比较git diff file#将工作区中的文件和本地库历史记录比较，不带文件名时多个文件比较git diff [历史版本] file      
分支操作
查看分支情况
git branchgit branch -v 
新建分支
git branch branch_name
切换分支
git checkout branch_name
合并分支
#切换到被合并的分支上，然后执行merge命令git merge branch_name
关于远程仓库的操作
关于远程仓库的地址
#查看现在库里保存的远程仓库的地址git remote -v#设置远程仓库的地址，也可以理解为为origin创建一个别名git remote add origin (加上远程仓库的地址，就比如https)#删除现在的远程仓库的地址git remote rm origin
本地库的推送
git push origin master#master可以改为其他分支，必须指定
克隆
git clone (加上远程库的地址)#克隆会帮你初始好本地库，并帮你把远程库下载到本地，还可以为你的origin创建好别名
拉取
#pull=fetch+merge#抓取,该操作只是把远程仓库的东西下载下来，并没有修改你本地的文件git fetch origin master #这时你可以切换到origin/master这个分支上查看变化git checkout origin/master #然后通过两个分支的合并就可以变成远程仓库的样子git merge origin/master#当然直接执行pull也可以git pull origin master


如何给你的U盘或移动硬盘自定义图标
Wed, 27 Nov 2019 00:00:00 +0000
操作步骤
首先，选好自己想要自定义的图片，将该图片转为32*32的ico文件。关于怎么转换，直接上网搜就好了。
然后新建一个 autorun.inf 文件，并编辑里面的内容为如下
[autorun]icon=icon.ico
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这个文件放进去了。
这是从某位博主上发现的操作，时代久远，已经找不到原文了


HCS
Mon, 25 Nov 2019 00:00:00 +0000
HTML
Hyper Text Markup Language 超文本标记语言由标签构成的语言，标记语言不是编程语言
HTML文档后缀名为html或htm
标签可分为围堵标签和自闭和标签。围堵标签就是有开始标签和结束标签，比如。自闭和标签就是开始标签和结束标签是在一起的，比如 
标签可以嵌套
在开始标签中可以定义属性。属性是由键值对构成的，值需要用引号引出，单引号或双引号都可以
标签不区分大小写
             title                 Hello world     
标签
文件标签
html :  html文档的根标签
head：头标签。用于指定html文档的一些属性。引入外部资源
title：标题标签
body：体标签
<！DOCTYPE html> html5中定义该文档是html文档
文本标签
1.    2.  to 
  
to   3.
或
      4.
   5.
   6.   7. 8.
图片标签
列表标签
1
2
1
2
链接标签
name
div和span
  
语义化标签
  
表格标签
表单标签
表单是用来采集用户输入的数据的，用于和服务器进行交互，使用到的标签有：form
用户名：
密码：
    
表单项标签
input：可以通过type属性值，改变元素展示的样式
             用户名：
    密码：
    性别：男         女    
        爱好：游戏         
java    
        图片：
    隐藏域：
       用户名： 
            
    
    
             取色器：
    生日：
    生日：
    邮箱：
    年龄：
select：下拉列表
省份：

主键ID	姓名	年龄	邮箱
{{item.id}}	{{item.name}}	{{item.age}}	{{item.email}}

类型	描述	大小
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	年份表示

关键字	描述
NULL	该数据列可以包含NULL值
NOT NULL	该数据列不允许为NULL值
DEFAULT	为数据列指定默认值
PRIMARY KEY	设数据列为主键
AUTO_INCREMENT	设数据列为自动递增，设用于整数
UNSIGNED	设数据列为无符号
CHARACTER SET [name]	为数据列指定一个字符集
COMMENT	注释

访问级别	访问修饰符	同类	同包不同类(不含子类)	同包子类	不同的包(不含子类)	不同包子类
公开的	public	√	√	√	√	√
受保护的	protected	√	√	√		√
默认的	什么都不加	√	√
私有	private	√

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true\|false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。	true\|false	false
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J\|LOG4J\|LOG4J2JDK_LOGGING\| COMMONS_LOGGING\| STDOUT_LOGGING \|NO_LOGGING	未设置