Golang redis.Client类代码示例

func PutRedisClient(client *redis.Client) {
	if RedisClientPool == nil {
		RedisClientPool = make(chan *redis.Client, MAX_POOL_SIZE)
	}
	if len(RedisClientPool) >= MAX_POOL_SIZE {
		client.Quit()
		return
	}
	RedisClientPool <- client
}

func handler(p *httputil.ReverseProxy, redisClient *redis.Client) func(http.ResponseWriter, *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {

		hash := hashKey(r)

		serializableResponse := SerializableResponse{make(map[string][]string), nil}

		s, err := redisClient.Get(hash)
		if err != nil { // The request is not cached
			rec := httptest.NewRecorder()
			log.Println("Non cached: " + hash)

			// Perform the real request and cache it
			p.ServeHTTP(rec, r)

			for k, v := range rec.Header() {
				serializableResponse.Header[k] = v
			}
			serializableResponse.Body = rec.Body.Bytes()

			jsonResponse, err := json.Marshal(serializableResponse)
			if err != nil {
				panic(err)
			}
			redisClient.Set(hash, jsonResponse)
			w.Header().Set("X-Eidetic", "Live request")

		} else { // The request is cached
			log.Println("Cached!: " + hash)

			// Load the cached request
			err = json.Unmarshal([]byte(s), &serializableResponse)
			if err != nil {
				panic(err)
			}

			w.Header().Set("X-Eidetic", "Cached request")

		}

		//Copy the data to the actual ResponseWriter
		// log.Println("\n\n\nResponse Headers:")
		for k, v := range serializableResponse.Header {
			w.Header()[k] = v
			// log.Println(k + ": ")
			// for _, str := range v {
			// 	log.Println("  " + str)
			// }
		}
		w.Write([]byte(serializableResponse.Body))
		// log.Println("\nResponse body:\n" + string(serializableResponse.Body))

	}
}

func spawnConsumer() error {
	var err error
	var consumer *redis.Client

	consumer = redis.New()

	err = consumer.ConnectNonBlock(host, port)

	if err != nil {
		log.Fatalf("Consumer failed to connect: %s\n", err.Error())
		return err
	}

	log.Println("Consumer connected to redis-server.")

	rec := make(chan []string)

	log.Printf("Consumer will read exactly 6 messages before quitting.\n")

	go consumer.Subscribe(rec, "channel")

	var ls []string

	for j := 0; j < 6; j++ {
		ls = <-rec
		log.Printf("Consumer received message[%d]: %v\n", j, strings.Join(ls, ", "))
	}

	log.Printf("Closing consumer...\n")

	consumer.Quit()

	return nil
}

//初始化redis连接
//传入配置参数
func Init(config ...*Config) {
	config = checkConfig(config)

	for i := 0; i < len(config); i++ {
		var client *redis.Client
		client = redis.New()
		err1 := client.Connect(config[i].Host, config[i].Port)
		log.Println(config[i].Host+":"+strconv.Itoa(int(config[i].Port)), "Connect ...")
		_, err2 := client.Ping()

		if err1 != nil || err2 != nil {
			log.Println("ERROR: Redis Connect failed!")
			os.Exit(0)
		}
		redisSlice = append(redisSlice, client)
		for j := 0; j < len(config[i].Data); j++ {
			structRedis[config[i].Data[j]] = client
		}
	}
}

func (s SerialReader) processSerialData(redisConnection *redis.Client) {
	serialConnection := s.newSerialConnection()
	reader := bufio.NewReader(serialConnection)
	re := regexp.MustCompile("^([^:]+):(.+)$")

	for {
		reply, err := reader.ReadBytes('\n')

		if err != nil {
			log.Printf("processSerialData() #1: %s", err)
			continue
		}

		data := strings.TrimSpace(string(reply))

		if len(data) == 0 {
			continue
		}

		log.Printf("%s", data)
		raw_data := re.FindStringSubmatch(data)

		if len(raw_data) == 0 {
			continue
		}

		metrics := strings.Split(raw_data[2], ",")
		channel := fmt.Sprintf("rpi-moteino-collector:%s", raw_data[1])

		for i := 0; i < len(metrics); i++ {
			metric_key_and_value := strings.Split(metrics[i], ":")

			if len(metric_key_and_value) != 2 {
				continue
			}

			value := fmt.Sprintf("%s,%d,%s", metric_key_and_value[0], uint64(time.Now().Unix()), metric_key_and_value[1])

			_, err := redisConnection.LPush(channel, value)
			if err != nil {
				log.Printf("processSerialData() #2: %s", err)
			}

			_, err = redisConnection.Publish(channel, value)
			if err != nil {
				log.Printf("processSerialData() #3: %s", err)
			}
		}

		_, err = redisConnection.LTrim(channel, 0, 10)
		if err != nil {
			log.Printf("processSerialData() #4: %s", err)
		}
	}
}

func main() {
	var client *redis.Client

	client = redis.New()
	client.Connect("localhost", 6379)

	s, _ := client.Ping()
	fmt.Println(s)
	client.Incr("hello")
	s, _ = client.Get("hello")
	fmt.Println(s)
	client.Quit()
}

func spawnPublisher() error {
	var err error
	var publisher *redis.Client

	publisher = redis.New()

	err = publisher.Connect(host, port)

	if err != nil {
		log.Fatalf("Publisher failed to connect: %s\n", err.Error())
		return err
	}

	log.Println("Publisher connected to redis-server.")

	log.Println("Publishing some messages...")

	publisher.Publish("channel", "Hello world!")
	publisher.Publish("channel", "Do you know how to count?")

	for i := 0; i < 3; i++ {
		publisher.Publish("channel", i)
	}

	log.Printf("Closing publisher...\n")

	publisher.Quit()

	return nil
}