1 mysql 连接池代码

package lib

import (
"database/sql"
"fmt"
"strconv" "github.com/arnehormann/sqlinternals/mysqlinternals"
_ "github.com/go-sql-driver/mysql"
) var MYSQL map[string]string = map[string]string{
"host": "127.0.0.1:3306",
"database": "",
"user": "",
"password": "",
"maxOpenConns": "0",
"maxIdleConns": "0",
} type SqlConnPool struct {
DriverName string
DataSourceName string
MaxOpenConns int64
MaxIdleConns int64
SqlDB *sql.DB // 连接池
} var DB *SqlConnPool func init() {
dataSourceName := fmt.Sprintf("%s:%s@tcp(%s)/%s", MYSQL["user"], MYSQL["password"], MYSQL["host"], MYSQL["database"])
maxOpenConns, _ := strconv.ParseInt(MYSQL["maxOpenConns"], 10, 64)
maxIdleConns, _ := strconv.ParseInt(MYSQL["maxIdleConns"], 10, 64) DB = &SqlConnPool{
DriverName: "mysql",
DataSourceName: dataSourceName,
MaxOpenConns: maxOpenConns,
MaxIdleConns: maxIdleConns,
}
if err := DB.open(); err != nil {
panic("init db failed")
}
} // 封装的连接池的方法
func (p *SqlConnPool) open() error {
var err error
p.SqlDB, err = sql.Open(p.DriverName, p.DataSourceName)
p.SqlDB.SetMaxOpenConns(int(p.MaxOpenConns))
p.SqlDB.SetMaxIdleConns(int(p.MaxIdleConns))
return err
} func (p *SqlConnPool) Close() error {
return p.SqlDB.Close()
} func (p *SqlConnPool) Query(queryStr string, args ...interface{}) ([]map[string]interface{}, error) {
rows, err := p.SqlDB.Query(queryStr, args...)
defer rows.Close()
if err != nil {
return []map[string]interface{}{}, err
}
// 返回属性字典
columns, err := mysqlinternals.Columns(rows)
// 获取字段类型
scanArgs := make([]interface{}, len(columns))
values := make([]sql.RawBytes, len(columns))
for i, _ := range values {
scanArgs[i] = &values[i]
}
rowsMap := make([]map[string]interface{}, 0, 10)
for rows.Next() {
rows.Scan(scanArgs...)
rowMap := make(map[string]interface{})
for i, value := range values {
rowMap[columns[i].Name()] = bytes2RealType(value, columns[i].MysqlType())
}
rowsMap = append(rowsMap, rowMap)
}
if err = rows.Err(); err != nil {
return []map[string]interface{}{}, err
}
return rowsMap, nil
} func (p *SqlConnPool) execute(sqlStr string, args ...interface{}) (sql.Result, error) {
return p.SqlDB.Exec(sqlStr, args...)
} func (p *SqlConnPool) Update(updateStr string, args ...interface{}) (int64, error) {
result, err := p.execute(updateStr, args...)
if err != nil {
return 0, err
}
affect, err := result.RowsAffected()
return affect, err
} func (p *SqlConnPool) Insert(insertStr string, args ...interface{}) (int64, error) {
result, err := p.execute(insertStr, args...)
if err != nil {
return 0, err
}
lastid, err := result.LastInsertId()
return lastid, err } func (p *SqlConnPool) Delete(deleteStr string, args ...interface{}) (int64, error) {
result, err := p.execute(deleteStr, args...)
if err != nil {
return 0, err
}
affect, err := result.RowsAffected()
return affect, err
} type SqlConnTransaction struct {
SqlTx *sql.Tx // 单个事务连接
} //// 开启一个事务
func (p *SqlConnPool) Begin() (*SqlConnTransaction, error) {
var oneSqlConnTransaction = &SqlConnTransaction{}
var err error
if pingErr := p.SqlDB.Ping(); pingErr == nil {
oneSqlConnTransaction.SqlTx, err = p.SqlDB.Begin()
}
return oneSqlConnTransaction, err
} // 封装的单个事务连接的方法
func (t *SqlConnTransaction) Rollback() error {
return t.SqlTx.Rollback()
} func (t *SqlConnTransaction) Commit() error {
return t.SqlTx.Commit()
} func (t *SqlConnTransaction) Query(queryStr string, args ...interface{}) ([]map[string]interface{}, error) {
rows, err := t.SqlTx.Query(queryStr, args...)
defer rows.Close()
if err != nil {
return []map[string]interface{}{}, err
}
// 返回属性字典
columns, err := mysqlinternals.Columns(rows)
// 获取字段类型
scanArgs := make([]interface{}, len(columns))
values := make([]sql.RawBytes, len(columns))
for i, _ := range values {
scanArgs[i] = &values[i]
}
rowsMap := make([]map[string]interface{}, 0, 10)
for rows.Next() {
rows.Scan(scanArgs...)
rowMap := make(map[string]interface{})
for i, value := range values {
rowMap[columns[i].Name()] = bytes2RealType(value, columns[i].MysqlType())
}
rowsMap = append(rowsMap, rowMap)
}
if err = rows.Err(); err != nil {
return []map[string]interface{}{}, err
}
return rowsMap, nil
} func (t *SqlConnTransaction) execute(sqlStr string, args ...interface{}) (sql.Result, error) {
return t.SqlTx.Exec(sqlStr, args...)
} func (t *SqlConnTransaction) Update(updateStr string, args ...interface{}) (int64, error) {
result, err := t.execute(updateStr, args...)
if err != nil {
return 0, err
}
affect, err := result.RowsAffected()
return affect, err
} func (t *SqlConnTransaction) Insert(insertStr string, args ...interface{}) (int64, error) {
result, err := t.execute(insertStr, args...)
if err != nil {
return 0, err
}
lastid, err := result.LastInsertId()
return lastid, err } func (t *SqlConnTransaction) Delete(deleteStr string, args ...interface{}) (int64, error) {
result, err := t.execute(deleteStr, args...)
if err != nil {
return 0, err
}
affect, err := result.RowsAffected()
return affect, err
} // others
func bytes2RealType(src []byte, columnType string) interface{} {
srcStr := string(src)
var result interface{}
switch columnType {
case "TINYINT":
fallthrough
case "SMALLINT":
fallthrough
case "INT":
fallthrough
case "BIGINT":
result, _ = strconv.ParseInt(srcStr, 10, 64)
case "CHAR":
fallthrough
case "VARCHAR":
fallthrough
case "BLOB":
fallthrough
case "TIMESTAMP":
fallthrough
case "DATETIME":
result = srcStr
case "FLOAT":
fallthrough
case "DOUBLE":
fallthrough
case "DECIMAL":
result, _ = strconv.ParseFloat(srcStr, 64)
default:
result = nil
}
return result
}

2 redis 连接池代码

package lib

import (
"strconv"
"time" "github.com/garyburd/redigo/redis"
) var REDIS map[string]string = map[string]string{
"host": "127.0.0.1:6379",
"database": "0",
"password": "",
"maxOpenConns": "0",
"maxIdleConns": "0",
} var Cache *RedisConnPool type RedisConnPool struct {
redisPool *redis.Pool
} func init() {
Cache = &RedisConnPool{}
maxOpenConns, _ := strconv.ParseInt(REDIS["maxOpenConns"], 10, 64)
maxIdleConns, _ := strconv.ParseInt(REDIS["maxIdleConns"], 10, 64)
database, _ := strconv.ParseInt(REDIS["database"], 10, 64) Cache.redisPool = newPool(REDIS["host"], REDIS["password"], int(database), int(maxOpenConns), int(maxIdleConns))
if Cache.redisPool == nil {
panic("init redis failed!")
}
} func newPool(server, password string, database, maxOpenConns, maxIdleConns int) *redis.Pool {
return &redis.Pool{
MaxActive: maxOpenConns, // max number of connections
MaxIdle: maxIdleConns,
IdleTimeout: 10 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", server)
if err != nil {
return nil, err
}
if _, err := c.Do("AUTH", password); err != nil {
c.Close()
return nil, err
}
if _, err := c.Do("select", database); err != nil {
c.Close()
return nil, err
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
_, err := c.Do("PING")
return err
},
}
} // 关闭连接池
func (p *RedisConnPool) Close() error {
err := p.redisPool.Close()
return err
} // 当前某一个数据库,执行命令
func (p *RedisConnPool) Do(command string, args ...interface{}) (interface{}, error) {
conn := p.redisPool.Get()
defer conn.Close()
return conn.Do(command, args...)
} //// String(字符串)
func (p *RedisConnPool) SetString(key string, value interface{}) (interface{}, error) {
conn := p.redisPool.Get()
defer conn.Close()
return conn.Do("SET", key, value)
} func (p *RedisConnPool) GetString(key string) (string, error) {
// 从连接池里面获得一个连接
conn := p.redisPool.Get()
// 连接完关闭,其实没有关闭,是放回池里,也就是队列里面,等待下一个重用
defer conn.Close()
return redis.String(conn.Do("GET", key))
} func (p *RedisConnPool) GetBytes(key string) ([]byte, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.Bytes(conn.Do("GET", key))
} func (p *RedisConnPool) GetInt(key string) (int, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.Int(conn.Do("GET", key))
} func (p *RedisConnPool) GetInt64(key string) (int64, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.Int64(conn.Do("GET", key))
} //// Key(键)
func (p *RedisConnPool) DelKey(key string) (interface{}, error) {
conn := p.redisPool.Get()
defer conn.Close()
return conn.Do("DEL", key)
} func (p *RedisConnPool) ExpireKey(key string, seconds int64) (interface{}, error) {
conn := p.redisPool.Get()
defer conn.Close()
return conn.Do("EXPIRE", key, seconds)
} func (p *RedisConnPool) Keys(pattern string) ([]string, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.Strings(conn.Do("KEYS", pattern))
} func (p *RedisConnPool) KeysByteSlices(pattern string) ([][]byte, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.ByteSlices(conn.Do("KEYS", pattern))
} //// Hash(哈希表)
func (p *RedisConnPool) SetHashMap(key string, fieldValue map[string]interface{}) (interface{}, error) {
conn := p.redisPool.Get()
defer conn.Close()
return conn.Do("HMSET", redis.Args{}.Add(key).AddFlat(fieldValue)...)
} func (p *RedisConnPool) GetHashMapString(key string) (map[string]string, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.StringMap(conn.Do("HGETALL", key))
} func (p *RedisConnPool) GetHashMapInt(key string) (map[string]int, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.IntMap(conn.Do("HGETALL", key))
} func (p *RedisConnPool) GetHashMapInt64(key string) (map[string]int64, error) {
conn := p.redisPool.Get()
defer conn.Close()
return redis.Int64Map(conn.Do("HGETALL", key))
}

  

redis mysql 连接池 之 golang 实现的更多相关文章

  1. nodejs + redis/mysql 连接池问题

    nodejs + redis/mysql 连接池问题 需不需要连接池 连接池的作用主要是较少每次临时建立连接所带来的开销.初步一看,nodejs运行单线程上,它不能同时使用多个连接,乍一看是不需要连接 ...

  2. 解决Mysql连接池被关闭 ,hibernate尝试连接不能连接的问题。 (默认mysql连接池可以访问的时间为8小时,如果超过8小时没有连接,mysql会自动关闭连接池。系统发布第二天访问链接关闭问题。

    解决Mysql连接池被关闭  ,hibernate尝试连接不能连接的问题. (默认MySQL连接池可以访问的时间为8小时,如果超过8小时没有连接,mysql会自动关闭连接池. 所以系统发布第二天访问会 ...

  3. Java Mysql连接池配置和案例分析--超时异常和处理

    前言: 最近在开发服务的时候, 发现服务只要一段时间不用, 下次首次访问总是失败. 该问题影响虽不大, 但终究影响用户体验. 观察日志后发现, mysql连接因长时间空闲而被关闭, 使用时没有死链检测 ...

  4. MySQL连接池

    1. using System; using System.Collections; using MySql.Data.MySqlClient; namespace Helper { /// < ...

  5. redis运用连接池报错解决

    redis使用连接池报错解决redis使用十几小时就一直报异常 redis.clients.jedis.exceptions.JedisConnectionException: Could not g ...

  6. tomcat中使用mysql连接池的配置

    1.下载相应的jar包,添加到工程中 需要下载的包主要有commons-pool2-2.2 commons-dbcp2-2.0.1-src commons-dbcp2-2.0.1  commons-c ...

  7. mysql连接池的使用工具类代码示例

    mysql连接池代码工具示例(scala): import java.sql.{Connection,PreparedStatement,ResultSet} import org.apache.co ...

  8. 用swoole简单实现MySQL连接池

    MySQL连接池 在传统的网站开发中,比如LNMP模式,由Nginx的master进程接收请求然后分给多个worker进程,每个worker进程再链接php-fpm的master进程,php-fpm再 ...

  9. 实现一个协程版mysql连接池

    实现一个协程版的mysql连接池,该连接池支持自动创建最小连接数,自动检测mysql健康:基于swoole的chanel. 最近事情忙,心态也有点不积极.技术倒是没有落下,只是越来越不想写博客了.想到 ...

随机推荐

  1. CF 990D Graph And Its Complement 第十八 构造、思维

    Graph And Its Complement time limit per test 2 seconds memory limit per test 256 megabytes input sta ...

  2. NOIP 2005 等价表达式 题解

    题意 给一个表达式然后再给n个表达式,判断是否等价 一道大模拟题,将a带为数,并且取模防止溢出 #include<bits/stdc++.h> using namespace std; c ...

  3. Kafka源码分析及图解原理之Producer端

    一.前言 任何消息队列都是万变不离其宗都是3部分,消息生产者(Producer).消息消费者(Consumer)和服务载体(在Kafka中用Broker指代).那么本篇主要讲解Producer端,会有 ...

  4. docker 搭建自己的github

    github 搭建:   自己搭建一个github网站(仓库)   daocloud:公共hub搜索git下载github镜像 docker pull gitlab/gitlab-ce:8.7.0-r ...

  5. Nginx实现高可用(了解)

    使用nginx实现反向代理和负载均衡时,nginx就是整个网站的入口了,所以需要保证nginx的高可用 主要资料包:链接:https://pan.baidu.com/s/1z_-xEM3uUICtZi ...

  6. springboot中动态修改log4j2日志级别

    springboot中动态修改log4j2日志级别 在spring boot中使用log4j2日志时,项目运行中,想要修改日志级别. 1.pom.xml依赖: <dependency> & ...

  7. Docker详解(二)

    目录 1.Docker常用命令 1.1 镜像命令 1.2 容器命令 1.2.1 常用的容器命令 1.2.2 重要的容器命令 序言:上一章我们初步介绍了一下Docker的概念,那么这次我们着手于Dock ...

  8. java对象排序(Comparable)详细实例

    对象实现Comparable接口 public class Field implements Comparable<Field>{ private String name; private ...

  9. Charles 破解版免费下载和注册安装教程

    本文参考:[Charles 破解版免费下载和注册安装教程](https://www.axihe.com/tools/charles/charles/free-use.html) **软件开发不易,请尽 ...

  10. asp.net配置全局应用程序类 巧妙达到定时生成静态页面

    //在项目里添加一个"全局应用程序类(Global Application Class)",在里面写这样的代码: public class Global : System.Web. ...