目录
一、defer
1. defer保证在函数结束时发生.
2. defer列表为先进后出
3. 参数在defer语句时计算.
下面来看一个例子: 写入文件
package main
import (
"aaa/functional/fbi"
"bufio"
"fmt"
"os"
)
// 我要写文件
func writefile() {
file, err := os.create("test.txt")
if err != nil {
panic("error")
}
defer file.close()
w := bufio.newwriter(file)
defer w.flush()
f := fbi.feibonaccq()
for i := 0; i < 20; i++ {
fmt.fprintln(w, f())
}
}
func main() {
writefile()
}
package fbi
func feibonaccq() func() int {
x, y := 0, 1
return func() int {
x, y = y, x+y
return x
}
}
将斐波那契数列写入文件. 这里有两个资源使用. 1. 创建文件, 然后文件关闭. 2. 写入资源, 将资源从缓存中刷入文件. 这两个操作都应该应该是成对出现的, 因此, 用defer 语句, 避免后面写着写着忘了, 也保证即使出错了, 也能够执行defer语句的内容
那么参数在defer语句时计算 是什么意思呢?
func trydefer() {
for i := 0; i < 10 ; i++ {
defer fmt.println(i)
}
}
打印结果：
9
8
7
6
5
4
3
2
1
0
二、错误处理
所谓的错误处理, 就是处理已知的错误, 不要抛出panic这样导致系统挂掉的错误发生.
比如下面的操作:
package main
import (
"aaa/functional/fbi"
"bufio"
"fmt"
"os"
)
// 我要写文件
func writefile(filename string) {
// os.o_excl|os.o_create创建一个新文件, 并且他必须不存在
file, err := os.openfile(filename, os.o_excl|os.o_create, 0666)
// 这时候打印panic就不太友好. 我们可以对错误类型进行处理
/*if err != nil {
panic("error")
}*/
// 这里就对错误的类型进行了捕获处理.
if err, ok := err.(*os.patherror); !ok {
fmt.println("未知错误")
} else {
fmt.printf("%s, %s, %s", err.path, err.op, err.err)
}
defer file.close()
w := bufio.newwriter(file)
defer w.flush()
f := fbi.feibonaccq()
for i := 0; i < 20; i++ {
fmt.fprintln(w, f())
}
}
func main() {
writefile("test.txt")
}
红色字体部分就是对错误进行了捕获处理.
三、统一错误处理的逻辑
下面模拟一个web服务器, 在浏览器地址栏输入文件的url, 然后显示文件的内容. 比如斐波那契数列的文件
package main
import (
"io/ioutil"
"net/http"
"os"
)
// 我们来模拟一个web服务器. 在url上输入一个地址, 然后显示文件内容
// 做一个显示文件的web server
func main() {
http.handlefunc("/list/", func(writer http.responsewriter, request *http.request) {
// 获取url路径, 路径是/list/之后的部分
path := request.url.path[len("/list/"):]
// 打开文件
file, err := os.open(path)
if err != nil {
panic("err")
}
defer file.close()
// 读出文件
b, err := ioutil.readall(file)
if err != nil {
panic("err")
}
// 写入文件到页面
writer.write(b)
})
// 监听端口:8888
err := http.listenandserve(":8888", nil)
if err != nil {
panic("err")
}
}
这里面主要注意一下我们对错误的处理. 都是直接打出panic. 这样是很不友好的.
如果页面输入的文件路径不对, 则直接404
按照之前第二步说的, 我们应该对panic进行处理. 比如打开文件的操作, 我们改为如下
// 打开文件
file, err := os.open(path)
if err != nil {
http.error(writer, err.error(), http.statusinternalservererror) return
}
defer file.close()
这样就好多了, 起码程序不会直接抛出异常
这是将系统的错误直接打出了, 比上面好一些, 但也不是特别友好, 通常我们不希望吧系统内部错误输出出来. 我们希望经过包装后输出错误
于是做了如下修改.
第一步: 将http.handlefunc中的函数部分提出来, 这部分是业务逻辑.
提出来以后做了如下修改. 1. 函数增加一个返回值error. 2. 遇到错误,直接return. 如下红色标出部分
package filelistener
import (
"io/ioutil"
"net/http"
"os"
)
func filehandler(writer http.responsewriter, request *http.request) error{
// 获取url路径, 路径是/list/之后的部分
path := request.url.path[len("/list/"):]
// 打开文件
file, err := os.open(path)
if err != nil {
return err
}
defer file.close()
// 读出文件
b, err := ioutil.readall(file)
if err != nil {
return err
}
// 写入文件到页面
writer.write(b)
return nil
}
第二: 封装错误内容
这里就体现了函数式编程的特点, 灵活
// 定义一个函数类型的结构, 返回值是erro
type handler func(writer http.responsewriter, request *http.request) error
// 封装error
func wraphandler(handler handler) func (http.responsewriter, *http.request) {
return func(writer http.responsewriter, request *http.request) {
// 执行原来的逻辑. 然后增加error的错误处理
err := handler(writer, request)
if err != nil {
code := http.statusok
switch {
case os.isnotexist(err):
code = http.statusnotfound
case os.ispermission(err):
code = http.statusserviceunavailable
default:
code = http.statusinternalservererror
}
http.error(writer, http.statustext(code), code)
}
}
}
调用的部分
// 我们来模拟一个web服务器. 在url上输入一个地址, 然后显示文件内容
// 做一个显示文件的web server
func main() {
http.handlefunc("/list/", wraphandler(filelistener.filehandler))
// 监听端口:8888
err := http.listenandserve(":8888", nil)
if err != nil {
panic("err")
}
}
这样, 当我们再次输入错误的文件路径时, 提示信息如下:
四、panic
发生panic的时候, 会做那些事呢?
1. 停止当前函数的执行
2. 一直向上返回, 执行每一层的defer
3. 如果没有遇到recover, 程序就退出
五、recover
1. 在defer 中调用
2. 获取panic的值
3. 如果无法处理, 可以重新panic
package main
import (
"fmt"
"github.com/pkg/errors"
)
func tryrecover() {
defer func(){
r := recover()
if r, ok := r.(error); ok {
fmt.println("error 发生", r.error())
} else {
panic(fmt.sprintf("未知错误:%v", r))
}
}()
panic(errors.new("错误"))
}
func main() {
tryrecover()
}
六、error vs panic
七、错误处理综合示例
第五条的案例, 我们进行了error的统一管理, 但是还没有对其他异常进行recover, 还有可能导致程序崩溃. 比如http://localhost:8888/abc. 继续优化代码.
这样很不友好, 我们在看看控制台, 发现程序并没有挂掉, 这是为什么呢? 想象一下, 应该是程序自动给我们recover了.
我们来看看server.go
原来server.go已经帮我们recover了, recover后并不是中断进程, 而是打印输出错误日志. 虽然如此, 但页面显示依然很难看. 因此我们要做两件事
1. 如果出现异常, 我们自己进行recover, 那么他就不会走系统定义的recover了. 这还不够, 这只是说控制台不会再打印出一大堆蓝色异常代码了. 我们还有做第二件事
2. 将出现异常的位置捕获出来, 并且, 打印到页面
第一步: 自定一定recover, 代替server.go中的recover
// 封装error
func wraperror(handler handler) func (http.responsewriter, *http.request) {
return func(writer http.responsewriter, request *http.request) {
defer func(){
if r := recover(); r != nil {
fmt.println("发生错误")
http.error(writer, http.statustext(http.statusinternalservererror), http.statusinternalservererror)
}
}()
// 执行原来的逻辑. 然后增加error的错误处理
err := handler(writer, request)
if err != nil {
code := http.statusok
switch {
case os.isnotexist(err):
code = http.statusnotfound
case os.ispermission(err):
code = http.statusserviceunavailable
default:
code = http.statusinternalservererror
}
http.error(writer, http.statustext(code), code)
}
}
}
这样异常就被我们捕获了, 页面打印出
这样就好看多了. 我们在对代码进行优化
我们将发生异常的地方进行处理
func filehandler(writer http.responsewriter, request *http.request) error {
// 获取url路径, 路径是/list/之后的部分
if c := strings.index(request.url.path, "/list/"); c != 0 {
return errors.new("url 不是已list开头")
}
path := request.url.path[len("/list/"):]
// 打开文件
file, err := os.open(path)
if err != nil {
return err
}
defer file.close()
// 读出文件
b, err := ioutil.readall(file)
if err != nil {
return err
}
// 写入文件到页面
writer.write(b)
return nil
}
页面打印效果
我们发现这个打印的还是系统给出的错误异常. 那么,我们有没有办法, 把这个异常打印出来呢?
if c := strings.index(request.url.path, "/list/"); c != 0 {
return errors.new("url 不是已list开头")
}
我们自己来定义一个异常处理的接口
type usererror interface {
error // 系统异常
message() string // 用户自定义异常
}
接口定义好了, 在哪里用呢? 你想打印出自己的异常信息, 那就不能打印系统的. 自定义信息在系统异常之前判断
// 执行原来的逻辑. 然后增加error的错误处理
err := handler(writer, request)
if err != nil {
if usererr, ok := err.(usererror); ok {
http.error(writer, usererr.message(), http.statusbadrequest)
return
}
code := http.statusok
switch {
case os.isnotexist(err):
code = http.statusnotfound
case os.ispermission(err):
code = http.statusserviceunavailable
default:
code = http.statusinternalservererror
}
http.error(writer, http.statustext(code), code)
}
接下来是具体实现了, 现在用户想要实现自定义一个usererror. 然后设置异常类型为usererror
type usererror string
func (u usererror) error() string{
return u.message()
}
func (u usererror) message() string {
return string(u)
}
func filehandler(writer http.responsewriter, request *http.request) error {
// 获取url路径, 路径是/list/之后的部分
if c := strings.index(request.url.path, "/list/"); c != 0 {
return usererror("url 不是已list开头")
}
path := request.url.path[len("/list/"):]
// 打开文件
file, err := os.open(path)
if err != nil {
return err
}
defer file.close()
// 读出文件
b, err := ioutil.readall(file)
if err != nil {
return err
}
// 写入文件到页面
writer.write(b)
return nil
}
这样一个实现自定义打印异常的功能就做好了. 异常也是可以封装的.
最后再来梳理这个小案例：
1. 我们有一个想法, 模拟web请求, 在浏览器url上输入一个文件路径, 打印文件的内容
2. 内容可能有错误, 进行异常处理.
3. 有时候异常抛出的是系统给出, 我们自己对异常进行recover, 然后打印出来
4. 打印自定义异常.
以下是完整代码
package handling
import (
"io/ioutil"
"net/http"
"os"
"strings"
)
type usererror struct {
content string
}
func (u usererror) error() string {
return u.message()
}
func (u usererror) message() string {
return u.content
}
func hanldering(writer http.responsewriter, request *http.request) error {
// 获取url, list之后的就是url
if s := strings.index(request.url.path, "/list/"); s != 0 {
return usererror{"path error, /list/"}
}
url := request.url.path[len("/list/"):]
// 根据url打开文件
file, err := os.open(url)
if err != nil {
return os.errnotexist
}
defer file.close()
// 打开以后把文件内容读出来
f, err := ioutil.readall(file)
if err != nil {
return os.errpermission
}
// 读出来以后, 写入到页面
writer.write(f)
return nil
}
package main
import (
"aaa/handlererror/linstenerfile/handling"
"github.com/siddontang/go/log"
"net/http"
"os"
)
type errorhandlering func(writer http.responsewriter, request *http.request) error
func wraperror(handler errorhandlering) func(http.responsewriter, *http.request) {
return func(writer http.responsewriter, request *http.request) {
defer func() {
if r := recover(); r != nil {
log.warn("other error")
http.error(writer, http.statustext(http.statusbadrequest), http.statusbadrequest)
}
}()
err := handler(writer, request)
//自定义异常处理
// 错误处理
if err != nil {
if usererr, ok := err.(usererror); ok {
log.warn("user error:", usererr.message())
http.error(writer, usererr.message(), http.statusbadrequest)
return
}
code := http.statusok
switch err {
case os.errnotexist:
code = http.statusnotfound
case os.errpermission:
code = http.statusbadrequest
default:
code = http.statusinternalservererror
}
http.error(writer, http.statustext(code), code)
}
}
}
type usererror interface {
error
message() string
}
func main() {
// 模拟web请求
http.handlefunc("/", wraperror(handling.hanldering))
// 指定服务端口
http.listenandserve(":8888", nil)
}
以上就是详解go语言的错误处理和资源管理的详细内容，更多关于go 错误处理 资源管理的资料请关注www.887551.com其它相关文章！
黄山市民网：https://www.huangshanshimin.com/
