最佳实践 on 菜鸟程序员

adodb方式连接sqlServer2k

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/go-ole/go-ole v1.2.4 // indirect
 github.com/mattn/go-adodb v0.0.1
 github.com/robfig/cron/v3 v3.0.1
 github.com/wonderivan/logger v1.0.0
 golang.org/x/net v0.0.0-20200904194848-62affa334b73 // indirect
)

main.go

package main

import (
 "database/sql"
 "flag"
 "fmt"
 "log"
 "strconv"

 _ "github.com/mattn/go-adodb"
 "github.com/robfig/cron/v3"
 "github.com/wonderivan/logger"
)

var (
 local bool
 remoteIP string
 remoteDS string
 database string
)

func init() {
 flag.BoolVar(&local, "local", false, "set window connect.")
 flag.StringVar(&remoteIP, "remoteIP", "192.168.0.10", "set up remote mssql of ip.")
 flag.StringVar(&remoteDS, "remoteDS", "MSSQLSERVER", "set up remote mssql of datasource.")
 flag.StringVar(&database, "database", "drivertest", "set up remote mssql of database.")
}

type Mssql struct {
 *sql.DB
 dataSource string
 database string
 windows bool
 sa *SA
}

type SA struct {
 user string
 passwd string
 port int
}

func NewMssql() *Mssql {
 mssql := new(Mssql)
 dataS := "localhost"
 if !local {
 dataS = fmt.Sprintf("%s\\%s", remoteIP, remoteDS)
 }

 mssql = &Mssql{
 // 如果数据库是默认实例（MSSQLSERVER）则直接使用IP，命名实例需要指明。
 // dataSource: "192.168.1.104\\MSSQLSERVER",
 dataSource: dataS,
 database: database,
 // windows: true 为windows身份验证，false 必须设置sa账号和密码
 windows: local,
 sa: &SA{
 user: "elink",
 passwd: "elink888",
 port: 1433,
 },
 }

 return mssql

}

func (m *Mssql) Open() error {
 config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s",
 m.database, m.dataSource)

 if m.windows {
 config = fmt.Sprintf("%s;Integrated Security=SSPI", config)
 } else {
 // sql 2000的端口写法和sql 2005以上的有所不同，在Data Source 后以逗号隔开。
 config = fmt.Sprintf("%s,%d;user id=%s;password=%s",
 config, m.sa.port, m.sa.user, m.sa.passwd)
 }

 var err error
 m.DB, err = sql.Open("adodb", config)
 fmt.Println(config)

 return err
}

func (m *Mssql) Select() {
 rows, err := m.Query("select uid, name from sysusers")
 if err != nil {
 fmt.Printf("select query err: %s\n", err)
 }
 i := 0
 for rows.Next() {
 var id, name string
 rows.Scan(&id, &name)
 fmt.Printf("id = %s, name = %s\n", id, name)
 i++
 }
 fmt.Println(i)
}

func main() {
 // flag.Parse()

 // m := NewMssql()
 // config1 := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s",
 // m.database, m.dataSource)

 // if m.windows {
 // config1 = fmt.Sprintf("%s;Integrated Security=SSPI", config1)
 // } else {
 // // sql 2000的端口写法和sql 2005以上的有所不同，在Data Source 后以逗号隔开。
 // config1 = fmt.Sprintf("%s,%d;user id=%s;password=%s",
 // config1, m.sa.port, m.sa.user, m.sa.passwd)
 // }
 // fmt.Println(config1)
 // err := mssql.Open()

 // checkError(err)

 // mssql.Select()

 // config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s\\MSSQLSERVER,%s;user id=%s;password=%s",
 // "drivertest", "192.168.0.10", "1433", "elink", "elink888")
 config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s\\MSSQLSERVER,%s;user id=%s;password=%s",
 "znykt", "37.64.227.132", "1433", "elink", "elink888")
 DB, err := sql.Open("adodb", config)
 if err != nil {
 log.Fatal(err)
 }

 crontab := cron.New(cron.WithSeconds()) //精确到秒
 // 定时任务
 deviceStatusOnline_spec := "*/5 * * * * ?" //秒 分 时 日 月 周
 // 定义定时器调用的任务函数
 _, err = crontab.AddFunc(deviceStatusOnline_spec, func() {
 rows, err := DB.Query("select top 200 id from MYCARGOOUTRECORD order by id desc")
 if err != nil {
 fmt.Printf("select query err: %s\n", err)
 }
 i := 0
 for rows.Next() {
 // var id, name string
 // rows.Scan(&id, &name)
 // fmt.Printf("id = %s, name = %s\n", id, name)
 i++
 }
 logger.Info("结果数量：" + strconv.Itoa(i))
 })
 if err != nil {
 log.Fatal(err)
 }
 // 启动定时器
 crontab.Start()
 select {}
}

// func checkError(err error) {
// if err != nil {
// log.Fatal(err)
// }
// }

AES-ECB-PKCS5

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "crypto/aes"
 "crypto/cipher"
 "encoding/base64"
 "encoding/hex"
 "fmt"
 "strings"
)

func Base64URLDecode(data string) ([]byte, error) {
 var missing = (4 - len(data)%4) % 4
 data += strings.Repeat("=", missing)
 res, err := base64.URLEncoding.DecodeString(data)
 fmt.Println(" decodebase64urlsafe is :", string(res), err)
 return base64.URLEncoding.DecodeString(data)
}

func Base64UrlSafeEncode(source []byte) string {
 // Base64 Url Safe is the same as Base64 but does not contain '/' and '+' (replaced by '_' and '-') and trailing '=' are removed.
 bytearr := base64.StdEncoding.EncodeToString(source)
 safeurl := strings.Replace(string(bytearr), "/", "_", -1)
 safeurl = strings.Replace(safeurl, "+", "-", -1)
 safeurl = strings.Replace(safeurl, "=", "", -1)
 return safeurl
}

func AesDecrypt(crypted, key []byte) []byte {
 block, err := aes.NewCipher(key)
 if err != nil {
 fmt.Println("err is:", err)
 }
 blockMode := NewECBDecrypter(block)
 origData := make([]byte, len(crypted))
 blockMode.CryptBlocks(origData, crypted)
 origData = PKCS5UnPadding(origData)
 // fmt.Println("source is :", origData, string(origData))
 return origData
}

func AesEncrypt(src, key string) []byte {
 block, err := aes.NewCipher([]byte(key))
 if err != nil {
 fmt.Println("key error1", err)
 }
 if src == "" {
 fmt.Println("plain content empty")
 }
 ecb := NewECBEncrypter(block)
 content := []byte(src)
 content = PKCS5Padding(content, block.BlockSize())
 crypted := make([]byte, len(content))
 ecb.CryptBlocks(crypted, content)
 // 普通base64编码加密 区别于urlsafe base64
 // fmt.Println("base64 result:", base64.StdEncoding.EncodeToString(crypted))

 // fmt.Println("base64UrlSafe result:", Base64UrlSafeEncode(crypted))
 return crypted
}

func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
 padding := blockSize - len(ciphertext)%blockSize
 padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 return append(ciphertext, padtext...)
}

func PKCS5UnPadding(origData []byte) []byte {
 length := len(origData)
 // 去掉最后一个字节 unpadding 次
 unpadding := int(origData[length-1])
 return origData[:(length - unpadding)]
}

type ecb struct {
 b cipher.Block
 blockSize int
}

func newECB(b cipher.Block) *ecb {
 return &ecb{
 b: b,
 blockSize: b.BlockSize(),
 }
}

type ecbEncrypter ecb

// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
// mode, using the given Block.
func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
 return (*ecbEncrypter)(newECB(b))
}
func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Encrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}

type ecbDecrypter ecb

// NewECBDecrypter returns a BlockMode which decrypts in electronic code book
// mode, using the given Block.
func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
 return (*ecbDecrypter)(newECB(b))
}
func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Decrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}

type Person struct {
 Name string `json:"name"`
 Age int `json:"age"`
}

func main() {

 key, _ := base64.StdEncoding.DecodeString("cmVmb3JtZXJyZWZvcm1lcg==")
 strkey := string(key)
 fmt.Println(strkey)
 fmt.Println([]byte(strkey))
 fmt.Println()
 fmt.Println()
 fmt.Println()

 // wait_encode_str := "{\"stationNo\":\"241\"}"
 // encode_str := AesEncrypt(wait_encode_str, "reformerreformer")
 // hex.EncodeToString(encode_str)
 // fmt.Println(hex.EncodeToString(encode_str))

 wait_decode_str := "34D4F1A0506840B2A6D93C20C098312FAEE02E16FC26144A0621512E9F20CBB0AD121A74EFAD7A8935B132981D6C4198E06B8949E593E2A7D6AB4AB640CC498EE58CD0A66B5B0BBAAE1DBF4C9E4A02DE5658319E93B46831595515FA9F8EFD4202631F09DADDCD575B40C7F76739B31393A455B10AE73B2093EBD6B58DB88D24ACFB0F1DD123A9883051C8986BE060A168024690058318B8271F12E9D4795ACED75BDCC4F1F9AF75743BB81066F64D934B02CD41BE0528F2CEFFC3C40AC1645CA53943024C236A75F247DF3131704BECA1AFE7ADB81343E6D5914940F4E608BECF0D290EDD3B0F0B1F9CE0CD1557479B9E888007A48B19557A989E325193BD0F3EF40C9530B6B6F0D60F231A2EA2A58E9EA0D3B212E6C7BD177D0165C3FB052CBB672E9591D57F81115EBAEF9DC8116813F8D67289A440403D3CC9C7B0F716736E04780C06FCE2BC2D01938AE55A14FD6E0965A241608A371136FC9229BB61093367C8E674AAA35C66F4004C6478C11DE085A81A8D289DDF47EFA422BB9311355FB35218112F26981084812B3FBA2CC55D1267804FE913495C1518342E94B1C45A122B0516C01488D7FB6FEB3A06F37F"

 hex_data, _ := hex.DecodeString(wait_decode_str)
 decode_str := AesDecrypt(hex_data, key)
 fmt.Println(string(decode_str))

 // b1, _ := Base64URLDecode("cmVmb3JtZXJyZWZvcm1lcg==")
 // fmt.Println(string(b1))

 // b2 := Base64UrlSafeEncode([]byte("reformerreformer"))
 // fmt.Println(b2)
}


import java.security.Key;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * AES加密类
 *
 */
public class AESUtils {
 /**
 * 密钥算法
 */
 private static final String KEY_ALGORITHM = "AES";

 private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

 /**
 * 初始化密钥
 *
 * @return byte[] 密钥
 * @throws Exception
 */
 public static byte[] initSecretKey() {
 // 返回生成指定算法的秘密密钥的 KeyGenerator 对象
 KeyGenerator kg = null;
 try {
 kg = KeyGenerator.getInstance(KEY_ALGORITHM);
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
 return new byte[0];
 }
 // 初始化此密钥生成器，使其具有确定的密钥大小
 // AES 要求密钥长度为 128
 kg.init(128);
 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();
 return secretKey.getEncoded();
 }

 /**
 * 转换密钥
 *
 * @param key
 * 二进制密钥
 * @return 密钥
 */
 public static Key toKey(byte[] key) {
 // 生成密钥
 return new SecretKeySpec(key, KEY_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return encrypt(data, k, cipherAlgorithm);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为加密模式
 cipher.init(Cipher.ENCRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return decrypt(data, k, cipherAlgorithm);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 public static String showByteArray(byte[] data) {
 if (null == data) {
 return null;
 }
 StringBuilder sb = new StringBuilder("{");
 for (byte b : data) {
 sb.append(b).append(",");
 }
 sb.deleteCharAt(sb.length() - 1);
 sb.append("}");
 return sb.toString();
 }

 /**
 * 将16进制转换为二进制
 *
 * @param hexStr
 * @return
 */
 public static byte[] parseHexStr2Byte(String hexStr) {

 if (hexStr.length() < 1)
 return null;
 byte[] result = new byte[hexStr.length() / 2];
 for (int i = 0; i < hexStr.length() / 2; i++) {
 int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
 int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
 result[i] = (byte) (high * 16 + low);
 }
 return result;
 }

 /**
 * 将二进制转换成16进制
 *
 * @param buf
 * @return
 */
 public static String parseByte2HexStr(byte buf[]) {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < buf.length; i++) {
 String hex = Integer.toHexString(buf[i] & 0xFF);
 if (hex.length() == 1) {
 hex = '0' + hex;
 }
 sb.append(hex.toUpperCase());
 }
 return sb.toString();
 }

 /**
 * @param str
 * @param key
 * @return
 * @throws Exception
 */
 public static String aesEncrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = cipher.doFinal(str.getBytes("utf-8"));
 return new BASE64Encoder().encode(bytes);
 }

 public static String aesDecrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = new BASE64Decoder().decodeBuffer(str);
 bytes = cipher.doFinal(bytes);
 return new String(bytes, "utf-8");
 }

 public static void main(String[] args) throws Exception {
 byte[] key = initSecretKey();
 System.out.println("key：" + Base64.encodeBase64String(key));
 System.out.println("key：" + showByteArray(key));


 // 指定key
// String kekkk = "9iEepr1twrizIEKrs1hs2A==";
 String kekkk = "cmVmb3JtZXJyZWZvcm1lcg==";
 byte[] bs = Base64.decodeBase64(kekkk);
 System.out.println(bs);
 System.out.println("kekkk:" + showByteArray(Base64.decodeBase64(kekkk)));
 Key k = toKey(Base64.decodeBase64(kekkk));

 String data = "{\"requestName\":\"BeforeIn\",\"requestValue\":{\"carCode\":\"浙AD0V07\",\"inTime\":\"2016-09-29 10:06:03\",\"inChannelId\":\"4\",\"GUID\":\"1403970b-4eb2-46bc-8f2b-eeec91ddcd5f\",\"inOrOut\":\"0\"},\"Type\":\"0\"}";
// System.out.println("加密前数据: string:" + data);
// System.out.println("加密前数据: byte[]:" + showByteArray(data.getBytes()));
// System.out.println();

 byte[] encryptData = encrypt(data.getBytes(), k);
 String encryptStr=parseByte2HexStr(encryptData);

 System.out.println("加密后数据: byte[]:" + showByteArray(encryptData));
 System.out.println("加密后数据: Byte2HexStr:" + encryptStr);
 System.out.println();

 byte[] encryptStrByte = parseHexStr2Byte("96B742F275ECC2C77374E888CC3AD5D46CDDDAFA3BBA1AA8184D07BED0D957B250DF794666F5ACA787A8D2F20FB7D195C39E78FBDBDDD2F14B00AFC021BA306B03DB52706969E8497F91084CCA48EB81D902E3C32112F1DB07B21B45314ECFA2742F838C368C770F9C21DE07B99844A691269F83C5582A4EE21FB2C22A2168420EBC4AEEE6FB7D3B182AE5158F1F8E62F3BE3AA26C4F220E382B304F91A52A8CD823B68129409BA6059621F3EC0C94BBE8C5A9C1236C9A137536502BB6354D56");
 System.out.println(encryptStrByte.length);
 byte[] decryptData = decrypt(encryptStrByte, k);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData));
 System.out.println("解密后数据: string:" + new String(decryptData));

 }
}

java依赖

base64

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "encoding/base64"
 "fmt"
 "strings"
)

//Base64UrlSafeEncode 需要替换掉一些字符
func Base64UrlSafeEncode(source []byte) string {
 // Base64 Url Safe is the same as Base64 but does not contain '/' and '+' (replaced by '_' and '-') and trailing '=' are removed.
 bytearr := base64.StdEncoding.EncodeToString(source)
 safeurl := strings.Replace(string(bytearr), "/", "_", -1)
 safeurl = strings.Replace(safeurl, "+", "-", -1)
 safeurl = strings.Replace(safeurl, "=", "", -1)
 return safeurl
}

func main() {

 //标准base64编码
 wait_encode_data := "reformerreformer"
 wait_decode_data := "cmVmb3JtZXJyZWZvcm1lcg"

 //使用标准库自带的方式加密
 sEnc := base64.StdEncoding.EncodeToString([]byte(wait_encode_data))
 fmt.Println(sEnc)

 sDec, _ := base64.StdEncoding.DecodeString("cmVmb3JtZXJyZWZvcm1lcg==")
 fmt.Println(string(sDec))

 //兼容base64编码
 uEnc := base64.URLEncoding.EncodeToString([]byte(wait_encode_data))
 fmt.Println(uEnc)

 uDec, _ := base64.URLEncoding.DecodeString(wait_decode_data)
 fmt.Println(string(uDec))

}

cbor

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "encoding/hex"
 "fmt"

 "github.com/fxamacker/cbor/v2"
)

func main() {

 b, _ := cbor.Marshal("hello world")
 fmt.Println(hex.EncodeToString(b))

 cborBytes, _ := hex.DecodeString(hex.EncodeToString(b))

 s := ""
 cbor.Unmarshal(cborBytes, &s)

 fmt.Printf("%s", s)
}

channel

Mon, 01 Jan 0001 00:00:00 +0000

顺序执行两个协程

package main

import (
 "fmt"
 "log"
 "math/rand"
 "sync"
 "time"
)

func main() {
 //顺序执行两个协程函数
 ch1 := make(chan string, 5)
 go testBoringWithChannelClose("boring!", ch1)
 ch2 := make(chan string, 5)
 go testBoringWithChannelClose("funning!", ch2)

 for b := range ch1 {
 go log.Printf("You say: %s", b)
 }

 for b := range ch2 {
 go log.Printf("You say: %s", b)
 }

}

func testBoringWithChannelClose(msg string, c chan string) {
 for i := 0; i < 20; i++ {
 c <- fmt.Sprintf("%s %d", msg, i)
 time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
 }
 fmt.Println(msg + "结束")
 close(c)
}

带缓冲的channel 就像一个携程池，去执行协程任务。

package main

import (
 "fmt"
 "log"
 "math/rand"
 "sync"
 "time"
)

func main() {


 //限制1024个协程数执行任务
 goNum1024Times()
}

// 控制1024个协程
func goNum1024Times() {
 var wg sync.WaitGroup
 ch := make(chan struct{}, 1024)
 for i := 0; i < 20000; i++ {
 wg.Add(1)
 ch <- struct{}{}
 go func() {
 defer wg.Done()
 fmt.Printf("%d\n", len(ch)) //打印通道的长度
 <-ch
 }()
 }
 wg.Wait()
}

CRC16

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "CRC15/method" //因为gomod 定义了模块名为 module CRC15 所以引用目录下的method
 "encoding/hex"
 "fmt"
 "strings"
)

func main() {

 byteArr, _ := hex.DecodeString("7F39F60116C067321223344556677889800112230100000000F700000000000000000000000000000000323030B7C2D8BB353030FABBF7D63130")
 checkVal := method.UsMBCRC16(byteArr)
 fmt.Println(strings.ToUpper(fmt.Sprintf("%X", checkVal)))
}

go.mod

module CRC15

go 1.13

method/crc16.go

package method

import (
 "encoding/hex"
 "fmt"
 "strings"
)

var auchCRCLo = [256]uint8{
 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
 0x43, 0x83, 0x41, 0x81, 0x80, 0x40,
}

var auchCRCHi = [256]uint8{
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
}

func UsMBCRC16(pucFrame []byte) int {
 ucCRCHi := 0xFF
 ucCRCLo := 0xFF
 iIndex := 0
 for i := 0; i < len(pucFrame); i++ {
 iIndex = ucCRCLo ^ int(pucFrame[i])
 ucCRCLo = ucCRCHi ^ int(auchCRCHi[iIndex])
 ucCRCHi = int(auchCRCLo[iIndex])
 }
 return ucCRCLo<<8 | ucCRCHi
}

func TopscommCrc16(param string, check string) bool {
 byteArr, _ := hex.DecodeString(param)
 checkVal := UsMBCRC16(byteArr)
 h := fmt.Sprintf("%X", checkVal)
 if h != strings.ToUpper(check) {
 return false
 }

 return true
}

gorm连接mssql

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 github.com/jinzhu/gorm v1.9.14
)

package main

import (
 "flag"
 "fmt"

 _ "github.com/denisenkom/go-mssqldb"
 "github.com/jinzhu/gorm"
)

type Dt_Cardtype struct {
 gorm.Model
 ID string `gorm:"id"`
 CardCname string `gorm:"CardCname"`
}

var (
 debug = flag.Bool("debug", true, "enable debugging")
 password = flag.String("password", "Elink666.", "the database password")
 port *int = flag.Int("port", 1433, "the database port")
 server = flag.String("server", "172.16.183.131", "the database server")
 user = flag.String("user", "sa", "the database user")
)

func main() {
 connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=carpark", *server, *user, *password, *port)
 db, err := gorm.Open("mssql", connString)
 if err != nil {
 panic("连接数据库失败")
 }
 defer db.Close()

 db.SingularTable(true)
 db.LogMode(true)
 db.CommonDB()

 var dc []Dt_Cardtype
 db.Find(&dc)

 fmt.Println(len(dc))
 // // 自动迁移模式
 // db.AutoMigrate(&Product{})

 // // 创建
 // db.Create(&Product{Code: "L1212", Price: 1000})

 // // 读取
 // var product Product
 // db.First(&product, 1) // 查询id为1的product
 // db.First(&product, "code = ?", "L1212") // 查询code为l1212的product

 // // 更新 - 更新product的price为2000
 // db.Model(&product).Update("Price", 2000)

 // // 删除 - 删除product
 // db.Delete(&product)
}

gorose连接mssql

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 github.com/gohouse/converter v0.0.3 // indirect
 github.com/gohouse/gorose v1.0.5
 github.com/gohouse/gorose/v2 v2.1.7
 github.com/jinzhu/gorm v1.9.14
)

package main

import (
 "flag"
 "fmt"
 "os"

 _ "github.com/denisenkom/go-mssqldb"
 gorose "github.com/gohouse/gorose/v2"
)

var err error
var engin *gorose.Engin

type DtCardtype struct {
 ID int64 `gorose:"id"`
 CardCname string `gorose:"CardCname"`
 Mark string `gorose:"Mark"`
}

var (
 debug = flag.Bool("debug", true, "enable debugging")
 password = flag.String("password", "123456", "the database password")
 port *int = flag.Int("port", 1433, "the database port")
 server = flag.String("server", "10.10.10.53", "the database server")
 user = flag.String("user", "sa", "the database user")
)

func init() {
 // 全局初始化数据库,并复用
 // 这里的engin需要全局保存,可以用全局变量,也可以用单例
 // 配置&gorose.Config{}是单一数据库配置
 // 如果配置读写分离集群,则使用&gorose.ConfigCluster{}
 // mysql Dsn示例 "root:root@tcp(localhost:3306)/test?charset=utf8&parseTime=true"
 connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=carpark", *server, *user, *password, *port)
 engin, err = gorose.Open(&gorose.Config{Driver: "mssql", Dsn: connString})
 if err != nil {
 fmt.Println(err)
 os.Exit(-1)
 }
}
func DB() gorose.IOrm {
 return engin.NewOrm()
}
func main() {
 var u []DtCardtype
 DB().Table("Park").First()
 fmt.Println(u)
}

go发送get或post请求

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "crypto/md5"
 "crypto/tls"
 "encoding/json"
 "fmt"
 "io"
 "io/ioutil"
 "log"
 "net/http"
 "strconv"
 "time"
)

func main() {
 // GetData()
 PostMethod()
}

//这是get请求
func GetData() {
 tr := &http.Transport{
 TLSClientConfig: &tls.Config{InsecureSkipVerify: true}} //如果需要测试自签名的证书 这里需要设置跳过证书检测 否则编译报错
 client := &http.Client{Transport: tr}
 resp, err := client.Get("https://192.168.7.15:8080/v1/getaction.do")
 //此处需要注意经过测试，不论是否有err在此之前一定要判断resp.Body如果不为空则需要关闭,测试环境go1.16
 if resp.Body != nil {
 defer resp.Body.Close()
 }
 if err != nil {
 fmt.Println("error:", err)
 return
 }

 body, err := ioutil.ReadAll(resp.Body)
 fmt.Println(string(body))
}

//这是post请求
func PostMethod() {
 var rsp io.Reader
 tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}} //如果需要测试自签名的证书 这里需要设置跳过证书检测 否则编译报错
 client := &http.Client{Transport: tr}
 data := "cmd=123"
 resp, err := client.Post("https://192.168.7.15:8080/v1/postaction.do", data, rsp)
 //此处需要注意经过测试，不论是否有err在此之前一定要判断resp.Body如果不为空则需要关闭,测试环境go1.16
 if resp.Body != nil {
 defer resp.Body.Close()
 }
 if err != nil {
 fmt.Println("err:", err)
 } else {
 body, er := ioutil.ReadAll(resp.Body)
 if er != nil {
 fmt.Println("err:", er)
 } else {
 fmt.Println(string(body))
 }
 }

}

func PostMethod() {
 //{"carmeraId":"epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$6","carmeraDesc":"","status":"1","areaId":"001","dataTime":"2020-11-17 14:30:12"}
 //{"carmeraId":"epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$7","carmeraDesc":"2F走廊西","status":"1","areaId":"001","dataTime":"2020-11-17 15:42:01"}
 m3 := map[string]string{
 "cameraId": "epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$7",
 "cameraDesc": "2F走廊西",
 "status": "1",
 "areaId": "001",
 "dataTime": "2020-11-17 15:42:01",
 }
 exportData, err := json.Marshal(m3)

 tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
 client := &http.Client{Transport: tr}
 req, err := http.NewRequest(http.MethodPost, "https://eug-test.elinkit.com.cn/epmet-acs/report/video/info", bytes.NewReader(exportData))
 if err != nil {
 log.Fatal(err.Error)
 }
 times := strconv.FormatInt(time.Now().Unix(), 10)
 data := []byte("c3c4029b9741f26ab4a4cbd98c2310ff" + times)
 has := md5.Sum(data)
 accessToken := fmt.Sprintf("%x", has)
 req.Header.Set("Content-Type", "application/json")
 req.Header.Set("AccessToken", accessToken)
 req.Header.Set("Timestamp", times)

 response, err := client.Do(req)
 //此处需要注意经过测试，不论是否有err在此之前一定要判断 response.Body 如果不为空则需要关闭,测试环境go1.16
 if response.Body != nil {
 defer response.Body.Close()
 }

 if err != nil {
 fmt.Println("err:", err)

 }

 body, er := ioutil.ReadAll(response.Body)
 if er != nil {
 fmt.Println("err:", er)
 }
 fmt.Println(string(body))
}

go脚本编程接受命令行参数

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "flag"
 "fmt"
)

func main() {
 // 定义几个变量，用于接收命令行的参数值
 var user string
 var password string
 var host string
 var port int
 // &user 就是接收命令行中输入 -u 后面的参数值，其他同理
 flag.StringVar(&user, "u", "root", "账号，默认为root")
 flag.StringVar(&password, "p", "", "密码，默认为空")
 flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
 flag.IntVar(&port, "P", 3306, "端口号，默认为3306")
 // 解析命令行参数写入注册的flag里
 flag.Parse()
 // 输出结果
 fmt.Printf("user：%v\npassword：%v\nhost：%v\nport：%v\n",
 user, password, host, port)

}

hmac算法

Mon, 01 Jan 0001 00:00:00 +0000

‌ HMAC （Hash-based Message Authentication Code）是一种基于哈希函数的消息认证码算法‌，用于验证数据的完整性和认证消息的发送者。HMAC结合了哈希函数和密钥，通过将密钥与消息进行哈希运算来生成消息认证码‌

HMAC的工作原理
HMAC使用一个密钥和一个哈希函数（如MD5、SHA-1、SHA-256等）生成一个固定长度的哈希值。具体步骤如下：

‌输入‌：消息和密钥。
‌处理‌：HMAC对输入的消息和密钥进行哈希处理，生成一个固定长度的哈希值。
‌输出‌：该哈希值即为HMAC签名‌

HMAC的安全性
HMAC的安全性依赖于密钥的保密性和所使用的哈希函数的抗碰撞能力。只有持有密钥的一方能够生成或验证该消息的签名，从而确保消息在传输过程中没有被篡改‌

HMAC的应用场景
HMAC广泛应用于各种需要确保数据完整性和认证的应用场景中，例如：

‌ IPSec ‌：在IPSec中，HMAC用于验证IP数据包的完整性和真实性。
‌ SSL/TLS ‌：在SSL/TLS协议中，HMAC用于验证通信双方的身份和数据完整性。

package main

import (
 "crypto/hmac"
 "crypto/sha256"
 "encoding/base64"
 "fmt"
)

func GenHmacSha256(message string, secret string) string {
 h := hmac.New(sha256.New, []byte(secret))
 h.Write([]byte(message))
 return base64.StdEncoding.EncodeToString(h.Sum(nil))
}

func main() {

 key := "VHc1CBWM0YS204rydm+wWxkQrqJSVyXAAgFRktVpOF4="
 str := "/report/data/device?timestamp=123456789&appKey=9aON8USr&nonce=123456"
 ret := GenHmacSha256(str, key)

 fmt.Printf("ret: %s\n", ret)
}

//RdYq6cvBpeF84HO8iQErRF6Aq9XdE2fDx5w4qjDWfrg=
//RdYq6cvBpeF84HO8iQErRF6Aq9XdE2fDx5w4qjDWfrg=
//6D+MQzWc3eU4eqZkXaUQ4xmeviQPljjzs4CQmF18ldk=
//6D+MQzWc3eU4eqZkXaUQ4xmeviQPljjzs4CQmF18ldk=

md5编码

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "crypto/md5"
 "fmt"
 "io"
)

func main() {
 str := "abcdefg"

 //方法一
 data := []byte(str)
 has := md5.Sum(data)
 md5str1 := fmt.Sprintf("%x", has) //将[]byte转成16进制

 fmt.Println(md5str1)

 //方法二

 w := md5.New()
 io.WriteString(w, str) //将str写入到w中
 md5str2 := fmt.Sprintf("%x", w.Sum(nil)) //w.Sum(nil)将w的hash转成[]byte格式

 fmt.Println(md5str2)
}

modbustcp-client

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/goburrow/modbus v0.1.0
 github.com/goburrow/serial v0.1.0 // indirect
)

package main

import (
 "log"
 "os"
 "time"

 "github.com/goburrow/modbus"
)

func main() {

 handler := modbus.NewTCPClientHandler("localhost:502")
 handler.Timeout = 10 * time.Second
 handler.SlaveId = 0 //SlaveId即modbustcp协议从0开始得第6字节称，在厂家协议中称为RTU地址无效字段，标准协议中如果是0则为广播地址
 handler.Logger = log.New(os.Stdout, "test: ", log.LstdFlags)
 // Connect manually so that multiple requests are handled in one connection session
 err := handler.Connect()
 if err != nil {
 log.Fatalf("连接错误：%+v", err)
 }
 defer handler.Close()

 // modbus.Tc
 // modbus.NewClient(handler)
 client := modbus.NewClient(handler)
 log.Printf("客户端：%+v", client)
 client.ReadHoldingRegisters(40001, 10)

 res, e1 := client.ReadHoldingRegisters(40001, 2)
 if e1 != nil {
 log.Fatalf("E1错误：%+v", e1)
 }
 log.Printf("资源内容1：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容2：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容3：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容4：%+v", res)

 results1, err := client.ReadDiscreteInputs(15, 2)
 results2, err = client.WriteMultipleRegisters(1, 2, []byte{0, 3, 0, 4})

}

opc-client

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "fmt"

 "github.com/konimarti/opc"
)

func main() {
 client, _ := opc.NewConnection(
 "Matrikon.OPC.Simulation.1", // ProgId
 []string{"localhost"}, // OPC servers nodes
 []string{"Random.Real8", "Random.String"}, // slice of OPC tags
 )
 defer client.Close()

 // read single tag: value, quality, timestamp
 fmt.Println(client.ReadItem("Random.Real8"))

 // read all added tags
 fmt.Println(client.Read())
}

Post上传文件

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "encoding/json"
 "fmt"
 "io"
 "io/ioutil"
 "log"
 "mime/multipart"
 "net/http"
 "os"
 "path/filepath"
)

func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (UploadFileRes, error) {
 file, err := os.Open(path)
 if err != nil {
 return UploadFileRes{}, err
 }
 defer file.Close()

 body := &bytes.Buffer{}
 writer := multipart.NewWriter(body)
 part, err := writer.CreateFormFile(paramName, filepath.Base(path))
 if err != nil {
 return UploadFileRes{}, err
 }
 _, err = io.Copy(part, file)

 for key, val := range params {
 _ = writer.WriteField(key, val)
 }
 err = writer.Close()
 if err != nil {
 return UploadFileRes{}, err
 }

 request, err := http.NewRequest("POST", uri, body)
 if err != nil {
 log.Fatal(err)
 return UploadFileRes{}, err
 }
 request.Header.Add("Content-Type", writer.FormDataContentType())
 client := &http.Client{}
 resp, err := client.Do(request)
 if err != nil {
 log.Fatal(err)
 return UploadFileRes{}, err
 } else {
 defer resp.Body.Close()
 body, err := ioutil.ReadAll(resp.Body)
 // body := &bytes.Buffer{}
 // _, err := body.ReadFrom(resp.Body)
 if err != nil {
 log.Fatal(err)
 }

 // fmt.Println(resp.StatusCode)
 // fmt.Println(resp.Header)
 // fmt.Println(body.Bytes())

 var uploadFileRes UploadFileRes
 json.Unmarshal(body, &uploadFileRes)
 return uploadFileRes, nil
 }
 return UploadFileRes{}, fmt.Errorf("lib throwe")
}

func main() {

 extraParams := map[string]string{}
 res, err := newfileUploadRequest("http://192.168.1.56:1502/uploadeFile", extraParams, "file", "/home/koala/project/tmp/images/1.png")
 if err != nil {
 log.Fatal(err)
 }
 fmt.Println(res)

 sep := string(os.PathSeparator)
 fmt.Println(sep)
}

type UploadFileRes struct {
 ErrCode string `json:"errCode"`
 ErrMsg string `json:"errMsg"`
 Data string `json:"data"`
}

RSA-encryption

Mon, 01 Jan 0001 00:00:00 +0000

csdn_private.pem

-----BEGIN csdn_privateKey-----
MIIEpAIBAAKCAQEAv5so1PIs1jaJPJ7fOQBUAzpIqf8kZ7vCETs9sGXCs2XzqwH4
sYyzPcU9NY5CBMMtev9bW0oPyETQCsaS5HtbpgHwRPqRfbcSWZXkodUUUgSNP2ss
/74tMjw4tnx4kxW/EmsZnGJGKuyY7Tf5IlI7QD6U9nWWRKAEsKSbyd/7H3HzLxoB
xZsMbXXI3MgERzJcsmacWPnVG98i7QH0oSu+a7zSse5zSrW/RtKQj8WtAOMVZ7FP
x4fqofj6JGXot4SFBkwSgnPD2613PSPMQn6/G2dHUEJqmqtJr4j8ptP+1T6tWpy0
BVm/WhbkN9ymCOlds+SGMkyeCUs6daBJilQ9VQIDAQABAoIBADDsj2qAQ86WskgW
UO0fFlSUp0Uw7rzGBnGb7M6DzUk9eRBrOnMreAEHwe9Q2a6Zn51OYqdWq9z5JR37
Qjqw/N/QkucqC8hL3JWfXnesDro6i05sMVtD1gqDsf92nNsBrH4pdqqltUD0lL/N
kQGgeZyX3jVoJOx0532rKlRLqrWGU5acSosZqTTuCQEjBH94mA1KTvLy0CqZWyWo
yZ/OBtF61TxXa5qejJl4MJ8050UV8T7tqkckK9h4bColVS58VvnYaKST5bf33YiY
sAbE7/o8B9NW/3ogwJG6yvjXnSnICOLNUofb26zftW9DrcYGmLMnsPtm8Tj2xPLj
7zAjbekCgYEA8CZNYs72yDxJjvewvYmeWSkAO9goVBHQSSyMJcgdhiWG4IkZbaAo
1Mrvs3LBIOY1VMr2OjopzwSupNvKqOokLZ+2zcijvqDmv8AgZdh79JdaRVqqXf83
Zvun6RD1Par8vIfNIWPV/ruiM0QFcgbpd3VshAOJbqLv0QVb3Lb/f5MCgYEAzECj
uf1HKCgguRDvajG8aImES+xWdXubyA0yakS6xiBt9Pyr5sNkcum3FDIynj9/i/ke
MrK/4PtewwYwemWpccWf+EAXhQhj7bqKC5TsQr3gu9eQ+A9RVOGJ7WBJca9VY8q6
7jAWf/UlEx8WPxaV11jtvchzA1erwmMwafLGUHcCgYEAwf9PGHj0psD88z9oSVT4
1DHo/G8b9P4G8nXIKWVFZG7ATHa0UfjFw1DE3oPfPAJ8Jqlmy5bc211+77KWPmoX
G7wf4pEopgA5J8G+6kc9q1LxG4GoixJ24Px+oiqO0mhkjrBtp4GNB6Dv4NYcSAcJ
ZvU22lY5GWUKsiHQGbbDI30CgYEAx9h7GdCaXc0db1YFmrb9LJ9YpVyhn6OI4a0f
5eBHivFSBMFwhIIrd0/7xLP02OcyKcdeZ6aDnWL17gXRSwDLULlXcvNqz8xM0d6R
kRFuNUNJbyFVA5EhN9bROEPcuHIgL1q9ma3NZfd7BgGFp8a2Z5ToUKee+Oc/9BtO
1Gso5LMCgYBZKa3mZp1nmWHn7zlD+HeP/MACs34ZgaR33dGIx9j5jO8s5Gw98wJg
Rfjvuf73Yq9T7VhlJp6mZ+fDVuhrbBlI32Itrb+p7FztIx3rVBXjvvuhqOFDupYl
UttiUvkrWuoTKfbPhKZkKVDYp+fm/dd6JBa+c0+2kuwo6tm/Yr3kbw==
-----END csdn_privateKey-----

csdn_PublicKey.pem

-----BEGIN csdn_PublicKey-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv5so1PIs1jaJPJ7fOQBU
AzpIqf8kZ7vCETs9sGXCs2XzqwH4sYyzPcU9NY5CBMMtev9bW0oPyETQCsaS5Htb
pgHwRPqRfbcSWZXkodUUUgSNP2ss/74tMjw4tnx4kxW/EmsZnGJGKuyY7Tf5IlI7
QD6U9nWWRKAEsKSbyd/7H3HzLxoBxZsMbXXI3MgERzJcsmacWPnVG98i7QH0oSu+
a7zSse5zSrW/RtKQj8WtAOMVZ7FPx4fqofj6JGXot4SFBkwSgnPD2613PSPMQn6/
G2dHUEJqmqtJr4j8ptP+1T6tWpy0BVm/WhbkN9ymCOlds+SGMkyeCUs6daBJilQ9
VQIDAQAB
-----END csdn_PublicKey-----

package main

import (
 "crypto/rand"
 "crypto/rsa"
 "crypto/x509"
 "encoding/hex"
 "encoding/pem"
 "fmt"
 "os"
)

func Getkeys() {
 //得到私钥
 privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
 //通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
 x509_Privatekey := x509.MarshalPKCS1PrivateKey(privateKey)
 //创建一个用来保存私钥的以.pem结尾的文件
 fp, _ := os.Create("csdn_private.pem")
 defer fp.Close()
 //将私钥字符串设置到pem格式块中
 pem_block := pem.Block{
 Type: "csdn_privateKey",
 Bytes: x509_Privatekey,
 }
 //转码为pem并输出到文件中
 pem.Encode(fp, &pem_block)

 //处理公钥,公钥包含在私钥中
 publickKey := privateKey.PublicKey
 //接下来的处理方法同私钥
 //通过x509标准将得到的ras私钥序列化为ASN.1 的 DER编码字符串
 x509_PublicKey, _ := x509.MarshalPKIXPublicKey(&publickKey)
 pem_PublickKey := pem.Block{
 Type: "csdn_PublicKey",
 Bytes: x509_PublicKey,
 }
 file, _ := os.Create("csdn_PublicKey.pem")
 defer file.Close()
 //转码为pem并输出到文件中
 pem.Encode(file, &pem_PublickKey)

}

//使用公钥进行加密
func RSA_encrypter(path string, msg []byte) []byte {
 //首先从文件中提取公钥
 fp, _ := os.Open(path)
 defer fp.Close()
 //测量文件长度以便于保存
 fileinfo, _ := fp.Stat()
 buf := make([]byte, fileinfo.Size())
 fp.Read(buf)
 //下面的操作是与创建秘钥保存时相反的
 //pem解码
 block, _ := pem.Decode(buf)
 //x509解码,得到一个interface类型的pub
 pub, _ := x509.ParsePKIXPublicKey(block.Bytes)
 //加密操作,需要将接口类型的pub进行类型断言得到公钥类型
 cipherText, _ := rsa.EncryptPKCS1v15(rand.Reader, pub.(*rsa.PublicKey), msg)
 return cipherText
}

//使用私钥进行解密
func RSA_decrypter(path string, cipherText []byte) []byte {
 //同加密时，先将私钥从文件中取出，进行二次解码
 fp, _ := os.Open(path)
 defer fp.Close()
 fileinfo, _ := fp.Stat()
 buf := make([]byte, fileinfo.Size())
 fp.Read(buf)
 block, _ := pem.Decode(buf)
 PrivateKey, _ := x509.ParsePKCS1PrivateKey(block.Bytes)
 //二次解码完毕，调用解密函数
 afterDecrypter, _ := rsa.DecryptPKCS1v15(rand.Reader, PrivateKey, cipherText)
 return afterDecrypter
}

func main() {

 // Getkeys()

 //尝试调用
 msg := []byte("RSA非对称加密很棒")
 ciphertext := RSA_encrypter("csdn_PublicKey.pem", msg)
 //转化为十六进制方便查看结果
 fmt.Println(hex.EncodeToString(ciphertext))
 result := RSA_decrypter("csdn_private.pem", ciphertext)
 fmt.Println(string(result))

}

stdin-stdout-stderr

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "fmt"
)

func main() {
 v1 := "123"
 v2 := 123
 v3 := "Have a nice day\n"
 v4 := "abc"
 fmt.Print(v1, v2, v3, v4)
 fmt.Println()
 fmt.Println(v1, v2, v3, v4)
 fmt.Print(v1, " ", v2, " ", v3, " ", v4, "\n")
 fmt.Printf("%s%d %s %s\n", v1, v2, v3, v4)
}

stderr

package main

import (
 "io"
 "os"
)

func main() {
 myString := ""
 arguments := os.Args
 if len(arguments) == 1 {
 myString = "Please give me one argument!"
 } else {
 myString = arguments[1]
 }
 io.WriteString(os.Stdout, "This is Standard output\n")
 io.WriteString(os.Stderr, myString)
 io.WriteString(os.Stderr, "\n")
}

stdin

package main

import (
 "bufio"
 "fmt"
 "os"
)

func main() {
 var f *os.File
 f = os.Stdin
 defer f.Close()
 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 fmt.Println(">", scanner.Text())
 }
}

stdin-command-line

package main

import (
 "fmt"
 "os"
 "strconv"
)

func main() {
 if len(os.Args) == 1 {
 fmt.Println("Please give one or more floats.")
 os.Exit(1)
 }

 arguments := os.Args
 min, _ := strconv.ParseFloat(arguments[1], 64)
 max, _ := strconv.ParseFloat(arguments[1], 64)
 for i := 2; i < len(arguments); i++ {
 n, _ := strconv.ParseFloat(arguments[i], 64)
 if n < min {
 min = n
 }
 if n > max {
 max = n
 }
 }
 fmt.Println("Min:", min)
 fmt.Println("Max:", max)
}

stdout

package main

import (
 "io"
 "os"
)

func main() {
 myString := ""
 arguments := os.Args
 if len(arguments) == 1 {
 myString = "Please give me one argument!"
 } else {
 myString = arguments[1]
 }
 io.WriteString(os.Stdout, myString)
 io.WriteString(os.Stdout, "\n")
}

UDP简单的示例

Mon, 01 Jan 0001 00:00:00 +0000


package main

import (
 "context"
 "encoding/hex"
 "fmt"
 "log"
 "net"
 "time"
)

func main() {
 // 本质上udp不存在传统意义上的服务端和客户端， 他其实是无连接的。
 // 但是实际使用中， 总要有一方去监听数据， 另一方去连接所以才有了 一个服务 一个客户

 // 创建一个监听服务
 // conn, err := net.Dial("udp", ":30000")
 // conn, err := net.DialUDP("udp", &net.UDPAddr{
 // IP: net.ParseIP("0.0.0.0"),
 // Port: 45103,
 // }, &net.UDPAddr{
 // IP: net.ParseIP("127.0.0.1"),
 // Port: 30000,
 // })

 // 连接已经创建的服务
 conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
 IP: net.ParseIP("127.0.0.1"),
 Port: 30000,
 })

 if err != nil {
 log.Fatalf("连接建立错误: %s", err.Error())
 return
 }
 defer conn.Close()

 //7F06FE01993FFF3C16
 //7F32F601143801001F0250000100000000000000000000000000000000323030B7C2D8BB353030FABBF7D63130381411111501893E
 //7F32F60115384000200250000100000000000000000000000000000000323030B7C2D8BB353030FABBF7D631303814111115012F09

 // go func() {
 // 创建一个计时器
 timeTickerChan := time.Tick(time.Second * 2)
 ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Millisecond*800))
 defer cancel()
 for {
 select {
 case <-timeTickerChan:
 input, err := hex.DecodeString("7F06FE01993FFF3C16")
 if err != nil {
 fmt.Printf("输入值解码错误：%s\n", err.Error())
 continue
 }

 //客户端请求数据写入 conn，并传输
 conn.WriteToUDP([]byte(input), &net.UDPAddr{
 IP: net.ParseIP("10.10.10.4"),
 Port: 8887,
 })
 writeCount, err := conn.Write([]byte(input))
 if err != nil {
 log.Printf("数据发送错误：%s\n", err.Error())
 continue
 }
 log.Printf("输入值：%s; 发送量: %d\n", string(input), writeCount)

 go func(ctx context.Context) {
 //服务器端返回的数据写入空buf
 buf := make([]byte, 1024)
 // conn.ReadFrom()
 // conn.ReadFromUDP()
 cnt, serverAddr, err := conn.ReadFrom(buf)
 if err != nil {
 log.Printf("客户端读取数据失败 %s\n", err)
 return
 }
 //回显服务器端回传的信息
 log.Printf("服务器端回复: %s; 服务端信息：%s", hex.EncodeToString(buf[0:cnt]), serverAddr.String())
 }(ctx)

 select {
 case <-ctx.Done():
 fmt.Println("call successfully!!!")
 continue
 case <-time.After(time.Duration(time.Millisecond * 900)):
 fmt.Println("timeout!!!")
 continue
 }

 // input, _ = hex.DecodeString("7F32F601143801001F0250000100000000000000000000000000000000323030B7C2D8BB353030FABBF7D63130381411111501893E")
 // log.Printf("输入值：%v\n", input)
 // //客户端请求数据写入 conn，并传输
 // conn.Write([]byte(input))
 // //服务器端返回的数据写入空buf
 // cnt, err = conn.Read(buf)
 // if err != nil {
 // log.Printf("客户端读取数据失败 %s\n", err)
 // continue
 // }
 // //回显服务器端回传的信息
 // log.Printf("服务器端回复" + hex.EncodeToString(buf[0:cnt]) + "\n")

 // input, _ = hex.DecodeString("7F32F60115384000200250000100000000000000000000000000000000323030B7C2D8BB353030FABBF7D631303814111115012F09")
 // log.Printf("输入值：%v\n", input)
 // //客户端请求数据写入 conn，并传输
 // conn.Write([]byte(input))
 // //服务器端返回的数据写入空buf
 // cnt, err = conn.Read(buf)
 // if err != nil {
 // log.Printf("客户端读取数据失败 %s\n", err)
 // continue
 // }
 // //回显服务器端回传的信息
 // log.Printf("服务器端回复" + hex.EncodeToString(buf[0:cnt]) + "\n")
 }
 }

 // }()

}

websocket-client

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "encoding/json"
 "fmt"
 "log"
 "net/url"
 "sync"
 "time"

 "github.com/gorilla/websocket"
)

var mutex sync.Mutex

func main() {
 // u := url.URL{Scheme: "ws", Host: "8.136.204.163:8000"}
 u := url.URL{Scheme: "ws", Host: "localhost:8001"}
 c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
 if err != nil {
 log.Fatalf("%+v", err)
 }
 defer c.Close()
 // c.SetCloseHandler(func(code int, text string) error {
 // fmt.Printf("SetCloseHandler %d:%s", code, text)
 // // message := websocket.FormatCloseMessage(code, "")
 // // c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
 // return nil
 // })
 // c.SetPingHandler(func(appData string) error {
 // fmt.Printf("SetPingHandler %s", appData)
 // return nil
 // })
 // c.SetPongHandler(func(appData string) error {
 // fmt.Printf("SetPingHandler %s", appData)
 // return nil
 // })

 pingParam := make(map[string]interface{})
 pingParam["msgId"] = 3
 pingParam["action"] = "Heartbeat"
 pingData := make(map[string]interface{})
 pingData["echo"] = "ping"
 pingParam["data"] = pingData

 param := make(map[string]interface{})
 param["msgId"] = 2
 param["action"] = "Login"
 data := make(map[string]interface{})
 data["authName"] = "taian"
 data["authToken"] = "7ee193f504125d7d9e715e0252648856"
 data["clientName"] = "taian123"
 param["data"] = data
 mutex.Lock()
 c.WriteJSON(param)
 mutex.Unlock()

 // res := make(map[string]interface{})
 // err1 := c.ReadJSON(&res)
 // if err1 != nil {
 // fmt.Printf("%+v\n", err1)
 // log.Fatalln(err1)
 // }
 // bs, _ := json.Marshal(res)
 // log.Printf("%s\n", string(bs))

 // mutex.Lock()
 // err0 := c.WriteJSON(pingParam)
 // mutex.Unlock()
 // if err0 != nil {
 // log.Fatalf("写ping命令ERR：%+v\n", err1)
 // }

 // res = make(map[string]interface{})
 // err1 = c.ReadJSON(&res)
 // if err1 != nil {
 // log.Fatalf("读ping命令ERR: %+v\n", err1)
 // }
 // bs, _ = json.Marshal(res)
 // log.Printf("%s\n", string(bs))

 go func() {
 t := time.NewTicker(time.Second * 4)
 defer t.Stop()
 for {
 <-t.C
 mutex.Lock()
 c.WriteJSON(pingParam)
 mutex.Unlock()
 }
 }()

 go func() {
 for {
 res := make(map[string]interface{})
 err1 := c.ReadJSON(&res)
 if err1 != nil {
 fmt.Printf("%+v\n", err1)
 continue
 }
 bs, _ := json.Marshal(res)
 log.Printf("%s\n", string(bs))
 }

 }()

 // param["action"] = "GetDevice"
 // data = make(map[string]interface{})
 // data["index"] = 1
 // data["count"] = -1

 param0 := make(map[string]interface{})
 param0["msgId"] = 4
 param0["action"] = "RegDeviceData"
 data0 := make(map[string]interface{})
 data0["names"] = []string{"S01"}
 data0["count"] = 1
 param0["data"] = data0

 mutex.Lock()
 err0 := c.WriteJSON(param0)
 mutex.Unlock()
 if err0 != nil {
 log.Fatalf("%+v", err0)
 }

 param1 := make(map[string]interface{})
 param1["msgId"] = 4
 param1["action"] = "GetRealDeviceData"
 data1 := make(map[string][]string)
 data1["names"] = []string{"S01"}
 param1["data"] = data1

 mutex.Lock()
 err1 := c.WriteJSON(param1)
 mutex.Unlock()
 if err1 != nil {
 log.Fatalf("%+v", err1)
 }
 select {}
}

xorm连接mssql

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 xorm.io/xorm v1.0.2
)

main.go

package main

import (
 "flag"
 "fmt"
 "time"

 _ "github.com/denisenkom/go-mssqldb"
 "xorm.io/xorm"
)

type Park struct {
 ID string `xorm:"Id"`
 Name string `xorm:"Name"`
}

var (
 debug = flag.Bool("debug", true, "enable debugging")
 password = flag.String("password", "123456", "the database password")
 port *int = flag.Int("port", 1433, "the database port")
 server = flag.String("server", "10.10.10.53", "the database server")
 user = flag.String("user", "sa", "the database user")
)

func main() {

 connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=ed;encrypt=disable", *server, *user, *password, *port)
 engine, err := xorm.NewEngine("mssql", connString)
 //控制台打印SQL语句

 if err != nil {
 fmt.Println(err)
 return
 }
 defer engine.Close()
 engine.SetConnMaxLifetime(120 * time.Second)
 engine.SetMaxOpenConns(16)
 engine.SetMaxIdleConns(8)

 err = engine.Ping()
 if err != nil {
 fmt.Println(err)
 return
 }
 var sv []Park
 engine.ShowSQL(true)

 // err = engine.SQL("SELECT TOP 1000 id,CardCname FROM Dt_CardType order by id asc").Find(&sv)
 engine.Find(&sv)
 if err != nil {
 fmt.Println(err)
 return
 }
 fmt.Println(len(sv))
}

遍历字符串

Mon, 01 Jan 0001 00:00:00 +0000

package main

import "fmt"

func main() {
 var str = "Hello北京&"

 //1. 按index遍历,这种方式按照字节遍历，对于非ASCII字符会出现乱码。因为"北京"每个字占3个字节
 fmt.Println("按index遍历开始")
 for i := 0; i < len(str); i++ {
 fmt.Printf("%d:%c--", i, str[i])
 }
 fmt.Println("按index遍历结束")

 //2. 用for-range遍历,这种方式是按照字符遍历的，不会出现乱码，但是下标index会出现不连续的情况，它具有不确定性
 fmt.Println("for-range遍历开始")
 for i, ch := range str {
 fmt.Printf("%d:%c--", i, ch)
 }
 fmt.Println("for-range遍历结束")

 //3. 转rune切片遍历
 fmt.Println("转rune切片遍历开始")
 str2 := []rune(str)
 for i := 0; i < len(str2); i++ {
 fmt.Printf("%d:%c--", i, str2[i])
 }
 fmt.Println("\n转rune切片遍历结束")
}

定时执行

Mon, 01 Jan 0001 00:00:00 +0000

最简单的定时执行

package main

import (
 "fmt"
 "time"
)

func main() {

 go func() {
 // 创建一个计时器
 timeTickerChan := time.Tick(time.Second * 5)
 for {
 fmt.Println("123")
 <-timeTickerChan
 }
 }()

 fmt.Println(112233)
 //一定要阻止主线程退出定时任务才能有效
 select {}
}

cron定时执行

require github.com/robfig/cron/v3 v3.0.1

package main

import (
 "fmt"
 "github.com/robfig/cron/v3"
 "time"
)

func main() {
 // 新建一个定时任务对象
 // 根据cron表达式进行时间调度，cron可以精确到秒，大部分表达式格式也是从秒开始。
 //crontab := cron.New() 默认从分开始进行时间调度
 crontab := cron.New(cron.WithSeconds()) //精确到秒
 //定义定时器调用的任务函数
 task := func() {
 fmt.Println("hello world", time.Now())
 }
 //定时任务
 spec := "*/5 * * * * ?" //cron表达式，每五秒一次
 // 添加定时任务,
 crontab.AddFunc(spec, task)
 // 启动定时器
 crontab.Start()
 // 定时任务是另起协程执行的,这里使用 select 简答阻塞.实际开发中需要
 // 根据实际情况进行控制
 select {} //阻塞主线程停止
}

读MySQL数据库所有表并输出见表语句

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "fmt"

 "gorm.io/driver/mysql"
 "gorm.io/gorm"
)

type ShowTablesRes struct {
 // 注意这里也要改数据库名
 TableName string `gorm:"column:Tables_in_${database}"`
}
type CreateRes struct {
 Table string
 CreateTable string `gorm:"column:Create Table"`
}

func main() {

 dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", "${username}", "${password}", "${ip}:${port}", "${database}")
 // useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=true&serverTimezone=GMT%2B8"
 fmt.Println(dsn)

 db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
 if err != nil {
 panic("failed to connect database")
 }


 var showTablesRes []ShowTablesRes
 db.Raw("show tables").Scan(&showTablesRes)
 // fmt.Println(&showTablesRes)
 for _, v := range showTablesRes {
 // fmt.Printf("%s\n", v.TableName)
 var createRes []CreateRes
 showTableStruct := "show create table " + v.TableName
 db.Raw(showTableStruct).Scan(&createRes)
 fmt.Printf("%s;\n", createRes[0].CreateTable)

 }

}

链接sqlserver2008

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 github.com/go-ole/go-ole v1.2.4 // indirect
 github.com/mattn/go-adodb v0.0.1 // indirect
 golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect
)

package main

import (
 "database/sql"
 "fmt"
 "log"

 _ "github.com/denisenkom/go-mssqldb"
)

// var (
// debug = flag.Bool("debug", true, "enable debugging")
// password = flag.String("password", "123456", "the database password")
// port *int = flag.Int("port", 1433, "the database port")
// server = flag.String("server", "10.10.10.53", "the database server")
// user = flag.String("user", "sa", "the database user")
// )

func main() {
 // var debug = flag.Bool("debug", false, "enable debugging")
 // var password = flag.String("password", "123456", "the database password")
 // var port *int = flag.Int("port", 1433, "the database port")
 // var server = flag.String("server", "10.10.10.53", "the database server")
 // var user = flag.String("user", "sa", "the database user")
 // var database = flag.String("database", "ed", "the database name")

 // if *debug {
 // fmt.Printf(" password:%s\n", *password)
 // fmt.Printf(" port:%d\n", *port)
 // fmt.Printf(" server:%s\n", *server)
 // fmt.Printf(" user:%s\n", *user)
 // }
 connString := fmt.Sprintf("server=%s;database=%s;user id=%s;password=%s;port=%d;encrypt=disable", "10.10.10.53", "ed", "sa", "123456", 1433)

 fmt.Printf(" connString:%s\n", connString)

 db, err := sql.Open("mssql", connString)
 if err != nil {
 log.Fatal("Open connection failed:", err.Error())
 return
 }

 err = db.Ping()
 if err != nil {
 fmt.Print("PING:%s", err)
 return
 }
 fmt.Println(1)
}

使用redis

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "fmt"
 "log"
 "math/rand"
 "sync"
 "time"

 "github.com/go-redis/redis"
)

var redisdb *redis.Client
var wg sync.WaitGroup

func main() {
 wg.Add(1)
 go testRedisBase()
 wg.Wait()
}

var map1 map[string]string

func testRedisBase() {
 defer wg.Done()

 //连接服务器
 redisdb = redis.NewClient(&redis.Options{
 Addr: "localhost:6379", // use default Addr
 Password: "", // no password set
 DB: 0, // use default DB
 })

 //心跳
 pong, err := redisdb.Ping().Result()
 log.Println(pong, err) // Output: PONG <nil>

 result, err := redisdb.BLPop(10*time.Second, "list_test").Result()
 log.Println("result:", result, err, len(result))

 ch := make(chan struct{})
 map1 = make(map[string]string)
 go func() {
 for {
 content, _ := redisdb.BLPop(10*time.Second, "list_test").Result()
 if content != nil {
 ch <- struct{}{}
 map1[content[1]] = content[1]
 }
 }
 }()

 for {
 <-ch
 for k, v := range map1 {
 log.Println(k, ":", v)
 }
 if _, ok := map1["1"]; ok {
 log.Println(map1["1"])
 }
 delete(map1, "1")
 for k, v := range map1 {
 log.Println(k, ":", v)
 }
 }

 // ExampleClient_String()
 // ExampleClient_List()
 // ExampleClient_Hash()
 // ExampleClient_Set()
 // ExampleClient_SortSet()
 // ExampleClient_HyperLogLog()
 // ExampleClient_CMD()
 // ExampleClient_Scan()
 // ExampleClient_Tx()
 // ExampleClient_Script()
 // ExampleClient_PubSub()
}

func ExampleClient_String() {
 log.Println("ExampleClient_String")
 defer log.Println("ExampleClient_String")

 //kv读写
 err := redisdb.Set("key", "value", 1*time.Second).Err()
 log.Println(err)

 //获取过期时间
 tm, err := redisdb.TTL("key").Result()
 log.Println(tm)

 val, err := redisdb.Get("key").Result()
 log.Println(val, err)

 val2, err := redisdb.Get("missing_key").Result()
 if err == redis.Nil {
 log.Println("missing_key does not exist")
 } else if err != nil {
 log.Println("missing_key", val2, err)
 }

 //不存在才设置 过期时间 nx ex
 value, err := redisdb.SetNX("counter", 0, 1*time.Second).Result()
 log.Println("setnx", value, err)

 //Incr
 result, err := redisdb.Incr("counter").Result()
 log.Println("Incr", result, err)
}

func ExampleClient_List() {
 log.Println("ExampleClient_List")
 defer log.Println("ExampleClient_List")

 //添加
 log.Println(redisdb.RPush("list_test", "message1").Err())
 log.Println(redisdb.RPush("list_test", "message2").Err())

 //设置
 log.Println(redisdb.LSet("list_test", 2, "message set").Err())

 //remove
 ret, err := redisdb.LRem("list_test", 3, "message1").Result()
 log.Println(ret, err)

 rLen, err := redisdb.LLen("list_test").Result()
 log.Println(rLen, err)

 //遍历
 lists, err := redisdb.LRange("list_test", 0, rLen-1).Result()
 log.Println("LRange", lists, err)

 //pop没有时阻塞
 result, err := redisdb.BLPop(30*time.Second, "list_test").Result()
 log.Println("result:", result, err, len(result))
}

func ExampleClient_Hash() {
 log.Println("ExampleClient_Hash")
 defer log.Println("ExampleClient_Hash")

 datas := map[string]interface{}{
 "name": "LI LEI",
 "sex": 1,
 "age": 28,
 "tel": 123445578,
 }

 //添加
 if err := redisdb.HMSet("hash_test", datas).Err(); err != nil {
 log.Fatal(err)
 }

 //获取
 rets, err := redisdb.HMGet("hash_test", "name", "sex").Result()
 log.Println("rets:", rets, err)

 //成员
 retAll, err := redisdb.HGetAll("hash_test").Result()
 log.Println("retAll", retAll, err)

 //存在
 bExist, err := redisdb.HExists("hash_test", "tel").Result()
 log.Println(bExist, err)

 bRet, err := redisdb.HSetNX("hash_test", "id", 100).Result()
 log.Println(bRet, err)

 //删除
 log.Println(redisdb.HDel("hash_test", "age").Result())
}

func ExampleClient_Set() {
 log.Println("ExampleClient_Set")
 defer log.Println("ExampleClient_Set")

 //添加
 ret, err := redisdb.SAdd("set_test", "11", "22", "33", "44").Result()
 log.Println(ret, err)

 //数量
 count, err := redisdb.SCard("set_test").Result()
 log.Println(count, err)

 //删除
 ret, err = redisdb.SRem("set_test", "11", "22").Result()
 log.Println(ret, err)

 //成员
 members, err := redisdb.SMembers("set_test").Result()
 log.Println(members, err)

 bret, err := redisdb.SIsMember("set_test", "33").Result()
 log.Println(bret, err)

 redisdb.SAdd("set_a", "11", "22", "33", "44")
 redisdb.SAdd("set_b", "11", "22", "33", "55", "66", "77")
 //差集
 diff, err := redisdb.SDiff("set_a", "set_b").Result()
 log.Println(diff, err)

 //交集
 inter, err := redisdb.SInter("set_a", "set_b").Result()
 log.Println(inter, err)

 //并集
 union, err := redisdb.SUnion("set_a", "set_b").Result()
 log.Println(union, err)

 ret, err = redisdb.SDiffStore("set_diff", "set_a", "set_b").Result()
 log.Println(ret, err)

 rets, err := redisdb.SMembers("set_diff").Result()
 log.Println(rets, err)
}

func ExampleClient_SortSet() {
 log.Println("ExampleClient_SortSet")
 defer log.Println("ExampleClient_SortSet")

 addArgs := make([]redis.Z, 100)
 for i := 1; i < 100; i++ {
 addArgs = append(addArgs, redis.Z{Score: float64(i), Member: fmt.Sprintf("a_%d", i)})
 }
 //log.Println(addArgs)

 Shuffle := func(slice []redis.Z) {
 r := rand.New(rand.NewSource(time.Now().Unix()))
 for len(slice) > 0 {
 n := len(slice)
 randIndex := r.Intn(n)
 slice[n-1], slice[randIndex] = slice[randIndex], slice[n-1]
 slice = slice[:n-1]
 }
 }

 //随机打乱
 Shuffle(addArgs)

 //添加
 ret, err := redisdb.ZAddNX("sortset_test", addArgs...).Result()
 log.Println(ret, err)

 //获取指定成员score
 score, err := redisdb.ZScore("sortset_test", "a_10").Result()
 log.Println(score, err)

 //获取制定成员的索引
 index, err := redisdb.ZRank("sortset_test", "a_50").Result()
 log.Println(index, err)

 count, err := redisdb.SCard("sortset_test").Result()
 log.Println(count, err)

 //返回有序集合指定区间内的成员
 rets, err := redisdb.ZRange("sortset_test", 10, 20).Result()
 log.Println(rets, err)

 //返回有序集合指定区间内的成员分数从高到低
 rets, err = redisdb.ZRevRange("sortset_test", 10, 20).Result()
 log.Println(rets, err)

 //指定分数区间的成员列表
 rets, err = redisdb.ZRangeByScore("sortset_test", redis.ZRangeBy{Min: "(30", Max: "(50", Offset: 1, Count: 10}).Result()
 log.Println(rets, err)
}

//用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。
//每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数
func ExampleClient_HyperLogLog() {
 log.Println("ExampleClient_HyperLogLog")
 defer log.Println("ExampleClient_HyperLogLog")

 for i := 0; i < 10000; i++ {
 redisdb.PFAdd("pf_test_1", fmt.Sprintf("pfkey%d", i))
 }
 ret, err := redisdb.PFCount("pf_test_1").Result()
 log.Println(ret, err)

 for i := 0; i < 10000; i++ {
 redisdb.PFAdd("pf_test_2", fmt.Sprintf("pfkey%d", i))
 }
 ret, err = redisdb.PFCount("pf_test_2").Result()
 log.Println(ret, err)

 redisdb.PFMerge("pf_test", "pf_test_2", "pf_test_1")
 ret, err = redisdb.PFCount("pf_test").Result()
 log.Println(ret, err)
}

func ExampleClient_PubSub() {
 log.Println("ExampleClient_PubSub")
 defer log.Println("ExampleClient_PubSub")
 //发布订阅
 pubsub := redisdb.Subscribe("subkey")
 _, err := pubsub.Receive()
 if err != nil {
 log.Fatal("pubsub.Receive")
 }
 ch := pubsub.Channel()
 time.AfterFunc(1*time.Second, func() {
 log.Println("Publish")

 err = redisdb.Publish("subkey", "test publish 1").Err()
 if err != nil {
 log.Fatal("redisdb.Publish", err)
 }

 redisdb.Publish("subkey", "test publish 2")
 })
 for msg := range ch {
 log.Println("recv channel:", msg.Channel, msg.Pattern, msg.Payload)
 }
}

func ExampleClient_CMD() {
 log.Println("ExampleClient_CMD")
 defer log.Println("ExampleClient_CMD")

 //执行自定义redis命令
 Get := func(rdb *redis.Client, key string) *redis.StringCmd {
 cmd := redis.NewStringCmd("get", key)
 redisdb.Process(cmd)
 return cmd
 }

 v, err := Get(redisdb, "NewStringCmd").Result()
 log.Println("NewStringCmd", v, err)

 v, err = redisdb.Do("get", "redisdb.do").String()
 log.Println("redisdb.Do", v, err)
}

func ExampleClient_Scan() {
 log.Println("ExampleClient_Scan")
 defer log.Println("ExampleClient_Scan")

 //scan
 for i := 1; i < 1000; i++ {
 redisdb.Set(fmt.Sprintf("skey_%d", i), i, 0)
 }

 cusor := uint64(0)
 for {
 keys, retCusor, err := redisdb.Scan(cusor, "skey_*", int64(100)).Result()
 log.Println(keys, cusor, err)
 cusor = retCusor
 if cusor == 0 {
 break
 }
 }
}

func ExampleClient_Tx() {
 pipe := redisdb.TxPipeline()
 incr := pipe.Incr("tx_pipeline_counter")
 pipe.Expire("tx_pipeline_counter", time.Hour)

 // Execute
 //
 // MULTI
 // INCR pipeline_counter
 // EXPIRE pipeline_counts 3600
 // EXEC
 //
 // using one rdb-server roundtrip.
 _, err := pipe.Exec()
 fmt.Println(incr.Val(), err)
}

func ExampleClient_Script() {
 IncrByXX := redis.NewScript(`
 if redis.call("GET", KEYS[1]) ~= false then
 return redis.call("INCRBY", KEYS[1], ARGV[1])
 end
 return false
 `)

 n, err := IncrByXX.Run(redisdb, []string{"xx_counter"}, 2).Result()
 fmt.Println(n, err)

 err = redisdb.Set("xx_counter", "40", 0).Err()
 if err != nil {
 panic(err)
 }

 n, err = IncrByXX.Run(redisdb, []string{"xx_counter"}, 2).Result()
 fmt.Println(n, err)
}

支持RabbitMQ的AMQP

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "log"

 "github.com/streadway/amqp"
)

func failOnError(err error, msg string) {
 if err != nil {
 log.Fatalf("%s: %s", msg, err)
 }
}

func main() {
 // 连接 RabbitMQ
 conn, err := amqp.Dial("amqp://admin:admin@127.0.0.1:5673")
 failOnError(err, "连接失败")
 defer conn.Close()

 // 建立一个 channel ( 其实就是TCP连接 ）
 ch, err := conn.Channel()
 failOnError(err, "打开通道失败")
 defer ch.Close()

 // 创建一个名字叫 "hello" 的队列
 q, err := ch.QueueDeclare(
 "hello", // name
 false, // durable
 false, // delete when unused
 false, // exclusive
 false, // no-wait
 nil, // arguments
 )
 failOnError(err, "创建队列失败")

 // 构建一个消息
 body := "Hello World!"
 msg := amqp.Publishing{
 ContentType: "text/plain",
 Body: []byte(body),
 }

 // 构建一个生产者，将消息 放入队列
 err = ch.Publish(
 "", // exchange
 q.Name, // routing key
 false, // mandatory
 false, // immediate
 msg)
 log.Printf(" [x] Sent %s", body)
 failOnError(err, "Failed to publish a message")
}