PHP Closure闭包类详解 /2020/08/23/2020-08-23-PHP-Closure%E9%97%AD%E5%8C%85%E7%B1%BB%E8%AF%A6%E8%A7%A3/ 前言

最近很久没有更新 Blog 了，上班之后确实回家已经是瘫软状态，没办法搬砖要负责任，有奇葩需求要让奇葩需求不奇葩。

作为一个现代的 PHP 程序员很少有不接触 Laravel 的吧，接触了 Laravel 或多或少要接触 Collection 类，接触了 Collection 类肯定会接触到 Closure。

Collection 类是一个很好的工具类，用起来各种优雅，这里我们先卖个关子后面再源码解析 Collection 类。今天我们讲的是 Closure 闭包类的使用。

Closure 闭包类

Closure 类是用于代表匿名函数的类，匿名函数会产生这个类型的对象，Closure 类摘要如下：

1
2
3
4
5
6
7
8
9
Closure {
    /* 方法 */
    __construct ( void )
    public static Closure bind(
        Closure $closure ,
        object $newthis [, mixed $newscope = 'static']
    ): Closure
public Closure bindTo(object $newthis [, mixed $newscope = 'static'] ): Closure
}

方法说明：

  • Closure::__construct 用于禁止实例化的构造函数

  • Closure::bind 复制一个闭包，绑定指定的 $this 对象和类作用域

  • Closure::bindTo 复制当前闭包对象，绑定指定的 $this 对象和类作用域

Closure::bind 是 Closure::bindTo 的静态版本，其说明如下：

1
2
3
4
public static Closure bind(
        Closure $closure ,
        object $newthis [, mixed $newscope = 'static']
    ): Closure

参数说明：

  • $closure 表示需要绑定的闭包对象
  • $newthis 表示需要绑定到闭包对象的对象，或者 NULL 创建未绑定的闭包
  • $newscope 表示想要绑定给闭包的类作用域，可以传入类名或类的实例，默认值是’static’，表示不改变。
1
public Closure bindTo(object $newthis [, mixed $newscope = 'static'] ): Closure

参数说明：

  • $newthis 表示需要绑定到闭包对象的对象，或者 NULL 创建未绑定的闭包
  • $newscope 表示想要绑定给闭包的类作用域，可以传入类名或类的实例，默认值是’static’，表示不改变。

相关实例

Closure::bind 例子 1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
/**
 * 复制一个闭包，绑定类作用域。
 */
class Person
{
    private static string $nickname = '小名';
}

/**
 * 回调函数
 * 获取Person类静态私有成员属性
 * @return mixed
 */
$person = function () {
    return static::$nickname;
};

// 给闭包绑定了 Person 实例的作用域，但未给闭包绑定 $this 对象
// 可以理解为：给回调函数中的static绑定对应的运行环境
$bindPerson = Closure::bind($person, null, new Person());

echo $bindPerson() . PHP_EOL;

Closure::bind 例子 2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
/**
 * 复制一个闭包，绑定 $this 和 类所有作用域。
 */
class Person
{
    private string $name = '张某';
}

/**
 * 回调函数
 * 获取Person类私有成员属性
 * @return mixed
 */
$person = function () {
    return $this->name;
};

// 给闭包绑定了 Person 类的作用域，
// 同时将 Person 实例对象作为$this对象绑定给闭包
$bindPerson = Closure::bind($person, new Person(), 'Person');

echo $bindPerson() . PHP_EOL;

Closure::bind 例子 3：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
/**
 * 复制一个闭包，绑定 $this 和 类公有作用域。
 */
class Person
{
    public string $name = '孙悟空';
    private string $nickname = '斗战胜佛';
}

/**
 * 回调函数
 * 获取Person类公有成员属性
 * @return mixed
 */
$person = function () {
    // echo $this->nickname . PHP_EOL;
    return $this->name;
};

// 将 Person 实例对象作为 $this 对象绑定给闭包, 保留闭包原有作用域
$bindPerson = Closure::bind($person, new Person());

echo $bindPerson() . PHP_EOL;

Closure::bindTo 例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
/**
 * 复制一个闭包，绑定 $this 和 类公有作用域。
 */
class Person
{
    public string $name = '孙悟空';
    private string $nickname = '斗战胜佛';
}

// 回调函数输出绑定对象的属性
$callback = function () {
    echo $this->name . PHP_EOL;
    echo $this->nickname . PHP_EOL;
};

// 将Person的上下文绑定到回调函数上
$bindPerson = $callback->bindTo(new Person(), new Person());

$bindPerson();

总结

其实 PHP 的 Closure 类是声明匿名函数时就会产生一个 Closure 对象，这个对象可以通过bindTo方法来指定$this 绑定的对象以及对应的作用域。

]]> PHP PHP Ubuntu更新PHP版本 /2020/06/06/2020-06-06-Ubuntu%E6%9B%B4%E6%96%B0PHP%E7%89%88%E6%9C%AC/ 前言

都 2020 年了，PHP 版本都出到了 7.4.6。可是服务器上的 PHP 还是 7.1。对于我这个喜欢最新版本的人来说简直是不能忍受。怎么办？干！

安装 PHP 相关

公司环境有专门的运维，编译安装无可厚非。我们自己就没有必要折腾自己，又没啥特殊的服务要求，整那么多幺蛾子也没必要。直接添加源搞起来。

1
2
3
4
5
6
7
8
9
10
11
12
13
sudo apt-get install software-properties-common
sudo add-apt-repository ppa:ondrej/php
# 安装
sudo apt-get install php7.4 php7.4-fpm php7.4-mysql php7.4-gd php7.4-mbstring php7.4-bcmath php7.4-sqlite3 php7.4-cli php7.4-soap
# 启动
sudo service php7.4-fpm start
# 重启
sudo service php7.4-fpm restart
# 停止
sudo service php7.4-fpm stop

# 进行默认的版本选择
update-alternatives --config php

基本这样就完事儿了。剩下就是调整 nginxu 对应的 fastcgi_pass 参数，让 PHP 处理对应的请求就好了。

总结

别和我说什么不是编译安装不高级，特么的技术为的是解决问题，我的需求是快速搭建，没有什么特殊的管理需要，点到为止。而且现在服务器多数都是用 Docker 了。这种直接安装的无非就是一些老项目要迁移版本升级而已。简单实用快速就是王道。

]]> PHP PHP MySQL8 Laravel数据库连接失败 /2020/05/31/2020-05-31-MySQL-8-Laravel%E6%95%B0%E6%8D%AE%E5%BA%93%E8%BF%9E%E6%8E%A5%E5%A4%B1%E8%B4%A5/ 前言

娘希匹的~ 懒得装环境直接 Docker 了一个 MySQL 最新版，版本是 8 来着。结果我用 Navicat 连接成功，满心欢喜的以为 OJBK 了。结果换 Laravel 去 migrate 时结果肯定时不行吖。

为什么不行？

标题有点开车的感觉，真实的刺激哈哈哈。因为 MySQL8 的密码加密方式换成了 caching_sha2_password 而我们的 PDO 貌似还不支持这种方式。所以只能是使用下面的命令进行降级了。将 caching_sha2_password 降级成为 mysql_native_password。

1
2
ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '{此处替换新的密码}';
FLUSH PRIVILEGES;

为什么是 PDO 问题呢？我在使用 Golang 的数据库时候并不会出现这个问题，而 PHP PDO 连接的时候就哎。

总结

谁让你 PHP 是世界上最好的语言呢？这么多新语言，我还是爱你的 PHP。

]]> MySQL PHP Laravel PHP Laravel MySQL Docker 容器互相连接 /2020/05/30/2020-05-30-Docker-%E5%AE%B9%E5%99%A8%E4%BA%92%E7%9B%B8%E8%BF%9E%E6%8E%A5/ 前言

最近看Hyperf有个Docker安装环境，直接运行了。按照官方的教材运行起来是没有问题，可是光一个服务端没啥用啊，PHP 没有搭配 MySQL 就太没有灵魂了。既然是开发环境，我要怎么才能让已经运行的Hyperf容器连接到新建的MySQL容器呢？

运行 Docker Hyperf

Hyperf 是基于 swoole 的，但是 swoole 在 window 上运行不了，只能借助 Docker 了。

1
docker run --name myhyperf -v $pwd/skeleten:/hyperf-skeleton -p 9501:9501 -dit --entrypoint /bin/sh hyperf/hyperf:7.4-alpine-v3.9-cli-v4.5.2
2
3
# 镜像容器运行后，在容器内安装 Composer
4
wget https://github.com/composer/composer/releases/download/1.10.6/composer.phar
5
chmod u+x composer.phar
6
mv composer.phar /usr/local/bin/composer
7
# 将 Composer 镜像设置为阿里云镜像，加速国内下载速度
8
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer
9
10
# 通过 Composer 安装 hyperf/hyperf-skeleton 项目
11
composer create-project hyperf/hyperf-skeleton
12
13
# 进入安装好的 Hyperf 项目目录
14
cd hyperf-skeleton
15
# 启动 Hyperf
16
php bin/hyperf.php start

浏览器访问：http://127.0.0.1:9501 OJBK ~

到这里我们要解决的问题才正真开始，我们需要有MySQL去配合Hyperf。我们需要怎么做呢？

开始解决这个问题

创建网络：

1
docker network create hyperfdb_network

创建使用这个网络创建MySQL：

1
docker run --name mydb --net=hyperfdb_network -p 3306:3306 -it -v $pwd/data/mysql:/var/lib/mysql:rw -v $pwd/data/mysql:/var/lib/mysql-logs:rw -v $pwd/config/mysql/conf.d:/etc/mysql/conf.d:ro -e MYSQL_ROOT_PASSWORD=123456 --restart=always -d mysql:8.0.20

将已存在的容器连接到mydb相同的网络

1
# hyperfdb_network 是刚才创建的网络名称
2
# myhyperf 是hyperf容器的名称
3
docker network connect hyperfdb_network myhyperf

我们进入我们 myhyperf 容器：

1
docker exec -it myhyperf sh
2
3
ping mydb

我们发现已经通了。

测试

我们虽然是ping通了网络，但是MySQL使用不知道是否准确。

1
<?php
2
$dsn = "mysql:dbname=test;host=mydb";
3
$db_user = 'root';
4
$db_pass = '123456';
5
try {
6
    $pdo = new PDO($dsn, $db_user, $db_pass);
7
    echo '连接成功' . PHP_EOL;
8
} catch (PDOException $e) {
9
    echo '数据库连接失败' . $e->getMessage();
10
}

总结

Docker做开发环境还是挺舒服的。快速搭建就开始学习写代码了。

]]> Docker Docker Golang并发控制 /2020/05/13/2020-05-13-Golang%E5%B9%B6%E5%8F%91%E6%8E%A7%E5%88%B6/ 前言

最近决定研究下 Golang，借助王垠大神的说法就是学习一门语言优先从他的特性入手，我们的 Golang 的特性就是 goroutine。这个 goroutine 是一个什么东西呢？就像是漩涡鸣人的影分身。

Goroutine 最简单的例子

我们要在 Golang 中使用协程最简单的方法就是在对应函数前面使用 go 关键字。

1
package main
2
3
import (
4
    "fmt"
5
)
6
7
func hello() {
8
    fmt.Println("Hello Goroutine")
9
}
10
11
func main() {
12
    go hello()
13
}

我们直接执行就会发现没有任何执行结果，这是为嘛吖？小朋友你是否有很多问号。因为我们的 main 也是一个 goroutine，他是主 goroutine，因为主没有任何的阻塞，主 goroutine（主体鸣人受伤） 快速执行退出，导致其他的 goroutine（影分身） 没有被执行就退出了。

我们来试试简单的修改，让其他 goroutine 也能返回执行出结果。

1
package main
2
3
import (
4
    "fmt"
5
    "time"
6
)
7
8
func hello() {
9
    fmt.Println("Hello Goroutine")
10
}
11
12
func main() {
13
    go hello()
14
    time.Sleep(2 * time.Second)
15
}

这样的问题就是，我们不知道我们的 goroutine 什么时候才会结束啊。不可能无限制延长 time.Sleep 的时间吧，这样不科学。

同步 Goroutine

我们同步 Goroutine 的方式：

  • Channel
  • sync 包

Channel

我们可以使用 Channel 在通道之间传递值，当然因为 channel 有会阻塞的特性，可以利用这特性来进行协程同步。

1
package main
2
3
import "fmt"
4
5
func hello(i chan int) {
6
    fmt.Println("Hello Goroutine")
7
    <-i
8
}
9
10
func main() {
11
    // 无缓存channel
12
    // 根据Go语言内存模型规范，对于从无缓冲Channel进行的接收，发生在对该Channel进行的发送完成之前
13
    i := make(chan int)
14
    go hello(i)
15
    i <- 1
16
}

这个是无缓存 channel 的，在 goroutine 中，channel 先执行了打印语句，然后阻塞等待接收值，知道主 goroutine 告诉他，值来了（你歇着吧）。整个程序流程才会结束。

当然在有缓存的 channel 中这种顺序需要调换一下，否则你会发现程序啥也不输出。

1
package main
2
3
import "fmt"
4
5
func hello(i chan int) {
6
    fmt.Println("Hello Goroutine")
7
    i <- 1
8
}
9
10
func main() {
11
    // 有缓存channel
12
    // 对于带缓冲的Channel，对于Channel的第K个接收完成操作发生在第K+C个发送操作完成之前，其中C是Channel的缓存大小。
13
    i := make(chan int, 1)
14
    go hello(i)
15
    <-i
16
}

在我们的接收之前，必须完成发送，否则会发生死锁阻塞。

sync 包

我们也可以使用 sync 包提供的功能进行 goroutine 的同步。

1
package main
2
3
import (
4
    "fmt"
5
    "sync"
6
)
7
8
func hello(wg *sync.WaitGroup) {
9
    fmt.Println("Hello World")
10
    wg.Done()
11
}
12
13
func main() {
14
    var wg sync.WaitGroup
15
    wg.Add(1)
16
    go hello(&wg)
17
18
    // 等待结束
19
    wg.Wait()
20
}

利用缓存 channel+sync 包实现对 goroutine 并发控制

1
package main
2
3
import (
4
    "fmt"
5
    "sync"
6
    "time"
7
)
8
9
func main() {
10
11
    wg := &sync.WaitGroup{}
12
13
    limiter := make(chan bool, 10)
14
    for i := 0; i < 100; i++ {
15
        wg.Add(1)
16
        limiter <- true // 当传入 10 后，如果没有接收通道会阻塞，达到我们控制协程并发的效果
17
        go download(i, limiter, wg)
18
    }
19
    wg.Wait()
20
}
21
22
func download(index int, limiter chan bool, wg *sync.WaitGroup) {
23
    defer wg.Done()
24
    fmt.Println("start to download :", index)
25
    time.Sleep(1 * time.Second)
26
    <-limiter
27
}

总结

我总结的这些只是我目前为止所见所学，当然会有更加复杂的方式。希望能在后续工作中用到。

]]> Golang Golang 设计模式之抽象工厂模式 /2020/04/29/2020-04-29-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/ 前言

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。是前面简单工厂模式和工厂方法模式的升级，该超级工厂又成为其他工厂的工厂。这种类型的设计模式属于创建型类型，它提供一种创建对象的最佳方式。

为什么说是工厂的工厂，在工厂方法模式中具体的工厂负责生产具体的产品，每个具体工厂对应一种具体的类。

抽象工厂模式

在抽象工厂模式中包含如下几个角色：

  • AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
  • ConcreteFactory（具体工厂）：它实现了抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于等级结构中。
  • AbstractProduct（抽象产品）：它为每个产品声明接口，在抽象产品中声明了产品所有的业务方法
  • ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明方法。

在抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以是接口，也可以是抽象类或者具体类，其典型代码如下所示：

1
package com.yubulang.abstractfactory;
2
3
// 抽象一个工厂
4
public abstract class AbstractFactory {
5
    public abstract AbstractProductA createProductA();
6
7
    public abstract AbstractProductB createProductB();
8
}
9
10
// 实现工厂就相当于创建了一个工厂，工厂还能随意组装我们的生产线
11
// 生产对应的产品
12
class ConcreteFactory01 extends AbstractFactory {
13
    public AbstractProductA createProductA() {
14
        return new ConcreteProductA01();
15
    }
16
17
    public AbstractProductB createProductB() {
18
        return new ConcreteProductB01();
19
    }
20
}
21
22
abstract class AbstractProductA {
23
24
}
25
26
abstract class AbstractProductB {
27
28
}
29
30
class ConcreteProductA01 extends AbstractProductA {
31
32
}
33
34
class ConcreteProductB01 extends AbstractProductB {
35
36
}

与工厂方法模式一样，抽象工厂模式也可为每个产品提供一组重载的工厂方法，以不同的方式对产品对象进行创建。

抽象工厂模式总结

由于它提供了功能更为强大的工厂类并且具备较好的可扩展性，在软件开发中得以广泛应用，尤其是在一些框架和 API 类库的设计中，例如在 Java 语言的 AWT（抽象窗口工具包）中就使用了抽象工厂模式，它使用抽象工厂模式来实现在不同的操作系统中应用程序呈现与所在操作系统一致的外观界面。抽象工厂模式也是在软件开发中最常用的设计模式之一。

主要优点：

抽象工厂模式的主要优点如下：

  • 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易，所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。

  • 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

  • 增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

主要缺点：

增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

总结

具体还是看大家如何应用，跟着需求走。

]]> 设计模式 设计模式 设计模式之工厂方法模式 /2020/04/25/2020-04-25-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%B7%A5%E5%8E%82%E6%96%B9%E6%B3%95%E6%A8%A1%E5%BC%8F/ 前言

简单工厂模式（静态方法工厂）存在着一系列问题：

  • 工厂类集中了所有的实例（产品）的创建逻辑，一旦这个类进行修改不能正常工作，整个系统都会受到影响
  • 违背“开放-关闭原则”，一旦添加新产品就不得不去修改工厂类的逻辑，这样就会造成工厂逻辑臃肿切过于复杂
  • 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的登记结构

我们为了解决上面的问题，我们需要使用一个新的设计模式：工厂方法模式

工厂方法模式（Factory Method）

定义：

工厂方法模式的作用就是封装对象的创建，由子类决定创建对象是什么。

适用范围：

  • 工厂方法模式是new一个对象的替代品，所以在有需要生成对象的地方都可以使用，但是要慎重的考虑当前任务是不是需要增加一个工厂类进行管理，避免使自己的代码更加复杂。
  • 需要灵活、可扩展的框架时，可以考虑采用工厂方法模式。

说明：

  • Camera

    相机抽象类的抽象，由具体的实现相机类去实现

  • CanonCamera

    具体的佳能相机类，可以有多个，继承于Camera

  • Factory

    抽象工厂类，负责定义产品对象的产生

  • CameraFactory

    具体的工厂实现类，继承于Factory。

我们那个相机举例子，我们的相机是一个产品，不同牌子的相机有不同的特点，也由不同厂家来生产。我们先抽象出对应的相机产品。

相机相关类

1
package com.yubulang.factorymethod;
2
3
// 相机产品的抽象
4
public abstract class Camera {
5
    public abstract void focus();
6
    public abstract void screen();
7
}

有了相机的抽象，我们需要的是实现实现类：

佳能相机实现类

1
package com.yubulang.factorymethod;
2
3
public class CanonCamera extends Camera {
4
    @Override
5
    public void focus() {
6
        System.out.println("佳能对焦系统");
7
    }
8
9
    @Override
10
    public void screen() {
11
        System.out.println("佳能拍照");
12
    }
13
}

尼康相机实现类

1
package com.yubulang.factorymethod;
2
3
public class NikonCamera extends Camera {
4
    @Override
5
    public void focus() {
6
        System.out.println("尼康对焦系统");
7
    }
8
9
    @Override
10
    public void screen() {
11
        System.out.println("尼康拍摄");
12
    }
13
}

工厂相关类——用于生产相机相关

抽象工厂类：

1
package com.yubulang.factorymethod;
2
3
public abstract class Factory {
4
    public abstract <T> T getCamera(Class<T> clz);
5
}

实现一个相机工厂类：

1
package com.yubulang.factorymethod;
2
3
public class CameraFactory extends Factory {
4
    @Override
5
    public <T> T getCamera(Class<T> clz) {
6
        Camera camera = null;
7
8
        try {
9
            camera = (Camera) Class.forName(clz.getName()).newInstance();
10
        } catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
11
            e.printStackTrace();
12
        }
13
14
        return (T) camera;
15
    }
16
}

有了对应的工厂我们就必须让对应的工厂为我们生产对应的相机产品。我们调用者只用找对应的工厂生产对应的产品就好了。

1
package com.yubulang.factorymethod;
2
3
public class Photographer {
4
    public static void main(String[] args) {
5
        // 作为调用者，我们要使用对应的相机，就叫对应的工厂去给我们生产就好了
6
        CameraFactory cameraFactory = new CameraFactory();
7
8
        CanonCamera canonCamera = cameraFactory.getCamera(CanonCamera.class);
9
        canonCamera.focus();
10
        canonCamera.screen();
11
12
        NikonCamera nikonCamera = cameraFactory.getCamera(NikonCamera.class);
13
        nikonCamera.focus();
14
        nikonCamera.screen();
15
    }
16
}

工厂方法模式的优缺点

优点：

  • 良好的封装性，代码结构清晰

    不需要知道对象的创建过程，降低模块间的耦合

  • 工厂方法模式的拓展性非常优秀

    在增加产品类的情况下，只需要修改具体的工厂类，或者拓展一个工厂内就可以拥抱变化。

  • 屏蔽产品类

    类的任何变化，调用者无需关心，他只需要关心产品的接口。

  • 典型的解耦框架

    高层模块只需要知道产品的抽象类，其他的实现类无需关心，迪米特原则，我们不需要就不要去交流，符合依赖倒置原则，只依赖产品的抽象，符合里式替换原则，使用产品子类替换产品父类，当然也没问题

缺点：

  • 类结构的复杂化：

    每次为工厂方法模式添加新产品都需要写一个新的产品类，还要引入抽象层。

总结

具体还是要看业务怎么样来决定这些设计模式的使用。

]]> 设计模式 设计模式 设计模式之简单工厂（静态工厂模式） /2020/04/24/2020-04-24-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E7%AE%80%E5%8D%95%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/ 前言

简单工厂模式（静态工厂模式），最为一个出镜率比较高的设计模式，相对来说比较简单，大家可以很快上手，我觉得还是举例子给大家会比较好理解也记忆。

我们首先看看它的优缺点：

  • 优点是比较好理解，简单易操作
  • 缺点是违反了设计模式的 OCP 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码或者尽量少修改代码

理想小镇的聪明面包达人

我们想象一下，一个理想小镇上有个面包达人，他教会了好几个徒弟，徒弟们也准守传承按照指定的配方去做面包，每当想到一个新的做法面包达人都要挨个徒弟的教会他们。

我们就先模拟一下这个远古笨办法，我们定义一个面包的抽象类，每种面包我们都可以继承这个基础类，然后两个徒弟都开始要做面包就会有以下的代码：

1
package com.yubulang.simplefactory;
2
3
// 我们要生产一个相机，是要准备不同的
4
public abstract class Bread {
5
    // 准备材料
6
    public abstract void prepare();
7
8
    // 制作
9
    public abstract void make();
10
11
    // 包装
12
    public abstract void pack();
13
}
14
15
public class ButterBread extends Bread {
16
    public void prepare() {
17
        System.out.println("准备奶油面包的材料");
18
    }
19
20
    public void make() {
21
        System.out.println("制作奶油面包");
22
    }
23
24
    public void pack() {
25
        System.out.println("包装奶油面包");
26
    }
27
}
28
29
public class MeatLoaf extends Bread {
30
    public void prepare() {
31
        System.out.println("准备肉松面包的材料");
32
    }
33
34
    public void make() {
35
        System.out.println("制作肉松面包");
36
    }
37
38
    public void pack() {
39
        System.out.println("包装肉松面包");
40
    }
41
}
42
43
class Apprentice01 {
44
    public static void makeBread(String name) {
45
        Bread bread = null;
46
        switch (name) {
47
            case "肉松面包":
48
                bread = new MeatLoaf();
49
                break;
50
            case "奶油面包":
51
                bread = new ButterBread();
52
                break;
53
        }
54
55
        if (bread != null) {
56
            System.out.println("徒弟一：");
57
            bread.make();
58
            bread.pack();
59
            System.out.println("徒弟一卖面包");
60
        }
61
    }
62
}
63
64
class Apprentice02 {
65
    public static void makeBread(String name) {
66
        Bread bread = null;
67
        switch (name) {
68
            case "肉松面包":
69
                bread = new MeatLoaf();
70
                break;
71
            case "奶油面包":
72
                bread = new ButterBread();
73
                break;
74
        }
75
76
        if (bread != null) {
77
            System.out.println("徒弟二：");
78
            bread.make();
79
            bread.pack();
80
            System.out.println("徒弟二卖面包");
81
        }
82
    }
83
}
84
85
public class Main {
86
    public static void main(String[] args) {
87
        Apprentice01.makeBread("奶油面包");
88
        Apprentice02.makeBread("奶油面包");
89
    }
90
}

这个时候我们还有香肠面包、香肠面包要交给徒弟，那么我们代码要改的地方是不是有很多地方了。这个时候面包达人看出问题了，每个徒弟都要教一遍怎么做新面包是不是很累，那我们把他们叫一起来，一锅烩了岂不是更快。

统一课堂（及工厂）分开教的小灶变成了大课堂。这个大课堂我们可以把它看成一个规范的工厂。代码升级：

1
package com.yubulang.simplefactory;
2
3
// 我们要生产一个相机，是要准备不同的
4
public abstract class Bread {
5
    // 准备材料
6
    public abstract void prepare();
7
8
    // 制作
9
    public abstract void make();
10
11
    // 包装
12
    public abstract void pack();
13
}
14
15
public class ButterBread extends Bread {
16
    public void prepare() {
17
        System.out.println("准备奶油面包的材料");
18
    }
19
20
    public void make() {
21
        System.out.println("制作奶油面包");
22
    }
23
24
    public void pack() {
25
        System.out.println("包装奶油面包");
26
    }
27
}
28
29
public class MeatLoaf extends Bread {
30
    public void prepare() {
31
        System.out.println("准备肉松面包的材料");
32
    }
33
34
    public void make() {
35
        System.out.println("制作肉松面包");
36
    }
37
38
    public void pack() {
39
        System.out.println("包装肉松面包");
40
    }
41
}
42
43
// 大课堂教授徒弟们做面包
44
public class SimpleFactory {
45
    public static Bread createBread(String name) {
46
        Bread bread = null;
47
        switch (name) {
48
            case "肉松面包":
49
                bread = new MeatLoaf();
50
                break;
51
            case "奶油面包":
52
                bread = new ButterBread();
53
                break;
54
        }
55
56
        return bread;
57
    }
58
}
59
60
class Apprentice01 {
61
    public static void makeBread(String name) {
62
        Bread bread = SimpleFactory.createBread(name);
63
64
        if (bread != null) {
65
            System.out.println("徒弟一：");
66
            bread.make();
67
            bread.pack();
68
            System.out.println("徒弟一卖面包");
69
        }
70
    }
71
}
72
73
class Apprentice02 {
74
    public static void makeBread(String name) {
75
        Bread bread = SimpleFactory.createBread(name);
76
77
        if (bread != null) {
78
            System.out.println("徒弟二：");
79
            bread.make();
80
            bread.pack();
81
            System.out.println("徒弟二卖面包");
82
        }
83
    }
84
}
85
86
public class Main {
87
    public static void main(String[] args) {
88
        Apprentice01.makeBread("奶油面包");
89
        Apprentice02.makeBread("奶油面包");
90
    }
91
}

这样我们的面包达人是不是就省事儿了不少。教一次两个徒弟都会了，如果要挨个挨个教（挨个挨个的改代码就太累了）。所以我们把这些共有的部分抽离出来，节省大家的时间。

总结

这里我们已经看出简单工厂模式的简单强大之处了吧——其实就是把创建对象的公用部抽取独立出来了。

但是这个不是一个好方式，因为你每次添加新对象的时候都要去修改这个类，逻辑上是没问题，但是从代码上来说这不是一个好办法。

别急后面还有好几种工厂模式，可以为我们提供解决的思路。

]]> 设计模式 设计模式 设计模式之单例模式（三） /2020/04/23/2020-04-23-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F%EF%BC%88%E4%B8%89%EF%BC%89/ 前言

懒汉模式虽然起到了延迟加载的，但是总的来说这个东西还不是很靠谱，我们只能继续探寻下去。今天我们来看看剩下的三种：双重检查、静态内部类、枚举方式。

单例模式（双重检查）

双重检查，主要是使用 volatile 关键字，声明我们的类中的静态属性

1
package com.yubulang.type06;
2
3
public class Singleton {
4
    private Singleton() {
5
    }
6
7
    private static volatile Singleton instance;
8
9
    // 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
10
    // 同时保证了效率，推荐使用
11
    public static Singleton getInstance() {
12
        if (instance == null) {
13
            synchronized (Singleton.class) {
14
                if (instance == null) {
15
                    instance = new Singleton();
16
                }
17
            }
18
        }
19
20
        return instance;
21
    }
22
}

优缺点分析：

  • 双重检查概念是多线程开发中常使用的，如上面代码所示，我们进行了两次 if (instance == null)检查，这样就可以保证线程安全了。
  • 这样实例化代码只用执行一次，后面再次访问时，判断 if (instance == null)，直接 return 实例化对象，也避免的反复进行方法同步。
  • 线程安全；延迟加载；效率较高
  • 结论：在实际开发中，推荐使用这种单例设计模式。

单例模式（静态内部类）

这个方式主要利用了静态内部类的特点，我们会在结论告诉大家为啥。

1
package com.yubulang.type07;
2
3
// 静态内部类, 推荐使用
4
public class Singleton {
5
    private Singleton() {
6
    }
7
8
    // 写一个静态内部类，该类中有一个静态的属性 Singleton
9
    private static class SingletonInstance {
10
        private static final Singleton INSTANCE = new Singleton();
11
    }
12
13
    // 提供一个静态的共有方法，直接返回
14
    public static Singleton getInstance() {
15
        return SingletonInstance.INSTANCE;
16
    }
17
}

优缺点分析：

  • 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
  • 静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
  • 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  • 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
  • 结论：推荐使用

单例模式（枚举方式）

枚举是 jdk 1.5 提供的，我们可以利用它的特点来进行单例的声明

1
package com.yubulang.type08;
2
3
// 使用枚举方法，可以实现单例，推荐
4
enum Singleton {
5
    INSTANCE;
6
7
    public void method01() {
8
        System.out.println("ok");
9
    }
10
}

优缺点分析：

  • 这借助 JDK 1.5 中添加的枚举来实现单例模式，不仅可以避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  • Effective Java 作者 Josh Bloch 提倡的方式
  • 结论：推荐使用

总结

我们说了八种单例模式的实现方式，Java 真的吐槽一下方式太多了哈哈哈，那么这么多方式我们只需要记住推荐使用的那几个，我们推荐使用：

  • 饿汉式（静态代码块）——在确定肯定会被使用到时，这样可以避免内存浪费
  • 双重检查
  • 静态内部类
  • 枚举方式

单例模式的注意事项

  • 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式提高系统性能
  • 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new
  • 单例模式使用的场景：需要频繁的进行创建和销毁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（即：重量级对象），但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据源、session 工厂等）
]]> 设计模式 设计模式 设计模式之单例模式（二） /2020/04/21/2020-04-21-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F%EF%BC%88%E4%BA%8C%EF%BC%89/ 前言

前面我们介绍了单例模式的饿汉模式，其实饿汉式很好理解，形象的记忆就是不管怎么样，先把内存吃掉再说。本着贪多嚼不烂的原则，我们今天来看看懒汉式，这个懒汉式就有三种不同的形式。当然还是理解为主。

懒汉式（线程不安全）

在同一个线程中运行，这个方法没有问题。我们先看代码，后面再来看看这个懒汉式的优缺点。

1
package com.yubulang.type03;
2
3
public class Singleton {
4
    private Singleton() {
5
    }
6
7
    private static Singleton instance;
8
9
    // 提供一个静态的公有方法，当使用到该方法时，才去创建instance
10
    // 懒汉式1 这个因为懒，懒得线程都不安全了
11
    public static Singleton getInstance() {
12
        if (instance == null) {
13
            instance = new Singleton();
14
        }
15
16
        return instance;
17
    }
18
}

优缺点：

  • 起到了 Lazy Loading 效果，但是只能在单线程下使用。
  • 如果在多线程下，一个线程进入了 if (instance == null) 判断语句块，还未来得及往下执行，另一个进程也通过了这个判断语句，这时便会产生多个实例。所以在多线程的情况下不要使用这种方式
  • 结论：在实际开发中，不要使用这种模式

懒汉式（线程安全，同步方法）

为了得到一个线程安全的代码，我们加入了 synchronized 代码，但是这个方法有利有弊。

1
package com.yubulang.type04;
2
3
public class Singleton {
4
    private Singleton() {
5
    }
6
7
    private static Singleton instance;
8
9
    // 提供一个静态的公有方法，当使用到该方法时，才去创建instance
10
    // 懒汉式2 为了解决线程安全问题，我们加入同步代码
11
    public static synchronized Singleton getInstance() {
12
        if (instance == null) {
13
            instance = new Singleton();
14
        }
15
16
        return instance;
17
    }
18
}

优缺点：

  • 解决了线程不安全问题
  • 效率太低了，每个线程在想获得类的实例时候，执行 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低。
  • 结论：在实际开发中，不推荐使用这种方法

懒汉式（线程安全，同步代码块）

其实这种写法，是白给，因为和第一个中模式一样，我们先看代码再看总结

1
package com.yubulang.type05;
2
3
public class Singleton {
4
    private Singleton() {
5
    }
6
7
    private static Singleton instance;
8
9
    // 提供一个静态的公有方法，当使用到该方法时，才去创建instance
10
    // 懒汉式3 为了解决线程安全问题，我们加入同步代码
11
    public static Singleton getInstance() {
12
        if (instance == null) {
13
            synchronized (Singleton.class) {
14
                instance = new Singleton();
15
            }
16
        }
17
18
        return instance;
19
    }
20
}

优缺点：

  • 这种方式，本意是想引出下面的改进版本，因为前面同步方法效率太低，改为同步产生实例化的代码块
  • 但是这种同步方式并不能起到线程同步的作用。跟第三种实现方式遇到的情景一致，假如一个线程进入了 if (instance == null) 判断语句块，还未来得及往下执行，另一个进程也通过了这个判断语句，这时便会产生多个实例。所以在多线程的情况下不要使用这种方式
  • 结论：在实际开发中，不要使用这种模式

总结

其实懒汉式大叫了解一下就好了。实际开发中并不怎么使用，让它存在主要是为了引出下面的的一些方法。PEACE！！！

]]> 设计模式 设计模式 设计模式之单例模式（一） /2020/04/20/2020-04-20-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F%EF%BC%88%E4%B8%80%EF%BC%89/ 单例模式简介

单例设计模式，就是采取一定的方法保证整个的软件系统中，对某个类只能存在一个对象实例，并且类只提供一个取得对象实例的方法（静态方法）。

单例模式有八种方式：

  1. 饿汉式（静态常量）
  2. 饿汉式（静态代码块）
  3. 懒汉式（线程不安全）
  4. 懒汉式（线程安全，同步方法）
  5. 懒汉式（线程安全，同步代码块）
  6. 双重检查
  7. 静态内部类
  8. 枚举

饿汉式（静态常量）

步骤如下：

  • 构造器私有化（防止通过 new 来创建对象——申请内存空间）
  • 类的内部创建对象
  • 向外暴露一个静态的公有方法（getInstance）

代码实现：

1
package com.yubulang.type01;
2
3
/**
4
 * 饿汉式（静态常量）
5
 */
6
public class Singleton {
7
    // 1. 私有化构造器，防止外部new创建对象
8
    private Singleton() {
9
    }
10
11
    // 2. 本类内部创建对象实例
12
    private final static Singleton instance = new Singleton();
13
14
    // 提供给一个公有的静态方法，返回实例对象
15
    public static Singleton getInstance() {
16
        return instance;
17
    }
18
}

测试代码：

1
package com.yubulang.type01;
2
3
import org.junit.Test;
4
5
public class SingletonTest {
6
    @Test
7
    public void test() {
8
        Singleton singleton01 = Singleton.getInstance();
9
        Singleton singleton02 = Singleton.getInstance();
10
        System.out.println(singleton01 == singleton02);
11
    }
12
}

优缺点说明：

优点：这个写法简单，就是在类装载的时候完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，会造成内存浪费。

这种方式基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因很多种，因此不能确定其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazyloading 的效果。

结论：这个单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

1
package com.yubulang.type02;
2
3
/**
4
 * 饿汉式（静态常量）
5
 */
6
public class Singleton {
7
    // 私有化构造器，防止外部new创建对象
8
    private Singleton() {
9
    }
10
11
    // 本类内部声明
12
    private static Singleton instance;
13
14
    static {
15
        // 在静态代码块中创建单例对象
16
        instance = new Singleton();
17
    }
18
19
    // 提供给一个公有的静态方法，返回实例对象
20
    public static Singleton getInstance() {
21
        return instance;
22
    }
23
}

优缺点说明：

  • 这种方式和上面的方式其实类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面一样。
  • 结论：这种单例模式可用，但是可能造成内存浪费。

总结

贪多嚼不烂，我们就先记住两种饿汉式写法。其主要的中心思想还是将类构造私有化，提供一个静态方法创建实例对象，利用类加载器加载时创建来达到可用的安全单例，但是容易造成内存浪费。

]]> 设计模式 设计模式 设计模式之UML类图 /2020/04/17/2020-04-17-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8BUML%E7%B1%BB%E5%9B%BE/ 前言

我们要给别人讲解一个问题的时候，最直观的方法莫过于用图形的方式去讲解，而不是枯燥的文字。毕竟我们还是个孩子的时候，图画更能给我们带来触动，而文字我们因为一些认知的问题会导致一些理解能力上的偏差。设计模式里面的UML类图就是可以让你给别人讲解设计理念的时候，不用再是枯燥的代码和文字，而是直接给别人用类图的形式来表达的一种方式。

为了方便大家了解，我会给出对应的类图，以及对应的代码实现，让大家有个初步的概念，方便大家来学习设计模式这枯燥的东西。

我们常见的几种关系：泛化（Generalization）、实现（Realization）、关联（Association）、聚合（Aggregation）、组合（Composition），依赖（Dependency）。

继承的类图

继承是我们在OOP中最常见的一种方式，让我们可以节约了不少的开发时间。继承也有一些别的文字描述方式：泛化。它是一种特殊的依赖。

继承就是指一个子类继承了另外一个的功能，并且可以增加它自己的新功能的能力。

表示方法：

​ 继承使用空心箭头 + 实线表示。

示例：

未命名文件

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\Example;
5
6
abstract class BaseExample {
7
    public abstract function method01();
8
    public abstract function method02();
9
}
10
11
class ExtendsExample extends BaseExample
12
{
13
    public function method01()
14
    {
15
        // TODO: Implement method01() method.
16
    }
17
18
    public function method02()
19
    {
20
        // TODO: Implement method02() method.
21
    }
22
23
    public function method03()
24
    {
25
26
    }
27
}

实现的类型图

实现表示一个类（class）实现interface接口（可以实现多个接口）的功能。

表示方法：

​ 使用空心三角形 + 虚线表示

示例：

我们都用过相机，有的相机只是可以拍照，但是有的相机例如拍立得，不仅可以拍照还能够打印出照片。

image-20200417202448443

代码实现：

1
<?php
2
3
namespace Neilyoz\Example;
4
5
interface Camera
6
{
7
    public function photograph();
8
}
9
10
interface Printer
11
{
12
    public function printer();
13
}
14
15
class Polaroid implements Camera, Printer
16
{
17
    public function photograph()
18
    {
19
        echo "拍照" . PHP_EOL;
20
    }
21
22
    public function printer()
23
    {
24
        echo "冲洗照片" . PHP_EOL;
25
    }
26
}

依赖的类图

介绍：

对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。

使用依赖的类作为参数传入到对应方法中即可。

表示方法：

​ 依赖关系用 虚线箭头 表示

示例：

人不管离不开空气和水对吧，我们依赖这两个东西生存，我们可以用类图来描述下。

image-20200417211623429

代码实例：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\Example;
5
6
class Oxygen
7
{
8
}
9
10
class Water
11
{
12
}
13
14
class Person
15
{
16
    public function metabolism(Oxygen $oxygen, Water $water)
17
    {
18
        // 使用 氧气 水代谢
19
    }
20
}

关联的类图

对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。

表示方法：

​ 关联关系用实现箭头表示。

示例：

我们的农作物的成熟和天气气候有关系，当一个类需要知道另一个类时，可以用关联。

image-20200417214512708
1
<?php
2
declare(strict_types=1);
3
4
class Climatic
5
{
6
    public function getCondition()
7
    {
8
        return "秋天";
9
    }
10
}
11
12
class Cropper
13
{
14
    private Climatic $climaticConditions;
15
16
    public function __construct(Climatic $climatic)
17
    {
18
        $this->climaticConditions = $climatic;
19
    }
20
21
    public function mature()
22
    {
23
        if ($this->climaticConditions->getCondition() === "秋天") {
24
            echo "成熟了" . PHP_EOL;
25
            return;
26
        }
27
28
        echo "再等等" . PHP_EOL;
29
    }
30
}

聚合的类图

表示一种弱的”拥有”关系，即 has-a 关系，体现的是 A 对象可以包含 B 对象，但 B 对象不是 A 对象的一部分（可有可无的那种）。两个对象具有各自的生命周期。

表示方法：

​ 聚合关系用 空心菱形 + 实线箭头 表示

示例：

大家都是人，是人就要混圈子，人的生命周期和圈子的生命是不一样的，有的人活100多岁，有的圈子没多久也会解散，但是圈子解散不影响人的生命。

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\Example;
5
6
class Person
7
{
8
    private float $money;
9
10
    public function collectMoney(float $money)
11
    {
12
        $this->money += $money;
13
    }
14
}
15
16
class Group
17
{
18
    private array $members = [];
19
20
    public function addMember(Person $person)
21
    {
22
        $this->members[] = $person;
23
    }
24
25
    // 分钱
26
    public function cents()
27
    {
28
        array_map(function ($person) {
29
            $person->collectMoney(rand(0, 100));
30
        }, $this->members);
31
    }
32
}

组合的类图

组合是一种强的‘拥有’关系，是一种contains-a的关系，体现了严格的部分和整体关系，部分和整体的生命周期一样。

表示方法：

​ 组合关系用 实心的菱形+实线箭头 表示，还可以使用连线两端的数字表示某一端有几个实例。

示例：

一个男人必须有个大头还必须有个小头才能算完整吧。这种就提现了我们的强拥有关系。

image-20200417221251218
1
<?php
2
declare(strict_types=1);
3
4
class BigHead
5
{
6
}
7
8
class SmallHead
9
{
10
11
}
12
13
class Man
14
{
15
    private BigHead $bigHead;
16
    private SmallHead $smallHead;
17
18
    public function __construct()
19
    {
20
        // 代码中这里是我们固定不可替换的
21
        $this->bigHead = new BigHead();
22
        $this->smallHead = new SmallHead();
23
    }
24
}

总结

其实UML类图的形式复杂起来也很复杂，但是有这些基础的构图，我们无非就是搭积木而已。Peace！！！

]]> 设计模式 设计模式 设计模式初探 /2020/04/16/2020-04-16-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E5%88%9D%E6%8E%A2/ 前言

设计模式作为一个程序员，相信大家肯定不会陌生，它是一些成熟的且通用的程序设计解决方案，针对这些肯定会存在一些理论基础，来为这些这些模式提供理论依据，这里我们就要先搞明白这些理论到底是什么，这样我们对设计模式有事半功倍的效果。

设计模式的基本原则：

  1. 单一职责原则
  2. 开闭原则
  3. 里式替换原则
  4. 依赖倒转原则
  5. 接口隔离原则
  6. 合成复用原则
  7. 迪米特法则

单一职责原则

定义：规定每个类都应该有一个单一的功能，并且该功能应该由这个类完全封装起来。

作用：它用于控制类的粒度大小

这个原则很好理解，我们的类在做某些事情的时候只专注与自己领域内的事儿就可以了，譬如我们的模型类就只针对特定模型进行操作，而不会去关心操作类里面的逻辑，这样单一的职责隔离，可以方便我们维护。

举个理想化例子：

现实生活中，我们的摄影师是什么都干的，布景、服装、灯光、拍照，可以说是累成狗。

但是在程序设计的世界里面，我们更加希望的是这样：

  • 我们的摄影师主要负责就是控制相机，指挥助手。
  • 指导助手布景，而具体的布景、服装和灯光布置可以交给我们助手。

我们用代码模拟下现实生活：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\SingleResponsibility;
5
6
class RealPhotographer
7
{
8
    private string $name;
9
10
    public function __construct(string $name)
11
    {
12
        $this->name = $name;
13
    }
14
15
    // 沟通
16
    public function communicate(): void
17
    {
18
        echo $this->name . ' 在沟通' . PHP_EOL;
19
    }
20
21
    // 布置场景
22
    public function layout()
23
    {
24
        echo $this->name . ' 在布置场景' . PHP_EOL;
25
    }
26
27
    // 搭配服装
28
    public function matchingClothing()
29
    {
30
        echo $this->name . ' 搭配衣服' . PHP_EOL;
31
    }
32
33
    // 调整灯光
34
    public function adjustTheLights()
35
    {
36
        echo $this->name . ' 调整灯光' . PHP_EOL;
37
    }
38
39
    // 控制相机
40
    public function controlCamera()
41
    {
42
        echo $this->name . ' 控制相机' . PHP_EOL;
43
    }
44
}

我们可以看到一个摄影师负责了方方面面，俗话就是管的太宽了，我们要缩小粒度，让我们的摄影师只是专注拍照的本质，所以我们可以把 布置场景 、搭配服装 、调整灯光 交给助手去完成。我们来修改下这个方法，让特定的事儿给专业的人去完成。

我们修改下这个类：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\SingleResponsibility;
5
6
// 摄影师类
7
class Photographer
8
{
9
   private string $name;
10
11
   public function __construct(string $name)
12
   {
13
       $this->name = $name;
14
   }
15
16
   // 控制相机
17
   public function controlCamera()
18
   {
19
       echo $this->name . " 操作控制相机拍照" . PHP_EOL;
20
   }
21
22
   // 指挥助手
23
   public function commandAssistant(Helper $helper)
24
   {
25
       $helper->receivedCommand();
26
       $helper->matchingClothing();
27
       $helper->adjustTheLights();
28
       $helper->layout();
29
   }
30
}
31
32
// 助手类
33
class Helper
34
{
35
   private string $name;
36
37
   public function __construct(string $name)
38
   {
39
       $this->name = $name;
40
   }
41
42
   public function receivedCommand()
43
   {
44
       echo $this->name . '收到指挥' . PHP_EOL;
45
   }
46
47
   // 布置场景
48
   public function layout()
49
   {
50
       echo $this->name . ' 在布置场景' . PHP_EOL;
51
   }
52
53
   // 搭配服装
54
   public function matchingClothing()
55
   {
56
       echo $this->name . ' 搭配衣服' . PHP_EOL;
57
   }
58
59
   // 调整灯光
60
   public function adjustTheLights()
61
   {
62
       echo $this->name . ' 调整灯光' . PHP_EOL;
63
   }
64
}

这样我们就把职责更加明确的分配了，其实程序员有时候更像是一个管理者的觉得，我们需要管理具体的类去做具体的事儿。在管理这些类的时候，我们要合理的划分这些类的职责，否则职责到后面越来越混乱，反而影响我们的管理。所以单一职责让我们能更好的控制类的粒度。

开闭原则

定义：一个软件实体应当对扩展开放，对修改关闭。

我们的软件随着时间推移是会发生一些变化的，但是已有的代码已经是稳定运行的，我们不应该去修改这些成熟的代码扩展他们的功能，除非逼不得已。所以这就考验到我们的设计水平了。

我们还是看看下面这个场景：

  • 摄影师工作时不只是只用一个牌子的相机，不同的厂商的相机，有不同的效果

我们来看看我们通常专注于实现的代码是什么样子的：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\OpenAndClose;
5
6
class Photographer
7
{
8
    private string $name;
9
10
    public function __construct(string $name)
11
    {
12
        $this->name = $name;
13
    }
14
15
    public function photograph(string $camera)
16
    {
17
        switch ($camera) {
18
            case '佳能':
19
                echo $this->name . ' 使用佳能拍' . PHP_EOL;
20
                break;
21
            case '尼康':
22
                echo $this->name . ' 使用尼康拍' . PHP_EOL;
23
                break;
24
            case '索尼':
25
                echo $this->name . ' 使用索尼拍' . PHP_EOL;
26
                break;
27
            default:
28
                echo $this->name . ' 使用手机拍' . PHP_EOL;
29
                break;
30
        }
31
    }
32
}

这里代码看着是实现了我们的需求，但是如果客户要求用 哈苏 、宾得、富士拍照呢？你是不是要去修改 photograph 这个方法。这样就违背了我们的开闭原则。那我们要怎么才能不修改代码的情况下，去完成我们的进击的需求呢？我们可以这样改：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\OpenAndClose;
5
6
interface Camera
7
{
8
    function photograph(): string;
9
}
10
11
class CannonCamera implements Camera
12
{
13
    public function photograph(): string
14
    {
15
        return ' 使用佳能拍' . PHP_EOL;
16
    }
17
}
18
19
class NikonCamera implements Camera
20
{
21
    public function photograph(): string
22
    {
23
        return ' 使用尼康拍' . PHP_EOL;
24
    }
25
}
26
27
class SonyCamera implements Camera
28
{
29
    public function photograph(): string
30
    {
31
        return ' 使用索尼拍' . PHP_EOL;
32
    }
33
}
34
35
class FujiCamera implements Camera
36
{
37
    public function photograph(): string
38
    {
39
        return ' 使用富士拍' . PHP_EOL;
40
    }
41
}
42
43
class Photographer
44
{
45
    private string $name;
46
47
    public function __construct(string $name)
48
    {
49
        $this->name = $name;
50
    }
51
52
    public function photograph(Camera $camera): void
53
    {
54
        echo $this->name . $camera->photograph();
55
    }
56
}
57
58
$photographer = new Photographer("鱼不浪");
59
$photographer->photograph(new CannonCamera());
60
$photographer->photograph(new NikonCamera());
61
$photographer->photograph(new SonyCamera());
62
$photographer->photograph(new FujiCamera());

我们可以使用接口把相机的拍照功能抽象出来，这样即使是有新的相机进来，我们无非就是实现这个接口就能达到扩展的目的，而不需要去修改我们的现有代码。

里式替换原则

定义：所有引用基类的地方必须透明地使用其子类的对象。

使用里式替换原则时需要注意如下：

  • 子类的所有方法必须在父类中声明，或子类必须实现父类中声明的所有方法。根据里氏代换原则，为了保证系统的扩展性，在程序中通常使用父类来进行定义，如果一个方法只存在子类中，在父类中不提供相应的声明，则无法在以父类定义的对象中使用该方法。
  • 我们在运用里氏代换原则时，尽量把父类设计为抽象类或者接口，让子类继承父类或实现父接口，并实现在父类中声明的方法，运行时，子类实例替换父类实例，我们可以很方便地扩展系统的功能，同时无须修改原有子类的代码，增加新的功能可以通过增加一个新的子类来实现。里氏代换原则是开闭原则的具体实现手段之一。

其实还是一个抽象的概念，我们还是拿摄影师来说：

  • 摄影师拿相机，至于什么牌子的相机我们不管，我们只是抽象相机这个概念
1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\Liskv;
5
6
abstract class Camera
7
{
8
    public function open()
9
    {
10
        echo "相机开机" . PHP_EOL;
11
    }
12
13
    public abstract function screen(): void;
14
}
15
16
class CannonCamera extends Camera
17
{
18
    public function screen(): void
19
    {
20
        echo "佳能拍照" . PHP_EOL;
21
    }
22
}
23
24
class NikonCamera extends Camera
25
{
26
    public function screen(): void
27
    {
28
        echo "尼康拍照" . PHP_EOL;
29
    }
30
}
31
32
class Photographer
33
{
34
    /**
35
     * 这里参数是父类，我们可以传入子类
36
     * @param Camera $camera
37
     */
38
    public function screen(Camera $camera)
39
    {
40
        $camera->open();
41
        $camera->screen();
42
    }
43
}
44
45
$photographer = new Photographer();
46
$photographer->screen(new CannonCamera());
47
$photographer->screen(new NikonCamera());

依赖倒转原则

定义：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。

这个我们在开闭原则中已经给出了实例，我们就是针对上层抽象进行的编程。

我们来看看常用的三种注入方式：

  • 构造注入
  • 设值注入
  • 接口传递注入

我们挨个看，为了省事儿我就只用一个类来演示：

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\Dependency;
5
6
interface Camera
7
{
8
    public function open(): void;
9
10
    public function screen(): void;
11
}
12
13
// 实现相机接口
14
class CannonCamera implements Camera
15
{
16
    public function open(): void
17
    {
18
        echo "打开佳能相机" . PHP_EOL;
19
    }
20
21
    public function screen(): void
22
    {
23
        echo "佳能相机拍照" . PHP_EOL;
24
    }
25
}
26
27
// 实现相机接口
28
class NikonCamera implements Camera
29
{
30
    public function open(): void
31
    {
32
        echo "打开尼康相机" . PHP_EOL;
33
    }
34
35
    public function screen(): void
36
    {
37
        echo "尼康相机拍照" . PHP_EOL;
38
    }
39
}
40
41
class Photographer
42
{
43
    private Camera $camera;
44
45
    // 使用构造注入
46
    public function __construct(Camera $camera)
47
    {
48
        $this->camera = $camera;
49
    }
50
51
    /**
52
     * 使用设值注入
53
     * @param Camera $camera
54
     */
55
    public function setCamera(Camera $camera): void
56
    {
57
        $this->camera = $camera;
58
    }
59
60
    /**
61
     * 使用接口传递注入
62
     * @param Camera $camera
63
     */
64
    public function open(Camera $camera): void
65
    {
66
        $camera->open();
67
    }
68
69
    public function screen()
70
    {
71
        $this->open($this->camera);
72
        $this->camera->screen();
73
    }
74
}
75
76
// 我们摄影师本来有自己佳能相机
77
$photographer = new Photographer(new CannonCamera());
78
// 并用它进行拍照
79
$photographer->screen();
80
81
// 朋友带着尼康相机来了，他拿朋友的尼康相机来玩儿
82
$photographer->setCamera(new NikonCamera());
83
$photographer->screen();

接口隔离原则

定义：

  • 客户端不应该依赖它不需要的接口。
  • 类间的依赖关系应该建立在最小的接口上。

我们通过上面的例子，发现接口真的是一个好东西，可以让我们解耦很多我们的程序。

还是摄影师的例子，不同摄影师有不同的行为，我们不排除有的摄影师啥都 OK，有的摄影师也缺乏一些能力。

  • 摄影师可以拍摄表达作品想法
  • 摄影师也要和客户沟通，但有的摄影师只是工具人，不需要沟通
  • 有的摄影师自己重洗胶片，有的直接用数码

对于这些接口我们的摄影师不用都实现，实现自己需要的接口就好了。

1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\InterfaceSegregation;
5
6
interface Screen
7
{
8
    public function screen();
9
}
10
11
interface Communicate
12
{
13
    public function communicate();
14
}
15
16
interface RinseTheFilm
17
{
18
    public function rinseTheFilm();
19
}
20
21
class PhotographerOne implements Screen, Communicate
22
{
23
    public function screen()
24
    {
25
        echo "PhotographerOne 拍照" . PHP_EOL;
26
    }
27
28
    public function communicate()
29
    {
30
        echo "PhotographerOne 沟通" . PHP_EOL;
31
    }
32
}
33
34
class PhotographerTwo implements Screen, Communicate, RinseTheFilm
35
{
36
    public function screen()
37
    {
38
        echo "PhotographerTwo 拍照" . PHP_EOL;
39
    }
40
41
    public function communicate()
42
    {
43
        echo "PhotographerTwo 沟通" . PHP_EOL;
44
    }
45
46
    public function rinseTheFilm()
47
    {
48
        echo "PhotographerTwo 冲洗照片了" . PHP_EOL;
49
    }
50
}

合成复用原则

定义：尽量使用合成、聚合的方式，而不是使用继承

这里有很多种情况，还是用代码来举例说明，我们在有时候在开发中，有时候类可能会用到别的类的方法，我们可以有继承，依赖，聚合，组合的关系。继承会导致我们的程序耦合度过高，所以我们会选择另外的三种方式：

  • 依赖
1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\Composite;
5
6
class CompositeParent
7
{
8
    public function method1()
9
    {
10
        echo "方法1" . PHP_EOL;
11
    }
12
13
    public function method2()
14
    {
15
        echo "方法2" . PHP_EOL;
16
    }
17
18
    public function method3()
19
    {
20
        echo "方法3" . PHP_EOL;
21
    }
22
}
23
24
class CompositeChild
25
{
26
    public function method1(CompositeParent $compositeParent)
27
    {
28
        $compositeParent->method1();
29
    }
30
}
  • 聚合
1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\Composite;
5
6
class CompositeParent
7
{
8
    public function method1()
9
    {
10
        echo "方法1" . PHP_EOL;
11
    }
12
13
    public function method2()
14
    {
15
        echo "方法2" . PHP_EOL;
16
    }
17
18
    public function method3()
19
    {
20
        echo "方法3" . PHP_EOL;
21
    }
22
}
23
24
class CompositeChild
25
{
26
    private CompositeParent $compositeParent;
27
28
    public function setCompositeParent(CompositeParent $compositeParent): void
29
    {
30
        $this->compositeParent = $compositeParent;
31
    }
32
}
  • 组合
1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\Composite;
5
6
class CompositeParent
7
{
8
    public function method1()
9
    {
10
        echo "方法1" . PHP_EOL;
11
    }
12
13
    public function method2()
14
    {
15
        echo "方法2" . PHP_EOL;
16
    }
17
18
    public function method3()
19
    {
20
        echo "方法3" . PHP_EOL;
21
    }
22
}
23
24
class CompositeChild
25
{
26
    private CompositeParent $compositeParent;
27
28
    public function __construct()
29
    {
30
        $this->compositeParent = new CompositeParent();
31
    }
32
}

迪米特法则

定义：

  • 一个对象应该对其他对象保持最少的了解
  • 类与类关系越密切，耦合度越大
  • 一个类对自己依赖的类知道的越少越好，对于被依赖的类不管多复杂，都尽量将逻辑封装在内部。对外部除了提供 public 方法，不要透露任何信息
  • 只与直接的朋友通信
  • 直接朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、聚合等。其中我们称出现成员变量，方法参数，方法返回值中的类为直接朋友，而局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。
1
<?php
2
declare(strict_types=1);
3
4
namespace Neilyoz\DesignPatternBase\LawOfDemeter;
5
6
use phpDocumentor\Reflection\Types\This;
7
8
class Student
9
{
10
11
}
12
13
class Police
14
{
15
16
}
17
18
class LawOfDemeter
19
{
20
    // 直接朋友
21
    private Student $student;
22
23
    public function getStudent(): Student
24
    {
25
        return $this->student;
26
    }
27
28
    public function setStudent(Student $student): void
29
    {
30
        $this->student = $student;
31
    }
32
33
    public function doSomething()
34
    {
35
        // 非直接朋友
36
        $police = new Police();
37
    }
38
}

总结

根据这些基本的原则去理解设计模式，感觉不会太困难，当然会 UML 类图就最好了。

]]> 设计模式 设计模式 Redis 持久化 /2020/04/15/2020-04-15-Redis-%E6%8C%81%E4%B9%85%E5%8C%96/ 前言

相比 Memcache 而言，Redis 可以把数据持久化到我们的磁盘上。来保证缓存的数据不会应为断电而丢失。

简介

数据存放于：

  • 内存：高效、断电（关机）内存数据会丢失
  • 硬盘：读写速度慢于内存，断电数据不会丢失

Redis 持久化存储支持两种方式：RDB 和 AOF。

  • RDB 一定时间存储文件
  • AOF 默认每秒存储历史命令

Redis 支持持久化的内存数据库，也就是Redis需要经营将内存中的数据同步到硬盘来保证持久化。

RDB

RDB 是 redis database 缩写。是Redis的默认持久化机制。

功能核心函数 dbSave （生成RDB文件）和 rdbLoad（从文件加载内存）两个函数。

快照是默认持久化方式。这种方式就是将内存中数据以快照的方式写入到二进制文件中，默认的文件名为 dump.rdb

优点：

  • 快照保存数据极快、还原数据快
  • 适用于灾难备份

缺点：

  • 小内存机器不适合使用，RDB机制符合要求就会照快照

快照条件：

1
1. 服务器正常关闭时  redis-cli shutdown
2
2. key满足一定条件，会进行快照
3
redis.conf
4
save 900 1    # 每900秒（15分钟）至少1个key发生变化，产生快照
5
save 300 10   # 每300秒（5分钟）至少10个key发生变化，产生快照
6
save 60 10000 # 每60秒（1分钟）至少10000个key发生变化，产生快照

AOF

由于快照方式实在一定间隔时间做一次，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改。如果应用要求不能丢失任何修改的话，可以采用aof持久化方式。

Append-only file：aof比快照方式有更好的持久化性，是由于在使用aof持久化方式时，redis会将每一个收到的写命令都通过write函数追加到文件中（默认是appendonly.aof）。当redis重启时会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。

每当执行服务器（定时）任务或者函数时flushAppendOnlyFile函数都会被调用，这个函数执行以下两个工作aof写入保存：

  • WRITE：根据条件，将aof_buf中的缓存写入到AOF文件中
  • SAVE：根据条件，调用fsync或fdatasync函数，将AOF文件保存到磁盘中

有三种方式如下（默认是：每秒fsync一次）

  • appendonly yes 启用aof持久化模式
  • appendfsync <parameter>
    • always 收到写命令就立刻写入磁盘，最慢，但保证完全的持久化
    • everysec 每秒钟写入磁盘一次，在性能和持久化方面做了很好的折中
    • no 完全依赖os，性能最好，持久化没保证

产生的问题：

aof的方式也同时带来了另一个问题。持久化文件会变得越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。

总结

开启配置之后，我们已经拥有了比较健全的持久化方案了。具体的调整还是要看具体的业务需求了。

]]> Redis Redis Redis 事务了解一下 /2020/04/14/2020-04-14-Redis-%E4%BA%8B%E5%8A%A1%E4%BA%86%E8%A7%A3%E4%B8%80%E4%B8%8B/ 前言

和MySQL一样，我们的Redis也支持事务操作，事务操作可以执行多个命令（按顺序串行化执行，执行中不会被其他命令插入）。

Redis事务

Redis事务可以一次执行多个命令（允许在一次单独的步骤中执行一组命令），并且带有以下两个重要保证：

  1. Redis 会将一个事务中的所有命令序列化，然后按排序执行
  2. 执行中不会被其他命令插入，不许出现加塞现象

常用命令

1
# 取消事务，放弃执行事务块内的所有命令
2
DISCARD
3
4
# 执行所有事务内的命令
5
EXEC
6
7
# 标记一个事务块的开始
8
MULTI
9
10
# 取消 WATCH 命令对所有 key 的监视
11
UNWATCH
12
13
# 监视一个（或多个）key，如果在事务执行之前这个（或这些）key 被其他命令所改动，那么事务将被打断
14
WATCH key [key1 ...]

事务的执行过程

一个事务从开始到执行会经历以下三个阶段：

  • 开始事务
  • 命令入队
  • 执行事务

注意

  • 批量操作在发送 EXEC 命令前被放入队列缓存。
  • 收到 EXEC 命令之后，进入事务执行，事务中任意命令执行失败，其余的命令依然被执行，不支持回滚。
  • 收到 EXEC 命令之后，事务中存在未知命令，事务会被整个放弃。
  • 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

Watch 示例

我们在操作事务的时候，有可能存在对同一个key进行操作的时候，如果在事务提交之前，修改了对应的 key 就会导致一些数据错误，正确的做法就是要Watch这个值是否存在。

举个例子：

1
# 客户端1
2
WATCH account:Jack
3
4
MULTI
5
6
SET account:Jack 100
7
8
INCR account:Jack 100
9
10
EXEC

此时我们输入 EXEC 但是不敲下回车，切换到我们的客户端2

1
# 客户端2，我们客户端1的事务并没有提交，此时我们修改下 account:Jack
2
SET account:Jack 1000

我们先执行客户端2的数据，我们再去 客户端1 敲击回车，我们会发现我擦事务执行失败了。哈哈哈

应用场景

一组命令必须同时都执行，或者都不执行，我们想要保证一组命令在执行的过程中不被其他命令插入。

总结

总的来说Redis的事务不是很难理解，使用多几次就知道怎么玩儿了。

]]> Redis Redis Redis 常用命令及类型 /2020/04/13/2020-04-13-Redis-%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4%E5%8F%8A%E7%B1%BB%E5%9E%8B/ 前言

听说过二八定律的应该知道，我们百分之二十的东西是支撑着百分之八十的运作的。所以我们了解和学习一个东西一开始不需要事无巨细的每个都精通，可以优先了解 20%常用的，然后再去根据具体的需要了解剩下的 80%。毕竟时间有限，那么多业务要写。

常用的 Redis 命令

命令描述
keys *返回满足的所有键，可以模糊匹配，比如 keys abc* 代表 abc 开头的 key
type key查看 key 对应的数据类型
exists key是否存在指定的 key，存在返回 1，不存在返回 0
expire key second设置某个 key 的过期时间 时间为秒
del key删除某个 key
ttl key查看剩余时间，当 key 不存在时返回-2；存在但没有设置剩余生存时间时返回-1，返回 key 的剩余生存时间
persist key取消过期时间
pexpire key ms修改 key 的过期时间为毫秒
select选择数据库 0-15，默认为 16 个数据库
move key dbindex将当前数据中的 key 转移到其他数据库
randomkey随机返回一个 key
rename key key1重命名 key
echo打印命令
dbsize查看数据库 key 数量
info查看数据库信息
config get *实时传储收到的请求，返回相关的配置
flushdb清空当前数据库
flushall清空所有数据库

expire 使用场景

  • 限时的优惠活动信息
  • 网站数据缓存（对于一些需要定时更新的数据，例如积分排行榜）
  • 手机验证码
  • 限制网站访客访问频率（例如：一秒钟最多 10 次）

key的命名建议

redis单个key允许存入512M大小

  • key不要太长，尽量不要超过1024字节，消耗内存会降低查找的效率
  • key也不要太短，太短的话，key的可读性降低
  • 在一个项目中，key最好使用同一的命名规范，例如：user:id:name
  • key名称不区分大小写

Redis数据类型

String类型

string类型是Redis最基本的数据类型，一个键最大能存储512mb

string数据结构是简单的key-value类型，value其不仅是string，也可以是数字，是包含很多类型的特殊类型。

string类型是二进制安全的。意思是redis的string可以包含任何数据。比如序列化的对象进行存储，比如一张图片进行二进制存储，比如一个简单的字符串，数值等等。

String命令

赋值语法：

1
# Redis SET命令用于设置给定 key 的值，如果key已经存储值，set会复写旧值，且无视类型
2
SET KEY_NAME VALUE 
3
4
# 如果key不存在，则设值并返回1；如果key存在，则不设值并返回0
5
# 解决分布式锁 方案一，只有在key不存在时设置 key 的值，setnx(set if not exists)命令
6
# 指定的key不存在时，才会为key设置指定的值
7
SETNX key value
8
9
# expired 设置key的值为1x，过期时间为10秒，十秒后键值被清理
10
SETNX key 10 1x
11
12
# 给指定的 key 对应的值追加 value 至末尾，如果不存在，为其赋值
13
APPEND key_name value

取值语法：

1
# Redis GET命令用于获取指定 key 的值
2
# 如果key不存在，返回nil
3
# 如果key储存的值不是字符串类型，返回一个错误
4
GET key_name
5
6
# 用于获取存储在指定 key 中字符串的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定
7
GETRANGE key start end
8
9
# 对key所储存的字符串值，获取指定偏移量上的位(bit)
10
GETBIT key offset
11
12
# Getset 命令用于设置指定 key 的值，并返回 key 的旧值，当key不存在时，返回nil
13
# 先取值后赋值操作（先取出旧的值，再修改新的值），当key不存在返回nil
14
GETSET key_name value
15
16
# 返回 key 所存储字符串的长度
17
STRLEN key

批量语法：

1
# 批量写，一次性写入多个值
2
MSET key1 value1 key2 value2...
3
4
# 批量读，一次性读取多个值
5
MGET key1 key2 key3...

删值语法：

1
# 删除指定的key，如果存在，返回值数字类型。
2
DEL key_name

自增/自减（value必须是数字类型哟，否则报错）：

1
# INCR 命令将 key 中存储的数字值增1。如果key不存在，那么key的值会先初始化位0，
2
# 然后再执行 INCR 操作
3
INCR key_name
4
5
# 给指定的 key 加上指定大小的增量
6
INCRBY key_name 增量值
7
8
# DECR 命令将 key 中存储的数字值减1。如果key不存在，那么key的值会先初始化位0，
9
# 然后再执行 DECR 操作
10
DECR key_name
11
12
# 给指定的 key 减去指定大小的减值
13
DECRBY key_name

应用场景

  • string通常用于保存单个字符串或JSON字符串数据
  • string是二进制安全的，可以把一个图片文件作为字符串储存
  • 计数器（常规key-value缓存应用，常规技术：粉丝数，文章浏览量）

Hash类型

Hash类型是String类型的field和value的映射表，或者说是string的集合。Hash特别适合存储对象，相比较而言，将一个对象类型存储在Hash类型要存储在String类型里占用更少的内存空间，并对整个对象存取。

可以看成具有key和value的map容器，该类型非常适合存储键值对象的信息。

如：uname,upass,age等。该类型的数据仅占用很少的磁盘空间（相比于json）

Redis中每个Hash可以存储2^32 - 1键值对（40多亿）

常用命令

1
赋值语句：
2
# 指定的key，设定 field value
3
HSET key field value
4
5
# 同时将多个field-value(域-值)对设置到哈希表 key 中
6
HMSET key field value [field1 value1]...
7
8
9
取值语句：
10
# 获取存储在Hash中的值，根据field 获取 value
11
HGET key field
12
13
# 获取 key 所有给定字段的 value
14
HMGET key field [field1]
15
16
# 返回Hash表中所有的字段和值
17
HGETALL key
18
19
# 获取所有哈希表中的字段
20
HKEYS key
21
22
# 获取哈希表中字段的数量
23
HLEN key
24
25
26
删除语法：
27
# 删除一个或多个hash表字段
28
HDEL key field [field2]
29
30
31
其它语法：
32
# 只有在字段 field 不存在时，设置哈希表字段的值
33
HSETNX key field value
34
35
# 为哈希表 key 中的指定字段的整数值加上增量 increment
36
HINCRBY key field increment
37
38
# 为哈希表 key 中的指定字段的浮点数值加上增量 increment
39
HINCRBYFLOAT key field increment
40
41
# 查看哈希表 key 中，指定的字段是否存在
42
HEXISTS key field

应用场景

Hash的应用场景：（存储一个用户信息对象数据）

  • 常用于存储一个对象

Hash时最接近数据库结构的数据类型，可以将数据库一条记录或程序中一个对象转换成hashmap存放在redis中。

用户ID为查找的key，存储的value用户对象包含姓名、年龄、生日等信息，如果用普通的key/value结构来存储，主要以下两种存储方式：

  1. 将用户id作为查找key，把其他信息封装成一个对象以序列的方式存储，这种方式缺点是，增加了序列化/反序列化的开销，并且需要修改其中一项信息时，需要把整个对象取回，并修改操作需要对并发进行保护，引入CAS等复杂问题
  2. 这个用户信息对象由多少成员就存储多少个key-value对，用户id+对应的名称作为唯一标识来取得对应属性的值，虽然省去序列化开销和并发问题，但是用户ID为重复存储，如果存在大量这样的数据，内存浪费还是非常可观的。

List 类型

List类型是一个链表结构的集合，其主要功能有push、pop、获取元素等。更详细的说，List类型是一个双端链表的节后，我们可以通过相关操作进行集合的头部或者尾部添加和删除元素，List的设计非常简单精巧，及可以作为栈，也可以作为队列，满足绝大多数的需求。

按照插入顺序排序，你可以添加一个元素到列表头部或者尾部，一个列表最多可以包含 2^32-1 个元素（40忆个元素）类似Java中的LinkedList

常用命令

赋值语法：

1
# 将一个或多个值插入到列表头部(从左侧添加)
2
LPUSH key value1 [value2]
3
4
# 在列表中添加一个或多个值（从右侧添加）
5
RPUSH key value1 [value2]
6
7
# 将一个值插入到已存在的列表头部。如果列表不存在，操作无效
8
LPUSHX key value
9
10
# 一个值插入已存在的列表尾部（最右边）。如果列表不在，操作无效
11
RPUSHX key value

取值操作：

1
# 获取列表长度
2
LLEN key
3
4
# 通过索引获取列表中的元素
5
LINDEX key index
6
7
# 获取列表指定范围的元素
8
LRANGE key start end

描述：返回列表中指定区间内的元素，区间以偏移量start和end指定。

其中0表示列表第一个元素，1表示第二个元素，以此类推

也可以负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推

删除操作：

1
# 移出并获取列表的第一个元素（从左侧删除）
2
LPOP key
3
4
# 移出列表的最后一个元素，返回值为移除的元素（从右侧删除）
5
RPOP key
6
7
# 移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
8
BLPOP key1 [key2] timeout
9
10
# 移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
11
BRPOP key1 [key2] timeout
12
13
# 对一个列表进行裁剪（trim），就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
14
LTRIM key start stop

修改操作：

1
# 通过索引设置列表元素的值
2
LSET key index value
3
4
# 在列表的元素前或者后插入元素
5
# 将值 value 插入到列表 key 当中，位于值 world 之前或之后
6
LINSERT key BEFORE|AFTER world value

高级命令

高级语法：

1
# 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
2
RPOPLPUSH source destination
3
4
# 示例描述：
5
# a1的最后元素移到a2的左侧
6
RPOPLPUSH a1 a2 
7
8
# 循环列表，将最后元素移到最左侧
9
RPOPLPUSH a1 a1
10
11
# 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它；如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
12
BRPOPLPUSH source destination timeout

应用场景

项目常用：

  1. 对数据大的集合数据删减

    列表数据显示、关注列表、粉丝列表、留言评论、分页、热点新闻（top5）等

    利用LRANGE还可以很方便的实现分页的功能，在博客系统中，每篇博文的评论也可以存入一个单独的list中

  2. 任务队列

    List通常用来实现一个消息队列，而且可以确保先后顺序，不必像MySQL那样还要通过ORDER BY进行排序

任务队列介绍（生产者和消费者模式）：

在处理web客户端发送的命令请求，某些操作的执行时间会比我们预期的更长一些，通过将等待执行任务的相关信息放入队列里面，并在之后对队列进行处理，用户可以推迟执行那些需要一段时间才能完成的操作，这种将工作交给任务处理器来执行的做法被称为任务队列(Task Queue)

Set类型

Redis的Set是String类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复数据。Redis中集合是通过哈希表实现的，set是通过hashtable实现的。

集合中最大的成员数为 2^32 - 1 （40多亿个成员），类似于Java中的HashTable集合

常用命令

赋值语法：

1
# 向集合添加一个或多个成员
2
SADD key member1 [member2]

取值语法：

1
# 获取集合的成员数
2
SCARD key
3
4
# 返回集合中的所有成员
5
SMEMBERS key
6
7
# 判断 member 元素是否是集合 key 的成员
8
SISMEMBER key member
9
10
# 返回集合中一个或多个随机数
11
SRANDMEMBER key [count]

删除语法：

1
# 移除集合中一个或多个成员
2
SREM key member1 [member2]
3
4
# 移除并返回集合中的一个随机元素
5
SPOP key [count]
6
7
# 将 member 元素从 source 集合移动到 destination 集合
8
SMOVE source destination member

差集语法：

1
# 返回给点所有集合的差值（左侧）
2
SDIFF key1 key2
3
4
# 返回给定所有集合的差集并存储在 destination 中
5
SDIFFSTORE destination key1 [key2]

交集语法：

1
# 返回给定所有集合的交集（所有元素）
2
SINTER key1 [key2]
3
4
# 返回给定所有集合的交集并存储在 destination 中
5
SINTERSTORE destination key1 [key2]

并集语法：

1
# 返回所有给定集合的并集
2
SUNION key1 [key2]
3
4
# 所有给定集合的并集存储在 destination 中
5
SUNIONSTORE destination key1 [key2]

应用场景

常应用于：对两个集合间的数据计算进行交集、并集、差集计算

  1. 利用集合操作，可以取不同兴趣圈子的交集，以非常方便的实现如共同关注，共同喜好，二度好友等功能。对上面的所有集合操作，你还可以使用不同的命令选择结果返回给客户端还是存储到一个新的集合中。
  2. 利用唯一性，可以统计访问网站的所有独立ip、存取当天[某天]的活跃用户列表

ZSet类型

有序集合（sorted set）

  • Redis有序集合和集合一样也是string类型元素的集合，且不允许重复的成员
  • 不同的是每个元素都会关联一个double类型的分数，redis正是通过分数来为集合中的成员进行从小到大的排序
  • 有序集合的成员是唯一的，但（score）却可以重复
  • 集合是通过哈希实现的。集合最大的成员数为2^32 - 1（每个集合可存放40亿个成员）。

常用命令

赋值语法：

1
# 向有序集合添加一个或多个成员，或者更新已存在成员的分数
2
ZADD key score1 member1 [score2 member2]

取值语法：

1
# 获取有序集合的成员数
2
ZCARD key
3
4
# 计算在有序集合中指定区间分数的成员
5
ZCOUNT key min max
6
7
# 返回有序集合中指定成员的索引
8
ZRANGE key member
9
10
# 通过索引区间返回有序集合指定区间内的成员（低到高）
11
ZRANGE key start stop [WITHSCORES]
12
13
# 通过分数返回有序集合指定区间内的成员
14
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]
15
16
# 返回有序集合中指定区间内的成员，通过索引、分数从高到低
17
ZREVRANGE key start stop [WITHSCORES]
18
19
# 返回有序集合中指定分数分区区间内的成员，分数从高到低排序
20
ZREVRANGESCORE key max min [WITHSCORES]

删除语法：

1
# 删除集合
2
DEL key
3
4
# 移除有序集合中的一个或多个成员
5
ZREM key member [member1 ...]
6
7
# 移除有序集合中给定的排名区间的所有成员（第一名是0）（低到高排序）
8
ZREMRANGEBYRANK key start stop
9
10
# 移除有序集合中给定的分数区间的所有成员
11
ZREMRANGEBYSCORE key min max
12
13
# 增加 member 元素的分数 increment，返回值是更改后的分数
14
ZINCRBY key increment member

应用场景

销售排行，积分排行

  • Twitter 的 public timeline 可以以发表时间作为 score 来储存，这样获取时就是自动按时间排好序的
  • 一个存储全班同学成绩的 sorted set，其集合 value 可以是同学的学号，而 score 就可以是其考的分数，这样在数据插入集合的时候，就已经进行了天然的排序。
  • 用sorted set来做带权重的队列，普通消息的score 为1，重要消息的score为2，然后工作线程可以选择score的倒序来获取工作任务。让重要的任务优先执行。

Hyperloglog类型

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

什么是基数?

比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

常用命令

赋值语法：

1
# 添加指定元素到 HyperLogLog 中
2
PFADD key element [element ...]
3
4
# 将多个 HyperLogLog 合并为一个 HyperLogLog
5
PFMERGE destkey sourcekey [sourcekey ...]

取值语法:

1
# 返回给定 HyperLogLog 的基数估算值。
2
PFCOUNT key [key ...]

应用场景

基数不大，数据量不大就用不上，会有点大材小用浪费空间

有局限性，就只是统计基数数量，而没办法去知道具体的内容是什么

  • 统计注册IP数
  • 统计每日访问IP数
  • 统计页面实时UV数
  • 统计在线用户数
  • 统计用户每天搜索不同词条的个数
  • 统计真实文章阅读数

总结

掌握这些基本的redis操作已经是不在话下，当然具体怎么用用哪个类型还是要大家多多动手实践。

]]> Redis Redis Redis配置详解 /2020/04/13/2020-04-13-Redis%E9%85%8D%E7%BD%AE%E8%AF%A6%E8%A7%A3/ 前言

配置服务搭建环境也是我们开发人员的一种工作。好在Redis的配置不难，可以说简单的很。我们也需要看看了解一下每个配置的作用就能轻松搞定。

  1. Redis 默认不是以守护进程的方式运行，可以通过该配置项修改，使用 yes 启用保护进程

    1
    daemonize no

  2. 当 Redis 以守护进程方式运行时，Redis 默认会把 pid 写入/var/run/redis.pid 文件，可以通过 pidfile 指定

    1
    pidfile /var/run/redis.pid

  3. 指定 Redis 监听端口，默认端口为 6379

    1
    port 6379

  4. 绑定的主机地址

    1
    bind 127.0.0.1

  5. 当客户闲置多长时间之后关闭连接，如果指定为 0，表示关闭该功能

    1
    timeout 300

  6. 指定日志记录级别，Redis 总共支持四个级别：debug、verbose、notice、warning，默认为 verbose

    1
    loglevel verbose

  7. 日志记录方式，默认为标准输出，如果配置 Redis 为守护进程方式运行，而这里又配置为日志记录方式为标准日志将会发送给/dev/null

    1
    logfile stdout

  8. 设置数据库的数量，默认数据库为 0，可以使用 select <dbid>命令在连接上指定数据库 id

    1
    database 16

  9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合

    1
    save <second> <changes>
    2
    Redis 默认配置文件中提供三个条件：
    3
    save 900 1    # 900秒内有1一个修改
    4
    save 300 10   # 300秒内10个修改
    5
    save 60 10000 # 60秒内有10000个修改

  10. 指定存储至本地数据时是否压缩数据，默认为 yes，Redis 采用 ZF（压缩算法）压缩，如果为了节省 CPU 时间，可以关闭该选项，但会导致数据库文件变得巨大

    1
    rdbcompression yes

  11. 指定本地数据库文件名，默认为 dump.rdb

    1
    dbfilename dump.rdb

  12. 指定本地数据库存放目录

    1
    dir ./

  13. 设置当本机为 slave 服务时，设置 master 服务的 IP 地址及端口，在 Redis 启动时，它会自动从 master 进行数据同步

    1
    slaveof <masterip> <masterport>

  14. 当 master 服务设置了密码保护时，slave 服务连接 master 的密码

    1
    masterauth <master-password>

  15. 设置 Redis 连接密码，如果配置了连接密码，客户端在连接 Redis 时需要通过 auth <password> 命令提供密码，默认关闭

    1
    requirepass <password>

  16. 设置同一时间最大客户端连接数，默认无限制，Redis 可以同时打开的客户端连接数为 Redis 进程可以打开的最大文件描述，如果设置 maxclients 0，表示不做限制。当客户端连接数到达限制时，Redis 会关闭新的连接并向客户端返回 max number of clients reached 错误信息

    1
    maxclients 128

  17. 指定 Redis 最大内存限制，Redis 在启动时会把数据加载内存中，达到最大内存后，Redis 会先尝试清除已到期或即将到期的 key，当此方法处理后，仍然到达最大内存设置，将无法进行写入操作，但仍然可以进行读取操作，Redis 新的 vm 机制，会把 key 存放内存，value 会存放 swap 区

    1
    maxmemory <bytes>

  18. 指定是否在每次更新操作后进行日志记录，Redis 在默认情况下时异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失，因为 Redis 本身同步数据文件时按上面 save 条件来同步的，所以有的数据会在一段时间内只存在于内存中，默认为 no

    1
    appendonly no

  19. 指定更新日志文件名，默认为 appendonly.aof

    1
    appendfilename appendonly.aof

  20. 指定更新日志条件，共有三个可选值：

    • no：表示等操作系统进行数据缓存同步到磁盘（快）
    • always：表示每次更新操作后动手调用 fsync()将数据写到磁盘(慢，安全)
    • everysec：表示每秒同步一次（折中，默认值）
    1
    appendfsync everysec

  21. 指定是否启用虚拟内存机制，默认值为 no， 简单的介绍一下，VM 机制将数据分页存放，由 Redis 将访问量较少的页面及冷数据 swap 到磁盘上，访问多的页面由磁盘自动换出到内存中

    1
    vm-enabled no

  22. 虚拟内存文件路径，默认值为 /tmp/redis.swap，不可多个 Redis 实例共享

    1
    vm-swap-file /tmp/redis.swap

  23. 将所有大于 vm-max-memory 的数据存入虚拟内存，无论 vm-max-memory 设置多小，所有索引数据都是内存存储的（Redis 的索引数据 就是 keys），也就是说，当 vm-max-memory 设置为 0 的时候，其实所有 value 都存在于磁盘，默认为 0

    1
    vm-max-memory 0

  24. Redis swap 文件分成了很多的 page，一个对象可以保存在多个 page 上面，但一个 page 不能被多个对象共享，vm-page-size 是要根据存储的数据大小来设定的，作者建议如果存储很多小对象，page 大小最好设置为 32 或者 64bytes；如果存储很大大对象，则可以使用更大的 page，如果不确定，就使用默认值

    1
    vm-page-size 32

  25. 设置 swap 文件中的 page 数量，由于页表（一种表示页面空闲或使用的 bitmap）是在放在内存中的，在磁盘上每 8 个 pages 将消耗 1byte 的内存。

    1
    vm-pages 134217728

  26. 设置访问 swap 文件的线程数，最好不要超过机器的核数，如果设置为 0，那么所有对 swap 文件的操作都是串行的，可能会造成比较长时间的延迟，默认为 4

    1
    vm-max-threads 4

  27. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认开启

    1
    glueoutputbuf yes

  28. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法

    1
    hash-max-zipmap-entries 64
    2
    hash-max-zipmap-value 512

  29. 指定是否激活重置哈希，默认为开启

    1
    activerehashing yes

  30. 指定包含其他的配置文件，可以在同一主机上多个 Redis 实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件

    1
    include /path/to/local.conf

总结

随着版本的更新，肯定会有新的配置。不着急了有了这些配置选项，新的也只是小菜。

]]> Redis Redis Laravel Eloquent 模型关联关系（二） /2020/04/11/2020-04-11-Laravel-Eloquent-%E6%A8%A1%E5%9E%8B%E5%85%B3%E8%81%94%E5%85%B3%E7%B3%BB%EF%BC%88%E4%BA%8C%EF%BC%89/ 前言

前面我们已经演示了一对一，一对多，多对多的关系这三种是日常工作中很常见的关联关系，我们会介绍更加复杂的关联关系，分别是远层一对多和多态关联。

远层一对多关联

远层一对多在一对多关联的基础上加上了一个修饰词【远层】，意味着这个一对多关系不是直接关联，而是【远层】关联，远层关联需要借助中间表，前面我们讨论多对多关联也是借助中间表，但是远层一对多与其区别在于还是一对多的关联。

理论和实例结合才容易理解。如果博客系统是针对全球市场的话，可能针对不同的国家推出不同的用户系统和功能，然后中国用户过来就只展示中国用户发布的文章，日本用户过来就只展示日本用户发表的文章，这里就涉及了三张表，存储国家的 countries 表，存储用户的 users 表以及存储文章的 posts 表。

用户与文章是一对多的关联关系，国家与用户之间是一对多的关联（一个用户只能有一个国际），那么通过用户这张中间表，国家和文章之间也建立起来一对多的关联，只是这个关联不是直接的关联，而是【远层】的关联。

针对这个情况，我们说国家和文章之间是远层的一对多关联。

建立远层一对多关联关系

我们要先创建 Country 模型类及其对应数据库迁移：

1
php artisan make:model Country -m

编写新生成的数据库迁移文件对应迁移类的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('countries', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->string('name', 100)->unique();
6
        $table->string('slug', 100)->unique();
7
        $table->timestamps();
8
    });
9
}

然后，编写迁移文件为 users 表新增一个 country_id 字段：

1
php artisan make:migration alter_users_add_country_id --table=users

编写新生成的迁移类文件如下：

1
<?php
2
3
use Illuminate\Support\Facades\Schema;
4
use Illuminate\Database\Schema\Blueprint;
5
use Illuminate\Database\Migrations\Migration;
6
7
class AlterUsersAddCountryId extends Migration
8
{
9
    /**
10
     * Run the migrations.
11
     *
12
     * @return void
13
     */
14
    public function up()
15
    {
16
        Schema::table('users', function (Blueprint $table) {
17
            $table->integer('country_id')->unsigned()->default(0);
18
            $table->index('country_id');
19
        });
20
    }
21
22
    /**
23
     * Reverse the migrations.
24
     *
25
     * @return void
26
     */
27
    public function down()
28
    {
29
        Schema::table('users', function (Blueprint $table) {
30
            $table->dropColumn('country_id');
31
        });
32
    }
33
}

接下来，运行 php artisan migrate 让迁移生效。在 countries 表和 users 表填充一些测试数据便于后续测试。

准备好数据库、模型类并填充测试数据后，接下来，我们在 Country 模型类中通过 Eloquent 提供的 hasManyThrough 方法定义其与 Post 模型类之间的远层一对多关联：

1
public function posts()
2
{
3
    return $this->hasManyThrough(Post::class, User::class);
4
}

其中，第一个参数是关联的模型类，第二个参数是中间借助的模型类。

这样，我们就可以在代码中通过 Country 模型实例获取归属于该国家的所有文章了，查询方式和前面其它关联查询一样，可以懒惰式加载，也可以渴求式加载:

1
$country = Country::findOrFail(1);
2
$posts = $country->posts;

hasManyThrough 方法的签名

同样，我们在通过 hasManyThrough 方法定义一个远层一对多关联关系的时候，并没有指定关联字段，因为我们在定义字段数据库字段、模型类的时候遵循了 Eloquent 底层的约定：

1
public function hasManyThrough(
2
    $related, $through, $firstKey = null, $secondKey = null,
3
    $localKey = null, $secondLocalKey = null)
  • $related 关联模型类
  • $through 中间模型类
  • $firstKey 表示中间模型类与当前模型类的关联外键，按照默认约定，本例中凭借出来的字段是 country_id，正好和我们中间表 users 中新增的 country_id 吻合，所以不需要额外指定。
  • $secondKey 指的是中间模型类与关联模型类的关联外键，按照默认约定，在本例中凭借出来的字段是user_id，正好和我们在关联表 posts 中定义的 user_id 吻合，所以不需要额外指定。
  • $localKey 默认是当前模型类的主键 ID，
  • $secondLocalKey 是中间模型类的主键 ID

一对一的多态关联

接下来讲的三个关联关系都属于多态关联，多态关联允许目标模型通过单个关联归属多种类型的模型，根据模型之间关联关系类型，又可以将多态关联分为一对一，一对多，多对多三种关联。

这里的一对一关联是【多态】的，举个例子：假设在博客系统中用户可以设置头像，文章也可以设置缩略图，我们知道每个用户只能有一个头像，一篇文章只能有一个缩略图，所以此时：

  • 用户和图片是一对一关联
  • 文章和图片是一对一关联

通过多态关联，我们可以让用户和文章共享与图片的一对一关联，我们只需要在图片模型通过一次定义，就可以动态建立与用户和文章的关联。

如何建立一对一的多态关联

开始之前我们要创建图片模型类 Image 及其对应数据库迁移文件：

1
php artisan make:model Image -m

然后编写新创建的 create_images_table 迁移文件对应迁移类的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('images', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->string('url')->comment('图片URL');
6
        $table->morphs('imageable');
7
        $table->timestamps();
8
    });
9
}

其中 $table->morphs(‘imageable’) 用于创建 imageable_id 和 imageable_type 两个字段，其中 imageable_type 用于存放 User 模型类或 Post 模型类，而 imageable_id 用于存放对应的模型实例 ID，从而方便遵循默认约定建立多态关联。

运行 php artisan migrate 让迁移生效，准备好数据表和模型类后，接下来我们在模型类中建立一对一的多态关联。首先在 Image 模型类中通过 morphTo 建立其与 User/Post 模型类之间的关联：

Image.php 创建方法 imageable:

1
public function imageable()
2
{
3
    return $this->morphTo();
4
}

我们不需要指定任何字段，因为我们在创建数据表和定义关联方法的时候都遵循了 Eloquent 底层的约定，还是来看下 morphTo 方法的完整签名：

1
public function morphTo($name = null, $type = null, $id = null, $ownerKey = null)
  • $name 是关联关系的 i 你改成，默认是关联的方法名，本例为imageable
  • $type $id 是结合 $name 用于构建的关联字段，就是 imageable_type 和 imageable_id。由于我们的数据库字段和关联方法名都遵循了默认约定，所以不需要额外指定。如果你的数据库字段名是自定义的，比如 item_id 和 item_type，那么第一个参数值为 `item.
  • $ownerKey 是当前模型的主键 id

这样，我们就可以在 images 表中填充一些测试数据进行测试了，你可以借助填充器来填充，或者手动插入，需要注意的是在 imageable_type 字段中需要插入完整的类名作为类型，比如 App\User 或者 App\Post，以便 Eloquent 在插询的时候结合 imageable_id 字段利用反射构造对应的模型实例.

定义相对的关联关系

当然，我们在日常开发中，更常见的是获取某个用户的头像或者某篇文章的缩略图，这样，我们就需要在 User 模型中定义其与 Image 模型的关联：

1
public function image()
2
{
3
    return $this->morphOne(Image::class, 'imageable');
4
}

然后在 Post 模型中定义其与 Image 模型的关联：

1
public function image()
2
{
3
    return $this->morphOne(Image::class, 'imageable');
4
}

同样，因为我们遵循了 Eloquent 底册的约定，只需要传入最少的参数即可建立关联。morphOne 方法的完整签名如下：

1
public function morphOne($related, $name, $type = null, $id = null, $localKey = null)
  • $related 表示关联的模型类
  • $name $type $id 和前面 morphTo 方法的前三个参数一样，用于在关联表中拼接关联外键，在本例中就是 imageable_type 和 imageable_id，所以第三个和第四个参数不需要额外指定，当然如果你是用的是 item_id 和 item_type 字段需要将第二个参数设置为 item，如果结尾不是以 type 和 id 作为后缀，也需要通过 $type 和 $id 参数传入。
  • $localKey 表示当前模型类的主键 ID。

一对多的多态关联

理解了一对一的多态关联之后，一对多的多态关联理解起来就简单多了，其实就是模型类与关联类之间的关联变成一对多了，只不过这个一对多是多态的，如何理解这个多态，其实就是在关联表引入了类型的概念，关联表中的数据不再是与某一张表有关联，而是与多张表有关联，具体是哪张表通过关联类型来确定，具体与哪条记录关联，通过关联 ID 来确定。能理解到这个层面基本上就可以通吃多态关联了。这种逻辑和面向对象中的多态很像（面向对象三大特性：继承、封装、多态），所以将其称作「多态关联」。

博客系统避免不了评论，一篇文章和单页面我们会区分开来，我们用户可以评论文章也可以评论单页面，但是这些评论可以统一存储在一个表中。

在模型类中构建一对多多态关联

首先还是要创建对应数据表和模型，我们先创建评论模型类 Comment 及其数据库迁移文件：

1
php artisan make:model Comment -m

编写新生成的 create_comments_table 迁移文件对应迁移类的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('comments', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->text('content')->comment('评论内容');
6
        $table->integer('user_id')->unsigned()->default(0);
7
        $table->morphs('commentable');
8
        $table->index('user_id');
9
        $table->softDeletes();
10
        $table->timestamps();
11
    });
12
}

然后创建一个 Page 模型类及其对应数据库迁移文件用于存放页面内容：

1
php artisan make:model Page -m

编写新生成的 create_pages_table 迁移文件对应迁移类的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('pages', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->string('title');
6
        $table->string('slug')->unique();
7
        $table->text('content');
8
        $table->integer('user_id')->unsigned()->default(0);
9
        $table->index('user_id');
10
        $table->softDeletes();
11
        $table->timestamps();
12
    });
13
}

运行 php artisan migrate 让迁移生效。

准备好数据库之后，我们通过填充器填充一些数据到刚创建的两张数据表。然后在 Comment 模型类中通过 Eloquent 提供的 morphTo 方法定义其与 Post 模型和 Page 之间的一对多多态关联：

1
public function commentable()
2
{
3
    return $this->morphTo();
4
}

因为一个评论只会对应一篇文章/页面，所以，通过和一对一的多态关联同样的 morphTo 方法定义其与文章和页面的关联关系即可。和前面的一对一多态关联一样，因为我们的数据表字段和关联方法名都遵循了 Eloquent 底层的默认约定，所以不需要指定任何额外参数，即可完成关联关系的构建。这些默认约定我们在上面一对一多态关联中已经详细列出，这里就不再赘述了。

这样，我们就可以通过 Comment 实例查询其归属的文章或页面了：

1
$comment = Comment::findOrFail(1);
2
$item = $comment->commentable;

定义相对的关联关系

同样，我们在日常开发中，更多的是通过文章或页面实例获取对应的评论信息，比如在文章页或页面页获取该文章或页面的所有评论。为此，我们需要在 Post 模型类和 Page 模型类中定义其与 Comment 模型的关联关系，这需要通过 morphMany 方法来实现：

1
public function comments()
2
{
3
    return $this->morphMany(Comment::class, 'commentable');
4
}

和 morphOne 方法一样，因为我们遵循了 Eloquent 底层的默认约定，所以只需要传递很少的必要参数就可以定义关联关系了，morphMany 方法的完整签名如下：

1
public function morphMany($related, $name, $type = null, $id = null, $localKey = null)

这些参数的含义和 morphOne 方法完全一样，这里就不再赘述了。如果想要在 Post 模型下获取对应的所有评论，可以这么做：

1
$post = Post::with('comments')->findOrFail(23);
2
$comments = $post->comments;

对应的关联查询底层 SQL 语句是：

1
select
2
  *
3
from
4
  `comments`
5
where
6
  `comments`.`commentable_id` in (23)
7
  and `comments`.`commentable_type` = "App\Post"
8
  and `comments`.`deleted_at` is null

多对多的多态关联

多对多的多态关联比前面的一对一和一对多更加复杂，但是有了前面讲解的基础，理解起来也很简单。你可以类比下常规的多对多关联，现在加入了「多态」的概念，常规的多对多需要借助中间表，多态的也是，只不过此时不仅仅是两张表之间的关联，而是也要引入类型字段。

还是以文章和标签的关联为例，在常规的多对多关联中，中间表只需要一个标签 ID 和文章 ID 即可建立它们之间的关联，但当我们添加新的内容类型，比如页面、视频、音频，它们也有标签，而且完全可以共享一张标签表，此时仅仅一个文章 ID 已经满足不了定义内容与标签之间的关联了，所以此时引入多对多的多态关联，和前面两种多态关联思路一样，只是在多对多关联中，我们需要在中间表中引入类型字段来标识内容类型，将原来的文章 ID 调整为内容 ID，这样就可以从数据库层面满足不同内容类型与标签之间的关联了。

所以你可以看到从一对一、一对多（远层一对多）、多对多、一对一多态关联、一对多多态关联、多对多多态关联，它们之间是层层递进的，理解了前面的，后面的也就更好理解。

下面我们以标签与文章、页面关联关系为例，演示如何定义和使用多对多的多态关联。

在模型类中定义多对多的多态关联

首先我们要废弃原来的 post_tags 数据表，创建一个新的 taggables 数据表来构建不同内容类型与标签之间的关联：

1
php artisan make:migration create_taggables_table --create=taggables

编写新生成的 create_taggables_table 迁移文件对应迁移类的 up 方法如下：

1
Schema::create('taggables', function (Blueprint $table) {
2
    $table->increments('id');
3
    $table->integer('tag_id');
4
    $table->morphs('taggable');
5
    $table->index('tag_id');
6
    $table->unique(['tag_id', 'taggable_id', 'taggable_type']);
7
    $table->timestamps();
8
});

运行 php artisan migrate 让迁移生效。然后通过填充器填充一些测试数据到新生成的 taggables 数据表。

接下来我们在 Tag 模型类中通过 Eloquent 提供的 morphedByMany 方法定义其与其他模型类的多对多多态关联：

1
public function posts()
2
{
3
    return $this->morphedByMany(Post::class, 'taggable');
4
}
5
6
public function pages()
7
{
8
    return $this->morphedByMany(Page::class, 'taggable');
9
}

和之前一样，因为我们遵循了 Eloquent 底层的默认约定，所以我们只需传递必需参数，无需额外配置即可定义关联关系，我们来看下 morphedByMany 方法的完整签名：

1
public function morphedByMany($related, $name, $table = null, $foreignPivotKey = null, $relatedPivotKey = null, $parentKey = null, $relatedKey = null)
  • $related 表示关联的模型类
  • $name 表示关联的名称，和定义中间表数据迁移的时候 morphs 方法中指定的值一致，也就是 taggable.
  • $table 表示中间表名称，默认是第二个参数 $name 的复数形式，这里就是 taggables 了，因为我们创建数据表的时候遵循了这个约定，所以不需要额外指定
  • $foreignPivotKey 表示当前模型类在中间表中的外键，默认拼接结果是 tag_id，和我们在数据表中定义的一样，所以这里不需要额外指定。
  • $relatedPivotKey 表示默认是通过 $name 和 _id 组合而来，表示中间表中的关联 ID 字段，这里组合结果是 taggable_id，和我们定义的一致，也不需要额外指定。
  • $parentKey 默认表示当前模型类的主键 ID，即与中间表中 tag_id 关联的字段。
  • $relatedKey 表示关联模型类的主键 ID，这个因 $related 指定的模型而定。

如果你不是按照默认约定的规则定义的数据库字段，需要明确每一个参数的含义，然后传入对应的参数值，和之前一样，对新手来说，还是按照默认约定来比较好，免得出错。

定义好上述关联关系后，就可以查询指定标签模型上关联的文章/页面了：

1
$tag = Tag::with('posts', 'pages')->findOrFail(53);
2
$posts = $tag->posts;
3
$pages = $tag->pages;

定义相对的关联关系

最后，我们还可以在 Post 模型类或 Page 模型类中通过 Eloquent 提供的 morphToMany 方法定义该模型与 Tag 模型的关联关系（两个模型类中定义的方法完全一样）：

1
public function tags()
2
{
3
    return $this->morphToMany(Tag::class, 'taggable');
4
}

因为我们遵循和 Eloquent 底层默认的约定，所以指定很少的参数就可以定义多对多的多态关联，morphToMany 方法的完整签名如下：

1
public function morphToMany($related, $name, $table = null, $foreignPivotKey = null, $relatedPivotKey = null, $parentKey = null, $relatedKey = null, $inverse = false)

其中前七个参数和 morphedByMany 方法含义一致，只不过针对的关联模型对调过来，最后一个参数 $inverse 表示定义的是否是相对的关联关系，默认是 false。如果你是不按套路出牌自定义的字段，需要搞清楚以上参数的含义并传入自定义的参数值。

定义好上述关联关系后，就可以通过 Post 模型或 Page 模型获取对应的标签信息了：

1
$post = Post::with('tags')->findOrFail(6);
2
$tags = $post->tags;

对应的底层查询 SQL 语句是：

1
select
2
  `tags`.*,
3
  `taggables`.`taggable_id` as `pivot_taggable_id`,
4
  `taggables`.`tag_id` as `pivot_tag_id`,
5
  `taggables`.`taggable_type` as `pivot_taggable_type`
6
from
7
  `tags`
8
  inner join `taggables` on `tags`.`id` = `taggables`.`tag_id`
9
where
10
  `taggables`.`taggable_id` in (6)
11
  and `taggables`.`taggable_type` = "App\Post"

总结

至此，关于 Eloquent 模型内置支持的七种关联关系定义我们就已经全部介绍完了。还是要多动手练习才能慢慢熟悉。

]]> PHP PHP Laravel Laravel Eloquent 模型关联关系（一） /2020/04/11/2020-04-11-Laravel-Eloquent-%E6%A8%A1%E5%9E%8B%E5%85%B3%E8%81%94%E5%85%B3%E7%B3%BB%EF%BC%88%E4%B8%80%EF%BC%89/ 前言

Laravel Eloquent 模型支持的关联关系包括以下其中：

  • 一对一
  • 一对多
  • 多对多
  • 远层一对多
  • 多态关联（一对一）
  • 多态关联（一对多）
  • 多态关联（多对多）

不着急，我们一个一个的看如何使用。

一对一

一对一是最简单的关联关系，一般可用于某个扩展表与主表之间的关联关系。比如大型系统中，我们的用户表通常用于最基本的信息的存储，如：邮箱、用户名、密码等放在主表，然后用户的身份证信息，个性签名放在另外一张扩展表。需要的时候才会去扩展表取数据，从而提高查询性能。

在开始之前，我们先通过数据迁移建立一张 user_profiles 表，并创建对应的 UserProfile，这可以通过 php artisan 命令一次完成：

1
php artisan make:model UserProfile -m

在生成的 create_user_profiles 迁移文件中编写迁移类的 up 方法如下：

1
/**
2
  * Run the migrations.
3
  *
4
  * @return void
5
  */
6
public function up()
7
{
8
    Schema::create('user_profiles', function (Blueprint $table) {
9
        $table->id();
10
        $table->bigInteger("user_id")->comment("用户ID");
11
        $table->string("card_number")->comment("身份证号码");
12
        $table->timestamps();
13
    });
14
}

注意：我们在 user_profiles 表中添加了 user_id 字段用于指向所属用户，从而建立与 users 表的关联。运行 php artisan migrate 在数据库创建这张数据表。

准备好数据表之后，接下来我们创建 users 表和 user_profiles 表之间的关联，首先，我们在 User 模型类中通过 hasOne 方法定义它与 UserProfile 的的一对一关联，User 类中加入 profile 方法

1
public function profile() {
2
    return $this->hasOne(UserProfile::class);
3
}

实际的使用时：

1
$user = User::first();
2
$user->profile;

hasOne 方法的签名

1
public function hasOne($related, $foreignKey = null, $localKey = null)
  • $related 是关联模型的类名
  • $foreignKey 是关联模型所属表的外键
  • $localKey 是关联表的外键关联到当前模型所属表的那个字段

建立相对的关联关系

通常我们都是通过 User 模型获取 UserProfile 模型，但是有时候我们可以需要反过来通过 UserProfile 反查询所属的 User 模型，Eloquent 底层也为我们提供了相应的 belongsTo 方法来建立一对一关联关系，我们在 UserProfile 关联模型定义它与 User 模型的关联如下：

给 UserProfile.php 中加入 user 方法:

1
public function user()
2
{
3
    return $this->belongsTo(User::class);
4
}

实际的使用时：

1
$userProfile = UserProfile::first();
2
$userProfile->user;

belongsTo 方法的签名

和 hasOne 方法一样，belongsTo 方法也是遵循了默认的约定签名如下：

1
public function belongsTo($related, $foreignKey = null, $ownerKey = null, $relation = null);
  • $related 是关联模型的类名
  • $foreignKey 是当前模型所属表的外键
  • $owerKey 是关联模型类所属表的主键
  • $relation 是关联关系方法名，也是关联关系动态属性名

一对多

一对多关联是我们日常开发中经常碰到的一种关联关系。以博客系统为例，一个用户可以发布多篇文章，反过来，一篇文章只能归属于一个用户，那么用户和文章之间就是一对多的关系，同样，用户可以发布多条评论，一条评论只能归属于一个用户，用户与评论之间也是一对多的关系。

创建 posts 表以及对应迁移文件

1
php artisan make:model Post -m

对应迁移文件中的 Up 方法：

1
public function up()
2
{
3
    Schema::create('posts', function (Blueprint $table) {
4
        $table->id();
5
        $table->bigInteger("user_id")->comment("所属用户id");
6
        $table->string('title')->comment("文章标题");
7
        $table->longText('content')->comment("文章内容");
8
        $table->bigInteger('view')->comment("查看次数");
9
        $table->timestamps();
10
        $table->softDeletes();
11
    });
12
}

创建 User 模型对应的 posts 方法

要定义用户文章之间的一对多关联，可以在 User 模型类中通过 Eloquent 底层的提供的 hasMany 方法来实现：

1
public function posts()
2
{
3
    return $this->hasMany(Post::class, "user_id", "id")
4
}

实际的使用时：

1
$user = User::first();
2
$user->posts;

hasMany 方法的签名

1
public function hasMany($related, $foreignKey = null, $localKey = null)
  • $related 是关联模型的类名
  • $foreignKey 是关联模型所属表的外键
  • $localKey 是关联表的外键关联到当前模型所属表的那个字段

建立相对的关联的关系

我们将 Post 模型中的关联关系调用方法名为 author，这样，我们就需要手动指定更多的 belongsTo 方法传入参数：

Post.php 中加入 author 方法：

1
public function author()
2
{
3
    return $this->belongsTo(User::class, 'user_id', 'id', 'author');
4
}

实际的使用时：

1
$post = Post::first();
2
$post->author;

多对多

多对多关联在实际开发中很常见，还是以博客系统为例子，我们会为每篇文章设置标签，一篇文章往往有多个标签，反过来，一个标签可能会归属于多篇文章，这时，我们说文章和标签之间是多对多的关联关系。

多对多关联比一对一和一对多关联复杂一些，需要借助一张中间表才能建立关联关系。以文章标签为例，文章表已经存在，还需要创建一张 tags 表和中间表 post_tags 表。首先创建 Tag 模型类及其对应数据表 tags 迁移文件：

1
php artisan make:model Tag -m

编写 create_tags_table 迁移文件对应的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('tags', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->string('name', 100)->unique()->comment('标签名');
6
        $table->timestamps();
7
    });
8
}

然后创建 post_tags 数据表迁移文件：

1
php artisan make:migration create_post_tags_table --create=post_tags

编写对应迁移类的 up 方法如下：

1
public function up()
2
{
3
    Schema::create('post_tags', function (Blueprint $table) {
4
        $table->increments('id');
5
        $table->integer('post_id')->unsigned()->default(0);
6
        $table->integer('tag_id')->unsigned()->default(0);
7
        $table->unique(['post_id', 'tag_id']);
8
        $table->timestamps();
9
    });
10
}

运行 php artisan migrate 让迁移生效。

接下来，我们在 Post 模型类中定义其与 Tags 模型类的关联关系，通过 Eloquent 提供的 belongsToMany 方法来实现：

1
public function tags()
2
{
3
    return $this->belongsToMany(Tag::class, 'post_tags');
4
}

通过数据填充器填充一些数据到 tags 表和 post_tags 表，这样我们可以通过关联查询查询指定的 Post 模型上的标签信息了：

1
$post = Post::with('tags')->first();
2
$tags = $post->tags;

belongsToMany 方法的签名

可以看到我们在定义多对多关联的时候，也没有指定哪些字段进行关联，这样是遵循 Eloquent 底层默认约定的功劳， belongsToMany 方法签名如下：

1
public function belongsToMany($related, $table = null, $foreignPivotKey = null, $relatedPivotKey = null, $parentKey = null, $relatedKey = null, $relation = null)
  • $related 是关联模型的类名
  • $table 是建立多对多关联的中间表名，该表名默认凭借规则如下：
    • 当前模型+下划线+关联模型，这里是自定义的，默认转化是根据两个表名首字母排序之后，用下划线分割，如果默认的话，这里应该是post_tag，但是为了遵循 Laravel 表明为复数规定，我们自行定义一回。
  • $foreignPivotKey 是中间表中当前模型类的外键，默认拼接规则和前面一对一，一对多一样，所以本例中是 posts 表的 post_id 字段。
  • $relatedPivotKey 是中间表中当前模型类的外键，只不过作用于关联模型，所以本例中是tags表的tag_id字段。
  • $parentKey 表示对应当前模型哪个字段（即 $foreignPivotKey 映射到当前模型所属表的哪个字段），默认是主键 ID，即 posts 表的 id 字段，所以这里不需要额外指定。
  • $relatedKey 表示对应关联模型的哪个字段（即 $relatedPivotKey 映射到关联模型所属表的哪个字段），默认是关联模型的主键 ID，即 tags 表的 id 字段，所以这里也不需要额外指定。
  • $relation 表示关联关系名称，用于设置查询结果中的关联属性，默认是关联方法名。

建立相对的关联联系

与之前的关联关系一样，多对多关联也支持建立相对的关联关系，而且由于多对多的双方是平等的，不存在谁归属谁的问题，所以建立相对关联的方法都是一样的，我们可以在 Tag 模型中通过 belongsToMany 方法建立其与 Post 模型的关联关系：

1
public function posts()
2
{
3
    return $this->belongsToMany(Post::class, 'post_tags');
4
}

实际的使用时：

1
$tag = Tag::with('posts')->first();
2
$posts = $tag->posts;

获取中间表字段

1
$post = Post::first();
2
$post->tags;

Eloquent 还提供了方法允许你获取中间表的字段，你仔细查询结果字段，会发现 relations 字段中有一个 pivot 属性，中间表字段就存放在这个属性对象上。

中间表只有对应的中间表关联 id 没有时间戳，我们可以通过这个方式添加：

1
public function tags()
2
{
3
    return $this->belongsToMany(Tag::class, 'post_tags')->withTimestamps();
4
}

除了这样，你还在中间表定义了额外的字段信息，比如 user_id，通过 with 方法传入字段就将其返回了：

1
public function tags()
2
{
3
    return $this->belongsToMany(Tag::class, 'post_tags')->withPivot('user_id')->withTimestamps();
4
}

自定义中间表模型类

你可以通过自定义中间表对应模型类实现更多自定义操作，中间表模型继承自 Illuminate\Database\Eloquent\Relations\Pivot，Pivot 也是 Eloquent Model 类的子类，只不过为中间表操作定义了很多方法和属性，比如我们创建一个自定义的中间表模型类 PostTag：

1
namespace App;
2
3
use Illuminate\Database\Eloquent\Relations\Pivot;
4
5
class PostTag extends Pivot
6
{
7
    protected $table = 'post_tags';
8
}

这样，我们在定义多对多关联关系的时候指定自定义的模型类了：

1
public function tags()
2
{
3
    return $this->belongsToMany(Tag::class, 'post_tags')->using(PostTag::class);
4
}

更多中间表操作

此外，如果你觉得 pivot 可读性不好，你还可以自定义中间表实例属性名称：

1
$this->belongsToMany(Tag::class, 'post_tags')->as('taggable')->withTimestamps();

这样，就可以通过 $tag->taggable->created_at 访问中间表字段值了。

还可以通过中间表字段值过滤关联数据（支持 where 和 in 查询）：

1
return $this->belongsToMany(Tag::class, 'post_tags')->wherePivot('user_id', 1);
2
return $this->belongsToMany(Tag::class, 'post_tags')->wherePivotIn('user_id', [1, 2]);

总结

这里只是说了一个基础，更多高级的在后面呈现给大家。

]]> PHP PHP Laravel Mybatis-入门（九） /2020/04/09/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E4%B9%9D%EF%BC%89/ 前言

我们在实际开发中是不仅仅针对一张表，而是两张或者多张表联动的操作，这里我们经常面对的关系就是一对一，一对多，多对一，多对多等等。

这里我们搭建环境，我们看看最常见的数据关系，学生和老师的关系

  • 对于老师来说，一个老师拥有多个学生
  • 对于学生而言，多个学生都有一个老师
1
create table teachers (
2
    `id` int(20) not null auto_increment,
3
    `name` varchar(64) not null,
4
    PRIMARY KEY (`id`)
5
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
6
7
insert into teachers (`name`) values ('燕子李三');
8
9
create table students (
10
    `id` int(20) not null auto_increment,
11
    `name` varchar(64) not null,
12
    `tid` int(20) not null,
13
    PRIMARY KEY (`id`)
14
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
15
16
insert into students (`name`, `tid`) values ('张三', 1), ('李四', 1), ('王五', 1), ('赵六', 1);

我们导入数据库，然后开始创建项目。

搭建新项目

到目前为之，我觉得学习就是一个重复的过程，不停的创建新的实验性项目，当然我心里也是很烦的。但是没有办法，发现只有动手之后我才能知道到底哪里有问题，我才能有针对性的记忆。这里我们建立一个 mybatis-06 创建好之后，我们在需要在 pom.xml 的 project 标签中加入以下代码：

第一步，pom.xml 加入相应的配置

1
<!-- 在build中配置resource，来防止我们资源导出失败的问题 -->
2
<build>
3
    <resources>
4
        <resource>
5
            <directory>src/main/resources</directory>
6
            <includes>
7
                <include>**/*.properties</include>
8
                <include>**/*.xml</include>
9
            </includes>
10
            <filtering>true</filtering>
11
        </resource>
12
13
        <resource>
14
            <directory>src/main/java</directory>
15
            <includes>
16
                <include>**/*.properties</include>
17
                <include>**/*.xml</include>
18
            </includes>
19
            <filtering>true</filtering>
20
        </resource>
21
    </resources>
22
</build>

这个配置主要是为了相关的 XML 文件在编译之后，能被打包到对应的位置。

第二步：创建 db.properties mybatis-config.xml 配置类

db.properties 配置如下：

1
driver=com.mysql.jdbc.Driver
2
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Hongkong
3
username=root
4
password=

mybatis-config.xml 配置如下：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
6
<configuration>
7
    <properties resource="db.properties"/>
8
9
    <settings>
10
        <setting name="logImpl" value="STDOUT_LOGGING"/>
11
    </settings>
12
13
    <environments default="development">
14
        <environment id="development">
15
            <transactionManager type="JDBC"/>
16
            <dataSource type="POOLED">
17
                <property name="driver" value="${driver}"/>
18
                <property name="url" value="${url}"/>
19
                <property name="username" value="${username}"/>
20
                <property name="password" value="${password}"/>
21
            </dataSource>
22
        </environment>
23
    </environments>
24
</configuration>

第三步：创建 MybatisUtils 工具类

1
package com.yubulang.utils;
2
3
import org.apache.ibatis.io.Resources;
4
import org.apache.ibatis.session.SqlSession;
5
import org.apache.ibatis.session.SqlSessionFactory;
6
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
7
8
import java.io.IOException;
9
import java.io.InputStream;
10
11
public class MybatisUtils {
12
    private static SqlSessionFactory sqlSessionFactory;
13
14
    static {
15
        try {
16
            String resource = "mybatis-config.xml";
17
            InputStream in = Resources.getResourceAsStream(resource);
18
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
19
        } catch (IOException e) {
20
            e.printStackTrace();
21
        }
22
    }
23
24
    public static SqlSession getSqlSession() {
25
        return sqlSessionFactory.openSession();
26
    }
27
}

到这里我们已经有了一个基础的架子。

一对多

对于老师而言，一个老师负责多个学生，我们来创建两个实体类：

创建实体类

com.yubulang.pojo.Teacher.java：

1
package com.yubulang.pojo;
2
3
public class Teacher {
4
    private int id;
5
    private String name;
6
7
    public Teacher() {
8
    }
9
10
    public Teacher(int id, String name) {
11
        this.id = id;
12
        this.name = name;
13
    }
14
15
    public int getId() {
16
        return id;
17
    }
18
19
    public void setId(int id) {
20
        this.id = id;
21
    }
22
23
    public String getName() {
24
        return name;
25
    }
26
27
    public void setName(String name) {
28
        this.name = name;
29
    }
30
31
    @Override
32
    public String toString() {
33
        return "Teacher{" +
34
                "id=" + id +
35
                ", name='" + name + '\'' +
36
                '}';
37
    }
38
}

com.yubulang.pojo.Student，注意这里我们要关联 Teacher，所以在 Student 的属性中 teacher 应该对应 Teacher 类：

1
package com.yubulang.pojo;
2
3
public class Student {
4
    private int id;
5
    private String name;
6
    private Teacher teacher;
7
8
    public Student() {
9
    }
10
11
    public Student(int id, String name, Teacher teacher) {
12
        this.id = id;
13
        this.name = name;
14
        this.teacher = teacher;
15
    }
16
17
    public int getId() {
18
        return id;
19
    }
20
21
    public void setId(int id) {
22
        this.id = id;
23
    }
24
25
    public String getName() {
26
        return name;
27
    }
28
29
    public void setName(String name) {
30
        this.name = name;
31
    }
32
33
    public Teacher getTeacher() {
34
        return teacher;
35
    }
36
37
    public void setTeacher(Teacher teacher) {
38
        this.teacher = teacher;
39
    }
40
41
    @Override
42
    public String toString() {
43
        return "Student{" +
44
                "id=" + id +
45
                ", name='" + name + '\'' +
46
                ", teacher=" + teacher +
47
                '}';
48
    }
49
}

创建实现接口

com.yubulang.dao.StudentMapper.java, 因为关联方式有两种:

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.Student;
4
import com.yubulang.pojo.Teacher;
5
6
import java.util.List;
7
8
public interface StudentMapper {
9
10
    // 第一种方式 根据结果描述隐射关系
11
    List<Student> getStudent();
12
13
    // 第二种方式
14
    List<Student> getStudentList();
15
}

有了实现接口，我们需要对应的 xml 与之匹配它的实现。我们把 xml 放到 resources/com/yubulang/dao 中，命名为 StudentMapper.xml：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<mapper namespace="com.yubulang.dao.StudentMapper">
7
    <!-- 第一种方法，编写关联关系去查询 -->
8
    <select id="getStudent" resultMap="StudentTeacher">
9
        select * from students;
10
    </select>
11
12
    <resultMap id="StudentTeacher" type="Student">
13
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacherByTid"/>
14
    </resultMap>
15
16
    <select id="getTeacherByTid" resultType="Teacher">
17
        select * from teachers where id=#{id}
18
    </select>
19
20
    <!-- 第二种方法（相对简单）：根据查询结果来关联 -->
21
    <select id="getStudentList" resultMap="StudentTeacher2">
22
        select s.id sid, s.name sname, t.id tid, t.name tname from students s, teachers t where s.tid = t.id;
23
    </select>
24
25
    <resultMap id="StudentTeacher2" type="Student">
26
        <result property="id" column="sid"/>
27
        <result property="name" column="sname"/>
28
        <association property="teacher" javaType="Teacher">
29
            <result property="id" column="tid"/>
30
            <result property="name" column="tname"/>
31
        </association>
32
    </resultMap>
33
</mapper>

测试类的干活

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.Student;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
import java.util.List;
9
10
public class StudentMapperTest {
11
    @Test
12
    public void testGetStudent() {
13
        SqlSession sqlSession = MybatisUtils.getSqlSession();
14
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
15
        List<Student> studentList = mapper.getStudent();
16
        for (Student student : studentList) {
17
            System.out.println(student);
18
        }
19
20
        sqlSession.close();
21
    }
22
23
    @Test
24
    public void testGetStudentList() {
25
        SqlSession sqlSession = MybatisUtils.getSqlSession();
26
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
27
        List<Student> studentList = mapper.getStudentList();
28
        for (Student student : studentList) {
29
            System.out.println(student);
30
        }
31
32
        sqlSession.close();
33
    }
34
}

多对一

对于学生而言，多个学生跟着一个老师，我们来创建两个实体类：

创建实体类

com.yubulang.pojo.Teacher:

1
package com.yubulang.pojo;
2
3
import java.util.List;
4
5
public class Teacher {
6
    private int id;
7
    private String name;
8
9
    // 一个老师有多个学生
10
    private List<Student> students;
11
12
    public Teacher() {
13
    }
14
15
    public Teacher(int id, String name, List<Student> students) {
16
        this.id = id;
17
        this.name = name;
18
        this.students = students;
19
    }
20
21
    public int getId() {
22
        return id;
23
    }
24
25
    public void setId(int id) {
26
        this.id = id;
27
    }
28
29
    public String getName() {
30
        return name;
31
    }
32
33
    public void setName(String name) {
34
        this.name = name;
35
    }
36
37
    public List<Student> getStudents() {
38
        return students;
39
    }
40
41
    public void setStudents(List<Student> students) {
42
        this.students = students;
43
    }
44
45
    @Override
46
    public String toString() {
47
        return "Teacher{" +
48
                "id=" + id +
49
                ", name='" + name + '\'' +
50
                ", students=" + students +
51
                '}';
52
    }
53
}

com.yubulang.pojo.Student:

1
package com.yubulang.pojo;
2
3
public class Student {
4
    private int id;
5
    private String name;
6
    private int tid;
7
8
    public Student() {
9
    }
10
11
    public Student(int id, String name, int tid) {
12
        this.id = id;
13
        this.name = name;
14
        this.tid = tid;
15
    }
16
17
    public int getId() {
18
        return id;
19
    }
20
21
    public void setId(int id) {
22
        this.id = id;
23
    }
24
25
    public String getName() {
26
        return name;
27
    }
28
29
    public void setName(String name) {
30
        this.name = name;
31
    }
32
33
    public int getTid() {
34
        return tid;
35
    }
36
37
    public void setTid(int tid) {
38
        this.tid = tid;
39
    }
40
41
    @Override
42
    public String toString() {
43
        return "Student{" +
44
                "id=" + id +
45
                ", name='" + name + '\'' +
46
                ", tid=" + tid +
47
                '}';
48
    }
49
}

创建实现接口

com.yubulang.dao.TeacherMapper:

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.Teacher;
4
import org.apache.ibatis.annotations.Param;
5
6
public interface TeacherMapper {
7
    Teacher getTeacherById(@Param("tid") int id);
8
9
    Teacher getTeacherByIdAnother(@Param("tid") int id);
10
}

有了实现接口，我们需要对应的 xml 与之匹配它的实现。我们把 xml 放到 resources/com/yubulang/dao 中，命名为 TeacherMapper.xml：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<mapper namespace="com.yubulang.dao.TeacherMapper">
7
    <!--第一种方式（复杂度在sql）-->
8
    <select id="getTeacherById" resultMap="TeacherStudent">
9
        select t.id tid, t.name tname, s.id sid, s.name sname
10
        from teachers t,
11
             students s
12
        where t.id = s.tid
13
          and t.id = #{tid};
14
    </select>
15
16
    <resultMap id="TeacherStudent" type="Teacher">
17
        <result property="id" column="tid"/>
18
        <result property="name" column="tname"/>
19
        <collection property="students" ofType="Student">
20
            <result property="id" column="sid"/>
21
            <result property="name" column="sname"/>
22
            <result property="tid" column="tid"/>
23
        </collection>
24
    </resultMap>
25
26
    <!--第二种方式复杂度在凭借-->
27
    <select id="getTeacherByIdAnother" resultMap="TeacherStudentAnother">
28
        select id, name
29
        from teachers
30
        where id = #{tid}
31
    </select>
32
33
    <resultMap id="TeacherStudentAnother" type="Teacher">
34
        <result property="id" column="id"/>
35
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTid" column="id">
36
            <result property="id" column="id"/>
37
            <result property="name" column="name"/>
38
            <result property="tid" column="tid"/>
39
        </collection>
40
    </resultMap>
41
42
    <select id="getStudentByTid" resultType="Student">
43
        select *
44
        from students
45
        where tid = #{tid}
46
    </select>
47
</mapper>

测试代码的干货

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.Teacher;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
public class TeacherMapperTest {
9
    @Test
10
    public void testGetTeacherById() {
11
        SqlSession sqlSession = MybatisUtils.getSqlSession();
12
13
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
14
        Teacher teacherById = mapper.getTeacherById(1);
15
16
        System.out.println(teacherById);
17
18
        sqlSession.close();
19
    }
20
21
    @Test
22
    public void testGetTeacherByIdAnother() {
23
        SqlSession sqlSession = MybatisUtils.getSqlSession();
24
25
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
26
        Teacher teacherById = mapper.getTeacherByIdAnother(1);
27
28
        System.out.println(teacherById);
29
30
        sqlSession.close();
31
    }
32
}

总结

比之前更发杂了点，但是这些关系是我们做项目时常用的一些数组组成方式。有个基础，后面复杂的都不在话下。

]]> Java Java Mybatis Mybatis-入门（八） /2020/04/09/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E5%85%AB%EF%BC%89/ 前言

使用 xml 配置开发，我们 mybatis 也有注解开发。以后我们在公司做项目的时候多数会用到的注解，但是在 Mybatis 中还是 XML 为主。

我们这里也要回顾下什么是面向接口编程。

  • 真正的开发中，很多时候我们会面向接口编程
  • 根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，是的开发变得容易，规范性好
  • 在一个面向对象的系统中，系统的各种共嗯那个有许许多多不同的对象写作完成，大到各个模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是按照这种思想来编程。

关于接口的理解

  • 接口从更深层次的理解，就是定义（规范、约束）与实现（名实分离的原则）的分离
  • 接口的本身反应了系统设计人员对系统的抽象理解
  • 接口应有两类：
    • 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class）
    • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
  • 个体可能有多个抽象面，抽象体与抽象面是由区别的

三个面向的区别

  • 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法
  • 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
  • 接口设计与非接口设计时针对复用技术而言的，与面向对象（过程）不是一个问题。更多的体现就是对系整体的架构

使用注解开发

Mybatis 简单的操作我们可以使用注解来查询，这时候我们可以不需要配置 xml 文件，直接在接口类中去写注解。

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
import org.apache.ibatis.annotations.Insert;
5
import org.apache.ibatis.annotations.Select;
6
7
import java.util.List;
8
9
public interface UserMapper {
10
11
    @Select("select * from users")
12
    List<User> getUserList();
13
14
    @Insert("insert into users (`name`, `password`) values (#{name}, #{password})")
15
    int addUser(User user);
16
}

而我们的 mybatis-config.xml 中的 mapper 也只需要修改以下即可

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
6
<configuration>
7
    <properties resource="db.properties"/>
8
9
    <settings>
10
        <setting name="logImpl" value="STDOUT_LOGGING"/>
11
    </settings>
12
13
    <environments default="development">
14
        <environment id="development">
15
            <transactionManager type="JDBC"/>
16
            <dataSource type="POOLED">
17
                <property name="driver" value="${driver}"/>
18
                <property name="url" value="${url}"/>
19
                <property name="username" value="${username}"/>
20
                <property name="password" value="${password}"/>
21
            </dataSource>
22
        </environment>
23
    </environments>
24
25
    <mappers>
26
        <!-- 绑定接口 -->
27
        <mapper class="com.yubulang.dao.UserMapper"/>
28
    </mappers>
29
</configuration>

开始写测试代码搞起，有了这两个例子，我相信修改和删除是什么样的结果也不难了吧

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
import java.util.List;
9
10
public class UserMapperTest {
11
    @Test
12
    public void testGetUserList() {
13
        SqlSession sqlSession = MybatisUtils.getSqlSession();
14
15
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
16
        List<User> userList = mapper.getUserList();
17
18
        for (User user : userList) {
19
            System.out.println(user);
20
        }
21
22
        sqlSession.close();
23
    }
24
25
    @Test
26
    public void testAddUser() {
27
        SqlSession sqlSession = MybatisUtils.getSqlSession();
28
29
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
30
31
        User user = new User();
32
        user.setName("金毛狮王");
33
        user.setPassword("666666");
34
35
        int i = mapper.addUser(user);
36
        if (i > 0) {
37
            System.out.println("插入成功");
38
        }
39
40
        sqlSession.commit();
41
42
        sqlSession.close();
43
    }
44
}

总结

mybatis 其实在实际开发中多数是用到的 xml，复杂的基本是通过 xml 配置来完成。注解只是拓展下大家的知识面。

]]> Java Java Mybatis Mybatis-入门（七） /2020/04/08/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E4%B8%83%EF%BC%89/ 前言

我们的数据库会被请求很多数据，但是如果数据是很多的时候，我们肯定是分批返回而不是全部返回。所以在实际开发中，我们会对数据进行分页。

分页

分页操作的本质就是MySQL中的 limit 关键字，之前我们检索数据的做法是：

1
select * from users;

实际工作中，我们并不会这么用，因为数据库的数据随着时间的增加肯定是越来越多的，有可能是 1W、10W、100W，但是作为人我们没有办法一次性看这么多，而且性能上也是不允许。一般我们会使用 limit 来对其进行限制

1
-- 这句话就是从头部开始十五条
2
select * from users limit 0, 15;

有了这个基础我们就知道如何写 mybatis 了。无非就是组装这个 sql 嘛。还是将就上一篇文章的项目

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
5
import java.util.List;
6
import java.util.Map;
7
8
public interface UserMapper {
9
    User getUserById(int id);
10
11
    List<User> getUserByPage(Map<String, Integer> map);
12
}

UserMapper.xml

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<mapper namespace="com.yubulang.dao.UserMapper">
7
    <select id="getUserById" parameterType="int" resultType="User">
8
        select *
9
        from users
10
        where id = #{id};
11
    </select>
12
13
    <select id="getUserByPage" parameterType="map" resultType="User">
14
        select * from users limit #{offset}, #{pageSize}
15
    </select>
16
</mapper>

测试代码：

1
@Test
2
public void testGetUserByPage() {
3
    SqlSession sqlSession = MybatisUtils.getSqlSession();
4
5
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
6
7
    Map<String, Integer> map = new HashMap<String, Integer>();
8
    map.put("offset", 0);
9
    map.put("pageSize", 2);
10
11
    List<User> userList = mapper.getUserByPage(map);
12
13
    for (User user : userList) {
14
        System.out.println(user);
15
    }
16
17
    sqlSession.close();
18
}

总结

其实分页还有 RowBounds 和分页插件，这个感兴趣的可以自行查询，其实本质都是不变的，就是 SQL 语句 Limit 的控制。

]]> Java Java Mybatis Mybatis-入门（六） /2020/04/07/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E5%85%AD%EF%BC%89/ 前言

日志作为我们开发中的辅助工具，早期我们开发只是使用 System.out.println() 来输出内容，但是在实际开发中我们更青睐于日志系统，Mybatis 也支持日志系统的配置，我们来看看日志系统是如何配置启动的。

设置日志系统配置

日志系统的配置相当简单，只需要在 mybatis-config.xml 文件中加入 <settings> 标签即可，注意这里的 <setting> 中 name 和 value 都不能写错，必须和官方提供的文档相同，否则就会有不知名的原因报错，我们为了减少报错，我一般的习惯是直接打开官方文档复制即可。

支持的类型有：

  • SLF4J
  • LOG4J 【掌握】
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING【掌握】
  • NO_LOGGING

我们复用 Mybatis-入门（五） 项目的代码，在代码的基础上，加入这个配置选项，我们先使用系统 STDOUT_LOGGING 标准输出。

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
6
<configuration>
7
    <properties resource="db.properties"/>
8
9
    <settings>
10
        <!-- 标准的日志工厂 -->
11
        <setting name="logImpl" value="STDOUT_LOGGING"/>
12
    </settings>
13
14
    <typeAliases>
15
        <typeAlias type="com.yubulang.pojo.User" alias="User"/>
16
    </typeAliases>
17
18
    <environments default="development">
19
        <environment id="development">
20
            <transactionManager type="JDBC"/>
21
            <dataSource type="POOLED">
22
                <property name="driver" value="${driver}"/>
23
                <property name="url" value="${url}"/>
24
                <property name="username" value="${username}"/>
25
                <property name="password" value="${password}"/>
26
            </dataSource>
27
        </environment>
28
    </environments>
29
30
    <mappers>
31
        <mapper resource="com/yubulang/dao/UserMapper.xml"/>
32
    </mappers>
33
</configuration>

配置之后我们运行对应的测试，这样我们就可以看到命令行中就出现了很多日志信息：

1
Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
2
PooledDataSource forcefully closed/removed all connections.
3
PooledDataSource forcefully closed/removed all connections.
4
PooledDataSource forcefully closed/removed all connections.
5
PooledDataSource forcefully closed/removed all connections.
6
Opening JDBC Connection
7
Created connection 266437232.
8
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@fe18270]
9
==>  Preparing: select * from users where id = ?;
10
==> Parameters: 1(Integer)
11
<==    Columns: id, name, password
12
<==        Row: 1, 鱼不浪, 666666
13
<==      Total: 1
14
User{id=1, name='鱼不浪', password='666666'}
15
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@fe18270]
16
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@fe18270]
17
Returned connection 266437232 to pool.

LOG4J 日志

通常我们使用的最多的就是 LOG4J 这个日志，学习一个东西的时候需要知道它是什么

  • Log4j 是 Apache 的一个开源项目，通过使用 Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI 组件

  • 定义日志的输出格式

  • 定义每一条的日志的级别

  • 通过修改配置文件进行配置，不需要修改代码，这个才是我最喜欢的

  • 先导入 LOG4J 的包，注意这里在配置文件当中必须大写且完全一样，直接 pom.xml 中添加

1
<!-- log4j -->
2
<dependency>
3
    <groupId>log4j</groupId>
4
    <artifactId>log4j</artifactId>
5
    <version>1.2.17</version>
6
</dependency>

配置完成后，maven 安装一下对应的包，当然我们还要配置对应的 log4j 属性，我们把它放到 resources 的 log4j.properties 中去。

1
# 设置rootLogger的level等级为DEBUG，后面跟输出目的地 console, file
2
log4j.rootLogger=DEBUG,console,file
3
4
# 控制台输出的相关配置
5
log4j.appender.console=org.apache.log4j.ConsoleAppender
6
log4j.appender.console.Target=System.out
7
log4j.appender.console.Threshold=DEBUG
8
log4j.appender.console.layout=org.apache.log4j.PatternLayout
9
log4j.appender.console.layut.ConversionPattern=[%c]-%m%n
10
11
# 文件输出的相关设置
12
log4j.appender.file = org.apache.log4j.RollingFileAppender
13
log4j.appender.file.File = ./log/yubulang.log
14
log4j.appender.file.MaxFileSize = 10mb
15
log4j.appender.file.Threshold = DEBUG
16
log4j.appender.file.layout = org.apache.log4j.PatternLayout
17
log4j.appender.file.layout.ConversionPattern = [%p][%d{yy-MM-dd}][%c]%m%n
18
19
20
# 日志输出级别
21
log4j.logger.org.mybatis=DEBUG
22
log4j.logger.java.sql=DEBUG
23
log4j.logger.java.sql.Statement=DEBUG
24
log4j.logger.java.sql.ResultSet=DEBUG
25
log4j.logger.java.sql.PreparedStatement=DEBUG

将 <setting name="logImpl" value="STDOUT_LOGGING" /> 改为 <setting name="logImpl" value="LOG4J" /> 这样运行我们的测试文件就已经可以正常运行了。输出日志如下：

1
Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
2
Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
3
PooledDataSource forcefully closed/removed all connections.
4
PooledDataSource forcefully closed/removed all connections.
5
PooledDataSource forcefully closed/removed all connections.
6
PooledDataSource forcefully closed/removed all connections.
7
Opening JDBC Connection
8
Created connection 300031246.
9
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@11e21d0e]
10
==>  Preparing: select * from users where id = ?;
11
==> Parameters: 1(Integer)
12
<==      Total: 1
13
User{id=1, name='鱼不浪', password='666666'}
14
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@11e21d0e]
15
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@11e21d0e]
16
Returned connection 300031246 to pool.

Log4j 的简单使用

我们在测试类中 com/yubulang/dao/UserMapperTest.java 添加以下方法

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.apache.log4j.Logger;
7
import org.junit.Test;
8
9
public class UserMapperTest {
10
    static Logger logger = Logger.getLogger(UserMapperTest.class);
11
12
    @Test
13
    public void testGetUserById() {
14
        SqlSession sqlSession = MybatisUtils.getSqlSession();
15
16
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
17
18
        User user = mapper.getUserById(1);
19
20
        System.out.println(user);
21
22
        sqlSession.close();
23
    }
24
25
    @Test
26
    public void testLog4j() {
27
        // 普通信息
28
        logger.info("info：进入了testLog4j");
29
        logger.debug("debug：进入了testLog4j");
30
        logger.error("error：进入了testLog4j");
31
    }
32
}

总结

日志在我们的项目开发中十分的重要，但是好运的是使用他并不困难，值要配置以下就能轻松的使用。

]]> Java Java Mybatis Mybatis-入门（五） /2020/04/07/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E4%BA%94%EF%BC%89/ 前言

我们在实际开发的时候，有没有遇到数据库字段和我们实体类中字段不一样的时候。这个时候 Mybatis 有没有提供解决方案呢？作为一个程序框架肯定是考虑到了这点。举个例子我们数据库表像下面这样。直接给出 SQL，在数据库中执行就行了，还是放在我们的 mybatis 数据库中：

1
CREATE TABLE users_test (
2
    `id` int(20) UNSIGNED NOT NULL AUTO_INCREMENT,
3
    `name` VARCHAR(64) NOT NULL,
4
    `pwd` VARCHAR(64) NOT NULL,
5
    PRIMARY KEY(`id`)
6
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;
7
8
INSERT INTO `users_test` (`name`, `pwd`) VALUES ('鱼不浪', '666666'), ('鲁班', '666666'), ('西施', '666666'), ('麦特凯', '666666');

而我们的实体类是 com.yubulang.pojo.UserTest，里面的 password 与 数据库表的 pwd 现在是没有办法对应匹配的。我们需要让实体类与他绑定。

1
package com.yubulang.pojo;
2
3
public class UserTest {
4
    private int id;
5
    private String name;
6
    private String password;
7
8
    ...
9
}

为了复习之前的知识点，我们新建一个项目: mybatis-demo，一路下一步。哈哈哈

连接数据库配置

有了前面章节配置的学习，我们知道要在项目 resources 创建对应 db.properties, mybatis-config.xml 配置。

db.properties 如下：

1
driver=com.mysql.jdbc.Driver
2
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Hongkong
3
username=root
4
password=

创建完对应的属性，我们需要创建对应的 mybatis-config.xml 配置，${字段名} 就是我们 db.properties 对应的字段信息：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<configuration>
6
    <!-- 引入数据库相关属性 -->
7
    <properties resource="db.properties"/>
8
9
    <environments default="development">
10
        <environment id="development">
11
            <transactionManager type="JDBC"/>
12
            <dataSource type="POOLED">
13
                <property name="driver" value="${driver}"/>
14
                <property name="url" value="${url}"/>
15
                <property name="username" value="${username}"/>
16
                <property name="password" value="${password}"/>
17
            </dataSource>
18
        </environment>
19
    </environments>
20
</configuration>

有了这些基础配置，为了方便我们去使用 Mybatis，我们还需要写一个对应的 com.yubulang.utils.MybatisUtils 工具类：

1
package com.yubulang.utils;
2
3
import org.apache.ibatis.io.Resources;
4
import org.apache.ibatis.session.SqlSession;
5
import org.apache.ibatis.session.SqlSessionFactory;
6
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
7
8
import java.io.IOException;
9
import java.io.InputStream;
10
11
public class MybatisUtils {
12
    private static SqlSessionFactory sqlSessionFactory;
13
14
    static {
15
        String resource = "mybatis-config.xml";
16
17
        try {
18
            InputStream in = Resources.getResourceAsStream(resource);
19
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
20
        } catch (IOException e) {
21
            e.printStackTrace();
22
        }
23
    }
24
25
    public static SqlSession getSqlSession() {
26
        return sqlSessionFactory.openSession();
27
    }
28
}

在这里我们已经可以连接我们的数据库了，在连接完数据库，我们需要创建我们的实体类 com.yubulang.pojo.UserTest:

1
package com.yubulang.pojo;
2
3
public class UserTest {
4
    private int id;
5
    private String name;
6
    private String password;
7
8
    public UserTest() {
9
    }
10
11
    public UserTest(int id, String name, String password) {
12
        this.id = id;
13
        this.name = name;
14
        this.password = password;
15
    }
16
17
    public int getId() {
18
        return id;
19
    }
20
21
    public void setId(int id) {
22
        this.id = id;
23
    }
24
25
    public String getName() {
26
        return name;
27
    }
28
29
    public void setName(String name) {
30
        this.name = name;
31
    }
32
33
    public String getPassword() {
34
        return password;
35
    }
36
37
    public void setPassword(String password) {
38
        this.password = password;
39
    }
40
41
    @Override
42
    public String toString() {
43
        return "User{" +
44
                "id=" + id +
45
                ", name='" + name + '\'' +
46
                ", password='" + password + '\'' +
47
                '}';
48
    }
49
}

这一步完成后，我们已经有了实体类，这个时候就是创建对应的 Mapper 了，我们创建 com.yubulang.dao.UserTestMapper 这个实现接口类：

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.UserTest;
4
5
import java.util.List;
6
7
public interface UserTestMapper {
8
    List<UserTest> getUserTestList();
9
}

有了对应的实现接口，我们也要创建对应的 com.yubulang.dao.UserTestMapper.xml 让我们进行对其进行配置：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 注意这里的 namespace 是我们要隐射的实现接口类 -->
7
<mapper namespace="com.yubulang.dao.UserTestMapper">
8
    <!-- resultType 返回值类型，这里我们简单的，一会儿去 mybatis-config.xml 配置 -->
9
    <select id="getUserTestList" resultType="UserTest">
10
        select * from users_test;
11
    </select>
12
</mapper>

有了这个隐射文件，我们需要将其对应的路径引入到我们的 mybatis-config.xml 中去，当然还要配置对应的实体类别名：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<configuration>
6
    <properties resource="db.properties"/>
7
8
    <typeAliases>
9
        <typeAlias type="com.yubulang.pojo.UserTest" alias="UserTest"/>
10
    </typeAliases>
11
12
    <environments default="development">
13
        <environment id="development">
14
            <transactionManager type="JDBC"/>
15
            <dataSource type="POOLED">
16
                <property name="driver" value="${driver}"/>
17
                <property name="url" value="${url}"/>
18
                <property name="username" value="${username}"/>
19
                <property name="password" value="${password}"/>
20
            </dataSource>
21
        </environment>
22
    </environments>
23
24
    <mappers>
25
        <mapper resource="com/yubulang/dao/UserTestMapper.xml"/>
26
    </mappers>
27
</configuration>

实现代码这里已经是 Ok 的了。我们需要在 test/java 目录下创建一个 com.yubulang.dao.UserTestMapperTest 的测试文件来测试我们的代码：

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.UserTest;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
import java.util.List;
9
10
public class UserTestMapperTest {
11
    @Test
12
    public void testGetUserTestList() {
13
        SqlSession sqlSession = MybatisUtils.getSqlSession();
14
15
        UserTestMapper mapper = sqlSession.getMapper(UserTestMapper.class);
16
17
        List<UserTest> userTestList = mapper.getUserTestList();
18
        for (UserTest userTest : userTestList) {
19
            System.out.println(userTest);
20
        }
21
22
        sqlSession.close();
23
    }
24
}

运行测试，我们可以发现运行结果 password 是 null 而 name 正常输出。

1
User{id=1, name='鱼不浪', password='null'}
2
User{id=2, name='鲁班', password='null'}
3
User{id=3, name='西施', password='null'}
4
User{id=4, name='麦特凯', password='null'}

到这里，我们才是要开始解决我们的问题。其实解决这个问题的方法也简单，我们可以直接修改 com.yubulang.dao.UserTestMapper.xml 的 select sql 语句，改成下面这样：

1
select id, name, pwd as password from users_test;

这样一样能达成我们的效果，但是这显然有点笨。我们来看看科学的方法。

resultMap 结果集映射

从字面表达来说，结果集映射故名思意就是把结果集中的字段与我们的实体类字段隐射关联一下。我们还是对 com.yubulang.dao.UserTestMapper.xml 进行修改。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<mapper namespace="com.yubulang.dao.UserTestMapper">
7
    <!-- 结果集隐射 -->
8
    <resultMap id="UserTestMap" type="UserTest">
9
        <!-- 让对应的列名，对应我们的实体类属性 -->
10
        <result column="id" property="id"/>
11
        <result column="name" property="name"/>
12
        <result column="pwd" property="password"/>
13
    </resultMap>
14
15
    <!-- 原来的返回类型resultType 替换成为 resultMap -->
16
    <select id="getUserTestList" resultMap="UserTestMap">
17
        select * from users_test;
18
    </select>
19
</mapper>
  • resultMap 元素是 MyBatis 中最重要最强大的元素
  • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
  • ResultMap 的优秀之处——你完全可以不用显式地配置它们，可以把有需要隐射的字段来隐射

所以，我们这里只需要保留下不一样的需要隐射的字段就好了：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<mapper namespace="com.yubulang.dao.UserTestMapper">
7
    <!-- 结果集隐射 -->
8
    <resultMap id="UserTestMap" type="UserTest">
9
        <!-- 让对应的列名，对应我们的实体类属性 -->
10
        <!-- <result column="id" property="id"/> -->
11
        <!-- <result column="name" property="name"/> -->
12
        <result column="pwd" property="password"/>
13
    </resultMap>
14
15
    <!-- 原来的返回类型resultType 替换成为 resultMap -->
16
    <select id="getUserTestList" resultMap="UserTestMap">
17
        select * from users_test;
18
    </select>
19
</mapper>

总结

这里只是开胃菜，我们在项目中会有很多更加复杂的形式，一点点深入我们会接触到。就如文档中说的那样，世界如果总是这么简单就好了。不过还是劝解大家醒醒哈哈哈

]]> Java Java Mybatis Mybatis-入门（四） /2020/04/07/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E5%9B%9B%EF%BC%89/ 前言

在快速搭建 mybatis 环境，实现增删改查的操作，配置的相关操作之后，我们也需要了解一下 Mybatis 的生命周期以及作用域，之所以会提到肯定是在某些场景下容易出现问题。为了避免这些不必要的问题。

生命周期与作用域

右连接

不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的 并发问题。

SqlSessionFactoryBuilder:

  • 一旦创建了 SqlSessionFactory，就不需要它了
  • 局部变量

SqlSessionFactory：

  • 说白了可以把它认为是：数据库连接池
  • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
  • 因此 SqlSessionFactory 的最佳作用域是应用作用域（全局的）
  • 最简单的就是使用单例模式或者静态单例模式

SqlSession：

  • 连接到连接池的一个请求
  • SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
  • 有连接使用完也必须立马关闭，防止资源的占用
右连接

这里的每个 Mapper，就代表一个具体的业务主要就是负责 SQL 语句的执行。

总结

了解 Mybatis 的生命周期与作用域，可以帮助我们理解在项目实际开发的过程中，遇到的一些资源占用问题，防止错误的创建数据库资源造成不必要的资源浪费的现象。

]]> Java Java Mybatis Mybatis-入门（三） /2020/04/06/Mybatis-%E5%85%A5%E9%97%A8%EF%BC%88%E4%B8%89%EF%BC%89/ 前言

经过了增删改查的编写，我们对 Mybatis 的使用有了一个大致的了解，但是仅仅知道增删改查的使用还不够，就好像我们使用 Nginx 去作为服务器，我们作为程序员不仅是要用，更多的是去配置他们一样。所以我们也要来学习一下 Mybatis 的配置，也是我们真正要掌握的能力。

核心配置文件

官方建议把配置文件命名为：mybatis-config.xml，配置文档中的层级机构如下：

  • configuration（配置）
    • properties（属性）[完全掌握]
    • settings（设置）[部分掌握]
    • typeAliases（类型别名）[完全掌握]
    • typeHandlers（类型处理器）[了解]
    • objectFactory（对象工厂）[了解]
    • plugins（插件）[了解]
    • environments（环境配置）[完全掌握]
      • environment（环境变量）
        • transactionManager（事务管理器）
        • dataSource（数据源）
    • databaseIdProvider（数据库厂商标识）[了解]
    • mappers（映射器）[完全掌握]

看着多，我们一个一个的看。我们进入配置的时候最先配置的肯定是连接数据库的环境配置。所以我们先看环境配置。

environments（环境配置）

Mybatis 是可以配置多个环境的，这种机制有助于 SQL 隐射应用于多个数据库之中。例如：开发的时候我们用开发数据库、生产的时候我们使用生产数据库。

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

我们来看看：配置中的一些描述,这个是我配置的环境

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<!-- 核心配置文件 -->
6
<configuration>
7
    <!-- 多个开发环境配置 -->
8
    <!-- 这里可以配置多个环境，但是default是指定我们默认使用的环境是哪个 -->
9
    <!-- 修改值，只需要对应 <environment> 的id即可，这里默认的是development -->
10
    <environments default="development">
11
        <!-- id 是对环境的命名 -->
12
        <environment id="development">
13
            <!-- 事务管理器 -->
14
            <transactionManager type="JDBC"/>
15
            <dataSource type="POOLED">
16
                <property name="driver" value="com.mysql.jdbc.Driver"/>
17
                <property name="url"
18
                          value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=Hongkong"/>
19
                <property name="username" value="root"/>
20
                <property name="password" value=""/>
21
            </dataSource>
22
        </environment>
23
24
        <environment id="test">
25
            <transactionManager type="JDBC"/>
26
            <dataSource type="POOLED">
27
                <property name="driver" value="com.mysql.jdbc.Driver"/>
28
                <property name="url"
29
                          value=""/>
30
                <property name="username" value=""/>
31
                <property name="password" value=""/>
32
            </dataSource>
33
        </environment>
34
    </environments>
35
</configuration>

通过上面例子，我们可以学会使用配置多套运行环境。Mybatis 默认的事务管理器就是 JDBC，默认连接池是 POOLED。

属性（properties）

我们可以通过 properties 属性来实现引用配置文件。这些属性是可以外部配置并且替换的，既可以在典型的 Java 属性文件中配置，亦可以通过 properties 元素的子元素来传递。

这里我们在 resources 中创建 db.properties 文件，输入以下内容

1
driver=com.mysql.jdbc.Driver
2
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Hongkong
3
username=root
4
password=

输入完成后，这个文件可以在我们的核心配置文件中引入，引入时，我们需要注意顺序，引入顺序如上面，核心配置文件下面给出的顺序跳转到配置处

修改后的配置文件如下：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<!-- 核心配置文件 -->
6
<configuration>
7
    <!-- 引入外部配置文件 -->
8
    <!-- 因为 db.properties 和 mybatis-config.xml 在同一个文件下，我们直接输入文件名就好了。 -->
9
    <properties resource="db.properties"/>
10
11
    <!-- 多个开发环境配置 -->
12
    <environments default="development">
13
        <environment id="development">
14
            <!-- 事务管理 -->
15
            <transactionManager type="JDBC"/>
16
            <dataSource type="POOLED">
17
                <!-- 原来手写的文件，我们这里就可以直接使用 db.properties 中的定义的变量所代替 -->
18
                <property name="driver" value="${driver}"/>
19
                <property name="url" value="${url}"/>
20
                <property name="username" value="${username}"/>
21
                <property name="password" value="${password}"/>
22
            </dataSource>
23
        </environment>
24
    </environments>
25
26
    <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册-->
27
    <mappers>
28
        <mapper resource="com/yubulang/dao/UserMapper.xml"/>
29
    </mappers>
30
</configuration>

当然，我们的<properties>标签之中还能写入单独的属性<property>，我们也可以把对应的属性单独定义在这里。具体的代码大家可以自己尝试一下。如果定义的属性同时存在于 resource 外部配置文件中，同时使用了<property>，他会有限使用外部文件中定义的变量。

别名（typeAliases）

  • 类型别名可以为 Java 类设置一个缩写的名字。
  • 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

之前我们在 UserMapper.xml 中的类型上都需要使用全限定类名，这样写起来真的是又臭又长，就像下面这样

1
<select id="getUserList" resultType="com.yubulang.pojo.User">
2
    select * from users;
3
</select>

我们更加希望的是 resultType="User" 要达到这个目的，我们需要在 mybatis-config.xml 中设置<typeAliases>当然还是要提醒大家注意配置的顺序，必须按顺序配置，这里我给出了两个方式：

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<!-- 核心配置文件 -->
6
<configuration>
7
    <!-- 引入外部配置文件 -->
8
    <properties resource="db.properties"/>
9
10
    <!-- 第一个方式：挨个给实体类起别名 -->
11
    <typeAliases>
12
        <typeAlias type="com.yubulang.pojo.User" alias="User"/>
13
    </typeAliases>
14
15
    <!-- 第二个方式：直接扫描指定包 -->
16
    <!-- 这里需要注意，我们扫描包的时候，它的默认别名是类名，首字母小写！ -->
17
    <!-- <typeAliases>
18
        <package name="com.yubulang.pojo"/>
19
    </typeAliases> -->
20
21
    <!-- 多个开发环境配置 -->
22
    <environments default="development">
23
        <environment id="development">
24
            <!-- 事务管理 -->
25
            <transactionManager type="JDBC"/>
26
            <dataSource type="POOLED">
27
                <property name="driver" value="${driver}"/>
28
                <property name="url" value="${url}"/>
29
                <property name="username" value="${username}"/>
30
                <property name="password" value="${password}"/>
31
            </dataSource>
32
        </environment>
33
    </environments>
34
35
    <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册-->
36
    <mappers>
37
        <mapper resource="com/yubulang/dao/UserMapper.xml"/>
38
    </mappers>
39
</configuration>

这个时候，我们的 com/yubulang/dao/UserMapper.xml 就可以使用指定的别名了，不需要再写常常的全限定类名。

何时使用别名（typeAliases），用哪种？

  • 在实体类比较少的时候，使用第一种
  • 在实体类比较多的时候，使用第二种

第一种可以自定义别名，第二种则不行，如果非要修改，可以使用 @Alias() 注解给对应的实体类起别名。像下面这样：

1
package com.yubulang.pojo;
2
3
import org.apache.ibatis.type.Alias;
4
5
@Alias("CustomUser")
6
class User {
7
    ...
8
}

Mybatis 为常见的 Java 类型内建的类型别名。它们都是不区分大小写的，注意，为了应对原始类型的命名重复，采取了特殊的命名风格。
❤【连接传送门】❤

设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。目前记住对应的日志处理器怎么设置就好。具体的日志选项。

❤【连接传送门】❤

其他配置，用到再查，因为很少用。

  • typeHandlers（类型处理器）
  • objectFactory（对象工厂）
  • plugins（插件）
    • mybatis-generator-core
    • mybatis-plus
    • 通用 mapper

映射器（mappers）

MapperRegistry：注册绑定我们的 Mapper 文件；
方式一：

1
<mappers>
2
    <mapper resource="com/yubulang/dao/UserMapper.xml"/>
3
</mappers>

方式二：使用 class 文件绑定注册

1
<mappers>
2
    <mapper class="com.yubulang.dao.UserMapper"/>
3
</mappers>

方式三：使用扫描包进行注入绑定

1
<mappers>
2
    <package class="com.yubulang.dao"/>
3
</mappers>

方式二和三注意点：

  • 接口和他的 Mapper 配置文件必须同名
  • 接口和它的 Mapper 配置文件必须在同一包下

总结

通过学习这里的配置案例，我们应该已经达到以下的目的：

  • 将数据库配置文件外部引入
  • 实体类别名
  • 保证 UserMapper 接口和 UserMapper.xml 改为一致，并且放在同一个包下
]]> Java Java Mybatis Mybaits-入门（二） /2020/04/05/Mybaits-%E5%85%A5%E9%97%A8%EF%BC%88%E4%BA%8C%EF%BC%89/ 前言

有了第一篇《Mybaits-入门（一）》的铺垫，我们已经有一个基本的程序骨架了，虽然只是简单的查询，但是我们可以大概了解到 Mybatis 的相关操作了。接下来咱们一点一点的来，慢慢了解 Mybatis 的增、删、改、查操作。

CRUD

我们把上一篇文章中com/yubulang/dao/UserMapper.xml的配置贴出来，看看相关的参数

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
    <!-- resultType 返回类型：要填写全类型名 -->
10
    <select id="getUserList" resultType="com.yubulang.pojo.User">
11
        select * from users
12
    </select>
13
</mapper>

namespace

我们需要注意的是 namespace 中的包名和 Dao/Mapper 接口的包名一致。

select：选择查询语句

  • id 就是对应的 namespace 中的方法名
  • resultType：Sql 语句执行的返回值
  • parameterType：参数类型

刚才我们已经查询全部用户的方法，现在我们实现一个查询指定用户的 id 的用户消息。还是老规矩，我们先实现接口实现类。

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
5
import java.util.List;
6
7
public interface UserMapper {
8
    // 获取全部用户
9
    List<User> getUserList();
10
11
    // 根据id获取用户
12
    User getUserById(int id);
13
}

在接口实现类中添加了getUserById方法，同时我们也要在UserMapper.xml下面添加对应的 <select> 标签，这个标签需要我们传递参数进入 parameterType 参数类型。在写 sql 语句时，我们要用 #{id} 来做参数占位符。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
10
    <!-- resultType 返回类型：要填写全类型名 -->
11
    <select id="getUserList" resultType="com.yubulang.pojo.User">
12
        select * from users
13
    </select>
14
15
    <!-- 查询指定用户id的信息 -->
16
    <select id="getUserById" resultType="com.yubulang.pojo.User" parameterType="int">
17
        select * from users where id=#{id}
18
    </select>
19
</mapper>

写完之后，测试代码也要跟上：

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
import java.util.List;
9
10
public class UserMapperTest {
11
    @Test
12
    public void testGetUserList() {
13
        // 第一步：获得SqlSession对象
14
        SqlSession sqlSession = MybatisUtils.getSqlSession();
15
16
        // 执行SQL
17
        // 方式一：getMapper
18
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
19
        List<User> userList = mapper.getUserList();
20
        for (User user : userList) {
21
            System.out.println(user);
22
        }
23
24
        System.out.println("============================================");
25
26
        // 方式二：旧的一种方式不太推荐
27
        List<User> userList2 = sqlSession.selectList("com.yubulang.dao.UserMapper.getUserList");
28
        for (User user : userList2) {
29
            System.out.println(user);
30
        }
31
32
        // 关闭SqlSession
33
        sqlSession.close();
34
    }
35
36
    @Test
37
    public void testGetUserById() {
38
        SqlSession sqlSession = MybatisUtils.getSqlSession();
39
40
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
41
42
        User user = mapper.getUserById(1);
43
44
        System.out.println(user);
45
46
        sqlSession.close();
47
    }
48
}

insert： 插入操作

既然有查询，就肯定有插入的操作，其实方式都差不多，需要我们耐心的去重复，直到形成本能记忆。我们还是在 com.yubulang.dao.UserMapper 中创建一个 addUser 方法。

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
5
import java.util.List;
6
7
public interface UserMapper {
8
    // 获取全部用户
9
    List<User> getUserList();
10
11
    // 根据id获取用户
12
    User getUserById(int id);
13
14
    // 创建一个用户
15
    int addUser(User user);
16
}

UserMapper.xml也要加入对应的 <insert> 标签，这个 insert 标签，没有 returnType 标签，这里我们的 parameterType 是一个 User 类型，我们要怎么传值呢？Mybatis 允许我们直接使用类的字段属性做占位符。我们来看看 xml 文件如何编写。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
10
    <!-- resultType 返回类型：要填写全类型名 -->
11
    <select id="getUserList" resultType="com.yubulang.pojo.User">
12
        select * from users
13
    </select>
14
15
    <!-- 查询指定用户id的信息 -->
16
    <select id="getUserById" resultType="com.yubulang.pojo.User" parameterType="int">
17
        select * from users where id=#{id}
18
    </select>
19
20
    <!-- 创建一个用户 -->
21
    <!-- insert 没有returnType -->
22
    <!-- User 对象中的属性，可以直接取出 -->
23
    <insert id="addUser" parameterType="com.yubulang.pojo.User">
24
        insert into users (name, password) values (#{name}, #{password})
25
    </insert>
26
</mapper>

测试代码这个时候要跟上，在 test/java 目录 com.yubulang.dao.UserMapperTest 添加 testAddUser 测试方法：

1
@Test
2
public void testAddUser() {
3
    SqlSession sqlSession = MybatisUtils.getSqlSession();
4
5
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
6
7
    User user = new User();
8
    user.setName("赵云");
9
    user.setPassword("666666");
10
11
    int result = mapper.addUser(user);
12
    if (result > 0) {
13
        System.out.println("插入成功！");
14
    }
15
16
    sqlSession.close();
17
}

我们执行，会发现这条数据并未插入到数据库，这是为什么呢？因为增删改都需要提交事务才能完成入库。

所以我们需要将代码调整一下：

1
// 增删改查需要提交事务
2
@Test
3
public void testAddUser() {
4
    SqlSession sqlSession = MybatisUtils.getSqlSession();
5
6
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
7
8
    User user = new User();
9
    user.setName("赵云");
10
    user.setPassword("666666");
11
12
    int result = mapper.addUser(user);
13
    if (result > 0) {
14
        System.out.println("插入成功！");
15
    }
16
17
    // 提交事务
18
    sqlSession.commit();
19
20
    sqlSession.close();
21
}

parameterType 的参数为 map 时，这个方式实际开发中也会用到，我们也拿过来看看。

创建一个 addUserWithMap 接口实现方法到 UserMapper.java 接口中：

1
// 添加用户使用 Map 参数
2
int addUserWithMap(Map<String, Object> map);

添加对应的 xml 到 UserMapper.xml 中：

1
<insert id="addUserWithMap" parameterType="map">
2
    insert into users (name, password) values (#{userName}, #{passWord})
3
</insert>
4
```
5
6
键入测试代码：
7
```java
8
@Test
9
public void testAddUserWithMap() {
10
    SqlSession sqlSession = MybatisUtils.getSqlSession();
11
12
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
13
14
    Map<String, Object> map = new HashMap<String, Object>();
15
16
    map.put("userName", "大番薯");
17
    map.put("passWord", "666666");
18
19
    int result = mapper.addUserWithMap(map);
20
    if (result > 0) {
21
        System.out.println("插入成功！");
22
    }
23
24
    // 提交事务
25
    sqlSession.commit();
26
27
    sqlSession.close();
28
}
29
```
30
31
我们可以看到占位符 `#{userName}`,`#{passWord}` 是对应了 Map传入的键。
32
33
### update：修改操作
34
35
有了添加操作的铺垫，我相信 update 的操作也就是依葫芦画瓢的事儿，我还是继续将代码敲一遍。接口实现类代码如下：
36
37
```java
38
package com.yubulang.dao;
39
40
import com.yubulang.pojo.User;
41
42
import java.util.List;
43
44
public interface UserMapper {
45
    // 获取全部用户
46
    List<User> getUserList();
47
48
    // 根据id获取用户
49
    User getUserById(int id);
50
51
    // 创建一个用户
52
    int addUser(User user);
53
54
    // 修改一个用户
55
    int updateUser(User user);
56
}

UserMapper.xml也要加入对应的 <update> 标签。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
10
    <!-- resultType 返回类型：要填写全类型名 -->
11
    <select id="getUserList" resultType="com.yubulang.pojo.User">
12
        select * from users
13
    </select>
14
15
    <!-- 查询指定用户id的信息 -->
16
    <select id="getUserById" resultType="com.yubulang.pojo.User" parameterType="int">
17
        select * from users where id=#{id}
18
    </select>
19
20
    <!-- 创建一个用户 -->
21
    <!-- insert 没有returnType -->
22
    <!-- User 对象中的属性，可以直接取出 -->
23
    <insert id="addUser" parameterType="com.yubulang.pojo.User">
24
        insert into users (name, password) values (#{name}, #{password})
25
    </insert>
26
27
    <!-- 修改一个用户 -->
28
    <update id="updateUser" parameterType="com.yubulang.pojo.User">
29
        update users set name=#{name}, password=#{password} where id=#{id}
30
    </update>
31
</mapper>

测试代码走起，在 test/java 目录 com.yubulang.dao.UserMapperTest 添加 testUpdateUser 测试方法：

1
@Test
2
public void testUpdateUser() {
3
    SqlSession sqlSession = MybatisUtils.getSqlSession();
4
5
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
6
7
    User user = mapper.getUserById(3);
8
    user.setName(user.getName() + "修改");
9
10
    int result = mapper.updateUser(user);
11
    if (result > 0) {
12
        System.out.println("修改成功");
13
    }
14
15
    sqlSession.commit();
16
    sqlSession.close();
17
}

delete：删除操作

删除用户的操作接口实现类：

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
5
import java.util.List;
6
7
public interface UserMapper {
8
    // 获取全部用户
9
    List<User> getUserList();
10
11
    // 根据id获取用户
12
    User getUserById(int id);
13
14
    // 创建一个用户
15
    int addUser(User user);
16
17
    // 修改一个用户
18
    int updateUser(User user);
19
20
    // 删除一个用户
21
    int deleteUser(int id);
22
}

UserMapper.xml也要加入对应的 <delete> 标签。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
10
    <!-- resultType 返回类型：要填写全类型名 -->
11
    <select id="getUserList" resultType="com.yubulang.pojo.User">
12
        select * from users
13
    </select>
14
15
    <!-- 查询指定用户id的信息 -->
16
    <select id="getUserById" resultType="com.yubulang.pojo.User" parameterType="int">
17
        select * from users where id=#{id}
18
    </select>
19
20
    <!-- 创建一个用户 -->
21
    <!-- insert 没有returnType -->
22
    <!-- User 对象中的属性，可以直接取出 -->
23
    <insert id="addUser" parameterType="com.yubulang.pojo.User">
24
        insert into users (name, password) values (#{name}, #{password})
25
    </insert>
26
27
    <!-- 修改一个用户 -->
28
    <update id="updateUser" parameterType="com.yubulang.pojo.User">
29
        update users set name=#{name}, password=#{password} where id=#{id}
30
    </update>
31
32
    <!-- 删除一个用户 -->
33
    <delete id="deleteUser" parameterType="int">
34
        delete from users where id=#{id}
35
    </delete>
36
</mapper>

测试代码走起，在 test/java 目录 com.yubulang.dao.UserMapperTest 添加 testDeleteUser 测试方法：

1
@Test
2
public void testDeleteUser() {
3
    SqlSession sqlSession = MybatisUtils.getSqlSession();
4
5
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
6
7
    int result = mapper.deleteUser(4);
8
    if (result > 0) {
9
        System.out.println("删除成功");
10
    }
11
12
    sqlSession.commit();
13
    sqlSession.close();
14
}

总结

基本的操作不是很难，不过复杂的还需要我们看看文档，才能知道一些具体的使用场景，加油！动手！动手！动手！

]]> Java Java Mybatis Mybaits-入门（一） /2020/04/05/Mybaits-%E5%85%A5%E9%97%A8%EF%BC%88%E4%B8%80%EF%BC%89/ 前言

学完 JDBC 后，其实很多时候我们项目开发中不会直接使用 JDBC，而是会用到一些更好的第三方封装库，Mybatis 就是第三方库中使用人数最多，口碑最好的一个存在。为了快速上手，当然是盘它吖。

搭建 MySQL 数据库相关的表环境

  • 搭建数据库，并创建数据
1
-- 创建数据库
2
CREATE DATABASE IF NOT EXISTS `mybatis` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
3
4
-- 使用数据库
5
USE `mybatis`;
6
7
-- 创建users表
8
CREATE TABLE `users` (
9
  `id` int(20) unsigned NOT NULL AUTO_INCREMENT,
10
  `name` varchar(64) NOT NULL,
11
  `password` varchar(64) NOT NULL,
12
  PRIMARY KEY (`id`)
13
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
14
15
-- 插入数据库
16
INSERT INTO `users` (`name`, `password`) VALUES ('鱼不浪', '666666');
17
INSERT INTO `users` (`name`, `password`) VALUES ('鲁班', '666666');
18
INSERT INTO `users` (`name`, `password`) VALUES ('西施', '666666');
19
INSERT INTO `users` (`name`, `password`) VALUES ('麦特凯', '666666');
  • 新建普通的 maven 项目为mybatis-study，删除 src 目录，使他成为一个父项目
  • 在父项目的 pom.xml 中放入以下依赖
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6
7
    <groupId>org.example</groupId>
8
    <artifactId>mybatis-study</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10
11
    <!-- 导入依赖 -->
12
    <dependencies>
13
        <!-- mysql 驱动 -->
14
        <dependency>
15
            <groupId>mysql</groupId>
16
            <artifactId>mysql-connector-java</artifactId>
17
            <version>5.1.48</version>
18
        </dependency>
19
20
        <!-- mybatis -->
21
        <dependency>
22
            <groupId>org.mybatis</groupId>
23
            <artifactId>mybatis</artifactId>
24
            <version>3.5.4</version>
25
        </dependency>
26
27
        <!-- junit -->
28
        <dependency>
29
            <groupId>junit</groupId>
30
            <artifactId>junit</artifactId>
31
            <version>4.13</version>
32
        </dependency>
33
    </dependencies>
34
</project>
  • 创建名为 mybatis-01 的子项目，并进入src/main/resources 目录，创建一个mybatis-config.xml的文件，并输入以下配置
1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<!-- 核心配置文件 -->
6
<configuration>
7
    <!-- 多个开发环境配置 -->
8
    <environments default="development">
9
        <environment id="development">
10
            <!-- 事务管理 -->
11
            <transactionManager type="JDBC"/>
12
13
            <dataSource type="POOLED">
14
                <property name="driver" value="com.mysql.jdbc.Driver"/>
15
                <property name="url"
16
                          value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=Hongkong"/>
17
                <property name="username" value="root"/>
18
                <property name="password" value=""/>
19
            </dataSource>
20
        </environment>
21
    </environments>
22
</configuration>

  • 编写 Mybatis 工具类

    创建com.yubulang.utils包，在里面创建MybatisUtils.java工具类，然后输入以下代码

1
package com.yubulang.utils;
2
3
import org.apache.ibatis.io.Resources;
4
import org.apache.ibatis.session.SqlSession;
5
import org.apache.ibatis.session.SqlSessionFactory;
6
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
7
8
import java.io.IOException;
9
import java.io.InputStream;
10
11
// sqlSessionFactory 用来构造 sqlSession
12
public class MybatisUtils {
13
14
    private static SqlSessionFactory sqlSessionFactory;
15
16
    static {
17
        // 这里是固定搭配写一次就OJBK了
18
        try {
19
            // 使用mybatis第一步：获取我们的 sqlSessionFactory 对象
20
            String resource = "mybatis-config.xml";
21
            InputStream in = Resources.getResourceAsStream(resource);
22
23
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
24
        } catch (IOException e) {
25
            e.printStackTrace();
26
        }
27
    }
28
29
    /**
30
     * 既然有了sqlSessionFactory，我们可以通过它获取一个 SqlSession
31
     *
32
     * @return SqlSession
33
     */
34
    public static SqlSession getSqlSession() {
35
        return sqlSessionFactory.openSession();
36
    }
37
}

编写代码操作数据库

  • 实体类：我们创建 com.yubulang.pojo.User.java 这个实体类
1
package com.yubulang.pojo;
2
3
/**
4
 * 实体类
5
 */
6
public class User {
7
    private int id;
8
    private String name;
9
    private String password;
10
11
    public User() {
12
    }
13
14
    public User(int id, String name, String password) {
15
        this.id = id;
16
        this.name = name;
17
        this.password = password;
18
    }
19
20
    public int getId() {
21
        return id;
22
    }
23
24
    public void setId(int id) {
25
        this.id = id;
26
    }
27
28
    public String getName() {
29
        return name;
30
    }
31
32
    public void setName(String name) {
33
        this.name = name;
34
    }
35
36
    public String getPassword() {
37
        return password;
38
    }
39
40
    public void setPassword(String password) {
41
        this.password = password;
42
    }
43
44
    @Override
45
    public String toString() {
46
        return "User{" +
47
                "id=" + id +
48
                ", name='" + name + '\'' +
49
                ", password='" + password + '\'' +
50
                '}';
51
    }
52
}
  • Dao/Mapper 接口（其实可以理解成为 Dao 层）
1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
5
import java.util.List;
6
7
public interface UserMapper {
8
    List<User> getUserList();
9
}
  • 接口实现类，我们在 Mybatis 这里，由原来的UserDaoImpl.java直接用xml文件代替，com.yubulang.dao包下创建UserMapper.xml
1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
6
<!-- 绑定一个指定的Dao/Mapper接口 -->
7
<mapper namespace="com.yubulang.dao.UserMapper">
8
    <!-- 查询语句, id对应UserMapper接口中的方法名 -->
9
    <!-- resultType 返回类型：要填写全类型名 -->
10
    <select id="getUserList" resultType="com.yubulang.pojo.User">
11
        select * from users
12
    </select>
13
</mapper>

测试上面的代码

我们使用junit测试，在 maven 项目中 main 同级的有一个 test 文件夹，我们尽量让我们的测试文件，与我们的 main 包中的结构相同。

我们键入以下测试代码：

1
package com.yubulang.dao;
2
3
import com.yubulang.pojo.User;
4
import com.yubulang.utils.MybatisUtils;
5
import org.apache.ibatis.session.SqlSession;
6
import org.junit.Test;
7
8
import java.util.List;
9
10
public class UserMapperTest {
11
    @Test
12
    public void test() {
13
        // 第一步：获得SqlSession对象
14
        SqlSession sqlSession = MybatisUtils.getSqlSession();
15
16
        // 执行SQL
17
        // 方式一：getMapper
18
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
19
        List<User> userList = mapper.getUserList();
20
        for (User user : userList) {
21
            System.out.println(user);
22
        }
23
24
        System.out.println("============================================");
25
26
        // 方式二：旧的一种方式不太推荐
27
        List<User> userList2 = sqlSession.selectList("com.yubulang.dao.UserMapper.getUserList");
28
        for (User user : userList2) {
29
            System.out.println(user);
30
        }
31
32
        // 关闭SqlSession
33
        sqlSession.close();
34
    }
35
}

注意这里的报错信息：

1
org.apache.ibatis.binding.BindingException: Type interface com.yubulang.dao.UserMapper is not known to the MapperRegistry.

在这里我们会接触到一个新的概念就是MapperRegistry。这是因为我们在当初配置mybatis-config.xml的时候没有配置对应的<mappers>，我们将对应的 mapper 配置加入到mybatis-config.xml中，然后启动测试test()。

1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<!-- 核心配置文件 -->
6
<configuration>
7
    <!-- 多个开发环境配置 -->
8
    <environments default="development">
9
        <environment id="development">
10
            <!-- 事务管理 -->
11
            <transactionManager type="JDBC"/>
12
13
            <dataSource type="POOLED">
14
                <property name="driver" value="com.mysql.jdbc.Driver"/>
15
                <property name="url"
16
                          value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=Hongkong"/>
17
                <property name="username" value="root"/>
18
                <property name="password" value=""/>
19
            </dataSource>
20
        </environment>
21
    </environments>
22
23
    <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册-->
24
    <mappers>
25
        <mapper resource="com/yubulang/dao/UserMapper.xml"/>
26
    </mappers>
27
</configuration>

启动运行，我们则发现我擦，报错了。说没有办法找到我们的Could not find resource com/yubulang/dao/UserMapper.xml这个文件，这是因为 maven 的过滤机制导致的，我们可以修改pom.xml配置，让他支持我们的 xml 文件可以被编译到我们的 class 中去。

1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <parent>
6
        <artifactId>mybatis-study</artifactId>
7
        <groupId>org.example</groupId>
8
        <version>1.0-SNAPSHOT</version>
9
    </parent>
10
    <modelVersion>4.0.0</modelVersion>
11
12
    <artifactId>mybatis-01</artifactId>
13
14
    <!-- 在build中配置resource，来防止我们资源导出失败的问题 -->
15
    <build>
16
        <resources>
17
            <resource>
18
                <directory>src/main/resources</directory>
19
                <includes>
20
                    <include>**/*.properties</include>
21
                    <include>**/*.xml</include>
22
                </includes>
23
                <filtering>true</filtering>
24
            </resource>
25
26
            <resource>
27
                <directory>src/main/java</directory>
28
                <includes>
29
                    <include>**/*.properties</include>
30
                    <include>**/*.xml</include>
31
                </includes>
32
                <filtering>true</filtering>
33
            </resource>
34
        </resources>
35
    </build>
36
</project>

再次点击运行测试，就能正常跑起来了。

总结

有了 Mybatis 后，我们的数据查询操作基本就在xml实现，我们单独维护起来也更加方便。可以说提高了我们不少的生产力。当然这里只是入门的操作，我们更多的操作还要去实践应用。一定要多动手，不要怕出错！

]]> Java Java Mybatis Java 反射笔记 /2020/04/04/Java-%E5%8F%8D%E5%B0%84%E7%AC%94%E8%AE%B0/ 前言

有了之前的注解内容，要搭配 Java 反射就能给注解注入灵魂了。

Java Reflection——反射

基础概念

  • Reflecttion（反射）是 Java 被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取地任何类的内部信息，并且直接操作任意对象的内部属性及方法。
  • 加载完类之后，在堆内存的方法中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看类的结构。这个对象就像是一面镜子，透过这个镜子看到类的结构，所以 Reflection 我们形象的成为反射。

正常方式：引入需要的"包类"名称 -> 通过 new 实例化 -> 取得实例化对象
反射方式：实例化对象 -> getClass()方法 -> 得到完整的"包类"名称

反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理
  • 等等

优点和缺点

优点

  • 可以实现动态创建对象和编译，体现出很大的灵活性

缺点

  • 对性能有影响。使用反射基本上是一种解释操作，我们可以告诉 JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同操作。

反射相关的主要 API

  • java.lang.Class：代表一个类
  • java.lang.reflect.Method：代表类的方法
  • java.lang.reflect.Field：代表类的成员变量
  • java.lang.reflect.Constructor：代表类的构造器

Class 类

在 Object 类中定义了 getClass()方法，此方法被所有子类继承

1
public final Class getClass()

getClass 方法的返回值是一个 Class 类，此类是 Java 反射的源头，实际上所谓的反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

对象照镜子可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

  • Class 本身也是一个类
  • Class 对象只能由系统建立对象
  • 一个加载的类在 JVM 中只会有一个 Class 实例
  • 一个 Class 对象对应的是一个加载到 JVM 中的一个.class 文件
  • 每个类的实例都会记得自己是由哪个 Class 实例所生成
  • 通过 Class 可以完整地得到一个类中的所有被加载的结构
  • Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class 对象

看个实际例子：

1
package com.yubulang.pojo.demo01;
2
3
// 什么叫反射
4
public class Demo01 {
5
    public static void main(String[] args) throws ClassNotFoundException {
6
        // 通过反射获取类的Class对象
7
        Class c1 = Class.forName("com.yubulang.pojo.demo01.User");
8
        Class c2 = Class.forName("com.yubulang.pojo.demo01.User");
9
        Class c3 = Class.forName("com.yubulang.pojo.demo01.User");
10
        Class c4 = Class.forName("com.yubulang.pojo.demo01.User");
11
12
        // 一个类在内存中只有一个Class对象，所以hashCode都相同
13
        // 一个类被加载后，类整个结构都会被封装在Class对象中。
14
        System.out.println(c1.hashCode());
15
        System.out.println(c2.hashCode());
16
        System.out.println(c3.hashCode());
17
        System.out.println(c4.hashCode());
18
    }
19
}
20
21
// 实体类：
22
class User {
23
    private String name;
24
    private int id;
25
    private int age;
26
27
    public User() {
28
    }
29
30
    public User(String name, int id, int age) {
31
        this.name = name;
32
        this.id = id;
33
        this.age = age;
34
    }
35
36
    public String getName() {
37
        return name;
38
    }
39
40
    public void setName(String name) {
41
        this.name = name;
42
    }
43
44
    public int getId() {
45
        return id;
46
    }
47
48
    public void setId(int id) {
49
        this.id = id;
50
    }
51
52
    public int getAge() {
53
        return age;
54
    }
55
56
    public void setAge(int age) {
57
        this.age = age;
58
    }
59
60
    @Override
61
    public String toString() {
62
        return "User{" +
63
                "name='" + name + '\'' +
64
                ", id=" + id +
65
                ", age=" + age +
66
                '}';
67
    }
68
}

常用方法

方法名功能说明
static Class forName(String name)返回指定类名 name 的 Class 对象
Object newInstance()调用默认构造函数，返回 Class 对象的一个实例
String getName()返回此 Class 对象所表示的实体（类、接口、数组类或 void）的名称。
Class getSuperClass()返回当前 Class 对象的父类 Class 对象
Class[] getInterfaces()获取当前 Class 对象的接口
ClassLoader getClassLoader()返回该类的加载器
Constructor[] getConstructors()返回一个包含某些 Constructor 对象的数组
Method getMethod(String name, Class..T)返回 Mthod 对象，此对象的形参型为 paramType
Field[] getDeclaredFields()返回 Field 对象的一个数组

获取 Class 类的实例

  • 若已知具体的类，通过类的 class 属性获取，该方法最为安全可靠，程序性能最高
    1
    Class person = Person.class;
  • 已知某个类的实例，调用该实例的 getClass()方法获取 Class 对象
    1
    class Person {}
    2
    Person person = new Person();
    3
    Class person = person.getClass();
  • 已知一个类的全类名，且该类在类路径下，可通过 Class 类的静态方法 forName()获取，可能抛出 ClassNotFoundException
    1
    Class person = Class.forName("demo01.Person");
    综合实例代码：
1
package com.yubulang.pojo.demo02;
2
3
// 测试class类的创建方式有哪些
4
public class Demo02 {
5
    public static void main(String[] args) throws ClassNotFoundException {
6
        Person person = new Student();
7
        System.out.println("这个人是：" + person.getName());
8
9
        // 方式一：通过对象获得
10
        Class<? extends Person> c1 = person.getClass();
11
        System.out.println(c1.hashCode());
12
13
        // 方式二：通过forName获得
14
        Class<?> c2 = Class.forName("com.yubulang.pojo.demo02.Student");
15
        System.out.println(c2.hashCode());
16
17
        // 方式三：通过类名.class
18
        Class<Student> c3 = Student.class;
19
        System.out.println(c3.hashCode());
20
21
        // 方式四：基本内置类型的包装类都有一个Type属性
22
        Class<Integer> c4 = Integer.TYPE;
23
        System.out.println(c4);
24
25
        // 获得父类类型
26
        Class<?> c5 = c1.getSuperclass();
27
        System.out.println(c5);
28
    }
29
}
30
31
class Person {
32
    private String name;
33
34
    public Person() {
35
    }
36
37
    public Person(String name) {
38
        this.name = name;
39
    }
40
41
    public String getName() {
42
        return name;
43
    }
44
45
    public void setName(String name) {
46
        this.name = name;
47
    }
48
49
    @Override
50
    public String toString() {
51
        return "Person{" +
52
                "name='" + name + '\'' +
53
                '}';
54
    }
55
}
56
57
class Student extends Person {
58
    public Student() {
59
        this.setName("学生");
60
    }
61
}
62
63
class Teacher extends Person {
64
    public Teacher() {
65
        this.setName("老师");
66
    }
67
}

哪些类型可以有 Class 对象

  • class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
  • interface：接口
  • []：数组
  • enum：枚举
  • annotation：注解@interface
  • primitive type：基本数据类型
  • void

上代码验证下：

1
package com.yubulang.pojo.demo03;
2
3
import java.lang.annotation.ElementType;
4
5
public class Demo {
6
    public static void main(String[] args) {
7
        // 所有类型的Class
8
9
        Class<Object> c1 = Object.class; // 类
10
        Class<Comparable> c2 = Comparable.class;  // 接口
11
        Class<String[]> c3 = String[].class; // 一维数组
12
        Class<int[][]> c4 = int[][].class; // 二位数组
13
        Class<Override> c5 = Override.class; // 注解
14
        Class<ElementType> c6 = ElementType.class; // 枚举
15
        Class<Integer> c7 = Integer.class; // 基本类型
16
        Class<Void> c8 = void.class; // void
17
        Class<Class> c9 = Class.class; // Class
18
19
        System.out.println(c1);
20
        System.out.println(c2);
21
        System.out.println(c3);
22
        System.out.println(c4);
23
        System.out.println(c5);
24
        System.out.println(c6);
25
        System.out.println(c7);
26
        System.out.println(c8);
27
        System.out.println(c9);
28
29
        // 只要元素类型与维度一样，就是同一个Class
30
        int[] a = new int[10];
31
        int[] b = new int[100];
32
        System.out.println(a.getClass().hashCode());
33
        System.out.println(b.getClass().hashCode());
34
    }
35
}

Java 内存分析

  • 栈内存
    • 存放基本变量类型（会包含这个基本类型的具体数值）
    • 引用对象的变量（会存放这个引用在堆里面的具体地址）
  • 堆内存
    • 存放 new 的对象和数组
    • 可以被所有的线程共享，不会存放别的对象引用
  • 方法区
    • 可以被所有的线程共享
    • 包含了所有 class 和 static 变量

了解类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对类进行初始化

  • 类加载（Load）
    • 将类的 class 文件读入内存，并为之创建一个 java.lang.Class 对象。此过程由类加载器完成
  • 类的连接（Link）
    • 将类的二进制数据合并到 JRE 中
  • 类的初始化（Initialize）
    • JVM 负责对类进行初始化

类的加载与 ClassLoader 的理解

  • 加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
  • 链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。
    • 验证：确保加载的类信息符合 JVM 规范，没有安全方面的问题
    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法中进行分配。
    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
  • 初始化：
    • 执行类构造器<cIinit>()方法的过程，类构造器<cIinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
    • 虚拟机会保证一个类的<cIinit>()方法在多线程环境中被正确加锁和同步。

代码演示如下

1
package com.yubulang.pojo.demo04;
2
3
public class Demo {
4
    public static void main(String[] args) {
5
        /*
6
        1. 加载到内存，会产生一个类对应Class对象
7
        2. 链接，链接结束后 m = 0
8
        3. 初始化
9
            方法区会有类的白能量初始化信息，而赋值的动作会在下面完成
10
            <cInit>() {
11
                // 编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生
12
                System.out.println("A类静态代码块初始化");
13
                m = 300;
14
                m = 100;
15
            }
16
         */
17
        A a = new A();
18
        System.out.println(A.m);
19
    }
20
}
21
22
class A {
23
    static {
24
        System.out.println("A类静态代码块初始化");
25
        m = 300;
26
    }
27
28
    static int m = 100;
29
30
    public A() {
31
        System.out.println("A类的无参构造器初始化");
32
    }
33
}

什么时候会发生类初始化？

  • 类的主动引用（一定会发生类的初始化）

    • 当虚拟机启动，先初始化 main 方法所在类
    • new 一个类的对象
    • 调用类的静态成员（除了 final 常量）和静态方法
    • 使用 java.lang。reflect 包的方法和对类进行反射调用
    • 初始化一个类，如果其父类没有被初始化，则先初始化它的父类

  • 类的被动引用（不发生类的初始化）

    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
    • 通过数组定义类引用，不会触发此类的初始化
    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

上面话对应的例子：

1
package com.yubulang.pojo.demo05;
2
3
public class Demo {
4
    static {
5
        System.out.println("Main所在类被加载");
6
    }
7
8
    public static void main(String[] args) throws ClassNotFoundException {
9
        // 类的主动引用（一定会发生类的初始化）
10
        // 1. 主动引用，初始化一个类，如果其父类没有被初始化，则先会初始化其父类
11
        /*
12
        输出：
13
            Main所在类被加载
14
            父类被加载
15
            子类被加载
16
         */
17
        // Son son = new Son();
18
19
        // 2. 反射也会产生主动给引用
20
        /*
21
        输出：
22
            Main所在类被加载
23
            父类被加载
24
            子类被加载
25
         */
26
        // Class.forName("com.yubulang.pojo.demo05.Son");
27
28
        // 3. 调用类的静态成员（除了final常量）和静态方法
29
        /*
30
        输出：
31
            Main所在类被加载
32
            父类被加载
33
            子类被加载
34
            100
35
         */
36
        // System.out.println(Son.m);
37
38
        /*
39
        输出：
40
            Main所在类被加载
41
            父类被加载
42
            子类被加载
43
            Son出来秀了
44
         */
45
        // Son.show();
46
47
48
        // ====================================================
49
50
        // 类的被动引用（不会发生类的初始化）
51
        // 1. 当通过子类引用父类的静态变量，不会导致子类初始化
52
        /*
53
        输出：
54
            Main所在类被加载
55
            父类被加载
56
            2
57
         */
58
        // System.out.println(Son.b);
59
60
        // 2. 通过数组定义类引用，不会触发此类的初始化
61
        // 只有main类被加载
62
        // Son[] array = new Son[5];
63
64
        // 3. 引用常量不会触发此类的初始化
65
        // 只有main类被加载
66
        // System.out.println(Son.M);
67
    }
68
}
69
70
class Father {
71
    static int b = 2;
72
73
    static {
74
        System.out.println("父类被加载");
75
    }
76
}
77
78
class Son extends Father {
79
    static {
80
        System.out.println("子类被加载");
81
        m = 300;
82
    }
83
84
    static int m = 100;
85
    static final int M = 100;
86
87
    public static void show() {
88
        System.out.println("Son出来秀了");
89
    }
90
}

类加载器的作用

  • 类加载的作用：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口。
  • 类缓存：标准的 JavaSE 类加载器可以按照要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过 JVM 垃圾回收机制可以回收这些 Class 对象。

类加载器的作用

类加载器作用是用来把类（class）装载进内存。JVM 规范定义了如下类型的类的加载器。

  • 引导类加载器：用 C++编写，是 JVM 自带的类加载器，负责 Java 平台核心库，用来装载核心类库。该装载类无法直接获取
  • 扩展加载器：负责 jre/lib/ext 目录下 jar 包或 -D java.ext.dirs 指定目录下的 jar 包装入工作库
  • 系统类加载器：负责 java –classpath 或 -D java.class.path 所指的目录下的类与 jar 包装入工作，是常用的加载器。

我们来获取下类加载器：

1
package com.yubulang.pojo.demo06;
2
3
public class Demo {
4
    public static void main(String[] args) throws ClassNotFoundException {
5
        // 获取系统类的加载器
6
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
7
        System.out.println(systemClassLoader);
8
9
        // 获取系统类加载器的父类加载器 -> 扩展加载器
10
        ClassLoader parent = systemClassLoader.getParent();
11
        System.out.println(parent);
12
13
        // 获取扩展类加载器的父类加载器 -> 根加载器(C++)
14
        ClassLoader root = parent.getParent();
15
        System.out.println(root);
16
17
        // 测试当前类是哪个加载器加载的
18
        ClassLoader classLoader = Class.forName("com.yubulang.pojo.demo06.Demo").getClassLoader();
19
        System.out.println(classLoader);
20
21
        // 测试JDK的类，结果是根加载器（C++）那层的
22
        classLoader = Class.forName("java.lang.Object").getClassLoader();
23
        System.out.println(classLoader);
24
25
        // 如何获取系统类加载器可以加载的路径
26
        String classPath = System.getProperty("java.class.path");
27
        System.out.println(classPath);
28
29
        // 双清委派机制
30
        // 假设你自定义了一个 java.lang.String包，
31
        // 加载完成后Java会检测包的正确性，
32
        // 会用自身root加载的java.lang.String包，
33
        // 覆盖你写的包，以保证包的正确性
34
    }
35
}

创建运行类的对象

###获取类运行时类的完整结构
通过反射获取运行时类的完整结构，我们可以获取类的 Field、Method、Constructor、Superclass、Interface、Annotation。

  • 实现的全部接口
  • 所继承的父类
  • 全部的构造器
  • 全部的方法
  • 全部的字段
  • 注解

上例子

1
package com.yubulang.pojo.demo07;
2
3
4
import java.lang.reflect.Constructor;
5
import java.lang.reflect.Field;
6
import java.lang.reflect.Method;
7
8
public class Demo {
9
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
10
        Class<?> c1 = Class.forName("com.yubulang.pojo.demo07.User");
11
12
        // 获得类的名字
13
        System.out.println("=== 类的名字 ===");
14
        System.out.println(c1.getName()); // 获取 包和类的名字完整信息
15
        // 获取类的简单名字
16
        System.out.println(c1.getSimpleName()); // 获取 类的名字信息
17
18
        // 获取类的属性
19
        System.out.println("=== 类的 public 属性 ====");
20
        Field[] fields = c1.getFields(); // 获取类的 public 属性
21
        for (Field field : fields) {
22
            System.out.println(field);
23
        }
24
25
        System.out.println("=== 类的所有属性 ====");
26
        Field[] declaredFields = c1.getDeclaredFields(); // 获取类的所有属性
27
        for (Field declaredField : declaredFields) {
28
            System.out.println(declaredField);
29
        }
30
31
        // 获得指定属性的值
32
        System.out.println("=== 获得指定属性的值 ===");
33
        Field name = c1.getDeclaredField("name");
34
        System.out.println(name);
35
36
        // 获取所有的方法
37
        System.out.println("=== 获取所有的方法 ===");
38
        Method[] methods = c1.getMethods(); // 获取本类及其父类的全部public方法
39
        for (Method method : methods) {
40
            System.out.println("getMethods:" + method);
41
        }
42
43
        Method[] declaredMethods = c1.getDeclaredMethods(); // 获取本类的全部方法(包含私有方法）
44
        for (Method declaredMethod : declaredMethods) {
45
            System.out.println("getDeclaredMethods:" + declaredMethod);
46
        }
47
48
        // 获得指定方法
49
        System.out.println("=== 获得指定方法 ===");
50
        Method getName = c1.getMethod("getName", null);
51
        System.out.println(getName);
52
        Method setName = c1.getMethod("setName", String.class);
53
        System.out.println(setName);
54
55
        // 获取所有构造器
56
        System.out.println("=== 获取所有public构造器 ===");
57
        Constructor<?>[] constructors = c1.getConstructors();
58
        for (Constructor<?> constructor : constructors) {
59
            System.out.println(constructor);
60
        }
61
62
        System.out.println("=== 获取所有构造器 ===");
63
        Constructor<?>[] declaredConstructors = c1.getDeclaredConstructors();
64
        for (Constructor<?> constructor : declaredConstructors) {
65
            System.out.println(constructor);
66
        }
67
68
        // 获取指定构造器
69
        System.out.println("=== 获取指定构造器 ===");
70
        Constructor<?> constructor = c1.getConstructor(null);
71
        System.out.println(constructor);
72
        constructor = c1.getConstructor(String.class, int.class, int.class);
73
        System.out.println(constructor);
74
    }
75
}
76
77
class User {
78
    private String name;
79
    private int id;
80
    private int age;
81
82
    public User() {
83
    }
84
85
    public User(String name, int id, int age) {
86
        this.name = name;
87
        this.id = id;
88
        this.age = age;
89
    }
90
91
    public String getName() {
92
        return name;
93
    }
94
95
    public void setName(String name) {
96
        this.name = name;
97
    }
98
99
    public int getId() {
100
        return id;
101
    }
102
103
    public void setId(int id) {
104
        this.id = id;
105
    }
106
107
    public int getAge() {
108
        return age;
109
    }
110
111
    public void setAge(int age) {
112
        this.age = age;
113
    }
114
115
    @Override
116
    public String toString() {
117
        return "User{" +
118
                "name='" + name + '\'' +
119
                ", id=" + id +
120
                ", age=" + age +
121
                '}';
122
    }
123
}

小结

  • 在实际的操作中，取得类的信息的操作代码，并不会经常开发
  • 一定要熟悉 java.lang.reflect 包的作用，反射机制。
  • 如何获取属性、方法、构造器的名称，修饰符等。

有了 Class 对象，能做什么？

  • 创建类的对象：调用 Class 对象的 newInstance()方法

    • 类必须由一个无参数的构造器
    • 类的构造器的访问权限需要足够

没有无参构造器时，需要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。
步骤：

  • 通过 Class 类 getDeclaredConstrutor(Class … parameterTypes)取得本类的指定形参类型构造器
  • 想构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
  • 通过 Constructor 实例化对象

调用指定的方法

通过反射，调用类中的方法，通过 Method 类完成。

  • 通过 Class 类的 getMethod(String name, Class…parameterTypes)方法取得一个 Method 对象，并设置此方法操作时所需要的参数类型。
  • 之后使用 Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的 obj 对象的参数信息
1
Object invoke(Object obj, Object... args)
  • Object 对应原方法的返回值，若原方法无返回值，此时返回 null
  • 若原方法若为静态方法，此时形参 Object obj 可为 null
  • 若原方法形参列表为空，则 Object[] args 为 null
  • 若原方法声明为 private，则需要在调用此 invoke()方法前，显式调用方法对象的 setAccessible(true)方法，将可以访问 private 方法。

show the code：

1
package com.yubulang.pojo.demo08;
2
3
import java.lang.reflect.Constructor;
4
import java.lang.reflect.Field;
5
import java.lang.reflect.InvocationTargetException;
6
import java.lang.reflect.Method;
7
8
public class Demo {
9
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
10
        // 获取一个Class对象
11
        Class<?> c1 = Class.forName("com.yubulang.pojo.demo08.User");
12
13
        // 构建一个对象
14
        User user = (User) c1.newInstance();
15
16
        // 通过构造器创建对象（有参的）
17
        Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
18
        User user2 = (User) declaredConstructor.newInstance("鱼不浪", 1, 18);
19
        System.out.println(user2);
20
21
        // 通过反射调用方法
22
        // invoke(对象,  对象方法的参数)
23
        User user3 = (User) c1.newInstance();
24
        Method setName = c1.getMethod("setName", String.class);
25
        setName.invoke(user3, "鱼不浪");
26
27
        Method getName = c1.getMethod("getName", null);
28
        System.out.println(getName.invoke(user3, null));
29
30
        // 通过反射操作属性
31
        User user4 = (User) c1.newInstance();
32
        Field name = c1.getDeclaredField("name");
33
        // 不能直接操作私有属性，我们要关闭程序安全检测，属性或者方法的setAccessible
34
        name.setAccessible(true); // 因为是私有属性，所以要把访问类型改成可以访问
35
        name.set(user4, "鱼不浪");
36
        System.out.println(name.get(user4));
37
    }
38
}
39
40
class User {
41
    private String name;
42
    private int id;
43
    private int age;
44
45
    public User() {
46
    }
47
48
    public User(String name, int id, int age) {
49
        this.name = name;
50
        this.id = id;
51
        this.age = age;
52
    }
53
54
    public String getName() {
55
        return name;
56
    }
57
58
    public void setName(String name) {
59
        this.name = name;
60
    }
61
62
    public int getId() {
63
        return id;
64
    }
65
66
    public void setId(int id) {
67
        this.id = id;
68
    }
69
70
    public int getAge() {
71
        return age;
72
    }
73
74
    public void setAge(int age) {
75
        this.age = age;
76
    }
77
78
    @Override
79
    public String toString() {
80
        return "User{" +
81
                "name='" + name + '\'' +
82
                ", id=" + id +
83
                ", age=" + age +
84
                '}';
85
    }
86
}

setAccessible

  • Method 和 Field、Construtor 对象都有 setAccessible() 方法
  • setAccessible 作用时启动和禁用访问安全检查的开关
  • 参数值为 true 则表示反射的对象在使用时应该取消 Java 语法访问检查
    • 提高反射的效率。如果代码中必须用反射，该句代码需要频繁的被调用，那么请设置为 true
    • 使得原本无法访问的私有成员也可以访问
  • 参数值为 false 则表示反射的对象应该实施 Java 语言访问检查

测试代码上：

1
package com.yubulang.pojo.demo09;
2
3
import java.lang.reflect.InvocationTargetException;
4
import java.lang.reflect.Method;
5
6
public class Demo {
7
    // 普通方式调用
8
    public static void test01() {
9
        User user = new User();
10
        long startTime = System.currentTimeMillis();
11
        for (int i = 0; i < 1000000000; i++) {
12
            user.getName();
13
        }
14
        long endTime = System.currentTimeMillis();
15
16
        System.out.println("普通方式调用10亿次耗时：" + (endTime - startTime) + "ms");
17
    }
18
19
    // 反射方式调用
20
    public static void test02() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
21
        Class<?> c1 = Class.forName("com.yubulang.pojo.demo09.User");
22
        User user = (User) c1.newInstance();
23
        Method getName = c1.getMethod("getName");
24
        long startTime = System.currentTimeMillis();
25
        for (int i = 0; i < 1000000000; i++) {
26
            getName.invoke(user, null);
27
        }
28
        long endTime = System.currentTimeMillis();
29
30
        System.out.println("反射方式没关闭检测调用10亿次耗时：" + (endTime - startTime) + "ms");
31
    }
32
33
    // 反射方式调用 关闭检测
34
    public static void test03() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
35
        Class<?> c1 = Class.forName("com.yubulang.pojo.demo09.User");
36
        User user = (User) c1.newInstance();
37
        Method getName = c1.getMethod("getName");
38
        getName.setAccessible(true);
39
        long startTime = System.currentTimeMillis();
40
        for (int i = 0; i < 1000000000; i++) {
41
            getName.invoke(user, null);
42
        }
43
        long endTime = System.currentTimeMillis();
44
45
        System.out.println("反射方式关闭检测调用10亿次耗时：" + (endTime - startTime) + "ms");
46
    }
47
48
    public static void main(String[] args) {
49
        test01();
50
51
        try {
52
            test02();
53
            test03();
54
        } catch (Exception ignored) {
55
            System.out.println(ignored.getMessage());
56
        }
57
    }
58
}
59
60
class User {
61
    private String name;
62
    private int id;
63
    private int age;
64
65
    public User() {
66
    }
67
68
    public User(String name, int id, int age) {
69
        this.name = name;
70
        this.id = id;
71
        this.age = age;
72
    }
73
74
    public String getName() {
75
        return name;
76
    }
77
78
    public void setName(String name) {
79
        this.name = name;
80
    }
81
82
    public int getId() {
83
        return id;
84
    }
85
86
    public void setId(int id) {
87
        this.id = id;
88
    }
89
90
    public int getAge() {
91
        return age;
92
    }
93
94
    public void setAge(int age) {
95
        this.age = age;
96
    }
97
98
    @Override
99
    public String toString() {
100
        return "User{" +
101
                "name='" + name + '\'' +
102
                ", id=" + id +
103
                ", age=" + age +
104
                '}';
105
    }
106
}

反射操作泛型

  • Java 采用泛型擦除的机制来引入泛型，Java 中的泛型仅仅时给编译器 javac 使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
  • 为了通过反射操作这些类型，Java 新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被统一的 Class 类中的类型但是又和原始类型齐名的类型。
  • ParameterizedType：表示一种参数化类型，比如 Collection<String>
  • GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable：是各种类型变量的公共父接口
  • WildcardType：代表一种通配符类型表达式

上代码：

1
package com.yubulang.pojo.demo10;
2
3
import java.lang.reflect.Method;
4
import java.lang.reflect.ParameterizedType;
5
import java.lang.reflect.Type;
6
import java.util.List;
7
import java.util.Map;
8
9
public class Demo {
10
    // 通过反射获取泛型
11
    public void test01(Map<String, User> map, List<User> list) {
12
        System.out.println("test01");
13
    }
14
15
    public Map<String, User> test02() {
16
        System.out.println("test02");
17
        return null;
18
    }
19
20
    public static void main(String[] args) throws NoSuchMethodException {
21
        Method method = Demo.class.getMethod("test01", Map.class, List.class);
22
23
        // 获取参数的泛型类型
24
        Type[] genericParameterTypes = method.getGenericParameterTypes();
25
        for (Type genericParameterType : genericParameterTypes) {
26
            System.out.println(genericParameterType);
27
28
            // 检测参数是不是结构化参数类型
29
            if (genericParameterType instanceof ParameterizedType) {
30
31
                // 获取泛型类型中的真实类型
32
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
33
                for (Type actualTypeArgument : actualTypeArguments) {
34
                    System.out.println(actualTypeArgument);
35
                }
36
            }
37
        }
38
39
        System.out.println("==================================");
40
41
        Method method02 = Demo.class.getMethod("test02", null);
42
        // 获取函数的返回值泛型类型
43
        Type genericReturnType = method02.getGenericReturnType();
44
        // 检测参数是不是结构化参数类型
45
        if (genericReturnType instanceof ParameterizedType) {
46
            System.out.println(genericReturnType);
47
48
            // 获取泛型类型中的真实类型
49
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
50
            for (Type actualTypeArgument : actualTypeArguments) {
51
                System.out.println(actualTypeArgument);
52
            }
53
        }
54
    }
55
}
56
57
class User {
58
    private String name;
59
    private int id;
60
    private int age;
61
62
    public User() {
63
    }
64
65
    public User(String name, int id, int age) {
66
        this.name = name;
67
        this.id = id;
68
        this.age = age;
69
    }
70
71
    public String getName() {
72
        return name;
73
    }
74
75
    public void setName(String name) {
76
        this.name = name;
77
    }
78
79
    public int getId() {
80
        return id;
81
    }
82
83
    public void setId(int id) {
84
        this.id = id;
85
    }
86
87
    public int getAge() {
88
        return age;
89
    }
90
91
    public void setAge(int age) {
92
        this.age = age;
93
    }
94
95
    @Override
96
    public String toString() {
97
        return "User{" +
98
                "name='" + name + '\'' +
99
                ", id=" + id +
100
                ", age=" + age +
101
                '}';
102
    }
103
}

反射操作注解

  • getAnnotations
  • getAnnotation

练习注解：

1
package com.yubulang.pojo.demo11;
2
3
import java.lang.annotation.*;
4
import java.lang.reflect.Field;
5
6
// 练习反射操作注解
7
public class Demo {
8
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
9
        Class<?> c1 = Class.forName("com.yubulang.pojo.demo11.Student");
10
11
        // 通过反射获得注解
12
        Annotation[] annotations = c1.getAnnotations();
13
        for (Annotation annotation : annotations) {
14
            System.out.println(annotation);
15
        }
16
17
        // 获得注解的value的值
18
        TableMapper tableMapper = (TableMapper) c1.getAnnotation(TableMapper.class);
19
        System.out.println(tableMapper.value());
20
21
        // 获取类指定的注解
22
        Field name = c1.getDeclaredField("name");
23
        FieldMapper nameFieldAnnotation = name.getAnnotation(FieldMapper.class);
24
        System.out.println(nameFieldAnnotation.columnName());
25
        System.out.println(nameFieldAnnotation.type());
26
        System.out.println(nameFieldAnnotation.length());
27
    }
28
}
29
30
// 类名的注解
31
@Target(ElementType.TYPE)
32
@Retention(RetentionPolicy.RUNTIME)
33
@interface TableMapper {
34
    String value();
35
}
36
37
// 属性的注解
38
@Target(ElementType.FIELD)
39
@Retention(RetentionPolicy.RUNTIME)
40
@interface FieldMapper {
41
    String columnName();
42
43
    String type();
44
45
    int length();
46
}
47
48
@TableMapper("db_student")
49
class Student {
50
    @FieldMapper(columnName = "db_id", type = "int", length = 10)
51
    private int id;
52
53
    @FieldMapper(columnName = "db_age", type = "int", length = 10)
54
    private int age;
55
56
    @FieldMapper(columnName = "db_name", type = "varchar", length = 64)
57
    private String name;
58
59
    public Student() {
60
    }
61
62
    public Student(int id, int age, String name) {
63
        this.id = id;
64
        this.age = age;
65
        this.name = name;
66
    }
67
68
    public int getId() {
69
        return id;
70
    }
71
72
    public void setId(int id) {
73
        this.id = id;
74
    }
75
76
    public int getAge() {
77
        return age;
78
    }
79
80
    public void setAge(int age) {
81
        this.age = age;
82
    }
83
84
    public String getName() {
85
        return name;
86
    }
87
88
    public void setName(String name) {
89
        this.name = name;
90
    }
91
92
    @Override
93
    public String toString() {
94
        return "Student{" +
95
                "id=" + id +
96
                ", age=" + age +
97
                ", name='" + name + '\'' +
98
                '}';
99
    }
100
}

总结

反射和注解提供了给我们更多的操作空间，掌握它可以写出很多优雅的代码。Enjoy it！

]]> Java Java 反射 Java 注解笔记 /2020/04/04/Java-%E6%B3%A8%E8%A7%A3%E7%AC%94%E8%AE%B0/ 前言

之前我常用的语言是 PHP，受限于语言特性，说实话 PHP 被很多公司边缘化了，感觉后面发展空间和路子并不是很大，加上很多解决方案还是 Java 的比较多，且资料更加健全，我一头扎入了 Java 的学习中。

注解和反射在我们在现在的框架中常常看到，查看框架的底层也会发现反射的身影，如果我们不了解这些通用的方法，显然有点说不过去。边学边记录，记录自己的学习路线。

注解

基本概念

  • Annotation 是从 JDK5.0 开始引入的新技术
  • 作用：
    • 不是程序本身，可以对程序做出解释（这一点和注释没有什么区别）
    • 可以被其他程序（比如：编译器等）读取
  • Annotation 的格式：
    • 注解以“@注解名”在代码中存在，还可以添加一些参数值，例如：@SuppressWarnings(value=”unchecked”)
  • Annotation 在哪里使用？
    • 可以附加在 package、class、method、field 等上面，相当于给爱他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。

内置注解

  • @Override：定义在java.lang.Override中，此注解只适用于修饰方法，表示一个方法声明打算重写超类中的一个方法声明。
  • @Deprecated：定义在java.lang.Deprecated中，此注解可用于修饰方法，属性，类，表示不鼓励大家使用这个元素，通常是因为它很危险或者有更好的选择。
  • @SuppressWarning：定义在java.lang.SuppressWarning中，用来抑制编译时的警告信息
    • 与前面两个注解有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性使用就好了。
      • @SuppressWarning(“all”)
      • @SuppressWarning(“unchecked”)
      • @SuppressWarning(value={“unchecked”, “deprecation”})
      • 等等……

元注解

基本概念

  • 元注解的作用就是负责注解其他注解，Java 定义了 4 个标准的 meta-annotation 类型，他们被用来提供对其他 annotation 类型作说明。
  • 这些类型和它们所支持的类在java.lang.annotation包中找到。（@Target，@Retention，@Documented，@Inherited）
    • @Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
    • @Retention：表示需要在什么级别保存该注解信息，用于描述注解的声明周期（SOURCE < CLASS < RUNTIME）
    • @Documented：说明该注解将包含在 JavaDoc 中
    • @Inherited：说明子类可以继承父类中的该注解

@Target 用于描述注解的作用范围

我们查看源代码可以知道，Target 可以传入一个值 value 这个 value 的类型为 ElementType

1
public @interface Target {
2
    ElementType[] value();
3
}

让我们看看这个ElementType枚举类包含的值，表示注解作用在什么上面：

  • TYPE：作用在类、接口，包括注解、枚举

    1
    // 我们先定义一个注解，文件为 MyAnnotationDemo01.java
    2
    package com.yubulang.demo01;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(value = {ElementType.TYPE})
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象，我是用的 idea，如果注解不支持这个类型，注解是会有红线提示。

    1
    package com.yubulang.demo01;
    2
    3
    // 作用在类上
    4
    @MyAnnotationDemo01
    5
    public class AnnotationDemo {
    6
    7
    }
    8
    9
    // 作用在接口上
    10
    @MyAnnotationDemo01
    11
    interface TestInterface {
    12
    13
    }
    14
    15
    // 作用在注解上
    16
    @MyAnnotationDemo01
    17
    @interface TestAnnotation {
    18
    19
    }
    20
    21
    // 作用在枚举类上
    22
    @MyAnnotationDemo01
    23
    enum TestEnum {
    24
        HELLO,
    25
        WORLD,
    26
    }

  • FIELD：作用在属性字段，包括枚举和常量

    1
    // 定义一个注解
    2
    package com.yubulang.demo02;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.FIELD)
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo02;
    2
    3
    public class AnnotationDemo01 {
    4
        // 作用在name属性
    5
        @MyAnnotationDemo01
    6
        protected String name;
    7
    8
        // 作用在常量上
    9
        @MyAnnotationDemo01
    10
        protected final String id = "0001";
    11
    12
        enum HelloEnum {
    13
            THING01,
    14
            THING02
    15
        }
    16
    17
        // 作用在枚举类型
    18
        @MyAnnotationDemo01
    19
        protected HelloEnum helloEnum = HelloEnum.THING01;
    20
    }

  • METHOD：作用在方法

    1
    // 定义一个注解
    2
    package com.yubulang.demo03;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.METHOD)
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo03;
    2
    3
    public class AnnotationDemo01 {
    4
        // 作用于方法
    5
        @MyAnnotationDemo01
    6
        public void test() {
    7
    8
        }
    9
    }

  • PARAMETER：作用在方法参数上

    1
    // 定义一个注解
    2
    package com.yubulang.demo04;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.PARAMETER)
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo04;
    2
    3
    public class AnnotationDemo {
    4
        // 作用在方法的参数上
    5
        public void test(@MyAnnotationDemo01 String name) {
    6
    7
        }
    8
    }

  • CONSTRUCTOR：作用在构造方法上

    1
    // 定义一个注解
    2
    package com.yubulang.demo05;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.CONSTRUCTOR)
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo05;
    2
    3
    public class AnnotationDemo {
    4
        // 作用在构造函数上
    5
        @MyAnnotationDemo01
    6
        public AnnotationDemo() {
    7
    8
        }
    9
    10
        // 这里会报错，因为不是构造方法
    11
        // @MyAnnotationDemo01
    12
        // public void test() {
    13
        //
    14
        // }
    15
    }

  • LOCAL_VARIABLE：作用在局部变量上

    1
    // 定义一个注解
    2
    package com.yubulang.demo06;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.LOCAL_VARIABLE)
    8
    public @interface MyAnnotationDemo01 {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo06;
    2
    3
    public class AnnotationDemo {
    4
        public void test() {
    5
            // 作用在局部变量上
    6
            @MyAnnotationDemo01
    7
            String name = "李雷与韩梅梅";
    8
        }
    9
    }

  • ANNOTATION_TYPE：作用在注解上

    1
    // 定义一个注解
    2
    package com.yubulang.demo07;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.ANNOTATION_TYPE)
    8
    public @interface MyAnnotationDemo {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo07;
    2
    3
    // 作用在注解上
    4
    @MyAnnotationDemo
    5
    public @interface AnnotationDemo {
    6
    7
    }

  • PACKAGE：作用在包上

    1
    // 定义一个注解
    2
    package com.yubulang.demo08;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.PACKAGE)
    8
    public @interface MyAnnotationDemo {
    9
    }

    然后我们定义这个注解可以使用的对象，这里有个特殊我们需要创建一个 package-info.java 这个是包的描述文件。

    1
    // package-info.java
    2
    // 作用在包上
    3
    @MyAnnotationDemo
    4
    package com.yubulang.demo08;

  • TYPE_PARAMETER：作用在定义泛型的类型参数上

    1
    // 定义一个注解
    2
    package com.yubulang.demo09;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.TYPE_PARAMETER)
    8
    public @interface MyAnnotationDemo {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo09;
    2
    3
    // 作用在定义泛型类型参数上
    4
    class Demo<@MyAnnotationDemo T> {
    5
        private T data;
    6
    }
    7
    8
    public class AnnotationDemo {
    9
        public void test() {
    10
            Demo<String> demo = new Demo<>();
    11
        }
    12
    }

  • TYPE_USE：作用在泛型类型使用参数上

    1
    // 定义一个注解
    2
    package com.yubulang.demo10;
    3
    4
    import java.lang.annotation.ElementType;
    5
    import java.lang.annotation.Target;
    6
    7
    @Target(ElementType.TYPE_USE)
    8
    public @interface MyAnnotationDemo {
    9
    }

    然后我们定义这个注解可以使用的对象：

    1
    package com.yubulang.demo10;
    2
    3
    class Demo<T> {
    4
        private T data;
    5
    }
    6
    7
    public class AnnotationDemo {
    8
        // 作用在泛型类型使用时
    9
        Demo<@MyAnnotationDemo String> demo = new Demo<>();
    10
    }

@Retention 用于表示注解的生命周期

我们查看源代码可以知道，Retention 可以传入 value 这个值的类型为RetentionPolicy 枚举类

1
public @interface Retention {
2
    /**
3
     * Returns the retention policy.
4
     * @return the retention policy
5
     */
6
    RetentionPolicy value();
7
}

我们一般写代码的时候是源代码阶段（SOURCE），编译成 CLASS 的时候就是（CLASS），运行的时候就是（RUNTIME）。作用域由大到小应该是：RUNTIME > CLASS > SOURCE。

这个理解起来想容易，我们来使用一下：

1
// 例子一=============================
2
package com.yubulang.demo11;
3
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
7
// 只有在源代码时
8
@Retention(RetentionPolicy.SOURCE)
9
public @interface MyAnnotationDemo01 {
10
}
11
12
// 例子二=============================
13
package com.yubulang.demo11;
14
15
import java.lang.annotation.Retention;
16
import java.lang.annotation.RetentionPolicy;
17
18
// 注解在java文件编译成为class依然有效
19
@Retention(RetentionPolicy.CLASS)
20
public @interface MyAnnotationDemo02 {
21
}
22
23
// 例子三=============================
24
package com.yubulang.demo11;
25
26
import java.lang.annotation.Retention;
27
import java.lang.annotation.RetentionPolicy;
28
29
// 注解在运行时依然有效
30
@Retention(RetentionPolicy.RUNTIME)
31
public @interface MyAnnotationDemo03 {
32
}

@Documented 说明该注解将包含在 javadoc 中

默认的javadoc工具，是不包括注解的。但是如果声明注解时指定了 @Documented 这个注解就会被 javadoc 之类的工具处理，所以注解类型信息也会被包括在生成文档中，是一个标记注解，没有成员。

@Inherited 子类会继承父类的注解

1
package com.yubulang.demo12;
2
3
import java.lang.annotation.*;
4
5
@Target(ElementType.TYPE)
6
@Retention(RetentionPolicy.RUNTIME)
7
@Inherited
8
@interface InheritedTest {
9
    String value();
10
}
11
12
@InheritedTest("拥有Inherited")
13
class Person {
14
    public void methodOne() {
15
    }
16
17
    public void methodTwo() {
18
    }
19
}
20
21
class Student extends Person {
22
23
}
24
25
@Target(ElementType.TYPE)
26
@Retention(RetentionPolicy.RUNTIME)
27
@interface IsNotInherited {
28
    String value();
29
}
30
31
@IsNotInherited("未拥有Inherited")
32
class NotInheritedAnnotationPerson {
33
    public void methodOne() {
34
    }
35
36
    public void methodTwo() {
37
    }
38
}
39
40
class NotInheritedAnnotationStudent extends NotInheritedAnnotationPerson {
41
42
}
43
44
public class Test02 {
45
    public static void main(String[] args) {
46
        Class<Student> studentClass = Student.class;
47
48
        if (studentClass.isAnnotationPresent(InheritedTest.class)) {
49
            System.out.println(studentClass.getAnnotation(InheritedTest.class).value());
50
        }
51
52
        Class<NotInheritedAnnotationStudent> nStudentClass = NotInheritedAnnotationStudent.class;
53
54
        if (nStudentClass.isAnnotationPresent(IsNotInherited.class)) {
55
            System.out.println(nStudentClass.getAnnotation(IsNotInherited.class).value());
56
        }
57
    }
58
}

自定义注解

  • 使用@interface 自定义注解时，自动继承了 java.lang.annotation.Annotation 接口
  • 分析：
    • @interface 用来声明一个注解，格式：public @interface 注解名 {定义内容}
    • 其中的每一个方法实际上是声明了一个配置参数
    • 方法的名称就是参数的名称
    • 返回值类型就是参数类型（返回值只能是基本类型，Class，String，enum）
    • 可以通过 default 来声明参数的默认值
    • 如果只有一个参数成员，一般命名为 value
    • 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0 作为默认值

知道了这些基础的概念，我觉得还是要通过一些代码，才能巩固。废话就不多说我们看代码。

1
package com.yubulang.demo12;
2
3
import java.lang.annotation.ElementType;
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
import java.lang.annotation.Target;
7
8
public class Test01 {
9
    // 没有 default 默认值，我们必须给注解赋值
10
    // 有 default "" 可以显式赋值，也可以不赋值
11
    @MyAnnotation01(name = "大哥", schools = {"哈理工", "哈工大"})
12
    public void test() {
13
    }
14
15
    @MyAnnotation02("大哥")
16
    public void test02() {
17
    }
18
}
19
20
@Target({ElementType.TYPE, ElementType.METHOD})
21
@Retention(RetentionPolicy.RUNTIME)
22
@interface MyAnnotation01 {
23
    // 注解的参数：参数类型 + 参数名()
24
    String name() default "";
25
26
    int age() default 0;
27
28
    int id() default -1; // 如果默认值为 -1，代表不存在
29
30
    String[] schools() default {};
31
}
32
33
@Target({ElementType.TYPE, ElementType.METHOD})
34
@Retention(RetentionPolicy.RUNTIME)
35
@interface MyAnnotation02 {
36
    String value(); // 方法名为value，才能省略，其他的不行
37
}

总结

知道了怎么定义注解只是一个开始，我们想要注解去处理一些具体的事儿，还需要反射的配合才能实现。万丈高楼平地起，今天就到这里。

]]> Java Java CentOS 8 安装 Docker /2020/03/27/CentOS%208%20%E5%AE%89%E8%A3%85%20Docker/ 简单粗暴的安装

学习任何一个新技术，我都推荐在虚拟机里面去操作，毕竟环境干净搞完蛋不影响原来的操作系统。

依赖

1
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

添加 Docker 源

1
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

安装

1
sudo yum install docker-ce docker-ce-cli containerd.io --nobest

启动 Docker CE

1
sudo systemctl enable docker
2
sudo systemctl start docker

建立用户组

一般我们不会直接用root这个大权限的用户来操作，一般需要建立一个组加入docker组：

1
sudo groupadd docker

将当前用户加入 docker 组

1
sudo usermod -aG docker $USER

忒出当前客户端重新登录，进行下面的测试

Docker 镜像

由于某些原因，我们访问外网很慢，甚至是无法访问，好在有大厂这个镜像，所以赶紧换之。

新建一个配置文件/etc/docker/daemon.json

1
vi /etc/docker/daemon.json

输入以下内容：

1
{
2
  "registry-mirrors": [
3
    "https://dockerhub.azk8s.cn",
4
    "https://hub-mirror.c.163.com"
5
  ]
6
}

改完一定要重启！改完一定要重启！改完一定要重启！

1
sudo systemctl daemon-reload
2
sudo systemctl restart docker

测试 Docker 是否安装成功

执行以下命令：

1
docker run hello-world

输出：

1
Hello from Docker!
2
This message shows that your installation appears to be working correctly.
3
4
To generate this message, Docker took the following steps:
5
 1. The Docker client contacted the Docker daemon.
6
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
7
    (amd64)
8
 3. The Docker daemon created a new container from that image which runs the
9
    executable that produces the output you are currently reading.
10
 4. The Docker daemon streamed that output to the Docker client, which sent it
11
    to your terminal.
12
13
To try something more ambitious, you can run an Ubuntu container with:
14
 $ docker run -it ubuntu bash
15
16
Share images, automate workflows, and more with a free Docker ID:
17
 https://hub.docker.com/
18
19
For more examples and ideas, visit:
20
 https://docs.docker.com/get-started/

看到这个就证明 docker 已经 OJBK 了。

Docker 搭建 Swoole PHP 开发环境

我选择的是一个官方源 php:7.4-cli ，里面扩展还不是很全，但是后期可以通过 docker-php-ext-install 进行安装。

1
docker run -dit --name myswoole php:7.4-cli bash

这里我们来解析下相关的命令

  • run 运行一个容器

  • -d 让 docker 进入后台运行

  • -t 终端

  • -i 交互式操作

  • –name 将这个容器命名为 myswoole，这里的命名自行定义就好了

  • php:7.4-cli 这里是我选择的源

  • bash 这里表时交互使用的 shell

输入这个命令后，你会看到一段 hash ，然后就是没有任何反应了。其实这里容器已经启动了，速度真的是杠杠的，我们可以通过以下命令去查看这个命令。

1
docker ps

这个命令会列出所有正在运行的容器进程：

1
CONTAINER ID        IMAGE               COMMAND                  ...NAMES
2
90558d9a592b        php:7.4-cli         "docker-php-entrypoi…"   ...myswoole

好了，既然容器有了，我们就要进入容器通过命令行操作他了。

1
# 进入名为 myswoole 容器的bash
2
docker exec -it myswoole bash
3
4
# 进入命令行后
5
# 升级我们的依赖
6
# 默认的这个源没有vim，我会选择自己安装
7
# 因为Swoole需要使用到libssl-dev扩展
8
apt update
9
apt install vim libssl-dev
10
11
# 通过 pecl 安装 swoole
12
pecl install swoole
13
14
# 具体socket openssl http2 mysqlnd 是否安装你自己选择
15
16
# 安装完通过以下命令，获取扩展配置路径
17
php --ini
18
19
cd /usr/local/etc/php/conf.d/
20
vi swoole.ini
21
22
# 输入 extension=swoole.so
23
# 保存退出
24
# 查看已经有swoole扩展了
25
php -m

此时已经安装完毕，我们退出 bash 。这个容器已经改变，我们需要保存这个容器的修改。这里我们需要使用docker commit 命令。

首先我们通过docker ps命令获取运行容器列表

1
docker ps
2
3
CONTAINER ID        IMAGE               COMMAND                  ...NAMES
4
90558d9a592b        php:7.4-cli         "docker-php-entrypoi…"   ...myswoole

这里容器的hash值为90558d9a592b ，我们要保存的就是这个容器，所以需要这个 hash

1
# 保存这个hash值对应的容器的修改
2
docker commit 90558d9a592b myswoole:php7.4-cli
3
4
# 我们的 image 里面就多了 myswoole 了
5
docker images
6
7
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
8
myswoole            php7.4-cli          44a70414dc94        6 seconds ago       489MB
9
myphp               7.4-cli             95e2af34d266        About an hour ago   627MB
10
ubuntu              18.04               4e5021d210f6        5 days ago          64.2MB
11
php                 7.4-cli             040c7fa6ecb6        6 days ago          405MB

既然镜像已经保存，那么我们就要停止他，我们需要绑定本地的文件夹到容器里面，方便容器运行swoole程序。

1
docker ps
2
docker stop 90558d9a592b
3
# 这个时候我们需要调整
4
docker run -dit --name myswoole -p 80:3000 -v "$PWD":/usr/src/myapp -w /usr/src/myapp myswoole:php7.4-cli php index.php

命令分析：

  • -dit 表时后台运行交互终端
  • –name 命名容器名称为 myswoole
  • -p 80 端口和容器的 3000 端口绑定
  • -v 映射本地当前工作目录到容器的 /usr/src/myapp 目录中
  • -w 容器内的目录路径

执行命令，这里我们会发现报错了

1
docker: Error response from daemon: Conflict. The container name "/myswoole" is already in use by container "90558d9a592bddb6e94288b2ae4297448fb3094509696290d36fe6d1e268c4ce". You have to remove (or rename) that container to be able to reuse that name.
2
See 'docker run --help'.

提示我们这个容器已经存在相同的名称了，不慌简单粗暴干掉他们就好了。

1
docker ps -a
2
3
# 输出
4
CONTAINER ID        IMAGE                 COMMAND                  ...NAMES
5
90558d9a592b        php:7.4-cli           "docker-php-entrypoi…"   ...myswoole
6
7
# 开干
8
docker rm 90558d9a592b
9
10
# 再次执行命令
11
docker run -dit --name myswoole -p 80:3000 -v "$PWD":/usr/src/myapp -w /usr/src/myapp myswoole:php7.4-cli php index.php

在容器绑定的 “$PWD” 目录下创建一个index.php

1
<?php
2
$http = new Swoole\Http\Server("0.0.0.0", 3000);
3
4
$http->on('request', function ($request, $response) {
5
    $response->header("Content-Type", "text/html; charset=utf-8");
6
    $response->end("<h1>Hello Swoole. #".rand(1000, 9999)."</h1>");
7
});
8
9
$http->start();

在容器中执行 php index.php，然后我访问 本机地址的 80 端口。输出成功。这里只是单个程序的 Docker 学习，还有组合后面抽时间写。

]]> Docker Docker 深入理解箭头函数 /2020/03/20/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3%E7%AE%AD%E5%A4%B4%E5%87%BD%E6%95%B0/ 前言

箭头函数不仅仅是编写简洁代码的”捷径”。它还具有非常特殊且有用的特性。
JavaScript 充满了我们需要编写在其他地方执行的小函数的情况。

例如：

  • arr.forEach(func) —— forEach 对每个数组元素都执行 func
  • setTimeout(func) —— func 由内建调度器执行。

JavaScript 的精髓在于创建一个函数并将其传递到某个地方。

_在这样的函数中，我们通常不想离开当前上下文_。这就是箭头函数的主战场。

箭头函数没有”this”

箭头函数没有 this。如果访问 this，则会从外部获取。

例如，我们可以使用它在对象方法内部进行迭代：

1
let group = {
2
  title: 'Our Group',
3
  students: ['Johon', 'Peter', 'Alice'],
4
5
  showList() {
6
    this.students.forEach(student => console.log(this.title + '：' + student))
7
  }
8
}
9
10
group.showList()

这里 forEach 中使用了箭头函数，所以其中的 this.title 其实和外部方法 showList 的完全一样。那就是 group.title。

不能对箭头函数进行 new 操作

不具有this 自然也就意味着另一个限制：箭头函数不能用作构造函数。不能用 new 调用他们。

箭头函数也没有 arguments 变量

1
let demoFunc = () => {
2
  console.log(arguments) // 报错的
3
}

但是可以以下操作，来获取 arguments 使用它

1
function defer(f, ms) {
2
  return function() {
3
    setTimeout(() => f.apply(this, arguments), ms)
4
  }
5
}
6
7
function sayHi(who) {
8
  console.log('Hello, ' + who)
9
}
10
11
let sayHiDeferred = defer(sayHi, 2000)
12
sayHiDeferred('Johon') // 两秒后显示

不使用箭头函数的话，可以这么写：

1
function defer(f, ms) {
2
  let ctx = this
3
  setTimeout(function() {
4
    return f.apply(ctx, args)
5
  }, ms)
6
}

在这里，我们必须创建额外的变量 args 和 ctx，以便 setTimeout 内部的函数可以获取它们。

总结

箭头函数：

  • 没有 this
  • 没有 arguments
  • 不能使用 new 进行调用
  • 它们也没有 super

这是因为，箭头函数是针对那些对自己的“上下文”，但在当前上下文中起作用的短代码的。

]]> JavaScript JavaScript 对于一些PHP优化的思考 /2020/03/17/%E5%AF%B9%E4%BA%8E%E4%B8%80%E4%BA%9BPHP%E4%BC%98%E5%8C%96%E7%9A%84%E6%80%9D%E8%80%83/ 前言

这个真的是一个老生常谈了，偶尔放出来炒炒其实也挺香，PHP 我从5.*用到7.*，可以说真的是看着他辉煌看着他被其他语言（Golang、Node 捅菊花）。很多人也诟病它，但是我觉得我挺喜欢这门语言的。最最主要的是因为他简单方便。但是方便的东西，不一定能写好。

优化这个东西说实话，是技术的一些细枝末节，现在很多面试里面动不动就会问很多性能方面的东西，问的有水平的会给出具体的场景和一些相关数据，问的水的直接就是让你谈谈大数据量访问的处理，不给场景，不给任何信息，心里真的日了狗了，你怼他吧，他不爽还不一定要你。

环境：MacBook Pro 2015 款 8G 内存 I5 处理器 PHP 7.4.3

PHP 优化规则开始

使用最新版本的 PHP，这个是最简单

这个毋庸置疑吧，简单粗暴。PHP 的大哥们费尽心思的让 PHP 变快，但是由于一些生产环境原因，很多时候大家不敢去进行升级，从而享受不到新版 PHP 带来的性能提升。

新项目不要想了，PHP 能有多新就用多新。这样至少在运行环境上就已经有了较老版本的质的飞跃。

双引号（”）和单引号（’)的使用

先上代码测试来说一下：

1
<?php
2
3
function doubleQuotes($iterations)
4
{
5
    $temp_str = "";
6
    $start_time = microtime(true);
7
8
    for ($i = 0; $i < $iterations; $i++) {
9
        $temp_str .= "Hello World!";
10
    }
11
12
    echo "Time for doubleQuotes(): " . (microtime(true) - $start_time) . PHP_EOL;
13
}
14
15
function singleQuotes($iterations)
16
{
17
    $temp_str = '';
18
    $start_time = microtime(true);
19
20
    for ($i = 0; $i < $iterations; $i++) {
21
        $temp_str .= 'Hello World!';
22
    }
23
24
    echo "Time for singleQuotes(): " . (microtime(true) - $start_time) . PHP_EOL;
25
}
26
27
doubleQuotes(50000000);
28
singleQuotes(50000000);
29
30
// result:
31
// Time for doubleQuotes(): 2.1713919639587
32
// Time for singleQuotes(): 2.1337790489197

这么一看，确实单引号比双引号快，用它用它。我是觉得现在版本的 PHP 这个上面的性能差不了多少，至于怎么用还是看大家习惯了，我喜欢用单引号纯粹的因为不用按shift 键，仅此而已。

别再 for 循环的条件中调用函数

很多时候我们为了省事儿是不是会写以下的代码：

1
$arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
2
for ($i = 0; $i < count($arr); $i++) {
3
    echo $i . PHP_EOL;
4
}

这个代码可以跑，没问题的，但是你有没有想过，这个条件中的函数是会被每次都调用一次的。不信？那么我们自己定义一个函数来验证一下

1
function customCount($arr)
2
{
3
    echo "Hello" . PHP_EOL;
4
    return count($arr);
5
}
6
7
$arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
8
for ($i = 0; $i < customCount($arr); $i++) {
9
    echo $i . PHP_EOL;
10
}

运行一下，结果是不是很意外，少一行代码高出了很多事儿。

1
Hello
2
0
3
Hello
4
.
5
.
6
.
7
9
8
Hello

而正确的做法最好就是让循环的条件确定好，是一个确定的数字最好。修改这个代码的方式很简单。

1
$arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
2
$length = count($arr); // 把确定循环的数字提前求出来
3
for ($i = 0; $i < $length; $i++) {
4
    echo $i . PHP_EOL;
5
}

避免在文件里面使用相对路径

这个在早期 PHP 的时候，由于还没有composer这个工具的时候，很多框架都会自己去写 class_loader，更多老的项目更加是直接就 require和include了。期间会很多会用到相对路径，代码难读就不说了，性能还不能保证。所以现在有新项目，麻烦大哥们能composer管理就用composer毕竟现在已经是包开发时代了，自己造轮子嘛，不是不可以，你老板不嫌你慢，你随便。

记得释放资源

这个其实真的没什么好说的，计算机角度来说内存和 CPU 是真的快的不是一星半点。但是有了提升不代表这些资源是无穷无尽的，他是有限的你申请一点，总数就少那么一点点，而且你还不归还。那总有消耗殆尽的时候嘛。代码上来说就是以下：

1
$file = fopen('a.txt', 'rb'); // 申请
2
fclose($file); // 记得要归还

避免不必要的全局变量

很多老代码，像 Discuz 这种，一打开简直头大，各种 global 用的飞起来了。访问全局变量要比访问局部变量的开销来的大，可是为啥 Discuz 这么做，咱也不敢问。哈哈哈

使用 isset 代替 count()、strlen()、sizeof()

一般我们为了检测一个变量或者数组长度的时候会用到count()、strlen()、sizeof() 这些函数，但是这些长度操作可以用isset来代替：

1
$str = "1234567";
2
echo strlen($str) === 7 . PHP_EOL;
3
echo isset($str[6]) . PHP_EOL;

能使用静态方法和静态变量就用它吧

静态方法相对于静态方法来的更加快，因为不用 new 对象，不用申请内存。当然现在有预加载机制了，这条我觉得有待商榷。

foreach > for > while

这个就不多说了，反正多数是用 foreach。有时候数组的循环，可能会用array_map()来出来，毕竟现在又有什么函数式编程的概念了。

当然还有一个关键点的就是不要在 foreach 中频繁进行数据库查找等 I\O 操作，这个不是 PHP 给不给力的问题，而是数据库给不给力的问题了。频繁查找就相当于 I\O 操作，这个开销是巨大的。

echo 和 print 输出变量用','取代'.'会得到性能提升

双引号拼接的东西可以用 sprintf 去拼接

不管是可读性上来说还是新能考虑来说，我更喜欢 sprintf。

1
// 字段多了我头晕
2
$query = "SELECT * FROM users WHERE username='".$username"' AND AND password='" . $password . "'";
3
4
// 是不是更加舒服点
5
$query = sprintf( "SELECT * FROM users WHERE username='%s' AND password='%s'", $user, $password );

尽可能的使用(===)去判断

因为 == 还存在着一个隐形的变量转换，这个转换的过程也会消耗掉一些性能。

总结

其实 PHP 优化的点还有很多，这里给出的也只是语言层面的一些，以及一些平时自己喜欢的一些方法，更多的学习还是要看下大神的代码，我比较喜欢的一个框架就是 Laravel，虽然这个框架臃肿，但是里面的一些设计和实现还是值得细细品味的，我用的比较多的是这个库Illuminate\Support\Collection，要问我有什么缺点，缺点就是我快把循环给忘光了。。。

]]> PHP PHP 优化 实现React布局路由 /2020/03/13/%E5%AE%9E%E7%8E%B0React%E5%B8%83%E5%B1%80%E8%B7%AF%E7%94%B1/ 前言

疫情在家，本来开年就要入职的公司，入职时间是一拖再拖，这里真的是吐槽一下。在家呆着爸妈鼻子不是鼻子眼睛不是眼睛的，我心里也是日了狗，从新投简历，某些傻缺HR，一来就问你会Yii吗？我就纳闷了，现在的框架哪个不是容器搞一通。

哎，抱怨没用，动手最实际，朋友要我帮忙做个管理后台，用React帮他做，不得不说一个小白尽然也知道React了。这个前端框架的知名度不得不说。我图省事儿样式让我写不可能的用Ant Design吧。

搭架子过程

反正就是一堆命令什么

1
mkdir manager_beta && cd manager_beta
2
npx create-react-app .

漫长的等待…期间我打开了书，看了看JavaScript 设计模式，架子是搭建完了，开始antd的安装

1
npm i --save antd
2
npm i --save react-router-dom

默认的create-react-app下面不是不会暴露出配置文件的，所以还要执行一下命令，为什么还要配置，作为开发人员，配置都不自己控制，总是不安心的。好吧，其实我是要用less这东西得配置吖。

1
npm run eject
2
npm i --save less less-loader

接下来就是把下面这段配置放入config\webpack.config.js中了

1
// line: 50行左右
2
const lessRegex = /\.(less)$/;
3
const lessModuleRegex = /\.module\.(less)$/;
4
5
// line: 487行左右
6
{
7
    test: lessRegex,
8
        exclude: lessModuleRegex,
9
            use: getStyleLoaders({ importLoaders: 3 }, 'less-loader'),
10
},
11
{
12
    test: lessModuleRegex,
13
    use: getStyleLoaders(
14
        {
15
            importLoaders: 3,
16
            modules: true,
17
            getLocalIdent: getCSSModuleLocalIdent,
18
            modifyVars:{},
19
            javascriptEnabled: true,
20
        },
21
        'less-loader'
22
    ),
23
},

其实上面写的对我要说的怎么 实现React布局路由 有什么关系呢？好吧，我告诉你，一点关系都没有哈哈哈，我就是骗骗字数。

其实这个路由实现很简单，无非就是对react-router-dom的一个简单封装。用代码举例子吧。

1
import React from 'react';
2
import { Route, Switch } from 'react-router-dom';
3
4
const LayoutRoute = ({ component: Component, layout: Layout, ...rest}) => {
5
    return (
6
        <Route {...rest} render={props => (
7
<Layout>
8
                <Component {...props} />
9
            </Layout>
10
        )} />
11
    );
12
}
13
14
const MainLyout = props => (
15
    <div>
16
        <h1>Main</h1>
17
        {props.children}
18
    </div>
19
);
20
21
const OtherLyout = props => (
22
    <div>
23
        <h1>Other</h1>
24
        {props.children}
25
    </div>
26
);
27
28
const PgOne = () => {
29
    return (<p>PgOne</p>);
30
}
31
32
const XiaoluLi = () => {
33
    return (<p>XiaoluLi</p>)
34
}
35
36
const App = () => (
37
    <div>
38
        <Switch>
39
        <LayoutRoute exact path="/pgone" layout={MainLyout} component={PgOne}/>
40
            <LayoutRoute exact path="/xiaoluli" layout={OtherLyout} component={XiaoluLi}/>
41
        </Switch>
42
    </div>
43
)
44
45
ReactDOM.render(
46
  <App />,
47
  document.getElementById('root')
48
);

其实就是利用了组件props传值的方式实现了这个方法，扩展了Route。

总结

希望疫情快点过去，还有就是世界和平，别再来什么幺蛾子了。还有就是求工作吖。

]]> JavaScript React Laravel扩展包的开发 /2020/03/12/Laravel%E6%89%A9%E5%B1%95%E5%8C%85%E7%9A%84%E5%BC%80%E5%8F%91/ Laravel在2020年03月02日，发布了7.0版本，从3用到7一直都是用别人开发的包，由于疫情真的但是日了狗，在家找工作都不方便，怎么办学习吖，程序员哪里有休息可言。

扩展包的开发

1. 创建一个新项目，初始化扩展包配置

首先创建一个全新的Laravel项目：

1
composer create-project laravel/laravel package_demo --prefer-dist

接下来，在项目中创建目录package/{your_name}/{your_package_name}

1
mkdir -p packages/neilyoz/plugins

进入到这个目录，执行composer init

1
cd packages/neilyoz/plugins
2
composer init

接下来的就是看你具体的配置包信息了。执行完成后会生成一个composer文件。

1
{
2
    "name": "neilyoz/plugins",
3
    "type": "library",
4
    "authors": [
5
        {
6
            "name": "Neilyoz",
7
            "email": "neilyoz@foxmail.com"
8
        }
9
    ],
10
    "require": {},
11
    "description": "plugins system build with laravel."
12
}

2. 创建扩展包基本目录，文件

一般情况下，我会创建一下的目录

1
packages/neilyoz/plugins$ tree .
2
├── composer.json
3
├── src
4
└── tests

3. 修改扩展包 composer 配置

然后修改我们这个扩展包的composer.json文件，设置一下自动加载配置、以及扩展包的命名空间。

1
{
2
    "name": "neilyoz/plugins",
3
    "type": "library",
4
    "authors": [
5
        {
6
            "name": "Neilyoz",
7
            "email": "neilyoz@foxmail.com"
8
        }
9
    ],
10
    "require": {},
11
    "description": "plugins system build with laravel.",
12
    "autoload": {
13
        "psr-4": {
14
            "Neilyoz\\": "src/"
15
        }
16
    },
17
    "autoload-dev": {
18
        "psr-4": {
19
            "Neilyoz\\Plugins\\Tests\\": "test/"
20
        }
21
    }
22
}

4. 编写扩展包信息啦~

接下来，我们来创建 PluginsServiceProvider 、Plugin 文件。目录结构如下：

1
packages/neilyoz/plugins$ tree .
2
├── composer.json
3
├── src
4
│   └── Plugins
5
│       ├── Plugin.php
6
│       └── PluginsServiceProvider.php
7
└── tests
1
<?php
2
3
namespace Neilyoz\Plugins;
4
5
use Illuminate\Support\ServiceProvider;
6
7
class PluginsServiceProvider extends ServiceProvider
8
{
9
    public function boot()
10
    {
11
12
    }
13
14
    public function register()
15
    {
16
        $this->app->singleton('plugins', function() {
17
            return new Plugin();
18
        });
19
    }
20
}
1
<?php
2
3
namespace Neilyoz\Plugins;
4
5
class Plugin
6
{
7
    public function printRunning()
8
    {
9
        return 'Provider running...';
10
    }
11
}

到这里已经开发了一个最简单Laravel的扩展包了。

扩展包本地测试

把 PluginsServiceProvider 添加到项目的 config/app.php 中的 providers 数组中

1
'providers' => [
2
    ...
3
    Neilyoz\Plugins\PluginsServiceProvider::class,
4
],

这个时候要修改 package_demo 项目下的 composer.json

1
{
2
    "require": {
3
        ...,
4
        "neilyoz/plugins": "dev-master"
5
    },
6
    ...,
7
    "autoload": {
8
        ...,
9
        "psr-4": {
10
            ...,
11
            "Neilyoz\\": "packages/neilyoz/plugins/src/"
12
        }
13
    },
14
    ...
15
}

运行命令：

1
composer dumpautoload
2
composer update

修改 routes/web.php 文件：

1
Route::get('/', function () {
2
    dd(app('plugins')->printRunning());
3
});

此时，我们打开浏览器访问，我这里项目对应url为：homestead.test，显示Provider running... 表时你已经成功了。

参考文章

如何开发、本地测试、发布Laravel扩展包

]]> PHP PHP Laravel MySQL主从复制配置 /2020/03/11/MySQL%E4%B8%BB%E4%BB%8E%E5%A4%8D%E5%88%B6%E9%85%8D%E7%BD%AE/ 实现原理:
  • MySQL支持单项、异步复制，复制过程中一个服务器充当主服务器，而一个或多个其他服务器充当从服务器。
  • MySQL复制基于主服务器在二进制日志中跟踪所有对数据库的更改（更新、删除等等）
  • 每个从服务器从主服务器接收主服务器已经记录到其二进制日志的保存更新。

实现步骤：

  • Master将改变记录到二进制日志（binary log）中
  • Slave将Master的binary log events拷贝到它的中继日志（relay log）
  • Slave重做中继日志的时间，将改变反映它自己的数据。

MySQL主从复制图解

场景配置：

准备两台机器，IP为

  • 192.168.0.130
  • 192.168.0.131

在130服务器上打开my.cnf（MySQL的配置文件），找到相关binlog配置：

1
log-bin = mysql-bin #binlog开启
2
binlog_format = mixed #binlog的格式
3
server-id = 130 # 架构中的服务器唯一值
4
expire_logs_days = 10
5
early-plugin-load = ""

配置完成，重启Master Mysql服务器。连接我们的MySQL服务器运行命令查看服务器状态

1
show master status;
2
3
-- 了解一下
4
-- reset master;可以重新开始我们的binlog

这样，我们的Master主机上配置已经是OK了。

我们配置我们的131服务器上的从MySQL服务器配置，同样进入主机，我们打开my.cnf（MySQL的配置文件）

1
#log-bin = mysql-bin #注释关闭binlog日志
2
server-id = 131
3
relay_log = mysql-relay-bin
4
expire_logs_days = 10
5
early-plugin-load = ""

重启我们的Slave上的MySQL服务器。

完成上面操作，我们需要在Master MySQL中给Slave MySQL数据库授权，在我们Master上连接MySQL服务器。

1
-- 我允许slave@192.168.0.131这台机器 通过 mysql密码 访问当前的Master
2
grant replication slave on *.* to slave@192.168.0.131 identified by 'mysql密码'

主机已经配置完成。我们切换到我们的Slave主机，配置我们的Slave监听哪一台机器。

1
stop slave;
2
3
change master to
4
master_host='192.168.0.130',
5
master_port=3306,
6
master_user='slave',
7
master_password='主机mysql密码',
8
master_log_file='mysql-bin.000001',
9
master_log_pos=xxx;
10
-- master_log_file、master_log_pos 通过Master的show master status;查看
11
12
start slave; -- 开启slave服务器
13
14
show slave status\G
15
16
-- 查看Slave_IO_Running: Yes、Slave_SQL_Running: Yes 这两项就行

这里我们的主从设置已经完成，我们只需要在Master主机器上进行MySQL的操作就能检测我们的主从是否正常的进行复制了。

]]> MySQL MySQL Vue + Gin + Gorm 随便说 /2020/03/10/Vue-Gin-Gorm%E9%9A%8F%E4%BE%BF%E8%AF%B4/ 项目连接

😈 传送门 😈

背景

在家无聊搭建一个 Vue + Gin + Gorm 的程序，主要也是熟悉一下看了两天的Golang语言，在做的过程中能复习Golang的语法以及一些相关的前端Vue知识。

  • 熟悉了gin框架，以及中间件的使用
  • 熟悉了gorm数据库ORM的一些数据库操作
  • 复习Vue的一些相关知识点
  • 使用jwt-go搭建jwt验证，并把验证放到Gin中间件中
  • 使用yaml把配置文件独立到config文件夹

如何搭建

  1. frontend属于前端部分，进入到这个文件夹下
1
npm install && npm run serve
  1. 配置好数据库
  2. config文件夹，配置config.yaml
1
debug: true # 数据库调试，开启后命令行会显示对应的数据库操作
2
key: alexskywin # jwt加密串
3
mysql: # MySQL相关配置
4
  user: root
5
  pass:
6
  host: 127.0.0.1
7
  port: 3306
8
  database: demo
9
  charset: utf8mb4
  1. 运行main.go文件
1
go run main.go

毕竟只是快速看看怎么回事，go run就可以了。

总结

这个相当于一个前后端分离的架子，但是在做这个架子的时候，还是遇到了很多困难，翻看各种文档和各种Golang语法查漏补缺的时候，还是温故知新了不少东西。

说实话，如果不是公司有特别要求，我还是喜欢Laravel这个自动挡多一些。gin + gorm目前还是半自动档的框架，没办法谁让Golang火吖，不说精通但是也得会。不过Golang上手确实很快。

2020年Golang也会作为我一个研究的方向，当然不会丢下我的PHP，毕竟是世界上最好的语言！哈哈哈

]]> Golang Golang Gin Gorm Vue MySQL小表驱动大表 /2020/03/08/MySQL%E5%B0%8F%E8%A1%A8%E9%A9%B1%E5%8A%A8%E5%A4%A7%E8%A1%A8/ 前言

我们查询小表的数据肯定是比查询大表的数据来的快，所以我们可以用查询小表得到的结果集，作为查询条件去查询大表，这样提前的一个结果范围，能够让我们更快的获取数据。

准备基础数据

我们准备一个部门表，在实际中一个公司的部门肯定是比人员少，如果部门比人员还多的公司，那么请大家看清楚再入坑，不然会有很多意想不到的惊喜。

1
-- 创建部门表
2
-- 生产环境不要用DROP! 生产环境不要用DROP! 生产环境不要用DROP!
3
DROP TABLE IF EXISTS `department`; 
4
CREATE TABLE IF NOT EXISTS `department` (
5
    `id` int(11) NOT NULL AUTO_INCREMENT,
6
    `dept_name` varchar(200) DEFAULT NULL,
7
    `address` varchar(200) DEFAULT NULL,
8
    PRIMARY KEY(`id`)
9
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
10
11
-- 插入测试数据
12
INSERT INTO `department` (`dept_name`, `address`) VALUES ('研发部(RD)', '2层');
13
INSERT INTO `department` (`dept_name`, `address`) VALUES ('人事部(HR)', '3层');
14
INSERT INTO `department` (`dept_name`, `address`) VALUES ('市场部(MK)', '4层');
15
INSERT INTO `department` (`dept_name`, `address`) VALUES ('后勤部(MIS)', '5层');
16
INSERT INTO `department` (`dept_name`, `address`) VALUES ('财务部(FD)', '6层');
17
18
-- 创建雇员表
19
DROP TABLE IF EXISTS `testemployee`;
20
CREATE TABLE `testemployee` ( 
21
    `id` int(11) NOT NULL AUTO_INCREMENT,
22
    `name` VARCHAR(20) DEFAULT NULL,
23
    `dep_id` int(11) DEFAULT NULL,
24
    `age` int(11) DEFAULT NULL,
25
    `salary` DECIMAL(10, 2) DEFAULT NULL,
26
    `cus_id` int(11) DEFAULT NULL,
27
    PRIMARY key(`id`)
28
) ENGINE = INNODB DEFAULT CHARSET=utf8mb4;
29
30
-- 随机字符串函数
31
delimiter $$
32
DROP FUNCTION IF EXISTS `rand_str`;
33
CREATE FUNCTION rand_str(n int) RETURNS varchar(255)
34
BEGIN
35
declare str varchar(100) default 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
36
declare i int default 0;
37
declare res_str varchar(255) default 'php_';
38
39
while i < n do
40
SET res_str = CONCAT(res_str, SUBSTR(str, FLOOR(1 + RAND()*52), 1));
41
SET i = i + 1;
42
end while;
43
44
return res_str;
45
END$$
46
47
-- 存储过程
48
DROP PROCEDURE IF EXISTS `insert_emp`;
49
CREATE PROCEDURE `insert_emp`(in max_num int)
50
BEGIN
51
DECLARE i INT DEFAULT 0;
52
SET autocommit = 0;
53
repeat
54
set i = i + 1;
55
insert into `testemployee` (name, dep_id, age, salary, cus_id) VALUES (rand_str(5), floor(rand()*(6-1) + 1), floor(20 + RAND()*10), floor(2000 + RAND()*10), FLOOR(1 + RAND()*10));
56
UNTIL i = max_num
57
end repeat;
58
59
commit;
60
END$$
61
62
delimiter ;
63
64
-- 创建数据
65
CALL insert_emp(100000);

小表驱动大表

例子

我们先用直接操作，查询出 testemployee 的数据研发部和人事部的信息。

1
-- Time: 0.5s
2
SELECT * FROM `testemployee` WHERE dep_id = 2 OR dep_id = 3;

这里因为使用了 OR 即使是创建了索引，也会导致索引失效，全表查询。速度相对而言比较慢。

既然使用到了 OR 去做查询，testemployee 表全表查询肯定是比 department 表全表查询慢，所以我们可以使用小的数据表查询结果驱动大的数据集。

1
-- Time: 0.033s
2
SELECT * FROM `testemployee` WHERE dep_id IN (SELECT id FROM department WHERE dept_name='研发部(RD)' OR dept_name='人事部(HR)');

in与exists

其实两个可以互相替换，但是思想却大不相同。上面的语句我们看看如何改写

1
SELECT * FROM `testemployee` WHERE EXISTS (SELECT 2 FROM department WHERE dept_name='研发部(RD)' OR dept_name='人事部(HR)');

他和IN的区别在于，使用大表来驱动小表，子语句中是小表，至于什么时候使用，不言而喻了吧。

总结

这里的数据库表的例子可能不太恰当，但是主要是想说明一个观点。就是小表得到结果的数据肯定比大表快，通过小表我们缩小了确定数据的范围，而不用让大表逐条去比对数据。当然我们该做索引的地方还是要做索引。这个跑不掉。

]]> MySQL MySQL MySQL最大值Max的优化 /2020/03/08/MySQL%E6%9C%80%E5%A4%A7%E5%80%BCMax%E7%9A%84%E4%BC%98%E5%8C%96/ 前言

一个一个例子来，获取最大值max的优化。求数据的最大值，说实在话在我们的实际开发中还是挺好用的。可能数据表一万两万的时候不是很看的出来性能，但是任何东西都顶不住数量多啊。为了模拟这个数量多的环境，不废话，贴出代码，方便大家。

创建所需要的数据表以及数据

先来 300W 数据压压惊，我们来找 age 来找大哥，看谁才是最牛逼，最大的人。

1
-- 创建数据表
2
DROP TABLE IF EXISTS `testemployee`;
3
CREATE TABLE `testemployee` ( 
4
`id` int(11) NOT NULL AUTO_INCREMENT,
5
`name` VARCHAR(20) DEFAULT NULL,
6
`dep_id` int(11) DEFAULT NULL,
7
`age` int(11) DEFAULT NULL,
8
`salary` DECIMAL(10, 2) DEFAULT NULL,
9
`cus_id` int(11) DEFAULT NULL,
10
PRIMARY key(`id`)
11
) ENGINE = INNODB DEFAULT CHARSET=utf8mb4;
12
13
-- 随机生成字符串
14
delimiter $$
15
DROP FUNCTION IF EXISTS `rand_str`;
16
CREATE FUNCTION rand_str(n int) RETURNS varchar(255)
17
BEGIN
18
declare str varchar(100) default 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
19
declare i int default 0;
20
declare res_str varchar(255) default 'php_';
21
22
while i < n do
23
SET res_str = CONCAT(res_str, SUBSTR(str, FLOOR(1 + RAND()*52), 1));
24
SET i = i + 1;
25
end while;
26
27
return res_str;
28
END$$
29
delimiter ;
30
31
-- 存储过程
32
CREATE DEFINER=`root`@`localhost` PROCEDURE `insert_emp`(in max_num int)
33
BEGIN
34
DECLARE i INT DEFAULT 0;
35
SET autocommit = 0;
36
repeat
37
set i = i + 1;
38
insert into `testemployee` (name, dep_id, age, salary, cus_id) VALUES (rand_str(5), floor(1+rand()*10), floor(20 + RAND()*10), floor(2000 + RAND()*10), FLOOR(1 + RAND()*10));
39
UNTIL i = max_num
40
end repeat;
41
42
commit;
43
END
44
45
-- 记得CALL，300W个数据先玩玩
46
CALL insert_emp(3000000)

常规max操作看看性能

1
-- Time: 5.501s
2
SELECT max(age) FROM testemployee;

怀疑人生的时常吖，五秒多出现在服务器上简直就是一场灾难。这里我们发现 age 并没有索引对吧，那就干索引吧。

1
-- 索引搞起来
2
CREATE INDEX idx_age ON testemployee(age);
3
4
-- Time: 0.024s
5
SELECT max(age) FROM testemployee;

总结

其实这个优化不是很难，主要的还是要自己去动手把东西都做一遍，代码都给出来，欢迎大家自己动手去写写。

]]> MySQL MySQL MySQL优化系列（二） /2020/03/06/MySQL%E4%BC%98%E5%8C%96%E7%B3%BB%E5%88%97%EF%BC%88%E4%BA%8C%EF%BC%89/ 前言

说是优化，其实跟多是对以前一些概念的巩固，毕竟实践还是在理论牢靠的基础上进行的。所以这里我们先看看我们常用的一些关联查询方式。

JOIN链接

  • 应用形式
    • 内连接
    • 左连接
    • 右连接
    • 查询左表独有数据
    • 查询右表独有数据
    • 全连接
    • 查询左右表各自的独有的数据

创建表数据

1
-- 部门表
2
DROP TABLE IF EXISTS `department`;
3
CREATE TABLE `department`(
4
    `id` int(11) NOT NULL AUTO_INCREMENT,
5
    `deptName` varchar(30) DEFAULT NULL,
6
    `address` varchar(40) DEFAULT NULL,
7
    PRIMARY KEY(`id`)
8
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
9
10
INSERT INTO `department` VALUES ('1', '研发部（RD）', '2层');
11
INSERT INTO `department` VALUES ('2', '人事部（HR）', '3层');
12
INSERT INTO `department` VALUES ('3', '市场部（MK）', '4层');
13
INSERT INTO `department` VALUES ('4', '后请部（MIS）', '5层');
14
INSERT INTO `department` VALUES ('5', '财务部（FD）', '6层');
15
16
-- 员工表
17
DROP TABLE IF EXISTS `employee`;
18
CREATE TABLE `employee` (
19
    `id` int(11) NOT NULL AUTO_INCREMENT,
20
    `name` varchar(20) DEFAULT NULL,
21
    `dep_id` int(11) DEFAULT NULL,
22
    `age` int(11) DEFAULT NULL,
23
    `salary` decimal(10, 2) DEFAULT NULL,
24
    `cus_id` int(11) DEFAULT NULL,
25
    PRIMARY KEY(`id`)
26
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
27
28
INSERT INTO `employee` VALUES ('1', '鲁班', '1', '10', '1000.00', '1');
29
INSERT INTO `employee` VALUES ('2', '后羿', '1', '20', '2000.00', '1');
30
INSERT INTO `employee` VALUES ('3', '孙尚香', '1', '20', '2500.00', '1');
31
INSERT INTO `employee` VALUES ('4', '凯', '4', '20', '3000.00', '1');
32
INSERT INTO `employee` VALUES ('5', '典韦', '4', '40', '3500.00', '2');
33
INSERT INTO `employee` VALUES ('6', '貂蝉', '6', '20', '5000.00', '1');
34
INSERT INTO `employee` VALUES ('7', '孙膑', '6', '10', '5000.00', '1');
35
INSERT INTO `employee` VALUES ('8', '蔡文姬', '30', '35', '4000.00', '1');

内连接

演示文稿1
  • 作用：查询两张表的共有部分
  • 语句：SELECT field FROM tableA INNER JOIN tableB on A.key = B.key
1
SELECT * FROM employee e INNER JOIN department d ON e.dep_id = d.id;

左连接

左连接
  • 作用：把左边表的内容全部查出，右边表只查出满足条件的记录，A和B的共有再加上A的独有
  • 语句：SELECT field FROM tableA LEFT JOIN tableB on A.key = B.key
1
SELECT * FROM employee e LEFT JOIN department d ON e.dep_id = d.id;

右连接

右连接
  • 作用：把右边表的内容全部查出，左边表只查出满足条件的记录，A和B的共有再加上B的独有
  • 语句：SELECT field FROM tableA RIGHT JOIN tableB on A.key = B.key
1
SELECT * FROM employee e RIGHT JOIN department d on e.dep_id = d.id;

查询左表独有数据——左连接基础上加上WHERE条件

查询左表独有数据
  • 作用：获取左表数据，排除掉左表中的右表数据，
1
SELECT * FROM employee e LEFT JOIN department d ON e.dep_id = d.id WHERE d.id is null;

查询右表独有数据——有链接基础上加上WHERE条件

查询右表独有数据
  • 作用：获取右表数据，排除掉右表中的左表数据
1
SELECT * FROM employee e RIGHT JOIN department d on e.dep_id = d.id WHERE e.dep_id is null;

全连接

全连接
  • 作用：查询两个表的全部信息
  • 语句：SELECT field FROM employee e Full Outter Join department d ON e.dep_id = d.id;(MySQL不支持，Oracle可以，你说气不气)
1
(SELECT * FROM employee e LEFT JOIN department d ON e.dep_id = d.id)
2
UNION
3
(SELECT * FROM employee e RIGHT JOIN department d ON e.dep_id = d.id)

查询左右表各自的独有的数据

查询左右表各自的独有的数据
  • 作用：左表独有数据和右表独有数据查出
1
(SELECT * FROM employee e LEFT JOIN department d ON e.dep_id = d.id WHERE d.id is null)
2
UNION
3
(SELECT * FROM employee e RIGHT JOIN department d on e.dep_id = d.id WHERE e.dep_id is null)
]]> MySQL MySQL MySQL优化系列（一） /2020/03/06/MySQL%E4%BC%98%E5%8C%96%E7%B3%BB%E5%88%97%EF%BC%88%E4%B8%80%EF%BC%89/ 前言

不管是多么高深的套路，还是要构建在基础之上，在进入这个主题的时候，我更加愿意的去从基础入手来阐述这一整个流程。前面已经教会了大家如何产生数据，这里就是开始慢慢梳理一些基础的数据库基础概念。

存储引擎的概念

  • MySQL中的额数据用各种不同的技术存储在文件（或内存）中
  • 这些技术中的每一种技术都是用不同的存储机制、索引技巧、锁定水平并且最终提供广泛的不同的功能和能力
  • 通过不同的技术，你能够获得额外的速度或者功能，从而改善你的应用的整体功能
  • 这些不同的技术以及配套的相关功能在MySQL中被称作存储引擎

举个例子：

  • 如果你在研究大量的临时数据，你也许需要使用内存存储引擎。内存存储引擎能够在内存中存储所有的表格数据。
  • 也许需要一个支持事务处理的数据库（以确保事务处理不成功时数据的回退能力）选择支持事务的存储引擎

查看存储引擎

1
show engines;

查看当前使用的存储引擎

1
show variables like '%storage_engine%';

MyISAM和InnoDB的区别

  • 主外键

    • MyISAM不支持
    • InnoDB支持

  • 事务

    • MyISAM不支持
    • InnoDB支持

  • 行表锁

    • MyISAM 支持 表锁
    • InnoDB 支持 行锁

  • 缓存

    • MyISAM 只缓存索引，不缓存数据
    • InnoDB 不仅缓存索引，还缓存真实数据，对内存要求比较高，而且内存大小对性能有决定的影响

  • 表空间

    • 两者占用都很小

  • 关注点

    • MyISAM —— 性能
    • InnoDB —— 事务

  • 都默认安装，创建表用哪种默认引擎，看版本

  • 文件结构

    • MyISAM
      • b.frm 描述表结构文件，字段长度等
      • b.myd：数据信息文件，存储数据信息（如果采用独立表存储模式）
      • b.myi：索引信息文件
    • InnoDB
      • b.frm 描述表结构，字段长度等
      • b.ibd 存储数据信息和索引信息

SQL的执行顺序

代码编写顺序

`Select distinct 字段``Form 表名``JOIN 表明` `ON 连接条件``Where 查询条件``Group by 分组字段``Having 分组后条件``Order by 排序条件``Limit 查询起始位置, 查询条数`

MySQL读取顺序

`Form 表名``ON 连接条件``JOIN 表明` `Where 查询条件``Group by 分组字段``Having 分组后条件``Select distinct 字段``Order by 排序条件``Limit 查询起始位置, 查询条数`

整体过程

  • 先对多表进行关系分析，根据条件找出符合条件的记录
  • 在符合条件的基础上进行再次where条件筛选
  • 对筛选出来的内容进行分组操作
  • 分组完成后，使用Having再次筛选出满足条件的记录
  • 取所满足条件的记录
  • 对取出的记录进行排序
  • 最终从取出的记录当中获取多少条记录显示出来
]]> MySQL MySQL MySQL 轻松创建千万级测试数据 /2020/03/06/MySQL%E8%BD%BB%E6%9D%BE%E5%88%9B%E5%BB%BA%E5%8D%83%E4%B8%87%E7%BA%A7%E6%B5%8B%E8%AF%95%E6%95%B0%E6%8D%AE/ 前言

疫情期间，无奈新公司迟迟不能报道，心里真的是B了狗了。对于优化数据库的文章网络上很多，但是我觉得很不负责的是都不成体系，要么就是讲的片面，讲的也是千篇一律，索引、分析表、优化sql语句、分库分表什么的。

说了很多理论，看着一堆都头大，而且时间久远，为了复习还是重新写写博文吧。我保证这些代码都是我实实在在测试后才会贴上来的。保证能粘贴就使用。

不着急数据库优化一步一步来，我们既然要优化数据库，那么第一步就是要有数据。这里会介绍两种快速生成大量测试数据的方法，分别使用存储过程和临时数据表。

创建数据表

无论我们使用哪种方式，都需要使用一个数据表

1
CREATE TABLE `employee` (
2
    `id` int(11) NOT NULL AUTO_INCREMENT,
3
    `name` varchar(100) NOT NULL,
4
    `dep_id` int(11) NOT NULL,
5
    `age` int(11) NOT NULL,
6
    PRIMARY KEY (`id`)
7
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

使用存储过程

创建内存表

利用MySQL内存表插入速度快的特点，我们先利用函数和存储过程在内存表中生成数据，然后再从内存表插入普通表中。

1
CREATE TABLE `employee_memory` (
2
    `id` int(11) NOT NULL AUTO_INCREMENT,
3
    `name` varchar(100) NOT NULL,
4
    `dep_id` int(11) NOT NULL,
5
    `age` int(11) NOT NULL,
6
    PRIMARY KEY (`id`)
7
) ENGINE = MEMORY DEFAULT CHARSET = utf8mb4;

创建函数及存储过程

创建随机字符串，MySQL的随机数常用的方式：FLOOR( RAND() * (max - min) + min ) 生成[min, max]之间的数字包含min和max。

1
DELIMITER $$
2
DROP FUNCTION IF EXISTS rand_string;
3
CREATE FUNCTION `rand_string`(n INT) RETURNS varchar(255) CHARSET utf8mb4
4
    DETERMINISTIC
5
BEGIN
6
    DECLARE chars_str varchar(100) DEFAULT 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
7
    DECLARE return_str varchar(255) DEFAULT '' ;
8
    DECLARE i INT DEFAULT 0;
9
    WHILE i < n DO
10
        SET return_str = concat(return_str, substring(chars_str, FLOOR(1 + RAND() * 62), 1));
11
        SET i = i + 1;
12
    END WHILE;
13
    RETURN return_str;
14
END;
15
$$
16
17
DELIMITER ;

创建插入数据存储过程

1
DELIMITER $$
2
DROP PROCEDURE IF EXISTS add_employee_memory;
3
CREATE PROCEDURE add_employee_memory(IN n INT)
4
BEGIN
5
DECLARE i INT DEFAULT 1;
6
WHILE (i <= n) DO
7
        INSERT INTO `employee_memory` (name, dep_id, age) VALUES (rand_string(10), FLOOR(RAND() * (6-1) + 1), FLOOR(RAND() * (30 - 20) + 20));
8
        SET i = i + 1;
9
    END WHILE;
10
END
11
$$
12
13
DELIMITER ;

调用存储过程

1
CALL add_employee_memory(1000000);
2
-- 从内存表插入普通表
3
INSERT INTO employee SELECT NULL, `name`, `dep_id`, `age` FROM employee_memory;
4
DELETE FROM employee_memory;

执行肯定时没有问题的，但是报错了！SQL Error(1114)：The table 'employee_memory' is full警告我们内存满。别慌，我们可以通过修改max_heap_table_size=1024M这个参数调整，我测试能装个200W数据，不够？要啥自行车，执行几次就好了。。

数据生成完了，当然要记得把函数和过程给干掉哟。

1
DROP FUNCTION IF EXISTS rand_string;
2
DROP PROCEDURE IF EXISTS add_employee_memory;

如果使用脚本去逐条插入，大哥造千万数据的话，你就挂机睡觉吧，要不然LOL通宵也行啊，保证一个晚上你惊奇的发现也就能生成百万条数据。

使用临时数据表

创建临时表数据

1
CREATE TABLE temp_user_info(
2
    `id` int(11) NOT NULL AUTO_INCREMENT,
3
    `name` varchar(100) NOT NULL,
4
    `age` int(11) NOT NULL,
5
    PRIMARY KEY (`id`)
6
) ENGINE = InnoDB DEFAULT CHARSET=utf8mb4

用你熟悉的语言生成数据文件(文件名为：data.txt)

1
<?php
2
$userInfo = [];
3
$userStr = '';
4
5
for ($i=1; $i<=10000000; $i++) {
6
    $userInfo['id'] = $i;
7
    $userInfo['name'] = sprintf('php_user_%d', $i);
8
    $userInfo['age'] = rand(20, 30);
9
    // 1,php_user_1,22
10
    $userStr .= sprintf("%s\n", join(',', $userInfo));
11
12
    // 千万不要生成一条就入库一条！
13
    // 千万不要生成一条就入库一条！
14
    // 千万不要生成一条就入库一条！
15
    // 10w条再调用一次IO操作，一条调用一次操作，性能叫一个酸爽
16
    if ($i % 100000 === 0) {
17
        file_put_contents('./data.txt', $userStr, FILE_APPEND);
18
        echo $i . ' is Ok' . PHP_EOL;
19
        $userStr = '';
20
    }
21
}

文件生成的很快，我大PHP不愧是全世界最好的语言，哈哈哈。不说笑开始导入数据到临时表

1
load data LOCAL infile '[文件完整路径]/data.txt' replace into table `temp_user_info` fields terminated BY ',' lines terminated by'\n';

总结

本文总结了两个我创建大量数据的方法，我个人更喜欢用第二种，毕竟我不喜欢写SQL，我们工作中绝大多数都是使用PHP，而SQL只是在需要的时候才会去看看文档怎么写，而且SQL排查错误真的是难受，而且第二种方法我个人觉得更加效率。

]]> MySQL MySQL JavaScript设计模式——原型模式 /2020/03/04/JavaScript%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E2%80%94%E2%80%94%E5%8E%9F%E5%9E%8B%E6%A8%A1%E5%BC%8F/ 原型模式的定义

用原型实例指向创建对象的类，使用于创建新的对象的类共享原型对象的属性以及方法。

使用场景：

创建新的对象的类共享原型对象的属性以及方法，多以继承来呈现。

我们可以通过 JavaScript 特有的原型继承特性去实现原型模式，也就是创建一个对象作为另一个对象的 prototype 属性值，可以通过 Object.create(prototype, optionalDescriptorObjects)来实现原型继承。

1
var someAnimal = {
2
  name: "喵星人",
3
  eat: function() {}
4
};
5
6
// 使用Object.create创建一个新的动物
7
var anotherAnimal = Object.create(someAnimal, {
8
  eat: {
9
    value: function() {
10
      console.log("吃骨头");
11
    }
12
  }
13
});
14
anotherAnimal.name = "汪星人";

如果我们不想通过Object.create去创建，则可以使用以下代码实现

1
var someAnimal = {
2
  name: "喵星人",
3
  init: function(name) {
4
    this.name = name;
5
  },
6
  eat: function(thing) {
7
    console.log("吃" + thing);
8
  }
9
};
10
11
function anotherAnimal(name) {
12
  function F() {}
13
  F.prototype = someAnimal;
14
  var f = new F();
15
  f.init(name);
16
  return f;
17
}
18
19
var anotherAnimalObj = anotherAnimal("狗");
20
anotherAnimalObj.eat("骨头");

在 ES6 里面，就简单了。。。

1
class Animal {
2
  constructor(name) {
3
    this.name = name;
4
  }
5
6
  eat(thing) {
7
    console.log("吃" + thing);
8
  }
9
}
10
11
class AnotherAnimal extends Animal {
12
  constructor(name) {
13
    super(name);
14
  }
15
}

得益于 ES6 的便利，这个模式不用再像之前一样，复杂的编码了，当然这个也只能在开发的时候使用，我们的 Babel 还是会把代码编译成为 ES5 的运行模式，方便代码浏览器和终端都能识别运行。

]]> JavaScript JavaScript 设计模式 JavaScript设计模式——单例模式 /2020/03/04/JavaScript%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E2%80%94%E2%80%94%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/ 众所周知，程序开发有很多语言，它们拥有各种不同的语法和规则，但是通用的思想部分就是——数据结构、设计模式，业内俗称内功。我是 PHP 入行，用 PHP 来实现一个单例我觉得不是什么难题。突然有一天 Node.js 进入了我的视线，心想 JavaScript 这几年皮呀，但是我喜欢。

单例的定义：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。实现的方法为先判断实例是否存在，如果存在则直接返回，否则就创建实例再返回，这就保证了一个类只实例化一次。

使用场景：

一个单一对象。比如：数据库连接、弹窗，一次运行无论操作多少次数据库，连接只存在一个，弹窗不管点击多少次，弹窗只能创建一次。

代码实现：

1
class Singleton {
2
  constructor() {}
3
}
4
5
Singleton.getInstance = (() => {
6
  let instance;
7
8
  return () => {
9
    if (!instance) {
10
      instance = new Singleton();
11
    }
12
    return instance;
13
  };
14
})();
15
16
let s1 = Singleton.getInstance();
17
let s2 = Singleton.getInstance();
18
console.log(s1 === s2);

可以看出来，这个实现并不是很复杂，只是通过一个变量把实例缓存起来，判断这个变量缓存存在则返回instance这个实例。

]]> JavaScript JavaScript 设计模式 0x01 Promise理解第一个部分 /2020/03/04/0x01Promise%E7%90%86%E8%A7%A3%E7%AC%AC%E4%B8%80%E4%B8%AA%E9%83%A8%E5%88%86/ 基础铺垫

event loop 它的执行顺序：

  • 一开始整个脚本作为一个宏任务执行
  • 执行过程中同步代码直接执行，宏任务进入宏任务队列，微任务进入微任务队列
  • 当红任务执行完出队，检查微任务列表，有则一次执行，直到全部执行完
  • 执行浏览器 UI 线程渲染工作
  • 检查是否有Web Worker任务，有则执行
  • 执行完本轮的宏任务，回到 2，依次循环，直到宏任务和微任务队列都为空

微任务：

  • MutationObserver、Promise.then()或 reject()、Promise 为基础开发的其它技术，比如 feth Api v8 的垃圾回收过程、Node 独有的 process.nextTick。

宏任务：

  • script、setTimeout、setInterval、setImmdiate、I/O、UI rendering

注意：所有任务开始的时候，由于宏任务包括了 script，所以浏览器会先执行一个宏任务，在这个过程中你看到的延迟任务（例如：setTimeout）将放到下一轮宏任务中执行。

只看 Promise 部分（理解相对如容易）

题目一：

1
const promise1 = new Promise((resolve, reject) => {
2
  console.log("promise1");
3
});
4
console.log("1", promise1);

过程分析：

  • 从上至下，先遇到new Promise，执行该构造函数中的代码promise1
  • 然后执行同步代码1 ，此时promise1没有被resolve或者reject，因此状态还是pending

结果：

1
'promise1'
2
'1' Promise{<pending>}

题目二：

1
const promise = new Promise((resolve, reject) => {
2
  console.log(1);
3
  resolve("success");
4
  console.log(2);
5
});
6
7
promise.then(() => {
8
  console.log(3);
9
});
10
11
console.log(4);

过程分析：

  • 从上至下，先遇到new Promise，执行中的同步代码1
  • 再遇到resolve('success')，将promise的状态改为了resolved并且将值保存下来
  • 继续执行同步代码2
  • 跳出promise，往下执行，碰到promise.then这个微任务，将其加入微任务队列
  • 同步执行代码4
  • 本轮宏任务全部执行完毕，检查微任务队列，发现promise.then这个微任务则状态为resolved，执行它。

结果：

1
1 2 4 3

题目三：

1
const promise = new Pormise((resolve, reject) => {
2
  console.log(1);
3
  console.log(2);
4
});
5
6
promise.then(() => {
7
  console.log(3);
8
});
9
10
console.log(4);

过程分析：

  • 和题目二相似，只不过在promise中并没有resolve或者reject
  • 因此promise.then并不会执行，它只有在被改变了状态之后才会执行。

结果：

1
1 2 4

题目四：

1
const pormise1 = new Promise((resolve, reject) => {
2
  console.log("promise1");
3
  resolve("resolve1");
4
});
5
6
const promise2 = promise1.then(res => {
7
  console.log(res);
8
});
9
10
console.log("1", promise1);
11
console.log("2", promise2);

过程分析：

  • 从上至下，先遇到new Promise，执行该构造函数中的代码promise1
  • 碰到resolve函数，将promise1的状态改变为resolved，并将结果保存下来
  • 碰到promise1.then这个微任务，将它放入微任务队列
  • promise2是一个新状态为pending的Promise
  • 执行同步代码1，同时打印出promise1的状态是resolved
  • 执行同步代码2，同时打印出promise2的状态是pending
  • 宏任务执行完毕，查找微任务队列，发现promise1.then这个微任务且状态为resolved，执行它。

结果：

1
'promise1'
2
'1' Promise{<resolved>: 'resolve1'}
3
'2' Promise{<pending>}
4
'resolve1'

题目五：

1
const fn = () =>
2
  new Promise((resolve, reject) => {
3
    console.log(1);
4
    resolve("success");
5
  });
6
7
fn().then(res => {
8
  console.log(res);
9
});
10
11
console.log("start");

过程分析：

  • 从上至下，new Promise构造函数创建一个实例赋值给fn
  • fn()调用执行1
  • fn().then新的微任务，加入微任务队列中去
  • 执行同步代码start
  • 因为前面resolve，进入微任务队列执行，输出success

结果：

1
'1'
2
'start'
3
'success'

题目六：

fn调用放start之后

1
const fn = () =>
2
  new Promise((resolve, reject) => {
3
    console.log(1);
4
    resolve("success");
5
  });
6
7
console.log("start");
8
9
fn().then(res => {
10
  console.log(res);
11
});

过程分析：

  • new Promise赋值给fn，fn未发生调用
  • 执行同步代码start
  • fn发生调用，执行1，之后执行resolve
  • fn().then()随后执行，输出success

结果：

1
'start'
2
'1'
3
'success'

Promise 结合 setTimeout

题目一：

1
console.log("start");
2
setTimeout(() => {
3
  console.log("time");
4
});
5
Promise.resolve().then(() => {
6
  console.log("resolve");
7
});
8
console.log("end");

过程分析：

  • 刚开始整个脚本为一个宏任务执行，对于同步代码直接进入执行栈进行执行，因此先打印出start和end
  • setTimeout作为一个宏任务，放入宏任务队列（下一个循环）
  • Promise.then作为一个微任务，放入微任务队列
  • 本次宏任务执行完毕，检查微任务，发现Promise.then，然后执行
  • 接下来进入下一个宏任务，发现setTimeout，然后执行

结果：

1
'start'
2
'end'
3
'resolve'
4
'time'

题目二：

1
const promise = new Promise((resolve, reject) => {
2
  console.log("1");
3
  setTimeout(() => {
4
    console.log("timerStart");
5
    resolve("success");
6
    console.log("timerEnd");
7
  }, 0);
8
  console.log(2);
9
});
10
11
promise.then(res => {
12
  console.log(res);
13
});
14
15
console.log(4);

过程分析：

  • 从上至下，先遇到new Promise，执行该构造函数中的代码1
  • 然后碰到了定时器，将这个定时器中的函数放到下一个宏任务的延迟队列中等待执行
  • 执行同步代码2
  • 跳出promise函数，遇到promise.then，但其状态还是为pending，这里理解为先不执行
  • 执行同步代码4
  • 一轮循环过后，进入第二次宏任务，发现延迟队列中有setTimeout定时器，执行它
  • 首先执行timeStart，然后遇到了resolve，将promise的状态改为resolved且保存结果并将之前的promise.then推入微任务队列
  • 继续执行同步代码timerEnd
  • 宏任务全部执行完毕，查找微任务队列，发现promise.then这个微任务，执行它。

结果：

1
'1'
2
'2'
3
'4'
4
'timerStart'
5
'timerEnd'
6
'success'

题目三：

1
setTimeout(() => {
2
  console.log("timer1");
3
  setTimeout(() => {
4
    console.log("timer3");
5
  }, 0);
6
});
7
8
setTimeout(() => {
9
  console.log("timer2");
10
}, 0);
11
12
console.log("start");

过程分析：

  • script本来是一个宏任务，先执行start
  • setTimeout（timer1）、setTimeout（timer2）宏任务放入宏任务队列
  • 检测宏任务队列，执行timer1之后将setTimeout(timer3)加入宏任务队列，然后执行timer2
  • 检测宏任务队列，执行timer3

结果：

1
'start'
2
'timer1'
3
'timer2'
4
'timer3'

题目四：

1
setTimeout(() => {
2
  console.log("timer1");
3
  Promise.resolve().then(() => {
4
    console.log("promise");
5
  });
6
}, 0);
7
8
setTimeout(() => {
9
  console.log("timer2");
10
}, 0);
11
12
console.log("start");

过程分析：

  • script本身是宏任务，优先执行start
  • setTimeout(timer1)、setTimeout(timer2)放入宏任务队列，并开始执行
  • 执行宏任务timer1，产生微任务Promise.resolve().then，微任务进入队列执行promise
  • 执行宏任务timer2

题目五：

1
Promise.resolve().then(() => {
2
  console.log("promise1");
3
  const timer2 = setTimeout(() => {
4
    console.log("timer2");
5
  }, 0);
6
});
7
8
const timer1 = setTimeout(() => {
9
  console.log("timer1");
10
  Promise.resolve().then(() => {
11
    console.log("promise2");
12
  });
13
}, 0);
14
15
console.log("start");

过程分析：

  • script作为第一个宏任务来执行，这里标记为宏任务 1
  • 遇到Promise.resolve().then这个微任务，将then中的内容加入第一次的微任务队列，标为微任务 1
  • 遇到setTimeout（timer1），加入到宏任务队列，标为宏任务 2，等待执行
  • 执行宏任务 1的同步代码start，完成后，检查微任务队列
  • 发现有一个promise.then这个微任务执行，打印同步代码promise1，发现定时器timer2，将它加入宏任务 2的后面，标记为宏任务 3
  • 第一次微任务队列（微任务 1）执行完毕，执行第二次宏任务（宏任务 2），首先执行同步代码timer1
  • 然后遇到了promise2这个微任务，将它加入此次循环的微任务队列，标为微任务 2
  • 宏任务 2中没有同步代码可执行，查找本次循环的微任务队列（微任务 2），发现promise2
  • 第二轮执行完毕，执行宏任务 3，打印出timer2

结果：

1
'start'
2
'promise1'
3
'timer1'
4
'promise2'
5
'timer2'

题目六：

1
const promise1 = new Promise((resolve, reject) => {
2
  setTimeout(() => {
3
    reslove("success");
4
  }, 0);
5
});
6
7
const promise2 = pormise1.then(() => {
8
  throw new Error("error!!!");
9
});
10
11
console.log("promise1", promise1);
12
console.log("promise2", promise2);
13
14
setTimeout(() => {
15
  console.log("promise1", promise1);
16
  console.log("promise2", promise2);
17
}, 2000);

过程分析：

  • 先执行第一个new Promise中的函数，碰到setTimeout将它加入下一个宏任务列表
  • 跳出new Promise，碰到promise1.then这个微任务，但其状态还是为pending，这里理解为先不执行
  • promise2是一个新的状态为pending的Promise
  • 执行同步代码console.log('promise1')，则打印出的promise1的状态为pending
  • 执行同步代码console.log('promise2')，则打印出的promise2的状态为pending
  • 碰到第二个setTimeout定时器，将其放入下一个宏任务列表
  • 第一轮宏任务执行结束，并且没有微任务需要执行，因此执行第二轮任务
  • 先执行第一个定时器的内容，将promise1的状态改为resolved且保存结果并将之前的promise1.then推入微任务队列
  • 该定时器中没有其他的同步代码可执行，因此执行本轮的微任务队列，也就是promise1.then，它将抛出一个错误，且将promise2的状态设置为了rejected
  • 第一个定时器执行完毕，开始执行第二个定时器中的内容
  • 打印出promise1，且此时promise1的状态为resolved
  • 打印出promise2，且此时promise2的状态为rejected

结果：

1
'promise1' Promise{<pending>}
2
'promise2' Promise{<pending>}
3
Uncaught (in promise) Error: error!!!
4
'promise1' Promise{<resolved>: "success"}
5
'promise2' Promise{<rejected>: Error: error!!!}

题目七：

1
const promise1 = new Promise((resolve, reject) => {
2
  setTimeout(() => {
3
    resolve("success");
4
    console.log("timer1");
5
  }, 1000);
6
  console.log("promise1里面的内容");
7
});
8
9
const promise2 = promise1.then(() => {
10
  throw new Error("error!!!");
11
});
12
13
console.log("promise1", promise1);
14
console.log("promise2", promise2);
15
16
setTimeout(() => {
17
  console.log("timer2");
18
  console.log("promise1", promise1);
19
  console.log("promise2", promise2);
20
}, 2000);

结果：

1
'promise1里面的内容'
2
'promise1' Promise{<pending>}
3
'promise2' Promise{<pending>}
4
'timer1'
5
Uncaught (in promise) Error: error!!!
6
'timer2'
7
'promise1' Promise{<resolved>: success>}
8
'promise2' Promise{<reject>: error!!!>}
]]> JavaScript JavaScript 0x02 MongoDB 练习手札 /2019/12/02/0x02%20MongoDB%20%E7%BB%83%E4%B9%A0%E6%89%8B%E6%9C%AD/ 导入数据

为了方便我们的练习节省时间，最好的方法就是使用官方提供的数据。

数据地址：传送门

先下载下来，然后通过以下方法导入数据

1
mongoimport --db=zipcodes --collection=zipcodes --file=zips.json

没个 item 字段：

1
{
2
  "_id": "10280",
3
  "city": "NEW YORK",
4
  "state": "NY",
5
  "pop": 5574,
6
  "loc": [-74.016323, 40.710537]
7
}
  • _id 表示邮政编码
  • city 表示城市名称
  • state 表示城市所属州
  • pop 表示人口
  • loc 表示所在地的精度和维度

查询州人口大于 1000 万

1
db.zipcodes.aggregate([
2
  { $group: { _id: "$state", totalPop: { $sum: "$pop" } } },
3
  { $match: { totalPop: { $gte: 10 * 1000 * 1000 } } }
4
]);

聚合管道会至上而下的将处理结果传递给下一个阶段处理。上面例子就是先将文档进行以 state 为单位进行分组处理，计算每个州的人口总和，将分组后的统计记过通过聚合管道传递给下一个$match 进行筛选处理。

查询州下城市的平均人口

1
db.zipcodes.aggregate([
2
  {
3
    $group: { _id: { state: "$state", city: "$city" }, pop: { $sum: "$pop" } }
4
  },
5
  { $group: { _id: "$_id.state", avgCityPop: { $avg: "$pop" } } }
6
]);

解释下：这里我们先按照州和城市进行分组并计算人口总数，在将统计的结果，通过管道传递给下一个处理条件。

  1. 分解开来理解就是，第一次分组后的单条数据结果为：
1
// { $group: { _id: { state: "$state", city: "$city" }, pop: { $sum: "$pop" } } },
2
[{
3
"_id" : {
4
    "state" : "CO",
5
    "city" : "EDGEWATER"
6
  },
7
  "pop" : 13154
8
},...]
  1. 在这个数据结果的基础上，我们在进行分组聚合
1
// 以这个条件 { $group: { _id: "$_id.state", avgCityPop: { $avg: "$pop" } } }
2
[{
3
  "_id" : "MN",
4
  "avgCityPop" : 5335
5
}, ...]

可以看出来，我们的查询结果是按照传入数组至上而下的进行管道式处理。

查询一个州中最大和最小城市人口数据

有了上面两个案例的思路，我们可以借鉴的思路就是：

  • 先把数据按州、城市进行分组，并计算人口和
  • 对分组后的数据进行排序
  • 再讲分组信息按州进行分组，找出人口最大城市和人口最小城市
1
db.zipcodes.aggregate([
2
  {
3
    $group: {
4
      _id: { state: "$state", city: "$city" },
5
      pop: { sum: "$pop" }
6
    }
7
  },
8
  { $sort: { pop: 1 } }, // 1升序，-1降序
9
  {
10
    $group: {
11
      _id: "$_id.state",
12
      biggestCity: { $last: "$_id.city" },
13
      biggestPop: { $last: "$pop" }, // 自定义字段，取最后一条数据
14
      smallestCity: { $first: "$_id.city" },
15
      smallestPop: { $first: "$pop" } // 自定义字段，取第一条数据
16
    }
17
  },
18
19
  // 自定义返回字段，相当于我们MySQL中的 select
20
  {
21
    $project: {
22
      _id: 0, // 隐藏默认_id
23
      state: "$_id",
24
      biggestCity: { name: "$biggestCity", pop: "$biggestPop" },
25
      smallestCity: { name: "$smallestCity", pop: "$smallestPop" }
26
    }
27
  }
28
]);

只要理解聚合管道，我们就可以逐步的对数据记性逐级处理，来获取我们想要的数据

]]> MongoDB MongoDB 使用 ES6 写 Koa Web 项目 /2019/11/29/%E4%BD%BF%E7%94%A8-ES6-%E5%86%99-Koa-Web-%E9%A1%B9%E7%9B%AE/ 我们 node.js 只是实现了部分 ES6 的语法，所以为了让我们 ES6 的代码能 100% 在 node.js 下执行，必须使用我们的 babel 把 ES6 代码编译成 nodejs 可执行的代码。

  • node 环境：v12.13.1

开发环境搭建

首先，我们建立一个文件 my_koa

1
mkdir my_koa && cd my_koa
2
npm init -y

在我们的 my_koa 文件夹下就会产生一个 package.json 文件使我们的包配置文件，内容如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "test": "echo \"Error: no test specified\" && exit 1"
8
  },
9
  "keywords": [],
10
  "author": "Neilyoz",
11
  "license": "ISC"
12
}

然后安装我们的依赖

1
npm i --save-dev @babel/cli @babel/core @babel/node @babel/preset-env @babel/register eslint

安装完成后 package.json 如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "test": "echo \"Error: no test specified\" && exit 1"
8
  },
9
  "keywords": [],
10
  "author": "Neilyoz",
11
  "license": "ISC",
12
  "devDependencies": {
13
    "@babel/cli": "^7.7.4",
14
    "@babel/core": "^7.7.4",
15
    "@babel/node": "^7.7.4",
16
    "@babel/preset-env": "^7.7.4",
17
    "@babel/register": "^7.7.4",
18
    "eslint": "^6.7.1"
19
  }
20
}

我的习惯是将代码放到 my_koa\src 目录下进行管理，所以执行以下命令创建

1
mkdir src
2
touch index.js

归功于 npm 包管理的便利性，到这里已经成功了一半了。接下来就是要安装我们的主角 koa 了

1
npm i koa koa-router

npm 完成安装后，此时我们的 package.json 如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "test": "echo \"Error: no test specified\" && exit 1"
8
  },
9
  "keywords": [],
10
  "author": "Neilyoz",
11
  "license": "ISC",
12
  "devDependencies": {
13
    "@babel/cli": "^7.7.4",
14
    "@babel/core": "^7.7.4",
15
    "@babel/node": "^7.7.4",
16
    "@babel/preset-env": "^7.7.4",
17
    "@babel/register": "^7.7.4",
18
    "eslint": "^6.7.1"
19
  },
20
  "dependencies": {
21
    "koa": "^2.11.0",
22
    "koa-router": "^7.4.0"
23
  }
24
}

到这里我们需要的基础包就已经安装完成了。可以开始我们的编码部分。

打开 src/index.js 文件输入一下内容：

1
import Koa from "koa";
2
import KoaRouter from "koa-router";
3
4
const app = new Koa();
5
const router = new KoaRouter();
6
7
router.get("/", async ctx => {
8
  ctx.body = "Index";
9
});
10
11
app.use(router.routes()).use(router.allowedMethods());
12
13
app.listen(3000);

直接运行 node ./src/index.js ，我们会看到是报错的。因为这里的编码并没有编译成为 nodejs 认识的形式。

一般我们开发环境可以直接使用 babel-node ./src/index.js 来运行代码，因为有安装 @babel/node 为了方便，我一般会在 package.json 中定义一个命令来直接运行，代码如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "dev": "babel-node ./src/index.js"
8
  },
9
  "keywords": [],
10
  "author": "Neilyoz",
11
  "license": "ISC",
12
  "devDependencies": {
13
    "@babel/cli": "^7.7.4",
14
    "@babel/core": "^7.7.4",
15
    "@babel/node": "^7.7.4",
16
    "@babel/preset-env": "^7.7.4",
17
    "@babel/register": "^7.7.4",
18
    "eslint": "^6.7.1"
19
  },
20
  "dependencies": {
21
    "koa": "^2.11.0",
22
    "koa-router": "^7.4.0"
23
  }
24
}

要执行代码的时候只需要

1
npm run dev

可是开发环境修改完代码，总是要运行命令重新加载代码。那么怎么才能让代码保存，程序自动加载代码呢？

我使用 nodemon 来实现，首先我们要全局安装 nodemon

1
npm i -g nodemon

并且在 my_koa 的根目录下创建 nodemon.json 文件来保存 nodemon 运行需要的配置。

nodemon.json 文件内容如下：

1
{
2
  "exec": "npm run dev",
3
  "watch": ["src/*"],
4
  "ext": "js, html, css, json"
5
}

这时我们还需要在 package.json 加入一个自定义命令，如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "dev": "babel-node ./src/index.js",
8
    "watch": "nodemon"
9
  },
10
  "keywords": [],
11
  "author": "Neilyoz",
12
  "license": "ISC",
13
  "devDependencies": {
14
    "@babel/cli": "^7.7.4",
15
    "@babel/core": "^7.7.4",
16
    "@babel/node": "^7.7.4",
17
    "@babel/preset-env": "^7.7.4",
18
    "@babel/register": "^7.7.4",
19
    "eslint": "^6.7.1"
20
  },
21
  "dependencies": {
22
    "koa": "^2.11.0",
23
    "koa-router": "^7.4.0"
24
  }
25
}

这个时候我们执行 npm run watch 再修改 ./src/index.js 的代码，代码保存就可以自动加载了。

生产环境代码生成

因为src 中的代码还是开发环境的代码，并没有通过我们的 babel 进行编译转换，所以直接使用 node 是可能无法启动的，我们需要配置 .babelrc babel 的配置文件，来告诉 babel 具体要做哪些编译。

.babelrc 如下：

1
{
2
  "presets": [
3
    [
4
      "@babel/preset-env",
5
      {
6
        "targets": {
7
          "node": true
8
        }
9
      }
10
    ]
11
  ]
12
}

然后在 package.json 中定义一个 build 命令，内容如下：

1
{
2
  "name": "my_koa",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "build": "babel src --out-dir dist",
8
    "dev": "babel-node ./src/index.js",
9
    "watch": "nodemon"
10
  },
11
  "keywords": [],
12
  "author": "Neilyoz",
13
  "license": "ISC",
14
  "devDependencies": {
15
    "@babel/cli": "^7.7.4",
16
    "@babel/core": "^7.7.4",
17
    "@babel/node": "^7.7.4",
18
    "@babel/preset-env": "^7.7.4",
19
    "@babel/register": "^7.7.4",
20
    "eslint": "^6.7.1"
21
  },
22
  "dependencies": {
23
    "koa": "^2.11.0",
24
    "koa-router": "^7.4.0"
25
  }
26
}

执行我们 npm run build 就会在 my_koa 产生 dist 目录，这个目录里面的代码就是我们应用于生产环境的编译代码。

]]> Node.JS Node.js ES6 Babel koa 0x01 MongoDB 练习手札 /2019/11/19/0x01%20MongoDB%20%E7%BB%83%E4%B9%A0%E6%89%8B%E6%9C%AD/ 最近看 Node.js 相关的一些东西，跟着书上的教程实现了一个 Express + MongoDB + Vue.js 实验性项目，对于常年使用 LNMP 黄金搭档的我来说，不用写 SQL 语句真的是太爽了，也不用关心 MySQL 中的字段增减，真的是太幸福了。

既然学习就肯定要动手，不动手的学习就是耍流氓！说干就干！

MongoDB 的基本概念存入单元：

  1. 数据库 databases
  2. 集合 collection
  3. 文档 document

正确的理解名词有助于我们在未来的开发和工作中方便和他人进行沟通，MongoDB 中可以存在多个数据，而数据库中可以存在多个集合，每个集合中可以存放多条文档数据。

希望大家通过练习来掌握基础 MongoDB 操作，别光看，动手敲！ 别光看，动手敲！ 别光看，动手敲！

  1. 进入 my_practices 数据库
1
use my_practices
  1. 查看数据库
1
show dbs
  1. 向数据库的 user 集合插入一个文档
1
// insertOne 增加语义化一些
2
// 在开发中，因为集合中存放了多个文档，所以集合命名我更加习惯用复数的形式
3
// 当然这种习惯性的东西不强制每个人，只是我的个人习惯
4
// 当然MongoDB查询的方法还有insert,insertMany,分别是什么可以感兴趣的可以查询文档。
5
db.users.insertOne({
6
  username: "Tom",
7
  age: 18,
8
  gender: "male"
9
});
  1. 查询 user 集合中的文档
1
// find中可以传递空文档{}，也可以什么都不传，表示查询全部
2
db.users.find({});
  1. 向数据库的 user 集合中再插入一个文档
1
db.users.insertOne({
2
  username: "Jerry",
3
  age: 17,
4
  gender: "male"
5
});
  1. 查看当前数据库 user 集合中的文档
1
db.users.find({})
  1. 统计数据库 user 集合中的文档数量
1
db.users.find().count()
  1. 查询数据库 user 集合中 username 为 Tom 的文档
1
// 传递要查询文档中需要满足的条件
2
db.users.find({
3
  username: "Tom"
4
});
  1. 向数据库 user 集合中的 username 为 Tom 的文档，添加一个 address 属性，属性值为 Shenzhen.
1
// 修改指定文档对应的属性
2
db.users.update(
3
  {
4
    username: "Tom"
5
  },
6
  {
7
    $set: { address: "Shenzhen" }
8
  }
9
);
  1. 使用{username: ‘Herry’} 替换 username 为 Jerry 的文档
1
db.users.replaceOne(
2
  {
3
    username: "Jerry"
4
  },
5
  {
6
    username: "Herry"
7
  }
8
);
  1. 删除 username 为 Tom 的文档的 address 属性
1
// 删除指定文档对应的属性，为的是删除属性，所以属性对应的值可以随意
2
// 个人感觉值就是起了一个占位作用，美化语句而已
3
db.users.update(
4
  {
5
    username: "Tom"
6
  },
7
  {
8
    $unset: {
9
      address: ""
10
    }
11
  }
12
);
  1. 向 username 为 Tom 的文档中，添加一个 hobby：{cities: [‘BeiJing’, ‘ShangHai’], movies: [‘Hero’, ‘King’]}
1
// 修改之后，查询的时候我发现在一些GUI中，hobby的属性值被标记为Document
2
// 也就是说我们的hobby属性保存的是一个文档，这个文档叫做内嵌文档
3
db.users.update(
4
  {
5
    username: "Tom"
6
  },
7
  {
8
    $set: {
9
      hobby: {
10
        cities: ["BeiJing", "ShangHai"],
11
        movies: ["Hero", "King"]
12
      }
13
    }
14
  }
15
);
  1. 向 username 为 Herry 的文档中，添加一个 hobby: {movies: [‘Ip Man 1’, ‘Ip Man 2’]}
1
db.users.update(
2
  {
3
    username: "Herry"
4
  },
5
  {
6
    $set: {
7
      hobby: {
8
        movies: ["Ip Man 1", "Ip Man 2"]
9
      }
10
    }
11
  }
12
);
  1. 查看喜欢电影为 Hero 的文档
1
// MongoDB 支持直接通过内嵌文档的属性查询
2
// 注意通过内嵌文档查询，属性名必须使用引号括起来
3
db.users.find({
4
  "hobby.movies": "Hero"
5
});
  1. 向 Herry 的文档中添加新电影 Ip Man 3
1
// $push 用于向数组中添加一个新的元素
2
// 题外话：$addToSet 和 $push 拥有相同的功能，只是前者检测到集合中有这个值就不会添加
3
// 而后者不管数据是否重复
4
db.users.update(
5
  {
6
    username: "Herry"
7
  },
8
  {
9
    $push: {
10
      "hobby.movies": "Ip Man 3"
11
    }
12
  }
13
);
  1. 删除喜欢 BeiJing 的用户
1
db.users.remove({
2
  "hobby.cities": "BeiJing"
3
});
  1. 删除 user 集合
1
// 删除集合中所有的文档，效率不高
2
db.users.remove({})
3
// 更加方便的方法为
4
db.users.drop()
  1. 向 numbers 集合中插入 20000 条数据
1
// 这种形式，我的I7电脑都用了9.8s才完成插入
2
for (var i = 1; i <= 20000; i++) {
3
  db.numbers.insert({
4
    num: i
5
  });
6
}
7
8
// 这种形式则舒爽很多，仅仅使用了0.5s
9
var arr = [];
10
for (var i = 1; i <= 20000; i++) {
11
  arr.push({ num: i });
12
}
13
db.numbers.insert(arr);
14
15
// 项目开发中数据库的方法能少调用尽量少调用
  1. 查询 numbers 集合中 num 为 500 的文档
1
db.numbers.find({
2
  num: 500
3
});
4
5
// OR
6
7
db.numbers.find({
8
  num: {
9
    $eq: 500
10
  }
11
});
12
13
// 扩展: 不等于操作符为 $ne
  1. 查询 numbers 中 num 大于 500 的文档
1
// 大于500的
2
db.numbers.find({
3
  num: {
4
    $gt: 500
5
  }
6
});
7
8
// 大于等于500的
9
db.numbers.find({
10
  num: {
11
    $gte: 500
12
  }
13
});
14
15
// 扩展：$lt 小于 | $lte 小于等于
  1. 查询 numbers 中 num 小于 30 的文档
1
db.numbers.find({
2
  num: {
3
    $lt: 30
4
  }
5
});
  1. 查询 numbers 中 num 大于 40 小于 50 的文档
1
db.numbers.find({
2
  num: {
3
    $gt: 40,
4
    $lt: 50
5
  }
6
});
  1. 查询 numbers 中 num 大于 19996 的文档
1
db.numbers.find({
2
  num: {
3
    $gt: 19996
4
  }
5
});
  1. 查看 numbers 集合中的前 10 条数据
1
db.numbers.find().limit(10)
  1. 查看 numbers 集合中的第 11 条到 20 条数据
1
db.numbers.find().skip(10).limit(10)
  1. 查看 numbers 集合中的第 21 条到 30 条数据
1
db.numbers.find().skip(20).limit(10)
]]> MongoDB MongoDB