SpringBoot with IDEA

插件

lombok

• IDEA中下载后

• 在pom.xml文件中引入依赖

  1 2 3 4 5

  <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency>

• 常用注解

  1 2 3 4 5

  @Builder @Data @AllArgsConstructor @NoArgsConstructor ...

GsonFormat

• 可以快速的将JSON转换为实体类
• shortcut option + s

热部署

• pom文件中引入依赖

  1 2 3 4 5

  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency>

• pom文件中引入依赖

  1 2 3 4 5 6 7 8 9 10 11

  <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <fork>true</fork> </configuration> </plugin> </plugins> </build>

• Preferences – Compiler – Build project automatically ✅

• cmd + option + shift + / – registry – compiler.automake.allow.when.app.running – ✅

• 配置完成后，修改项目文件后会自动build

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()

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数据校验	支持	不支持
  复杂类型封装	支持	不支持

  配置文件yml和properties都可以获取值

  如果只是在某个业务逻辑中，需要获取一下某个配置文件中的某项值，使用@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 matches和Negative matches

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实例创建、运行、到销毁期间，总是伴随着各种各样的事件，这些事件统称为生命周期。

生命周期钩子

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

主要的生命周期函数分类

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

  • beforeCreate

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

  • created

    实例在内存中已创建ok，data和method已创建ok。此时还没有开始编译模版

  • beforeMount

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

  • mounted

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

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

  • beforeUpdate

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

  • updated

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

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

  • beforeDestroy

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

  • destroyed

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

STL容器共性

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

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

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

STL容器使用时机

使用场景

vector

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

deque

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

vector v.s. deque

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

list

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

set

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

map

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

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

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

1

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!