最近在弄beego,分享一个整理的mysql连接池

weixin_38103381 2019-09-20 09:53:32
package main

import (
"errors"
"fmt"
"github.com/gohouse/gorose"
"sync"
"time"
)

//频繁的创建和关闭连接,对系统会造成很大负担
//所以我们需要一个池子,里面事先创建好固定数量的连接资源,需要时就取,不需要就放回池中。
//但是连接资源有一个特点,我们无法保证连接长时间会有效。
//比如,网络原因,人为原因等都会导致连接失效。
//所以我们设置一个超时时间,如果连接时间与当前时间相差超过超时时间,那么就关闭连接。

type Factory struct {
conn *gorose.Connection
err error
}

func (factory *Factory)Close(){
factory.conn.Close()
}

func (factory *Factory)factory()(conn *gorose.Connection,err error){
return factory.conn,factory.err
}

//工厂方法,用于创建连接资源

func NewConn()(factory Factory){
var dbConfig = &gorose.DbConfigSingle{
Driver: "mysql", // driver: mysql/sqlite/oracle/mssql/postgres
EnableQueryLog: true, // if enable sql logs
SetMaxOpenConns: 0, // connection pool of max Open connections, default zero
SetMaxIdleConns: 0, // connection pool of max sleep connections
Prefix: "", // prefix of table
Dsn: "root:root@tcp(localhost:3306)/test?charset=utf8", // db dsn
}
// 初始化数据库链接, 默认会链接配置中 default 指定的值
// 也可以在第二个参数中指定对应的数据库链接, 见下边注释的那一行链接示例
connection, err :=gorose.Open(dbConfig )
return Factory{connection,err}
}


//连接
type Conn struct {
conn *gorose.Connection
//连接时间
time time.Time
}

//连接池
type ConnPool struct {
//互斥锁,保证资源安全
mu sync.Mutex
//通道,保存所有连接资源
conns chan *Conn
//工厂方法,创建连接资源
factory Factory
//判断池是否关闭
closed bool
//连接超时时间
connTimeOut time.Duration
}

//创建一个连接资源池
func NewConnPool(factory Factory, cap int, connTimeOut time.Duration) (*ConnPool, error) {
if cap <= 0 {
return nil, errors.New("cap不能小于0")
}
if connTimeOut <= 0 {
return nil, errors.New("connTimeOut不能小于0")
}

cp := &ConnPool{
mu: sync.Mutex{},
conns: make(chan *Conn, cap),
factory: factory,
closed: false,
connTimeOut: connTimeOut,
}
for i := 0; i < cap; i++ {
//通过工厂方法创建连接资源
newConn:=NewConn()
conn1, err := newConn.factory()
if err != nil {
cp.Close()
return nil, errors.New("factory出错")
}
//将连接资源插入通道中
cp.conns <- &Conn{conn: conn1, time: time.Now()}
}
return cp, nil
}

//获取连接资源
func (cp *ConnPool) Get() (*gorose.Connection, error) {
if cp.closed {
return nil, errors.New("连接池已关闭")
}

for {
select {
//从通道中获取连接资源
case connRes, ok := <-cp.conns:
{
if !ok {
return nil, errors.New("连接池已关闭")
}
//判断连接中的时间,如果超时,则关闭
//继续获取
if time.Now().Sub(connRes.time) > cp.connTimeOut {
connRes.conn.Close()
continue
}
return connRes.conn, nil
}
default:
{
//如果无法从通道中获取资源,则重新创建一个资源返回
newConn:=NewConn()
connRes, err := newConn.factory()
if err != nil {
return nil, err
}
return connRes, nil
}
}
}
}

//连接资源放回池中
func (cp *ConnPool) Put(conn *gorose.Connection) error {
if cp.closed {
return errors.New("连接池已关闭")
}

select {
//向通道中加入连接资源
case cp.conns <- &Conn{conn: conn, time: time.Now()}:
{
return nil
}
default:
{
//如果无法加入,则关闭连接
conn.Close()
return errors.New("连接池已满")
}
}
}

//关闭连接池
func (cp *ConnPool) Close() {
if cp.closed {
return
}
cp.mu.Lock()
cp.closed = true
//关闭通道
close(cp.conns)
//循环关闭通道中的连接
for conn := range cp.conns {
conn.conn.Close()
}
cp.mu.Unlock()
}

//返回池中通道的长度
func (cp *ConnPool) len() int {
return len(cp.conns)
}

func main() {

cp, _ := NewConnPool(NewConn(), 10, time.Second*10)

//获取资源
conn1, _ := cp.Get()
conn2, _ := cp.Get()

//这里连接池中资源大小为8
fmt.Println("cp len : ", cp.len())
//var session *gorose.Connection
session:= conn1.NewSession()

res,err := session.Table("users").First()
if err!=nil{
fmt.Println("db.Table",err)
return
}
fmt.Println(res)

//把2个连接资源放回池中
cp.Put(conn1)
cp.Put(conn2)
//这里显示为3
fmt.Println("cp len : ", cp.len())
cp.Close()
}
...全文
26 3 打赏 收藏 转发到动态 举报
写回复
用AI写文章
3 条回复
切换为时间正序
请发表友善的回复…
发表回复

430

社区成员

发帖
与我相关
我的任务
社区描述
其他技术讨论专区
其他 技术论坛(原bbs)
社区管理员
  • 其他技术讨论专区社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧