Java学习之路--内部类相关

静态内部类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
/**
目标:静态内部类的研究(了解语法即可)

什么是静态内部类?
有static修饰,属于外部类本身,会加载一次。

静态内部类中的成分研究:
类有的成分它都有,静态内部类属于外部类本身,只会加载一次
所以它的特点与外部类是完全一样的,只是位置在别人里面而已。

外部类=宿主
内部类=寄生

静态内部类的访问格式:
外部类名称.内部类名称

静态内部类创建对象的格式:
外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器;

静态内部类的访问拓展:
静态内部类中是否可以直接访问外部类的静态成员?可以的,外部类的静态成员只有一份,可以被共享!
静态内部类中是否可以直接访问外部类的实例成员?不可以的,外部类的是成员必须用外部类对象访问!!
小结:
静态内部类属于外部类本身,只会加载一次
所以它的特点与外部类是完全一样的,只是位置在别人里面而已。

*/
public class InnerClass {
public static void main(String[] args) {
// 外部类名称.内部类名称 对象名称 = new 外部类名称.内部类构造器
Outter.Inner in = new Outter.Inner();
in.setName("张三");
in.setAge(12);
System.out.println(in.getName());
System.out.println(in.getAge());
in.show();
}
}

class Outter{
public static int age1 = 12;
private double salary;

// 静态内部类:有static修饰,属于外部类本身,只会加载一次
public static class Inner{
private String name;
private int age;
public static String schoolName = "黑马";

public void show() {
System.out.println(name+"-->"+age+"岁~");
System.out.println(age1);
//System.out.println(salary);
}

public Inner() {
}

public Inner(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}
}

一般内部类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/**
目标:内部类_实例内部类(成员内部类)(了解语法为主)

什么是实例内部类:
无static修饰的内部类,属于外部类的每个对象的,跟着对象一起加载的。

实例内部类的成分特点:
实例内部类中不能定义静态成员,其他都可以定义。
可以定义常量。

实例内部类的访问格式:
外部类名称.内部类名称。

创建对象的格式:
外部类名称.内部类名称 对象名称 = new 外部类构造器.new 内部构造器;

拓展:
实例内部类中是否可以直接访问外部类的静态成员?可以的,外部类的静态成员可以被共享访问!
实例内部类中是否可以访问外部类的实例成员?可以的,实例内部类属于外部类对象,可以直接访问当前外部类对象的实例成员!
外部类访问内部类的成员需要创建内部类的对象,之后可以访问内部类的任何成员,包括private成员,需要注意的是成员内部类不可以有静态成员。
小结:
实例内部类属于外部类对象,需要用外部类对象一起加载,
实例内部类可以访问外部类的全部成员!
*/
public class InnerClass {
public static void main(String[] args) {
// 实例内部类属于外部类对象。实例内部类的宿主是外部类对象!!
Outter.Inner in = new Outter().new Inner();
in.show();
}
}
// 外部类
class Outter{
public static int age = 1;
private double salary;

// 实例内部类:无static修饰,属于外部类的对象
public class Inner{
private String name ;

public static final String schoolName = "黑马";
// 不能在实例内部类中定义静态成员!!!
// public static String schoolName = "黑马";
// public static void test(){
//
// }

// 实例方法
public void show(){
System.out.println(name+"名称!");
System.out.println(age);
System.out.println(salary);
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}
}

匿名内部类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
目标:匿名内部类的概述、

什么是匿名内部类?
就是一个没有名字的局部内部类。
匿名内部类目的是为了:简化代码,也是开发中常用的形式。

匿名内部类的格式:
new 类名|抽象类|接口(形参){
方法重写。
}
匿名内部类的特点:
1.匿名内部类是一个没有名字的内部类。
2.匿名内部类一旦写出来,就会立即创建一个匿名内部类的对象返回。
3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。
小结:
1.匿名内部类是一个没有名字的内部类。
2.匿名内部类一旦写出来,就会立即创建一个匿名内部类的对象返回。
3.匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型。

*/
public class Anonymity {
public static void main(String[] args) {
Animal a = new Animal(){
@Override
public void run() {
System.out.println("猫跑的贼溜~~");
}
};
a.run();
a.go();

Animal a1 = new Animal() {
@Override
public void run() {
System.out.println("狗跑的贼快~~~");
}
};
a1.run();
a1.go();


}
}
abstract class Animal{
public abstract void run();

public void go(){
System.out.println("开始go~~~");
}
}

注意事项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Outter{

static int x = 1;
static int y = 3;
static int z = 5;
static int func(){
return x + y;
}

static class Inner{
static int x = 2;
static int func(){
return x + y;
}
int z = 6;
public static void main(String[] args) {
System.out.println(x);
System.out.println(Outter.x);
System.out.println(func());
System.out.println(Outter.func());
System.out.println(new Inner().z);
System.out.println(new Outter().z);
}
}
}

/**
* 输出结果:
* 2
* 1
* 5
* 4
* 6
* 5
*/

说明:

  • 在静态内部类中,和外部类同名的变量和方法会覆盖外部的同名的静态变量和方法。
  • 若要访问外部类的静态方法或者变量则需要通过外部类名来调用,或者创建外部类对象来调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Outter{
static int x = 1;
class Inner {
int x = 2;
void function(){
System.out.println(x);
System.out.println(this);
System.out.println(this.x);
System.out.println(Outter.x);
System.out.println(Outter.this);
System.out.println(Outter.this.x);
System.out.println(new Outter().x);
}
}
public static void main(String[] args) {
Outter.Inner inner = new Outter().new Inner();
inner.function();
}
}

/**
* 输出结果:
* 2
* com.itheima._15单例模式.Outter$Inner@15db9742
* 2
* 1
* com.itheima._15单例模式.Outter@6d06d69c
* 1
* 1
*/

说明:

  • 在实例内部类中,和外部类同名的变量和方法会覆盖外部的同名的变量和方法。
  • 若要访问外部类的方法或者变量则需要通过外部类名来调用,或者创建外部类对象来调用,或者通过外部类名+this关键字来调用。

Java学习之路--常量初始化相关问题

看这段代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Test{

static final int a = 1;
static final int b;

static{
b = 1;
}

// ------------------------- //

final int aa = 1;
final int bb;
final int cc;

{
bb = 1;
}

Test(){
cc = 1;
// b = 1; ERROR
}

// ------------------------- //
// {
// b = 1; ERROR
// }

// static{
// bb = 1; ERROR
// }

}

常量初始化问题总结:

  • 静态常量初始化:
    • 定义时赋值
    • 静态代码快中赋值
  • 成员常量初始化:
    • 定义时赋值
    • 非静态代码快赋值
    • 构造函数中赋值
  • 注意出错情况:
    • 在非静态代码快中或构造函数中为静态常量赋值
    • 在静态代码快中为成员常量赋值

Nginx Lua扩展模块

Nginx Lua扩展模块

ngx_lua模块概念

ngx_lua 官方文档

ngx_lua 中文文档

淘宝开发的 ngx_lua 模块通过将 Lua 解释器集成进 Nginx,可以采用 Lua 脚本实现业务逻辑,由于 Lua 的紧凑、快速以及内建协程,所以在保证高并发服务能力的同时极大地降低了业务逻辑实现成本。

ngx_lua模块环境准备

下载 ngx-lua-module 模块有两个方式。

  • 方式一安装比较繁琐,需要手动下载其他依赖
  • 方式二安装简单快捷,集成了依赖,不需要手动下载依赖,建议方式二

不论方式一还是方式二安装,首先确保你为它安装好了环境,否则会安装报错。环境分别为:GCCPCREzlibOpenSSL环境安装传送门

方式一

方式一下载第三方模块 lua-nginx-module,前,需要先下载 LuaJIT 解析器。

LuaJIT 官网地址为:http://luajit.org/

  • LuaJIT 是采用 C 语言编写的 Lua 代表的解释器,我们先下载它。

    在官网上找到对应的下载地址:https://luajit.org/download.html

    在 Linux 上使用 wget 来下载: wget http://luajit.org/download/LuaJIT-2.0.5.tar.gz,这里下载在 /opt,下载的版本是 2.0.5。

1
2
cd /opt
wget http://luajit.org/download/LuaJIT-2.0.5.tar.gz

将下载的资源进行解压

1
tar -zxf LuaJIT-2.0.5.tar.gz

进入解压的目录

1
cd LuaJIT-2.0.5

执行编译和安装:

1
make && make install

image

  • 下载 lua-nginx-module

下载地址:https://github.com/openresty/lua-nginx-module/tags

在 Linux 上使用 wget 来下载: wget https://github.com/openresty/lua-nginx-module/archive/v0.10.16rc4.tar.gz,这里下载在 /opt,版本是 0.10.16rc4。

1
wget https://github.com/openresty/lua-nginx-module/archive/v0.10.16rc4.tar.gz

将下载的资源进行解压

1
tar -zxf lua-nginx-module-0.10.16rc4.tar.gz

目录名太长,更改目录名

1
mv lua-nginx-module-0.10.16rc4 lua-nginx-module

导入环境变量,告诉 Nginx 去哪里找 LuaJIT

1
2
export LUAJIT_LIB=/usr/local/lib
export LUAJIT_INC=/usr/local/include/luajit-2.0

进入 Nginx 的源码目录(安装包目录)执行如下命令:

1
2
./configure --prefix=/usr/local/nginx --add-module=/opt/lua-nginx-module
make && make install

注意事项

  1. 如果启动 Nginx 出现如下错误:

image

解决方案:

设置软链接,使用如下命令

1
ln -s /usr/local/lib/libluajit-5.1.so.2 /lib64/libluajit-5.1.so.2
  1. 如果启动 Nginx 出现以下错误信息

image

分析原因:因为 lua-nginx-module 是来自 OpenResty,错误中提示的 resty.core 是 OpenRestry 的核心模块,对其下的很多函数进行了优化等工作。以前的版本默认不会把该模块编译进去,所以需要使用的话,我们得手动安装,或者禁用就可以。但是最新的 lua-nginx-module 模块已经强制性安装了该模块,所以此处因为缺少 resty 模块导致的报错信息。

解决方案有两个:一种是下载对应的模块,另一种则是禁用掉 restry 模块,禁用的方式为:

1
2
3
http{
lua_load_resty_core off;
}
  • 测试

在 nginx.conf 下配置如下内容:

1
2
3
4
location /lua{
default_type 'text/html';
content_by_lua 'ngx.say("<h1>HELLO,LUA</h1>")';
}

配置成功后,启动 Nginx,通过浏览器进行访问,如果获取到如下结果,则证明安装成功。

image

方式二

方式二使用 OpenRestry 进行安装。OpenRestry 就是我们上面说到的 Nginx 的 Spring 之一。

概述

前面我们提到过,OpenResty 是由淘宝工程师开发的,所以其官方网站(http://openresty.org/)我们读起来是非常的方便。OpenResty 是一个基于 Nginx 与 Lua 的高性能 Web 平台,其内部集成了大量精良的 Lua 库、第三方模块以及大多数的依赖项。用于方便地搭建能够处理超高并发、扩展性极高的动态 Web 应用、Web 服务和动态网关。所以本身 OpenResty 内部就已经集成了 Nginx 和 Lua,所以我们使用起来会更加方便。

Linux安装

下载地址:http://openresty.org/cn/download.html。这里下载 1.19.9.1 版本。

1
2
3
cd /opt/openresty    # 没有就创建:mkdir /opt/openresty

wget https://openresty.org/download/openresty-1.19.9.1.tar.gz
  • 解压缩
1
tar -zxvf openresty-1.19.9.1.tar.gz
  • 进入 OpenResty 目录
1
cd openresty-1.19.9.1
  • 执行命令
1
./configure
  • 执行命令进行编译和安装
1
2
3
make && make install
# 或者
gmake && gmake install

默认安装在 /usr/local/ 下。

  • 进入 OpenResty 的目录,找到 nginx
1
cd /usr/local/openresty/nginx
  • 在 conf 目录下的 nginx.conf 添加如下内容:
1
vim conf/nginx.conf
1
2
3
4
location /lua {
default_type 'text/html';
content_by_lua 'ngx.say("<h1>HELLO,OpenRestry</h1>")';
}

重启 Nginx 配置文件

1
nginx -s reload
  • 先把 Nginx 停止运行
1
systemctl stop Nginx

然后在 sbin 目录下启动可执行文件 nginx

1
./sbin/nginx
  • 通过浏览器访问测试192.168.91.200

image

  • 通过浏览器访问测试192.168.91.200/lua

image

OpenResty卸载

卸载非常简单粗暴,相信我,这样卸载是对的,没什么问题。

  1. 停止 Nginx 服务
1
2
3
4
5
6
# 查看 Nginx 是否停止,没有则去停止
ps -ef | grep nginx

# 进入 sbin 目录
cd /usr/local/openresty/nginx/sbin
./nginx -s stop
  1. 输入以下指令全局查找 OpenResty 相关的文件
1
find / -name openresty
  1. find / -name openresty
1
rm -rf  此处跟查找出来的 Openresty 文件

ngx_lua指令图

使用 Lua 编写 Nginx 脚本的基本构建块是指令。指令用于指定何时运行用户 Lua 代码以及如何使用结果。

下图显示了执行指令的顺序。

image

先来解释下 * 的作用

  • * 代表 *_by_lua 指令,指令后面跟的是 lua 指令
  • *:_file,即 *_by_lua_file 指令,后面跟的是 lua 文件
  • *:_block,即 *_by_lua_block 指令,在 0.9.17 版后替换 init_by_lua_file

如上图所示,OpenResty 的执行阶段分为:

  • init_by_lua*:在每次 Nginx 重新加载配置时执行,初始化一些全局配置。
  • init_worker_by_lua*:该指令用于启动一些定时任务,如心跳检查、定时拉取服务器配置等。
  • set_by_lua* : 流程分支处理判断变量初始化
  • rewrite_by_lua* : 转发、重定向、缓存等功能(例如特定请求代理到外网)
  • access_by_lua* : IP 准入、接口权限等情况集中处理(例如配合 iptable 完成简单防火墙)
  • content_by_lua* : 内容生成
  • header_filter_by_lua* : 响应头部过滤处理(例如添加头部信息)
  • body_filter_by_lua* : 响应体过滤处理(例如完成应答内容统一成大写)
  • log_by_lua* : 会话完成后本地异步完成日志记录(日志可以记录在本地,还可以同步到其他机器)

语法API

ngx.say

返回结果给客户端。

语法:ngx.say("")

{4}
1
2
3
4
5
6
location / {
default_type 'text/plain';
content_by_lua_block {
ngx.say("Hello World")
}
}

你会在网页上看到 Hello World。

ngx.print

将输入参数合并发送给 HTTP 客户端 (作为 HTTP 响应体)。如果此时还没有发送响应头信息,本函数将先发送 HTTP 响应头,再输出响应体。

语法:ok, err = ngx.print(...)

1
2
3
4
5
6
local table = {
"hello, ",
{"world: ", true, " or ", false,
{": ", nil}}
}
ok, err = ngx.print(table)

将输出:

1
hello, world: true or false: nil

其中 ok 存储着输出的内容,如果输出失败,err 存储失败的原因。

本函数为异步调用,将立即返回,不会等待所有数据被写入系统发送缓冲区。要以同步模式运行,请在调用 ngx.print 之后调用 ngx.flush

ngx.flush

向客户端刷新响应输出。

语法:ok, err = ngx.flush(wait)

ngx.flush 接受一个布尔型可选参数 wait (默认值 false)。当通过默认参数(false)调用时,本函数发起一个异步调用。当把 wait 参数设置为 true 时,本函数将以同步模式执行。

  • 异步调用下,直接将数据返回,不等待输出数据被写入系统发送缓冲区。
  • 同步模式下,本函数不会立即返回,一直到所有输出数据被写入系统输出缓冲区,或到达发送超时 send_timeout 时间。

这个要和上方的 ngx.print 进行配合使用,开启同步模式,可以优化返回客户端多条数据的速度。

1
2
3
4
5
6
7
local table = {
"hello, ",
{"world: ", true, " or ", false,
{": ", nil}}
}
ok, err = ngx.print(table)
ngx.flush(true) -- 开启同步模式

ngx.arg

获取定义的变量。

语法:ngx.arg[n]

{4}
1
2
3
4
5
6
location /foo {
set $a 32;
set $b 56;
sum = ngx.arg[1] + ngx.arg[2] # 等价于 $a + $b
echo $sum;
}

将输出 88,是 32 和 56 的和。

ngx.var

读写 Nginx 变量值。

语法:ngx.var.xxx

{2,4}
1
2
3
4
5
6
location /foo {
set $my_var ''; # 创建 $my_var 变量
content_by_lua '
ngx.var.my_var = 123; # 使用 $my_var 变量
';
}

ngx.log

输出到日志中。格式:ngx.log(ngx.level,...)

可指定多个日志常量 ngx.level。

ngx.level有:

1
2
3
4
5
6
7
8
9
ngx.STDERR    -- 例如 ngx.log(ngx.STDERR)
ngx.EMERG
ngx.ALERT
ngx.CRIT
ngx.ERR
ngx.WARN
ngx.NOTICE
ngx.INFO
ngx.DEBUG

HTTP 方法常量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ngx.HTTP_GET
ngx.HTTP_HEAD
ngx.HTTP_PUT
ngx.HTTP_POST
ngx.HTTP_DELETE
ngx.HTTP_OPTIONS (v0.5.0rc24 版本加入)
ngx.HTTP_MKCOL (v0.8.2 版本加入)
ngx.HTTP_COPY (v0.8.2 版本加入)
ngx.HTTP_MOVE (v0.8.2 版本加入)
ngx.HTTP_PROPFIND (v0.8.2 版本加入)
ngx.HTTP_PROPPATCH (v0.8.2 版本加入)
ngx.HTTP_LOCK (v0.8.2 版本加入)
ngx.HTTP_UNLOCK (v0.8.2 版本加入)
ngx.HTTP_PATCH (v0.8.2 版本加入)
ngx.HTTP_TRACE (v0.8.2 版本加入)

HTTP 状态常量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
value = ngx.HTTP_OK 					(等于 200)
value = ngx.HTTP_CREATED (等于 201)
value = ngx.HTTP_SPECIAL_RESPONSE (等于 300)
value = ngx.HTTP_MOVED_PERMANENTLY (等于 301)
value = ngx.HTTP_MOVED_TEMPORARILY (等于 302)
value = ngx.HTTP_SEE_OTHER (等于 303)
value = ngx.HTTP_NOT_MODIFIED (等于 304)
value = ngx.HTTP_BAD_REQUEST (等于 400)
value = ngx.HTTP_UNAUTHORIZED (等于 401)
value = ngx.HTTP_FORBIDDEN (等于 403)
value = ngx.HTTP_NOT_FOUND (等于 404)
value = ngx.HTTP_NOT_ALLOWED (等于 405)
value = ngx.HTTP_GONE (等于 410)
value = ngx.HTTP_INTERNAL_SERVER_ERROR (等于 500)
value = ngx.HTTP_METHOD_NOT_IMPLEMENTED (等于 501)
value = ngx.HTTP_SERVICE_UNAVAILABLE (等于 503)
value = ngx.HTTP_GATEWAY_TIMEOUT (等于 504) (v0.3.1rc38 版本加入)

print

将参数值以 ngx.NOTICE 日志级别写入 Nginx 的 error.log 文件。

语法:print(...)

1
print("Hello")

等价于

1
ngx.log(ngx.NOTICE, "Hello")

ngx.ctx

一个 location 模块里的全局环境变量,存储基于请求的 Lua 环境数据。

语法:ngx.ctx.xxx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
location /sub {
content_by_lua '
ngx.say("sub pre: ", ngx.ctx.blah)
ngx.ctx.blah = 32
ngx.say("sub post: ", ngx.ctx.blah)
';
}

location /main {
content_by_lua '
ngx.ctx.blah = 73
ngx.say("main pre: ", ngx.ctx.blah)
local res = ngx.location.capture("/sub")
ngx.print(res.body)
ngx.say("main post: ", ngx.ctx.blah)
';
}

访问 GET /main 输出:

1
2
3
4
main pre: 73
sub pre: nil
sub post: 32
main post: 73

ngx.exit

退出某个阶段,如处理请求阶段、重定向阶段等。

语法:ngx.exit(status)

status 参数可以是 ngx.OKngx.ERROR 等等 HTTP 状态常量

1
2
3
4
5
ngx.status = ngx.HTTP_GONE
ngx.say("This is our own content")

-- 退出整个请求而不是当前处理阶段
ngx.exit(ngx.HTTP_OK)

可以直接使用数字作为参数,例如:

1
ngx.exit(501)

::: warning

数字作为参数仅支持 NGX_OKNGX_ERROR 的数字。

:::

ngx.sleep

无阻塞地休眠特定秒。时间可以精确到 0.001 秒 (毫秒)。

语法:ngx.sleep(seconds)

1
ngx.sleep(1000)

请求API

ngx.req.get_uri_args

返回一个 Lua table,包含当前请求的所有 URL 查询参数。

语法:args = ngx.req.get_uri_args([max_args])

1
2
3
4
5
6
7
8
9
10
11
12
location = /test {
content_by_lua '
local args = ngx.req.get_uri_args()
for key, val in pairs(args) do
if type(val) == "table" then
ngx.say(key, ": ", table.concat(val, ", "))
else
ngx.say(key, ": ", val)
end
end
';
}

访问 GET /test?foo=bar&bar=baz&bar=blah 将输出:

1
2
foo: bar
bar: baz, blah

多次出现同一个参数 key 时,将生成一个 Lua table,按顺序保存其所有 value。

ngx.req.set_uri_args

args 参数重写当前请求的 URI 请求参数。

语法:ngx.req.set_uri_args(args)

1
2
3
4
5
ngx.req.set_uri_args("a=3&b=hello%20world")

ngx.req.set_uri_args({ a = 3, b = "hello world" })

ngx.req.set_uri_args({ a = 3, b = {5, 6} })

在第二种情况下,本方法将根据 URI 转义规则转义参数的 key 和 value。

在第三种情况下,请求参数字符串为 a=3&b=5&b=6

ngx.header.HEADER

修改、添加、或清除当前请求待发送的 HEADER 响应头信息。

语法:ngx.header.HEADER = VALUE

HEADER 响应头信息不是自定义的,是请求头带有的。

1
2
3
4
-- 与 ngx.header["Content-Type"] = 'text/plain' 相同
ngx.header.content_type = 'text/plain';

ngx.header["X-My-Header"] = 'blah blah'

ngx.req.get_method

获取当前请求的 HTTP 请求方法名称。结果为类似 "GET""POST" 的字符串。

语法:ngx.req.get_method

1
value = ngx.req.get_method

ngx.req.set_method

method_id 参数的值改写当前请求的 HTTP 请求方法。当前仅支持 HTTP 请求方法 中定义的数值常量。

语法:ngx.req.set_method(method_id)

1
2
3
ngx.req.set_method(method_id)

ngx.req.set_method(ngx.HTTP_GET)

ngx.req.read_body

同步读取客户端请求体,不阻塞 Nginx 事件循环。

语法:ngx.req.read_body()

1
2
ngx.req.read_body()
local args = ngx.req.get_post_args()

ngx.req.get_post_args

返回一个 Lua table,包含当前请求的所有 POST 查询参数。

语法:args, err = ngx.req.get_post_args(max_args?)

::: warning

使用 ngx.req.get_post_args 获取参数前,必须使用 ngx.req.read_body 读取请求体。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
location = /test {
content_by_lua '
ngx.req.read_body()
local args, err = ngx.req.get_post_args()
if not args then
ngx.say("failed to get post args: ", err)
return
end
for key, val in pairs(args) do
if type(val) == "table" then
ngx.say(key, ": ", table.concat(val, ", "))
else
ngx.say(key, ": ", val)
end
end
';
}

请求

1
2
# Post request with the body 'foo=bar&bar=baz&bar=blah'
$ curl --data 'foo=bar&bar=baz&bar=blah' localhost/test

将输出:

1
2
foo: bar
bar: baz, blah

多次出现同一个参数 key 时,将生成一个 Lua table,按顺序保存其所有 value。

ngx.redirect

发出一个 HTTP 301302 重定向到 uri

可选项 status 参数指定 301302 哪个被使用。 默认使用 302

语法:ngx.redirect(uri, [status])

1
2
3
4
5
6
7
return ngx.redirect("/foo")

-- 等价于
return ngx.redirect("/foo", 301)

-- 等价于
return ngx.redirect("/foo", ngx.HTTP_MOVED_TEMPORARILY)

重定向到任意外部 URL 也是支持的,例如:

1
return ngx.redirect("http://www.baidu.com")

ngx.exec

使用 uriargs 参数执行一个内部跳转。内部指的是 Nginx 的某个 location 模块。

语法:ngx.exec(uri, [args])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
location /foo {
content_by_lua '
ngx.exec("/bar", "a=goodbye");
';
}

location /bar {
content_by_lua '
local args = ngx.req.get_uri_args()
for key, val in pairs(args) do
if key == "a" then
ngx.say(val)
end
end
';
}

访问 GET /foo/file.php?a=hello,将返回 『 hello 』 ,而不是 『 goodbye 』

::: warning

ngx.exec 方法与 ngx.redirect 是完全不同的,前者是个纯粹的内部跳转并且没有引入任何额外 HTTP 信号。

此方法的调用终止当前请求的处理。

ngx.location.capture

uri 发起一个同步非阻塞 Nginx 子请求。

语法:ngx.location.capture(uri,[options])

::: warning

它会请求 Nginx 的其他 location 模块,location 模块可以是其他文件目录的配置文件中,或任何其他 Nginx 模块。

:::

1
res = ngx.location.capture(uri,[options])

res 是返回的结果,它是一个「对象」,将包含四个元素的 Lua 表 (res.status, res.header, res.body, 和 res.truncated)。

  • res.status (状态) 保存子请求的响应状态码。
  • res.header (头) 用一个标准 Lua 表储子请求响应的所有头信息。如果是“多值”响应头,这些值将使用 Lua (数组) 表顺序存储。

如果子请求响应头包含下面的行:

1
2
3
Set-Cookie: a=3
Set-Cookie: foo=bar
Set-Cookie: baz=blah

res.header["Set-Cookie"] 将存储 Lua 表 {"a=3", "foo=bar", "baz=blah"}

options 选项

选项 作用
method 指定子请求的请求方法, 只接受类似 ngx.HTTP_POST 的常量
body 指定子请求的请求体 (仅接受字符串值)
args 指定子请求的 URI 请求参数 (可以是字符串或者 Lua 表)
ctx 指定一个 Lua 表作为子请求的 ngx.ctx 表,可以是当前请求的 ngx.ctx 表
vars 用一个 Lua 表设置子请求中的 Nginx 变量值
copy_all_vars 设置是否复制所有当前请求的 Nginx 变量值到子请求中,修改子请求的 nginx 变量值不影响当前 (父) 请求
share_all_vars 设置是否共享所有当前 (父) 请求的 Nginx 变量值到子请求中,修改子请求的 nginx 变量值将影响当前 (父) 请求
always_forward_body 当设置为 true 时,如果没有设置 body 选项,当前 (父) 请求的请求体将被转发给子请求

例如,发送一个 POST 子请求,可以这样做:

1
2
3
4
res = ngx.location.capture(
'/foo/bar',
{ method = ngx.HTTP_POST, args = { a = 1,b = 3}, body = 'Hello,World' }
)

等价于:

1
res = ngx.location.capture('/foo/bar?a=1&b=3')

method 选项默认值是 ngx.HTTP_GET

其他内容具体看中文文档,开头有转送门。

::: tip ngx.exec 和 ngx.location.capture 区别

ngx.exec 只会访问同一个配置文件的 location 模块。

ngx.location.capture 不仅如此,还可以访问其他配置文件的 location 模块。

ngx.req.set_uri

语法:ngx.req.set_uri(uri, jump?)

通过参数 uri 重写当前请求的 uri;参数 jump,表明是否进行 locations 的重新匹配。当 jump 为 true 时,调用 ngx.req.set_uri 后,Nginx 将会根据修改后的 uri,重新匹配新的 locations;如果 jump 为 false,将不会进行 locations 的重新匹配,而仅仅是修改了当前请求的 URI 而已。jump 的默认值为 false。

  • jump 为 true,等价于 rewrite…last
  • jump 为 false,等价于 rewrite…break

例如:

1
2
3
ngx.req.set_uri("/foo", true)  === rewrite ^ /foo last;

ngx.req.set_uri("/foo", false) === rewrite ^ /foo break;

指令API

init_by_lua

该指令在每次 Nginx 重新加载配置时执行,可以用来完成一些耗时模块的加载,或者初始化一些全局配置。

这是一个公共模块,把所有都用到的代码放到这个模块里,避免重复使用相同的代码。

比如每个模块都需要 MySQL 和 Redis,则在这个公共模块进行引用。

1
2
3
4
5
init_by_lua_block{
mysql = require "resty.mysql"
redis = require "resty.redis"
}
# 下方直接使用 MySQL 和 Redis 的 API

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 init_by_lua_file 引用 Lua 文件。

init_worker_by_lua

该指令用于启动一些定时任务,如心跳检查、定时拉取服务器配置等。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
init_worker_by_lua '
local delay = 3 -- in seconds
local new_timer = ngx.timer.at
local log = ngx.log
local ERR = ngx.ERR
local check

check = function(premature)
if not premature then
-- do the health check or other routine work
local ok, err = new_timer(delay, check)
if not ok then
log(ERR, "failed to create timer: ", err)
return
end
end
end

local ok, err = new_timer(delay, check)
if not ok then
log(ERR, "failed to create timer: ", err)
return
end
';

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 init_worker_by_lua_file 引用 Lua 文件。

set_by_lua

该指令只要用来做变量赋值,这个指令一次只能返回一个值,并将结果赋值给 Nginx 中指定的变量。

语法 说明
set_by_lua* <key> <value> key要加上 $ 符号,value 是 Lua 语言的格式

例如:

1
2
3
4
5
set_by_lua $name "
local uri_args = ngx.req.get_uri_args() -- 获取请求 ? 后的参数
name = uri_args['name'] -- 获取 key 为 name 的参数
return name..'先生' -- 在 name 后面加上 先生,作为 $name 的 value 返回给客户端
";

此时 key 为 $name 的 value 值是 URL 的参数 name 加上「先生」。

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 set_by_lua_file 引用 Lua 文件。

rewrite_by_lua

该指令用于执行内部 URL 重写或者外部重定向,典型的如伪静态化 URL 重写,本阶段在 Rewrite 处理阶段的最后默认执行。

例如:

1
2
3
4
5
6
7
8
9
10
11
location /foo {
set $a 12; # 创建变量 $a
set $b ""; # 创建变量 $b
rewrite_by_lua '
ngx.var.b = tonumber(ngx.var.a) + 1 # 此时 b = 13
if tonumber(ngx.var.b) == 13 then
return ngx.redirect("/bar"); # 重定向到 /bar
end
';
echo "res = $b"; # res = 13
}

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 rewrite_by_lua_file 引用 Lua 文件。

access_by_lua

该指令用于访问控制。例如,如果只允许内网 IP 访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
location / {
access_by_lua '
local res = ngx.location.capture("/auth")

if res.status == ngx.HTTP_OK then
return
end

if res.status == ngx.HTTP_FORBIDDEN then
ngx.exit(res.status)
end

ngx.exit(ngx.HTTP_INTERNAL_SERVER_ERROR)
';

# proxy_pass/fastcgi_pass/postgres_pass/...
}

注意,在 access_by_lua 处理内部,当调用 ngx.exit(ngx.OK) 时,nginx 请求将继续下一阶段的内容处理。要在 access_by_lua 处理中终结当前请求,调用 ngx.exit ,成功的请求设定 status >= 200 (ngx.HTTP_OK) 并 status < 300 (ngx.HTTP_SPECIAL_RESPONSE),失败的请求设定ngx.exit(ngx.HTTP_INTERNAL_SERVER_ERROR) (或其他相关的)。

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 access_by_lua_file 引用 Lua 文件。

content_by_lua

该指令是应用最多的指令,大部分任务是在这个阶段完成的,其他的过程往往为这个阶段准备数据,正式处理基本都在本阶段。

这个指令就相当于 Java 的一个方法,所有的代码都需要一个方法体作为环境。

例如:

1
2
3
4
5
6
7
content_by_lua_block {
set_by_lua $name "
local uri_args = ngx.req.get_uri_args() -- 获取请求 ? 后的参数
name = uri_args['name'] -- 获取 key 为 name 的参数
return name..'先生' -- 在 name 后面加上 先生,作为 $name 的 value 返回给客户端
";
}

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 content_by_lua_file 引用 Lua 文件。

header_filter_by_lua

该指令用于设置应答消息的头部信息。

例如:

1
2
3
4
location / {
proxy_pass http://mybackend;
header_filter_by_lua 'ngx.header.username = "frx"';
}

你会在请求头看到 name 为 frx

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 header_filter_by_lua_file 引用 Lua 文件。

body_filter_by_lua

该指令是对响应数据进行过滤,如截断、替换。

例如,在输出体转换所有的小写字母,我们可以这样用:

1
2
3
4
location / {
proxy_pass http://mybackend;
body_filter_by_lua 'ngx.arg[1] = string.upper(ngx.arg[1])'; # 转小写
}

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 body_filter_by_lua_file 引用 Lua 文件。

log_by_lua

该指令用于在 log 请求处理阶段,用 Lua 代码处理日志,但并不替换原有 log 处理。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
server {
location / {
proxy_pass http://mybackend;

log_by_lua '
local log_dict = ngx.shared.log_dict
local upstream_time = tonumber(ngx.var.upstream_response_time)

local sum = log_dict:get("upstream_time-sum") or 0
sum = sum + upstream_time
log_dict:set("upstream_time-sum", sum)

local newval, err = log_dict:incr("upstream_time-nb", 1)
if not newval and err == "not found" then
log_dict:add("upstream_time-nb", 0)
log_dict:incr("upstream_time-nb", 1)
end
';
}
}

如果不喜欢直接写 Lua 语法,把 Lua 语法 放到 Lua 文件里,使用 log_by_lua_file 引用 Lua 文件。

balancer_by_lua

该指令主要的作用是用来实现上游服务器的负载均衡器算法

ssl_certificate_by

该指令作用在 Nginx 和下游服务开始一个 SSL 握手操作时将允许本配置项的 Lua 代码。

简单案例

需求

发送请求:http://192.168.91.200?name=张三&gender=1

Nginx 接收到请求后,根据 gender 传入的值进行判断,如果 gender 传入的是 1,则在页面上展示张三先生,如果 gender 传入的是 0,则在页面上展示张三女士,如果未传或者传入的不是 1 和 2,则在页面上展示张三。

实现

在配置文件进行如下配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
location /getByGender {
default_type 'text/html';

set_by_lua $name "
local uri_args = ngx.req.get_uri_args()
gender = uri_args['gender']
name = uri_args['name']
if gender=='1' then
return name..'先生'
elseif gender=='0' then
return name..'女士'
else
return name
end
";
header_filter_by_lua "
ngx.header.aaa='bbb'
";
charset utf-8;
return 200 $name;
}

访问测试:http://192.168.91.200/getByGender?name=冯荣旭&gender=1

image

访问测试:http://192.168.91.200/getByGender?name=冯荣旭

image

ngx_lua操作Redis

Redis 在系统中经常作为数据缓存、内存数据库使用,在大型系统中扮演着非常重要的作用。

在 Nginx 核心系统中,Redis 是常备组件。Nginx 支持 3 种方法访问 Redis,分别是 HttpRedis 模块、HttpRedis2Module 模块、lua-resty-redis 库。

这三种方式中 HttpRedis 模块提供的指令少,功能单一,适合做简单缓存。HttpRedis2Module 模块比 HttpRedis 模块操作更灵活,功能更强大。而Lua-resty-redis 库是 OpenResty 提供的一个操作 Redis 的接口库,可根据自己的业务情况做一些逻辑处理,适合做复杂的业务逻辑。

本内容将主要以 Lua-resty-redis 来进行讲解。

Redis环境准备

准备一个 Redis 环境,并确保正常连接

1
2
3
# 连接地址
host= 192.168.91.200
port=6379
1
2
3
[root@master local]# /usr/local/bin/redis-server /etc/redis.conf
[root@master local]# redis-cli
127.0.0.1:6379>

API学习

lua-resty-redis 提供了访问 Redis 的详细 API,包括创建对接、连接、操作、数据处理等。这些 API 基本上与 Redis 的操作一一对应。

API 作用
redis = require “resty.redis” 引入 Redis 模块,类似于 Java 的 import。
redis,err = redis:new() 创建一个 Redis 对象给 redis,err 记录创建失败的原因。
ok,err=redis:connect(host,port[,options_table]) 设置连接 Redis 的连接信息。 ok:连接成功返回 1,连接失败返回 nil。 err:返回对应的错误信息。
redis:set_timeout(time) 设置请求操作 Redis 的超时时间,单位毫秒。
ok,err = redis:close() 关闭当前连接。 ok:连接成功返回 1,连接失败返回 nil。 err:返回对应的错误信息。
原生 Redis 命令如 get、set、lpush 等 所有的 Redis 命令都有自己的方法,方法名字和命令名字相同,只是全部为小写。

效果实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
location /redis {
default_type "text/html";
content_by_lua_block {
local redis = require "resty.redis" -- 引入 Redis
local redisObj = redis:new() -- 创建 Redis 对象
redisObj:set_timeout(1000) -- 设置超时数据为 1s
local ok,err = redisObj:connect("192.168.91.200",6379) -- 设置 Redis 连接信息
if not ok then -- 判断是否连接成功
ngx.say("failed to connection redis",err)
return
end
ok,err = redisObj:set("username","TOM") -- 存入数据
if not ok then -- 判断是否存入成功
ngx.say("failed to set username",err)
return
end
local res,err = redisObj:get("username") -- 从 Redis 中获取数据
ngx.say(res) -- 将数据写会消息体中
redisObj:close() -- 关闭 Redis 连接
}
}

运行测试效果

image

  • 查询redis
1
2
3
[root@master conf]# redis-cli
127.0.0.1:6379> get username
"TOM"

ngx_lua操作Mysql

MySQL 是一个使用广泛的关系型数据库。在 ngx_lua 中,MySQL 有两种访问模式,分别是是:

  • ngx_lua 模块和 lua-resty-mysql 模块,这两个模块是安装 OpenResty 时默认安装的。
  • 使用 drizzle_nginx_module(HttpDrizzleModule)模块,需要单独安装,这个库现不在 OpenResty 中。

lua-resty-mysql

这里使用的是 lua-resty-mysql 模块。

lua-resty-mysql 是 OpenResty 开发的模块,使用灵活、功能强大,适合复杂的业务场景,同时支持存储过程的访问。

MySQL环境准备

准备 MySQL,确保能正常连接

1
2
3
4
host: 192.168.91.200
port: 3306
username: root
password: 12345678

API学习

  • mysql = require "resty.mysql"

    引入 MySQL 模块,类似于 Java 的 import。

  • db,err = mysql:new()

    创建一个 MySQL 连接对象给 db,连接对象遇到错误时,db 为nil,err 为错误描述信息。

  • ok,err = db:connect(Options)

    尝试连接到一个MySQL服务器。Options 是一个参数的 Lua 表结构,里面包含数据库连接的相关信息。

    Options 选项:

1
2
3
4
5
host:服务器主机名或IP地址
port:服务器监听端口,默认为3306
user:登录的用户名
password:登录密码
database:使用的数据库名
  • db:set_timeout(time)

    设置子请求的超时时间,单位毫秒。

  • ok,err = db:close()

    关闭当前 MySQL 连接并返回状态。

1
2
ok:如果成功,则返回 1;如果出现任何错误,则将返回 nil
err:如果出现任何错误,返回错误描述。
  • bytes,err=db:send_query(sql)

    异步向远程 MySQL 发送一个查询。

    如果成功则返回成功发送的字节数;如果错误,则返回 nil 和错误描述。

  • res, err, errcode, sqlstate = db:read_result([rows])

    从 MySQL 服务器返回结果中读取一行数据。

    rows 指定返回结果集的最大值,默认为 4,可不写。

返回值:

1
2
3
4
res:操作的结果集,返回一个描述 OK 包或结果集包的 Lua 表
err:错误信息
errcode:MySQL 的错误码,比如 1064
sqlstate:返回由 5 个字符组成的标准 SQL 错误码,比如 42000

如果是查询,则返回一个容纳多行的数组。每行是一个数据列的key-value对,如下:

1
2
3
4
{
{id=1,username="TOM",birthday="1988-11-11",salary=10000.0},
{id=2,username="JERRY",birthday="1989-11-11",salary=20000.0}
}

如果是增删改,则返回类上如下数据

1
2
3
4
5
6
7
{
insert_id = 0,
server_status=2,
warning_count=1,
affected_rows=2,
message=nil
}

数据库连接四要素:

1
2
3
4
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.91.200:3306/nginx_db
username=root
password=12345678

表创建并插入数据

1
2
3
4
5
6
create table users(id int primary key auto_increment,name varchar(20));
insert into users(id,name) values(null,"TOM");
insert into users(id,name) values(null,"JERRY");
insert into users(id,name) values(null,"ROWS");
insert into users(id,name) values(null,"LUCY");
insert into users(id,name) values(null,"JACK");

数据查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
location /testMysql {
content_by_lua_block{
local mysql = require "resty.mysql"
local db, err = mysql:new() -- 创建实例
if not db then
ngx.say("new mysql error : ", err)
return
end

local ok,err = db:connect{
host="192.168.91.200",
port=3306,
user="root",
password="12345678",
database="nginx_db"
}

db:set_timeout(1000) -- 设置超时时间(毫秒)
-- 查询语句
local query_sql = "select * from users"
db:send_query(query_sql)
local res,err,errcode,sqlstate = db:read_result()

-- 返回数据 .. 代表拼接
ngx.say(res[1].id..","..res[1].name)
db:close()
}

}

问题

上面返回的是需要我们指定返回的数据,但是我们根本不知道查询的数据有多少条,长什么样子。

  • 如何获取返回数据的内容
  • 如何实现查询多条数据
  • 如何实现数据库的删改操作

lua-cjson处理查询结果

通过上述的案例学习,read_result() 得到的结果 res 都是 table 类型,要想在页面上展示,就必须知道 table 的具体数据结构才能进行遍历获取。处理起来比较麻烦。

接下来我们使用一种简单方式 cjson,使用它就可以将 table 类型的数据转换成 Json 字符串,把 Json 字符串展示在页面上即可。

步骤一:引入 cjson 模块

1
local cjson = require "cjson"

步骤二:调用 cjson 的 encode 方法进行类型转换

1
cjson.encode(res)

步骤三:测试

{20-27}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
location /testMysql {
content_by_lua_block{

local mysql = require "resty.mysql"
local cjson = require "cjson"

local db = mysql:new()

local ok,err = db:connect{
host="192.168.199.27",
port=3306,
user="root",
password="123456",
database="nginx_db"
}
db:set_timeout(1000)

-- db:send_query("select * from users where id = 1")

db:send_query("select * from users")
local res,err,errcode,sqlstate = db:read_result()

ngx.say(cjson.encode(res)) -- 转为 JSON 字符串格式

for i,v in ipairs(res) do -- 循环来返回数据
ngx.say("返回的数据:",v.id..","..v.name)
end

db:close()
}

}

数据库删改

优化 send_queryread_result,两个可以变成一体。

本方法是 send_queryread_result 组合的快捷方法。

语法:

1
res, err, errcode, sqlstate = db:query(sql[,rows])

有了该 API,上面的代码我们就可以进行对应的优化,如下:

{22,24}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
location /testMysql {
content_by_lua_block{

local mysql = require "resty.mysql"

local db = mysql:new()

local ok,err = db:connect{
host="192.168.91.200",
port=3306,
user="root",
password="12345678",
database="nginx_db",
max_packet_size=1024,
compact_arrays=false
}

db:set_timeout(1000)
-- 查询操作
local res,err,errcode,sqlstate = db:send_query("select * from users where id = 1")
-- 修改操作
local res,err,errcode,sqlstate = db:query("update users set name = 'bing' where id = 1")
-- 删除操作
local res,err,errcode,sqlstate = db:query("delete from users where id = 1")
-- 插入操作
local insert_sql = "insert into users(id,name) values(null,'kele')"
db:close()
}

}

综合小案例

使用 ngx_lua 模块完成查询 MySQL 数据,然后在 Redis 缓存预热。

分析:

  1. 先得有一张表(users),上面已经创建
  2. 浏览器输入如下地址
1
http://191.168.91.200?name=frx
  1. 从MySQL 表中查询出符合条件的数据,此时获取的结果为 table 类型
  2. 使用 cjson 将 table 数据转换成 json 字符串
  3. 将查询的结果数据存入 Redis 中

这里利用到 init_by_lua_block 指令,该指令上面介绍过,用于初始化全局变量。这里用于初始化 MySQL、Redis、cjson 模块。

还是使用了 quote_sql_str 指令,防止「拼」SQL,导致 SQL 注入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
init_by_lua_block{
redis = require "resty.redis"
mysql = require "resty.mysql"
cjson = require "cjson"
}
location /testMysql {
default_type "text/html";
content_by_lua_block{
-- 获取请求的参数 name
local param = ngx.req.get_uri_args()["name"]
-- 建立 mysql 数据库的连接
local db = mysql:new()
local ok,err = db:connect{
host="192.168.91.200",
port=3306,
user="root",
password="12345678",
database="nginx_db"
}
if not ok then
ngx.say("failed connect to mysql:",err)
return
end

-- 设置连接超时时间
db:set_timeout(1000)

-- 查询数据
local sql = "";

if not param then
sql="select * from users"
else
sql="select * from users where name=" .. "'" .. param .."'" -- sql 注入 ,不建议
sql="select * from users where name=" .. ngx.quote_sql_str(ch_param) -- 防止 sql 注入
end

local res,err,errcode,sqlstate=db:query(sql)

if not res then
ngx.say("failed to query from mysql:",err)
return
end

-- 连接redis
local rd = redis:new()
ok,err = rd:connect("192.168.91.200",6379)

if not ok then
ngx.say("failed to connect to redis:",err)
return
end

rd:set_timeout(1000)

-- 循环遍历数据
for i,v in ipairs(res) do
rd:set("user_"..v.username,cjson.encode(v))
end

ngx.say("success")

-- 关闭 MySQL 和 Rdis 的连接
rd:close()
db:close()
}
}