Java培训：高性能web平台openrestry简介

旧城等待， 2023-10-16 14:11 10阅读 0赞

### 　一、概述 ###

OpenResty® 是一个基于Nginx与Lua的高性能Web平台，其内部集成了大量精良的Lua库、第三方模块以及大多数的依赖项。用于方便地搭建能够处理超高并发、扩展性极高的动态 Web 应用、Web 服务和动态网关。

OpenResty® 通过汇聚各种设计精良的 \[Nginx\] 模块(主要由 OpenResty 团队自主开发)，从而将Nginx有效地变成一个强大的通用Web应用平台。这样，Web开发人员和系统工程师可以使用Lua脚本语言调动Nginx支持的各种C以及Lua模块，快速构造出足以胜任10K乃至1000K以上单机并发连接的高性能Web应用系统。

OpenResty® 的目标是让你的Web服务直接跑在Nginx服务内部，充分利用Nginx的非阻塞I/O模型，不仅仅对 HTTP客户端请求,甚至于对远程后端诸如MySQL、PostgreSQL、Memcached以及Redis等都进行一致的高性能响应。

OpenResty简单理解，就相当于封装了nginx,并且集成了LUA脚本，开发人员只需要简单的其提供了模块就可以实现相关的逻辑，而不再像之前，还需要在nginx中自己编写lua的脚本，再进行调用了。

### 　　二、安装 ###

linux安装openresty:

1、添加仓库执行命令

yum install yum-utils
        yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo

2、执行安装

yum install openresty

3、安装成功后 会在默认的目录如下：

/usr/local/openresty

4、启动openresty

cd  /usr/local/openresty/nginx/sbin
        ./nginx

#### 　　三、入门程序 ####

配置openresty的nginx配置文件\`conf/nginx.conf\`。在http模块下添加一个server配置。

server {
 listen 8080;
 location / {
 default_type text/html;
 content_by_lua_block {
 ngx.say("hello, world")
 }
 }
 }

重启openrestry

cd  /usr/local/openresty/nginx/sbin
        ./nginx -s reload

输入如下地址，进行访问 http://192.168.200.128:8080 浏览器输出 \`hello, world\`

### 　　四、openrestry中的常用Lua API介绍 ###

和一般的Web Server类似，我们需要接收请求、处理并输出响应。而对于请求我们需要获取如请求参数、请求头、Body体等信息;而对于处理就是调用相应的Lua代码即可;输出响应需要进行响应状态码、响应头和响应内容体的输出。因此我们从如上几个点出发即可。

### 　　五、接收请求 ###

获取nginx变量：\`ngx.var\`

server {
 listen 8080;
 location / {
 #定义nginx变量 
 set $b $host;
 
 default_type text/html;
 content_by_lua_block {
 local var = ngx.var; -- 获取nginx变量
 ngx.say("ngx.var.b : ", var.b, " ")
 ngx.var.b = 2; -- 设置变量值
 ngx.say("ngx.var.b : ", var.b, " ")
 ngx.say(" ")
 }
 }
 }

获取请求头：\`ngx.req.get\_headers()\`

server {
 listen 8080;
 location / {
 #定义nginx变量 
 set $b $host;
 
 default_type text/html;
 content_by_lua_block {
 local headers = ngx.req.get_headers()
 ngx.say("headers begin", " ")
 ngx.say("Host : ", headers["Host"], " ")
 ngx.say("user-agent : ", headers["user-agent"], " ")
 ngx.say("user-agent : ", headers.user_agent, " ")
 ngx.say("=======================================","") 
 for k,v in pairs(headers) do
 if type(v) == "table" then
 ngx.say(k, " : ", table.concat(v, ","), " ")
 else
 ngx.say(k, " : ", v, " ")
 end
 end
 ngx.say("headers end", " ")
 ngx.say(" ")
 }
 }
 }

get请求uri参数：\`ngx.req.get\_uri\_args()\`

server {
 listen 8080;
 location / {
 #定义nginx变量 
 set $b $host;
 
 default_type text/html;
 content_by_lua_block {
 ngx.say("uri args begin", " ")
 local uri_args = ngx.req.get_uri_args()
 ngx.say("param:username=",uri_args['username'], " ")
 ngx.say("param:password=",uri_args['password'], " ")
 ngx.say("uri args end", " ")
 ngx.say(" ")
 }
 }
 }

post请求参数：ngx.req.get\_post\_args()

server {
 listen 8080;
 location / {
 #定义nginx变量 
 set $b $host;
 
 default_type text/html;
 content_by_lua_block {
 ngx.say("uri args begin", " ")
 -- 获取请求体中的数据
 ngx.req.read_body()
 local uri_args = ngx.req.get_post_args() --获取key-value格式的数据
 ngx.say("param:username=",uri_args['username'], " ")
 ngx.say("param:password=",uri_args['password'], " ")
 ngx.say("uri args end", " ")
 ngx.say(" ")
 }
 }
 }

其他请求相关的方法：

> 获取请求的http协议版本：\`ngx.req.http\_version()\`

> 获取请求方法：\`ngx.req.get\_method()\`

> 获取请求头内容：\`ngx.req.get\_headers()\`

> 获取请求的body内容体：\`ngx.req.get\_body\_data()\`

### 　　六、输出响应 ###

server {
 listen 8080;
 location / {
 default_type text/html;
 content_by_lua_block {
 --写响应头
 ngx.header.a = "1"
 --多个响应头可以使用table
 ngx.header.b = {"2", "3"}
 --输出响应
 ngx.say("a", "b", " ")
 ngx.print("c", "d", " ")
 --200状态码退出
 return ngx.exit(200)
 }
 }
 }
 
 }

响应相关方法：

> ngx.header.xx = yy：输出响应头;

> ngx.print()：输出响应内容体;

> ngx.say()：同ngx.print()一样，但是会最后输出一个换行符;

> ngx.exit()：指定状态码退出;

> ngx.send\_headers()：发送响应状态码，当调用ngx.say/ngx.print时自动发送响应状态码;

> ngx.headers\_sent( )： 判断是否发送了响应状态码。

重定向

server {
            listen 8080;
            location / {
                default_type text/html;
                content_by_lua_block {
                    ngx.redirect("http://jd.com", 302);  
                }
            }
        }

### 　　Nginx全局内存 ###

使用过如Java的朋友可能知道如Ehcache等这种进程内本地缓存，Nginx是一个Master进程多个Worker进程的

工作方式，因此我们可能需要在多个Worker进程中共享数据，那么此时就可以使用ngx.shared.DICT来实现全

局内存共享。

#### 　　1、首先在nginx.conf的http部分定义一个全局内存，并指定内存大小。 ####

\`\`\`

共享全局变量，在所有worker间共享，如下：定义了一个名为shared\_data的全局内存，大小为1m

lua\_shared\_dict shared\_data 1m;

\`\`\`

#### 　　2、使用全局内存 ####

server { 
 listen 8080;
 location / {
 default_type text/html;
 content_by_lua_block {
 --1、获取全局共享内存变量
 local shared_data = ngx.shared.shared_data
 --2、获取字典值
 local i = shared_data:get("i")
 if not i then
 i = 1
 --3、惰性赋值
 shared_data:set("i", i)
 ngx.say("lazy set i ", i, " ")
 end
 --递增
 i = shared_data:incr("i", 1)
 ngx.say("i=", i, " ")
 }
 }
 }

#### 　　3、全局内存常用方法介绍 ####

ngx.shared.DICT

> 获取共享内存字典项对象

\`\`\`

语法：dict = ngx.shared.DICT

dict = ngx.shared\[name\_var\]

其中，DICT和name\_var表示的名称是一致的，比如上面例子中，shared\_data = ngx.shared.shared\_data

就是dict = ngx.shared.DICT的表达形式，

也可以通过下面的方式达到同样的目的：

shared\_data = ngx.shared\['shared\_data'\]

ngx.shared.DICT:get(key)

> 获取共享内存上key对应的值。如果key不存在，或者key已经过期，将会返回nil;如果出现错误，那么将会返回nil以及错误信息。

ngx.shared.DICT:get\_stale(key)

> 与get方法类似，区别在于该方法对于过期的key也会返回，第三个返回参数表明返回的key的值是否已经过期，true表示过期，false表示没有过期。

ngx.shared.DICT:set(key, value, exptime?, flags?)

> “无条件”地往共享内存上插入key-value对，这里讲的“无条件”指的是不管待插入的共享内存上是否已经存在相同的key。

> 三个返回值的含义：

> success：成功插入为true，插入失败为false

> err：操作失败时的错误信息，可能类似"no memory"

> forcible：true表明需要通过强制删除(LRU算法)共享内存上其他字典项来实现插入，false表明没有删除共享内存上的字典项来实现插入。

> exptime参数表明key的有效期时间，单位是秒(s)，默认值为0，表明永远不会过期;

> flags参数是一个用户标志值，会在调用get方法时同时获取得到

ngx.shared.DICT.safe\_set\*(key, value, exptime?, flags?)

> 与set方法类似，区别在于不会在共享内存用完的情况下，通过强制删除(LRU算法)的方法实现插入。如果内存不足，会直接返回nil和err信息"no memory"

ngx.shared.DICT.add\*(key, value, exptime?, flags?)

> 与set方法类似，与set方法区别在于不会插入重复的键(可以简单认为add方法是set方法的一个子方法)，如果待插入的key已经存在，将会返回nil和和err="exists"

ngx.shared.DICT.safe\_add\*(key, value, exptime?, flags?)

> 与safe\_set方法类似，区别在于不会插入重复的键(可以简单认为safe\_add方法是safe\_set方法的一个子方法)，如果待插入的key已经存在，将会返回nil和和err="exists"

ngx.shared.DICT.replace\*(key, value, exptime?, flags?)

> 与set方法类似，区别在于只对已经存在的key进行操作(可以简单认为replace方法是set方法的一个子方法)，如果待插入的key在字典上不存在，将会返回nil和错误信息"not found"

ngx.shared.DICT.delete\*(key)

> 无条件删除指定的key-value对，其等价于

> ngx.shared.DICT:set(key, nil)

ngx.shared.DICT.incr\*(key, value)

> 对key对应的值进行增量操作，增量值是value，其中value的值可以是一个正数，0，也可以是一个负数。value必须是一个Lua类型中的number类型，否则将会返回nil和"not a number";key必须是一个已经存在于共享内存中的key，否则将会返回nil和"not found".

ngx.shared.DICT.flush\_all\*()

> 清除字典上的所有字段，但不会真正释放掉字段所占用的内存，而仅仅是将每个字段标志为过期。

ngx.shared.DICT.flush\_expired\*(max\_count?)

> 清除字典上过期的字段，max\_count表明上限值，如果为0或者没有给出，表明需要清除所有过期的字段，返回值flushed是实际删除掉的过期字段的数目。

> 注意：

> 与flush\_all方法的区别在于，该方法将会释放掉过期字段所占用的内存

ngx.shared.DICT.get\_keys\*(max\_count?)

> 从字典上获取字段列表，个数为max\_count，如果为0或没有给出，表明不限定个数。默认值是1024个

> 注意：

> 强烈建议在调用该方法时，指定一个max\_count参数，因为在keys数量很大的情况下，如果不指定max\_count的值，可能会导致字典被锁定，从而阻塞试图访问字典的worker进程。

### 　　openresty执行过程分析 ###

Nginx与Lua编写脚本的基本构建块是指令。 指令用于指定何时运行用户Lua代码以及如何使用结果。openresty(Nginx+lua-nginx-module)中各个阶段执行的指令解释及其执行顺序。

![1695610974229\_执行顺序.jpg][1695610974229_.jpg]

> init\_by\_lua\*：初始化 nginx 和预加载 lua(nginx 启动和 reload 时执行);\*

> init\_worker\_by\_lua\*：每个工作进程(worker\_processes)被创建时执行，用于启动一些定时任务，比如心跳检查，后端服务的健康检查，定时拉取服务器配置等;\*

> ssl\_certificate\_by\_lua\*：对 https 请求的处理，即将启动下游 SSL(https)连接的 SSL 握手时执行，用例：按照每个请求设置 SSL 证书链和相应的私钥，按照 SSL 协议有选择的拒绝请求等;

> \*set\_by\_lua\*：设置 nginx 变量;

> rewrite\_by\_lua\*：重写请求(从原生 nginx 的 rewrite 阶段进入)，执行内部 URL 重写或者外部重定向，典型的如伪静态化的 URL 重写;\*

> access\_by\_lua\*：处理请求(和 rewrite\_by\_lua 可以实现相同的功能，从原生 nginx 的 access阶段进入);\*

> content\_by\_lua\*：执行业务逻辑并产生响应，类似于 jsp 中的 servlet;

> \*balancer\_by\_lua\*：负载均衡;

> header\_filter\_by\_lua\*：处理响应头;

> \*body\_filter\_by\_lua\*：处理响应体;

> log\_by\_lua：记录访问日志;

备注：\`\*\`表示两种选择，比如 \`log\_by\_lua\\\*\` 可以表示\`log\_by\_lua\`或\`log\_by\_lua\_file\`

nginx\_lua常用模块介绍

json格式化：cjson

server {
 listen 8080;
 location / {
 default_type text/html;
 content_by_lua_block {
 -- 引入cjson
 local cjson = require("cjson")
 
 --将lua对象 转为 json字符串
 local obj = {
 id = 1,
 name = "zhangsan",
 age = nil,
 is_male = false,
 hobby = {"film", "music", "read"}
 }
 local str = cjson.encode(obj)
 ngx.say("lua对象到字符串:",str,"")
 ngx.say("--------------------------------");
 
 --将字符串 转为 lua对象
 str = '{"hobby":["film","music","read"],"is_male":false,"name":"zhangsan","id":1,"age":null}'
 local obj = cjson.decode(str)
 ngx.say("字符串到lua对象:","")
 ngx.say("obj.age ",obj.age,"")
 ngx.say("obj.age == nil ",obj.age == nil,"")
 ngx.say("obj.age == cjson.null ",obj.age == cjson.null,"")
 ngx.say("obj.hobby[1] ",obj.hobby[1],"")
 }
 }
 }

redis客户端：resty.redis

-- 引入resty.redis库
    local redis = require("resty.redis")
    
    -- 定义关闭redis连接的方法
    local function close_redis(instance)
        if not instance then
            return
        end
        local ok, error = instance:close()
        if not ok then
            ngx.say(error)
        end
    end
    -- 创建redis连接
    local redis_ip = "127.0.0.1"
    local redis_port = "6379"
    local redis_instance = redis:new()
    redis_instance:set_timeout(1000)
    local ok, error = redis_instance.connect(redis_ip, redis_port)
    if not ok then
        ngx.say(error)
        return close_redis(redis_instance)
    end
    
    
    -- 执行redis命令
    local redis_key = "message"
    local redis_value = ngx.md5("hello, world")
    ok, error = redis_instance:set(redis_key, redis_value)
    if not ok then
        ngx.say(error)
        return close_redis(redis_instance)
    end
    
    local message, error = redis_instance:get(redis_key)
    if not message then
        ngx.say(error)
        return close_redis(redis_instance)
    end
    
    if message == ngx.null then
        message = ""
    end
    ngx.say(redis_key, ": ", message)
    
    -- 关闭redis连接
    close_redis(redis_instance)

mysql客户端：resty.mysql

配置\`openresty\`连接\`mysql\`

-- 引入resty.mysql库
    local mysql = require("resty.mysql")
    
    -- 定义关闭连接的方法
    local function close_db(instance)
        if not instance then
            return
        end
    
        instance:close()
    end
    
    -- 创建mysql实例对象
    local instance, error = mysql:new()
    if not instance then
        ngx.say(error)
        return
    end
    
    instance:set_timeout(1000)
    local properties = {
        host = "127.0.0.1",
        port = 3306,
        database = "wpsmail",
        user = "root",
        password = "123456"
    }
    -- 连接mysql
    local result, error, error_no, sql_state = instance:connect(properties)
    if not result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end

删除表

local drop_table_sql = "drop table if exists test"
    local drop_result, error, error_no, sql_state = instance:query(drop_table_sql)
    if not drop_result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end

创建表

local create_table_sql
    = "create table test(id int primary key auto_increment, ch varchar(100))"
    local create_result, error, error_no, sql_state = instance:query(create_table_sql)
    if not create_result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end

插入表数据

local insert_sql = "insert into test (ch) values('hello')"
    local insert_result, error, error_no, sql_state = instance:query(insert_sql)
    if not insert_result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end
    
    ngx.say("affected row: ", insert_result.affected_rows,
    ", insert id: ", insert_result.insert_id)

更新表数据

local update_table_sql
        = "update test set ch = 'hello2' where id =" .. insert_result.insert_id
    local update_result, error, error_no, sql_state = instance:query(update_table_sql)
    if not update_result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end
    
    ngx.say("affected row: ", insert_result.affected_rows)

查询表数据

local select_table_sql = "select id, ch from test"
    local select_result, error, error_no, sql_state = instance:query(select_table_sql)
    if not select_result then
        ngx.say("error: ", error, ", error_no: ",
            error_no, ", sql_state: ", sql_state)
        return close_db(instance)
    end
    
    for i, row in ipairs(select_result) do
        ngx.say(i, ": ", row)
    end

### 　　总结 ###

本文给大家介绍了openresty这一高性能web服务平台的基本使用。包括如何在openresty中处理请求和响应，在openresty是使用nginx的本地缓存(即nginx全局内存)。分析了openresty的整体执行过程，其中\`content\_by\_lua\*\`阶段，是执行业务逻辑并产生响应的阶段，我们的业务代码主要在此阶段编写。同时本文还介绍了如何使用\`resty.redis\`操作redis，使用\`resty.mysql\`来操作mysql，以及使用cjson进行数据的json格式化。

本文版权归黑马程序员Java培训学院所有，欢迎转载，转载请注明作者出处。谢谢!

作者：黑马程序员Java培训学院

首发：[https://java.itheima.com][https_java.itheima.com]

[1695610974229_.jpg]: https://img-blog.csdnimg.cn/img_convert/1ce1f9b84ba2a9dc4bb186b41bd112ef.jpeg
[https_java.itheima.com]: https://java.itheima.com/