MongoDB基础

MongoDB基础

1
2
3
brew services start mongodb-community@4.2

brew services stop mongodb-community@4.2

1. 基本概念

集合

集合类似于数组,在集合中可以存放文档

文档

文档是文档数据库的最小单元,我们操作和存储的内容都是文档

在MongoDB中数据库和集合都不需要手动创建

当创建文档时,如果文档所在的集合或数据库不存在,会自动创建集合和数据库

2. 基本指令

  • show dbs

    显示当前所有数据库

  • use [db names]

    进入到指定的数据库中

  • db

    表示当前所处的数据库

  • show collections

    查看数据库中所存在的集合

3. CRUD

(1) 插入文档

  • db.<collection>.insert()

    • 向集合中插入1个或多个文档

    • 向test数据库中的 stus 集合中插入一个新的学生对象

      {name: "孙悟空", age: 18, gender: "male"}

      1
      2
      3
      4
      5
      db.stus.insert({
      name: "孙悟空",
      age: 18,
      gender: "male"
      })
  • 向集合中插入文档时,如果没有指定_id属性,则数据库会用ObjectID()自动为文档添加_id,改属性作为文档的唯一标识。

  • 可以自己属性_id,数据库就不会再添加;如果自己指定,也必须确保唯一性

  • db.<collection>.insertOne()

  • db.<collection>.insertMany()

(2) 查询文档

  • db.<collection>.find()

    • 查询集合中所有符合条件的文档

    • find()可以接受一个对象作为条件

      find({})也表示查询所有文档

      {字段名: 值}: 查询字段是指定值的文档

    • find()返回是一个数组,可以用[]索引

  • db.<collection>.findOne()

    • 查询集合中符合条件的第一个文档
    • findOne()返回的是一个文档
  • db.<collection>.find().count() / db.<collection>.find().length

  • MongoDB支持通过内嵌文档的属性查询,如果要查询内嵌文档,通过.来匹配;如果要通过内嵌文档进行查询,此时属性名必须使用引号

    1
    2
    3
    db.users.find({
    "hobby.movies": "hero"
    });
  • .limit()可以设置显示数据的上限

  • 分页数据显示

    • .skip((页码-1) * 每页显示的条数).limit(每页显示的条数)

    • .skip()用于跳过指定数量的数据

    • MongoDB会自动调整skip()limit()的位置

(3) 修改文档

  • db.<collection>.update(查询条件,新对象)

    • 默认情况下用新对象替换旧对象

      1
      2
      //替换
      db.stus.update({name: "haven"}, {age: 28})
    • 如果需要修改指定属性,而不是替换,需要使用修改操作符

    • $set

      可以用来修改文档中的指定属性

      1
      2
      3
      4
      5
      6
      7
      8
      db.stus.update(
      {"_id" : ObjectId("5da96ae4298c2eb5254c4588")},
      {$set:{
      gender: "male",
      address: "liu sha he"
      }
      }
      )
    • $unset

      可以用来删除文档的指定属性

    • update()默认情况只改一个

  • db.<collection>.updateMany()

    • 同时修改多个符合条件的文档
  • db.<collection>.updateOne()

    • 更新第一个符合条件的文档
  • db.<collection>.replaceOne()

    • 替换一个文档
  • $push: 向数组中添加一个元素

    $addToSet: 向数组中添加一个元素,且没有重复

(4) 删除文档

  • db.<collection>.remove()

    • 可以根据条件来删除文档,传递的条件的方式和find()一样
    • 默认情况下,删除符合条件的所有文档
    • 如果remove()第二个参数为true,则只会删除一个
    • 如果只传递一个空对象作为参数,则删除全部文档
  • db.<collection>.deleteOne()

  • db.<collection>.deleteMany()

  • db.<collection>.drop()

    删除整个集合

  • db.dropDatabase()

SpringBoot配置

Spring Boot配置

1. 标记语言

  • 以前的配置文件:xxx.xml

  • YAML: 以数据为中心,比json, xml更适合作配置文件,实例如下

    1
    2
    server:
    port: 8081

    XML:

    1
    2
    3
    <server>
    <port>8081</port>
    </server>

2. YAML语法

(1) 基本语法

K :(空格)V — 表示一对键值对

以空格的缩进来控制层级关系,左对齐的一列数据都是同一层级

1
2
3
server: 
port: 8080
path: /hello

属性和值大小写敏感

(2) 值的写法

  • 字面量:普通的值(数字,字符串,布尔)

    k: v: 字面量直接来写

    ​ 字符串默认不需要加上单引号或双引号

    ​ 双引号:不会转义字符串里的特殊字符;特殊字符会作为本身想表示的意思

    name: "zhangsan \n lisi"输出zhangsan 换行 lisi

    ​ 单引号:会转义特殊字符,特殊字符最终只是一个普通的字符串

    name: "zhangsan \n lisi"输出zhangsan \n lisi

  • 对象(属性和值): 键值对

    k: v: 对象还是k: v的模式

    1
    2
    3
    friends:
    lastName: zhangsan
    age: 20

    行内写法:

    1
    friends: {lastName: zhangsan, age: 18}
  • 数组(List, Set)

    用- 值表示数组中的一个元素

    1
    2
    3
    4
    pets: 
    - cat
    - dog
    - pig

    行内写法

    1
    pets: [cat, dog, pig ]

    3. 配置文件值注入

    配置文件:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    server:
    port: 8081

    person:
    lastName: zhangsan
    age: 18
    boss: false
    birthDay: 2017/12/12
    maps: {k1: v1, k2: 12}
    list:
    - lisi
    - zhaoliu
    dog:
    name: myDog
    age: 2

    javaBean:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    /*
    * 将配置文件中配置的每一个属性的值,映射到这个组件中
    * @ConfigurationProperties:告诉Spring Boot将本类中的所有属性和配置文件中相关的配置进行绑定
    * prefix = "person":配置文件中哪个下面的所有属性进行一一映射
    *
    * 只有这个组件是容器中的组件,才能使用容器提供的@ConfigurationProperties功能
    * */
    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birthDay;
    private Dog dog;

    private Map<String, Object> maps;
    private List<Object> list;

    我们可以导入配置文件处理器,以后配置文件进行绑定就可以有提示:

    1
    2
    3
    4
    5
    6
    <!-- 导入配置文件处理器,配置文件进行绑定就会有提示 -->
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
    </dependency>

    @ConfigurationProperties获取值和@Value获取值的区别

    @ConfigurationProperties @Value
    功能 批量注入配置文件中的属性 一个一个指定
    松散绑定(松散语法) 支持松散语法绑定 不支持松散语法绑定
    SpEL 不支持 支持
    JSR30数据校验 支持 不支持
    复杂类型封装 支持 不支持

    配置文件ymlproperties都可以获取值

    如果只是在某个业务逻辑中,需要获取一下某个配置文件中的某项值,使用@Value

    如果说,我们专门编写了一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties

    配置文件注入值数据校验

    1
    2
    3
    4
    5
    6
    7
    @Component
    @ConfigurationProperties(prefix = "person")
    @Validated
    public class Person {
    // lastName必须为邮箱格式
    @Email
    private String lastName;

4. @PropertySource&ImportResource

@PropertySource:加载指定的配置文件

1
2
3
4
5
6
7
8
9
/*
* @ConfigurationProperties(prefix = "person")
* 默认从全局配置文件中获取值
* */
@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
//@Validated
public class Person {

@ImportResource:导入Spring的配置文件,让配置文件中的内容生效

Spring Boot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别;

想让Spring的配置文件生效,加载进来;

需要将@ImportResource标注在一个配置类上

1
2
3
4
5
6
7
8
9
@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication
public class SpringBoot01HelloworldQuickApplication {

public static void main(String[] args) {
SpringApplication.run(SpringBoot01HelloworldQuickApplication.class, args);
}

}

导入Spring的配置文件,让其生效

但不希望编写Spring的配置文件

1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="com.haven.springboot.sevice.HelloService" id="helloService">

</bean>
</beans>

SpringBoot推荐给容器中添加组件的方式: 推荐使用全注解方式

  1. 配置类===Spring配置文件
  2. 使用@Bean给容器中添加组件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
* @Configuration:告诉Spring Boot这是一个配置类
* 就是来替代之前Spring的配置文件
*
* 之前在Spring配置文件中用 <bean></bean> 标签添加组件
* */
@Configuration
public class MyAppConfig {

// 将方法的返回值添加到容器中,容器中这个组件默认的id就是方法名
@Bean
public HelloService helloService02(){
System.out.println("配置类@Bean给容器中添加组件");
return new HelloService();
}

}

5. 配置文件占位符

(1) 随机数

1
2
${random.value}, ${random.int}, ${random.long}
${random.int(10)}, ${random.int[1024, 65536]}

(2) 占位符获取之前配置的值,如果没有可以使用:指定默认值

1
2
3
4
5
6
7
8
9
person.last-name=张三${random.uuid}
person.age=${random.int}
person.birth-day=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.list=a,b,c
person.dog.name=${person.hello:hello}_dog
person.dog.age=15

6. Profile

(1) 多Profile文件

我们在主配置文件编写时,文件名可以是application-{profile}.properties/yml

默认使用application.properties的配置

(2)激活指定profile

  • 在配置文件中指定spring.profiles.active=dev

  • 命令行

    1
    --spring.profiles.active=dev

    Edit Configuration—>Program arguments

(3) yml多文档块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server:
port: 8081
spring:
profiles:
active: prod
---

server:
port: 8083
spring:
profiles: dev

---

server:
port: 8084
spring:
profiles: prod #指定属于那个环境

7. 配置文件加载位置

优先级由高到低,高优先级会覆盖低优先级的配置:

  • ./config/
  • ./
  • ./src/main/resources/config/
  • ./src/main/resources/

SpringBoot会从这四个位置全部加载主配置文件:互补配置

可以通过spring.config.location来改变默认的配置文件的位置

项目打包好后,可以使用命令行参数--spring.config.location=?的形式,启动项目的时候来指定配置文件的新位置;指定配置文件和默认加载的配置文件共同起作用,形成互补配置

8. 自动配置原理

配置文件能配置的属性参照

https://docs.spring.io/spring-boot/docs/2.1.8.RELEASE/reference/html/common-application-properties.html

自动配置原理

  1. SpringBoot启动时加载主配置类,开启了自动配置功能@EnableAutoConfiguration

  2. @EnableAutoConfiguration原理

    • 利用AutoConfigurationImportSelector给容器中导入一些组件

    • 查看AutoConfigurationImportSelector中的selectImports()方法

    1
    2
    // 获取候选的配置
    List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
    1
    2
    // getCandidateConfigurations()
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    1
    2
    3
    4
    SpringFactoriesLoader.loadFactoryNames()
    // 扫描所有jar包类路径下的 META-INF/spring.factories
    // 把扫描到的文件的内容包装成properties对象
    // 从properties获取到EnableAutoConfiguration.class的类名对应的值,然后把他们添加在容器中

    将类路径下 META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加到了容器中

    每一个这样的 xxxAutoConfiguration类都是容器中的一个组件,都加入到容器中,用他们做自动配置。

  3. 每一个自动配置类进行自动配置功能

  4. HttpEncodingAutoConfiguration(HTTP编码自动配置)为例,介绍自动配置原理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    @Configuration	// 表示是一个配置类,可以给容器中添加组件
    @EnableConfigurationProperties({HttpProperties.class}) // 启用指定类的ConfigurationProperties功能;将配置文件中对应的值和HttpProperties绑定起来,并把HttpProperties加入到ioc容器中

    @ConditionalOnWebApplication(
    type = Type.SERVLET
    ) // Spring底层@Conditional注解,根据不同的条件,如果满足指定的条件,整个配置类里面的配置就会生效;
    // 判断当前应用是否是web应用,如果是,则当前配置类生效;

    // 判断当前项目有没有这个类
    // CharacterEncodingFilter:SpringMVC中进行乱码解决的过滤器
    @ConditionalOnClass({CharacterEncodingFilter.class})

    // 判断配置文件中是否存在某个配置 spring.http.encoding;如果不存在,判断也是成立的
    // 即使配置文件中不配置spring.http.encoding=enabled,也是默认生效的
    @ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
    )
    public class HttpEncodingAutoConfiguration {
    // 他已经和SpringBoot的配置文件映射了
    private final Encoding properties;

    // 只有一个有参构造器的情况下,参数的值会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
    this.properties = properties.getEncoding();
    }

    @Bean // 给容器中添加一个组件,这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
    CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
    filter.setEncoding(this.properties.getCharset().name());
    filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
    filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
    return filter;
    }

    根据当前不同的条件判断,决定这个配置类是否生效。

    一旦配置类生效,这个配置类就会个容器中添加各种组件,这些组件是从对应的properties类中获取的,而这些类里面的每一个属性又是和配置文件绑定的。

  5. 所有在配置文件中能配置的属性,都是在xxxProperties类中封装着;配置文件能配置什么,就可以参照某个功能对应的属性类

    1
    2
    3
    4
    @ConfigurationProperties(	
    prefix = "spring.http"
    ) // 从配置文件中获取指定的值和bean的属性进行绑定
    public class HttpProperties {

精髓

  1. SpringBoot启动会加载大量的配置类

  2. 我们看我们的功能有没有SpringBoot默认写好的自动配置类;

  3. 再看这个自动配置类中到底配置了哪些组件(只要我们要用的组件有,我们就不需要再来配置)

  4. 给容器中自动配置类添加组件时,会从propertie中获取某些属性,我们就可以在配置文件中指定这些属性的值

    xxxAutoConfiguration:自动配置类,给容器中添加组件

    xxxProperties:封装配置文件中相关属性

9. 细节

1. @Conditional派生注解

作用:必须是@Conditional指定的条件成立,才给容器中添加组件,配置类里面的所有内容才生效

自动配置类必须在一定的条件下才能生效

通过

1
debug=true

让控制台打印自动配置报告,这样我们就可以很方便地知道哪些自动配置类生效

分为Positive matchesNegative matches

SpringBoot HelloWorld

SpringBoot HelloWorld

一个功能:

浏览器发送一个hello请求,浏览器接受请求并处理,响应hello字符串

1. 创建一个maven工程(jar)

2. 导入SpringBoot相关依赖

maven选择自动导入

1
2
3
4
5
6
7
8
9
10
11
12
13
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
</parent>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>
</dependencies>

(1) 父项目

1
2
3
4
5
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
</parent>

它的父项目是

1
2
3
4
5
6
7
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.1.8.RELEASE</version>
<relativePath>../../spring-boot-dependencies</relativePath>
</parent>
来真正管理Spring Boot里的所有依赖

SpringBoot的版本仲裁中心;

导入依赖默认不需要写版本(没有在dependencies中进行管理的自然需要声明版本号)

(2) 导入的依赖

1
2
3
4
5
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>

Spring-boot-starter-web

  • spring boot场景启动器: 帮我们导入了web模块正常运行所依赖的组件

  • SpringBoot将所有功能场景都抽取出来,做成一个个starters(启动器),只需要在项目中引入这些starter,相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

3. 编写主程序

1
@SpringBootApplication	// 来标注一个主程序类,说明这是一个Spring Boot类

@SpringBootApplication:SpringBoot标注在某个类上,说明这个类是SpringBoot的主配置类。SpringBoot就应该运行这个类的main 方法来启动SpringBoot类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication
  • @SpringBootConfiguration:SpringBoot的配置类

    标注在某个类上,表示这是一个Spring Boot配置类

  • @Configuration:配置类上标注这个注解

    配置类==配置文件;配置类也是容器中的一个组件;@Component

  • @EnableAutoConfiguration:开启自动配置功能

    以前我们需要配置的东西,SpringBoot自动帮我们配置

    1
    2
    3
    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration
  • @AutoConfigurationPackage:自动配置包

    @Import({Registrar.class})

    Spring的底层注解,@Import给容器中导入一个组件;导入的组件由Registrar.class

    将主配置类(@SpringBootApplication标注的类)的所在包及下面所有子包里面的所有组件都扫描到Spring容器中。

  • @Import({AutoConfigurationImportSelector.class})

    给容器中导入组件,

    AutoConfigurationImportSelector.class:导入哪些组件的选择器

    将所有需要导入的组件以全类名的方式返回;

    这些组件就会被添加到容器中;

    会给容器中导入非常多的自动配置类(xxxAutoConfiguration);就是给容器中导入这个场景需要的所有组件,并配置好这些组件

    有了自动配置类,就免去了手动编写配置注入功能组件的工作

    Spring Boot在启动时从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作

    J2EE的整体解决方案和自动配置都在spring-boot-autoconfiguration

4. 编写相关的Controller, Service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.haven.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
* @author HavenTong
* @date 2019-09-09 00:56
*/

@Controller
public class HelloController {

@ResponseBody
@RequestMapping("/hello")
private String hello(){
return ("Hello World");
}
}

5. 运行主程序测试

6. 简化部署

https://docs.spring.io/spring-boot/docs/2.1.8.RELEASE/reference/html/getting-started-first-application.html#getting-started-first-application-executable-jar

11.5

导入Spring Boot的maven插件

1
2
3
4
5
6
7
8
9
<!-- 可以将应用打包成一个可执行的jar包    -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

侧边栏—>Maven—>项目—>LifeCycle—>package

1
java -jar

进行执行

7. 使用SpringBoot Initializer创建的项目

  • resources

    • static: 保存的所有静态资源 js, css, 图片

    • templates: 保存所有的模版页面。(Spring Boot默认jar包使用嵌入式的Tomcat,默认不支持jsp的页面);

      可以使用模版引擎(freemarker, thymeleaf);

    • **application.properties: **Spring Boot应用的配置文件

Vue实例的生命周期

什么是生命周期

从Vue实例创建、运行、到销毁期间,总是伴随着各种各样的事件,这些事件统称为生命周期。

生命周期钩子

  • 生命周期事件的别名
  • 生命周期钩子 = 生命周期函数 = 生命周期事件

主要的生命周期函数分类

  • 创建期间的生命周期函数

    • beforeCreate

      实例刚在内存中被创建出来,此时还没有初始化好datamethods属性。只有默认的生命周期函数和默认的事件

    • created

      实例在内存中已创建ok,datamethod已创建ok。此时还没有开始编译模版

    • beforeMount

      此时已经完成了模版的编译,但是还没有挂载到页面中

    • mounted

      此时已经将编译好的模版挂载到了页面指定的容器中使用

  • 运行期间的生命周期函数

    • beforeUpdate

      状态更新之前执行此函数,此时data的状态是最新的,但是页面上显示的数据还是旧的,此时还没有重新渲染DOM节点

    • updated

      实例更新完毕后调用此函数,此时data的状态值和界面上显示的数据都已经完成了更新,界面已经被重新渲染完毕

  • 销毁期间的生命周期函数

    • beforeDestroy

      实例销毁之前调用,在这一步,实例依然完全可用

    • destroyed

      Vue实例销毁后调用,调用后,Vue实例指示的所有东西都会解绑定,所有的事件监听器会被移除,所有的子实例也会被销毁

STL Notes

STL容器共性

STL容器所提供的都是值寓意,而非引用寓意,也就是说当我们向容器插入元素的时候,容器内部实施了拷贝动作,将我们要插入的元素再另行拷贝一份放入到容器中,也就是说我们提供的元素必须能够拷贝。

若有指针,需要写拷贝构造,重载等号

  • 除了queue和stack之外,每个容器都提供可返回迭代器的函数,运用返回的迭代器就可以访问元素。
  • 通常STL不会抛出异常,需要使用者传入正确参数。
  • 每个容器都提供了一个默认的构造函数和默认的拷贝构造函数。
  • 大小相关的构造方法:
    • size()返回容器中元素的个数
    • empty()判断元素是否为空

STL容器使用时机

vector deque list set multiset map multimap
典型内存结构 单端数组 双端数组 双向链表 二叉树 二叉树 二叉树 二叉树
可随机存取 对key而言,是
元素搜寻速度 非常慢 对key而言,快 对key而言,快
元素安插移除 尾端 头尾两端 任何位置 - - - -

使用场景

vector

软件历史操作数据的存储,经常查看历史记录,但不会删除记录。

deque

排队购票系统,排队者的存储可以采用deque,支持头部快速移除,尾端快速添加。如果采用vector,头部移除会移动大量数据,速度慢。

vector v.s. deque

  • vector.at()比deque.at()效率高:vector.at(0)是固定的,deque的开始位置是不固定的
  • 如果有大量释放操作时,vector花的时间更少
  • deque支持头部的快速插入与移除

list

公交车乘客的存储,随时可能有乘客下车,支持频繁的不确定位置元素的移除和插入

set

对手机游戏的个人得分纪录的存储,存储要求从高分到低分的顺序排列

map

按ID号存储十万个用户,想要快速通过ID查找对应的用户。利用二叉树的查找效率。

[Hexo] Theme BeanTech

Ported Theme of Hux Blog, Thank Huxpro for designing such a flawless theme.

This BeanTech theme created by YuHsuan modified from the original Porter Kaijun


BeanTech Desktop

Usage


I publish the whole project for your convenience, so you can just follow the instruction down below, then you can easily customiz your own blog!

Let’s begin!!!

Init


1
2
3
git clone https://github.com/YenYuHsuan/hexo-theme-beantech.git ./hexo-beantech
cd hexo-beantech
npm install

Modify


Modify _config.yml file with your own info.
Especially the section:

Deployment

Replace to your own repo!

1
2
3
4
deploy:
type: git
repo: https://github.com/<yourAccount>/<repo>
branch: <your-branch>

Sidebar settings

Copy your avatar image to <root>/img/ and modify the _config.yml:

1
2
3
sidebar: true    # whether or not using Sidebar.
sidebar-about-description: "<your description>"
sidebar-avatar: img/<your avatar path>

and activate your personal widget you like

1
2
3
4
5
6
7
widgets:         # here are widget you can use, you can comment out
- featured-tags
- short-about
- recent-posts
- friends-blog
- archive
- category

if you want to add sidebar widget, please add at layout/_widget.

Signature Setup

Copy your signature image to <root>/img/signature and modify the _config.yml:

1
2
signature: true   # show signature
signature-img: img/signature/<your-signature-ID>

Go to top icon Setup

My icon is using iron man, you can change to your own icon at css/image.

Post tag

You can decide to show post tags or not.

1
home_posts_tag: true

home_posts_tag-true

1
home_posts_tag: false

home_posts_tag-false

Markdown render

My markdown render engine plugin is hexo-renderer-markdown-it.

1
2
3
4
5
6
7
8
9
10
# Markdown-it config
## Docs: https://github.com/celsomiranda/hexo-renderer-markdown-it/wiki
markdown:
render:
html: true
xhtmlOut: false
breaks: true
linkify: true
typographer: true
quotes: '“”‘’'

and if you want to change the header anchor ‘ℬ’, you can go to layout/post.ejs to change it.

1
2
3
4
5
6
async("https://cdn.bootcss.com/anchor-js/1.1.1/anchor.min.js",function(){
anchors.options = {
visible: 'hover',
placement: 'left',
icon: ℬ // this is the header anchor "unicode" icon
};

Hexo Basics


Some hexo command:

1
2
3
4
hexo new post "<post name>" # you can change post to another layout if you want
hexo clean && hexo generate # generate the static file
hexo server # run hexo in local environment
hexo deploy # hexo will push the static files automatically into the specific branch(gh-pages) of your repo!

Have fun ^_^


Please Star this Project if you like it! Follow would also be appreciated!
Peace!