type Integer int   func (a Integer) Less(b Integer) bool {     return a < b  }  func main() {     var a Integer = 1       if a.Less(2) {         fmt.Println("less then 2")     }    }

func (r ReceiverType) funcName(parameters) (results)

funcName(r, parameters);

func (a *Ingeger) Add(b Integer) {     *a += b }  func main() {     var a Integer = 1      a.Add(3)     fmt.Println("a =", a)     //  a = 4 }

func NewRect(x, y, width, height float64) *Rect {     return &Rect{x, y, width, height} }     func main() {     rect1 := NewRect(1,2,10,20)     fmt.Println(rect1.width) }

type Base struct {     name string }  func (base *Base) Set(myname string) {     base.name = myname }  func (base *Base) Get() string {     return base.name }  type Derived struct {     Base     age int  }  func (derived *Derived) Get() (nm string, ag int) {     return derived.name, derived.age }   func main() {     b := &Derived{}      b.Set("sina")     fmt.Println(b.Get()) }

type Base struct {     name string     age int }  func (base *Base) Set(myname string, myage int) {     base.name = myname     base.age = myage }  type Derived struct {     Base     name string }  func main() {     b := &Derived{}      b.Set("sina", 30)     fmt.Println("b.name =",b.name, "\tb.Base.name =", b.Base.name)     fmt.Println("b.age =",b.age, "\tb.Base.age =", b.Base.age) }

b = a b.Modify()

var a = [3] int{1,2,3} var b = a b[1]++ fmt.Println(a, b)   // [1 2 3] [1 3 3]

var a = [3] int{1,2,3} var b = &a　　　　// 引用語義 b[1]++ fmt.Println(a, b)   // [1 3 3] [1 3 3]

type interfaceName interface {       //方法列表   }  

package main      import "fmt"      type Human struct {         name string         age int         phone string     }      type Student struct {         Human //匿名字段         school string         loan float32     }      type Employee struct {         Human //匿名字段         company string         money float32     }      //Human實現SayHi方法     func (h Human) SayHi() {         fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)     }      //Human實現Sing方法     func (h Human) Sing(lyrics string) {         fmt.Println("La la la la...", lyrics)     }      //Employee重載Human的SayHi方法     func (e Employee) SayHi() {         fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,             e.company, e.phone)         }      // Interface Men被Human,Student和Employee實現     // 因為這三個類型都實現了這兩個方法     type Men interface {         SayHi()         Sing(lyrics string)     }      func main() {         mike := Student{Human{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}         paul := Student{Human{"Paul", 26, "111-222-XXX"}, "Harvard", 100}         sam := Employee{Human{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}         tom := Employee{Human{"Tom", 37, "222-444-XXX"}, "Things Ltd.", 5000}          //定義Men類型的變量i         var i Men          //i能存儲Student         i = mike　　　　         fmt.Println("This is Mike, a Student:")         i.SayHi()         i.Sing("November rain")          //i也能存儲Employee         i = tom         fmt.Println("This is tom, an Employee:")         i.SayHi()         i.Sing("Born to be wild")          //定義了slice Men         fmt.Println("Let's use a slice of Men and see what happens")         x := make([]Men, 3)         //這三個都是不同類型的元素，但是他們實現了interface同一個接口         x[0], x[1], x[2] = paul, sam, mike          for _, value := range x{             value.SayHi()         }     }

// 定義a為空接口     var a interface{}     var i int = 5     s := "Hello world"     // a可以存儲任意類型的數值     a = i     a = s

type Element interface{} type List [] Element  type Person struct {     name string     age int  }  //打印 func (p Person) String() string {     return "(name: " + p.name + " - age: "+strconv.Itoa(p.age)+ " years)" }  func main() {     list := make(List, 3)     list[0] = 1 //an int      list[1] = "Hello" //a string     list[2] = Person{"Dennis", 70}       for index, element := range list{         switch value := element.(type) {             case int:                 fmt.Printf("list[%d] is an int and its value is %d\n", index, value)             case string:                 fmt.Printf("list[%d] is a string and its value is %s\n", index, value)             case Person:                 fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)             default:                 fmt.Println("list[%d] is of a different type", index)         }        }    }

func main() {     list := make(List, 3)     list[0] = 1 // an int     list[1] = "Hello" // a string     list[2] = Person{"Dennis", 70}      for index, element := range list {         if value, ok := element.(int); ok {             fmt.Printf("list[%d] is an int and its value is %d\n", index, value)         } else if value, ok := element.(string); ok {             fmt.Printf("list[%d] is a string and its value is %s\n", index, value)         } else if value, ok := element.(Person); ok {             fmt.Printf("list[%d] is a Person and its value is %s\n", index, value)         } else {             fmt.Printf("list[%d] is of a different type\n", index)         }     } }

 t := reflect.TypeOf(i)    //得到類型的元數據,通過t我們能獲取類型定義里面的所有元素  v := reflect.ValueOf(i)   //得到實際的值，通過v我們獲取存儲在里面的值，還可以去改變值

tag := t.Elem().Field(0).Tag  //獲取定義在struct里面的標簽 name := v.Elem().Field(0).String()  //獲取存儲在第一個字段里面的值

var x float64 = 3.4 v := reflect.ValueOf(x) fmt.Println("type:", v.Type()) fmt.Println("kind is float64:", v.Kind() == reflect.Float64) fmt.Println("value:", v.Float())

var x float64 = 3.4 v := reflect.ValueOf(x) v.SetFloat(7.1)

var x float64 = 3.4 p := reflect.ValueOf(&x) v := p.Elem() v.SetFloat(7.1)

以前關注的數據存儲過程不太懂其中奧妙，最近遇到跨數據庫，同時對多個表進行CURD（Create增、Update改、Read讀、Delete刪），怎么才能讓繁瑣的數據CURD同步變得更容易呢？相信很多人會首先想到了MySQL存儲過程、觸發器，這種想法確實不錯。于是饒有興趣地親自寫了CUD（增、改、刪）觸發器的實例，用觸發器實現多表數據同步更新。

定義： 何為MySQL觸發器？

在MySQL Server里面也就是對某一個表的一定的操作，觸發某種條件（Insert,Update,Delete 等），從而自動執行的一段程序。從這種意義上講觸發器是一個特殊的存儲過程。下面通過MySQL觸發器實例，來了解一下觸發器的工作過程吧！

一、創建MySQL實例數據表：

在mysql的默認的測試test數據庫下，創建兩個表t_a與t_b：

在t_a表上分創建一個CUD（增、改、刪）3個觸發器，將t_a的表數據與t_b同步實現CUD，注意創建觸發器每個表同類事件有且僅有一個對應觸發器，為什么只能對一個觸發器，不解釋啦，看MYSQL的說明幫助文檔吧。

二、創建MySQL實例觸發器：

在實例數據表t_a上依次按照下面步驟創建tr_a_insert、tr_a_update、tr_a_delete三個觸發器

1、創建INSERT觸發器trigger_a_insert：

三、測試MySQL實例觸發器：

分別測試實現t_a與t_b實現數據同步CUD(增、改、刪)3個Triggers

1、測試MySQL的實例tr_a_insert觸發器：

在t_a表中新增一條數據，然后分別查詢t_a/t_b表的數據是否數據同步，測試觸發器成功標志，t_a表無論在何種情況下，新增了一條或多條記錄集時，沒有t_b表做任何數據insert操作，它同時新增了一樣的多條記錄集。

下面來進行MySQL觸發器實例測試：

2、測試MySQL的實例tr_a_update、tr_a_delete觸發器：

這兩個MySQL觸發器測試原理、步驟與tr_a_insert觸發器一樣的，先修改/刪除一條數據，然后分別查看t_a、t_b表的數據變化情況，數據變化同步說明Trigger實例成功，否則需要逐步排查錯誤原因。

世界上任何一種事物都其其優點和缺點，優點與缺點是自身一個相對立的面。當然這里不是強調“世界非黑即白”式的“二元論”，“存在即合理”嘛。當然 MySQL觸發器的優點不說了，說一下不足之處，MySQL Trigger沒有很好的調試、管理環境，難于在各種系統環境下測試，測試比MySQL存儲過程要難，所以建議在生成環境下，盡量用存儲過程來代替 MySQL觸發器。

本篇結束前再強調一下，支持觸發器的MySQL版本需要5.0以上，5.0以前版本的MySQL升級到5.0以后版本方可使用觸發器哦！

package com.abin.lee.util;

import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: abin
 * Date: 16-4-18
 * Time: 上午10:24
 * To change this template use File | Settings | File Templates.
 */
public class HttpClientUtil {
    private static CloseableHttpClient httpsClient = null;
    private static CloseableHttpClient httpClient = null;

    static {
        httpClient = getHttpClient();
        httpsClient = getHttpsClient();
    }

    public static CloseableHttpClient getHttpClient() {
        try {
            httpClient = HttpClients.custom()
                    .setConnectionManager(PoolManager.getHttpPoolInstance())
                    .setConnectionManagerShared(true)
                    .setDefaultRequestConfig(requestConfig())
                    .setRetryHandler(retryHandler())
                    .build();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return httpClient;
    }


    public static CloseableHttpClient getHttpsClient() {
        try {
            //Secure Protocol implementation.
 SSLContext ctx = SSLContext.getInstance("SSL");
            //Implementation of a trust manager for X509 certificates
 TrustManager x509TrustManager = new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] xcs,
                                               String string) throws CertificateException {
                }
                public void checkServerTrusted(X509Certificate[] xcs,
                                               String string) throws CertificateException {
                }
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
            };
            ctx.init(null, new TrustManager[]{x509TrustManager}, null);
            //首先設置全局的標準cookie策略
//            RequestConfig requestConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
 ConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(ctx, hostnameVerifier);
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.INSTANCE)
                    .register("https", connectionSocketFactory).build();
            // 設置連接池
 httpsClient = HttpClients.custom()
                    .setConnectionManager(PoolsManager.getHttpsPoolInstance(socketFactoryRegistry))
                    .setConnectionManagerShared(true)
                    .setDefaultRequestConfig(requestConfig())
                    .setRetryHandler(retryHandler())
                    .build();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return httpsClient;
    }

    // 配置請求的超時設置
    //首先設置全局的標準cookie策略
 public static RequestConfig requestConfig(){
        RequestConfig requestConfig = RequestConfig.custom()
                .setCookieSpec(CookieSpecs.STANDARD_STRICT)
                .setConnectionRequestTimeout(20000)
                .setConnectTimeout(20000)
                .setSocketTimeout(20000)
                .build();
        return requestConfig;
    }

    public static HttpRequestRetryHandler retryHandler(){
        //請求重試處理
 HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
            public boolean retryRequest(IOException exception,int executionCount, HttpContext context) {
                if (executionCount >= 5) {// 如果已經重試了5次，就放棄
 return false;
                }
                if (exception instanceof NoHttpResponseException) {// 如果服務器丟掉了連接，那么就重試
 return true;
                }
                if (exception instanceof SSLHandshakeException) {// 不要重試SSL握手異常
 return false;
                }
                if (exception instanceof InterruptedIOException) {// 超時
 return false;
                }
                if (exception instanceof UnknownHostException) {// 目標服務器不可達
 return false;
                }
                if (exception instanceof ConnectTimeoutException) {// 連接被拒絕
 return false;
                }
                if (exception instanceof SSLException) {// ssl握手異常
 return false;
                }

                HttpClientContext clientContext = HttpClientContext.adapt(context);
                HttpRequest request = clientContext.getRequest();
                // 如果請求是冪等的，就再次嘗試
 if (!(request instanceof HttpEntityEnclosingRequest)) {
                    return true;
                }
                return false;
            }
        };
        return httpRequestRetryHandler;
    }



    //創建HostnameVerifier
    //用于解決javax.net.ssl.SSLException: hostname in certificate didn't match: <123.125.97.66> != <123.125.97.241>
 static HostnameVerifier hostnameVerifier = new NoopHostnameVerifier(){
        @Override
 public boolean verify(String s, SSLSession sslSession) {
            return super.verify(s, sslSession);
        }
    };


    public static class PoolManager {
        public static PoolingHttpClientConnectionManager clientConnectionManager = null;
        private static int maxTotal = 200;
        private static int defaultMaxPerRoute = 100;

        private PoolManager(){
            clientConnectionManager.setMaxTotal(maxTotal);
            clientConnectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);
        }

        private static class PoolManagerHolder{
            public static  PoolManager instance = new PoolManager();
        }

        public static PoolManager getInstance() {
            if(null == clientConnectionManager)
                clientConnectionManager = new PoolingHttpClientConnectionManager();
            return PoolManagerHolder.instance;
        }

        public static PoolingHttpClientConnectionManager getHttpPoolInstance() {
            PoolManager.getInstance();
//            System.out.println("getAvailable=" + clientConnectionManager.getTotalStats().getAvailable());
//            System.out.println("getLeased=" + clientConnectionManager.getTotalStats().getLeased());
//            System.out.println("getMax=" + clientConnectionManager.getTotalStats().getMax());
//            System.out.println("getPending="+clientConnectionManager.getTotalStats().getPending());
 return PoolManager.clientConnectionManager;
        }


    }

    public static class PoolsManager {
        public static PoolingHttpClientConnectionManager clientConnectionManager = null;
        private static int maxTotal = 200;
        private static int defaultMaxPerRoute = 100;

        private PoolsManager(){
            clientConnectionManager.setMaxTotal(maxTotal);
            clientConnectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);
        }

        private static class PoolsManagerHolder{
            public static  PoolsManager instance = new PoolsManager();
        }

        public static PoolsManager getInstance(Registry<ConnectionSocketFactory> socketFactoryRegistry) {
            if(null == clientConnectionManager)
                clientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            return PoolsManagerHolder.instance;
        }

        public static PoolingHttpClientConnectionManager getHttpsPoolInstance(Registry<ConnectionSocketFactory> socketFactoryRegistry) {
            PoolsManager.getInstance(socketFactoryRegistry);
//            System.out.println("getAvailable=" + clientConnectionManager.getTotalStats().getAvailable());
//            System.out.println("getLeased=" + clientConnectionManager.getTotalStats().getLeased());
//            System.out.println("getMax=" + clientConnectionManager.getTotalStats().getMax());
//            System.out.println("getPending="+clientConnectionManager.getTotalStats().getPending());
 return PoolsManager.clientConnectionManager;
        }

    }

    public static String httpPost(Map<String, String> request, String httpUrl){
        String result = "";
        CloseableHttpClient httpClient = getHttpClient();
        try {
            if(MapUtils.isEmpty(request))
                throw new Exception("請求參數不能為空");
            HttpPost httpPost = new HttpPost(httpUrl);
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            for(Iterator<Map.Entry<String, String>> iterator=request.entrySet().iterator(); iterator.hasNext();){
                Map.Entry<String, String> entry = iterator.next();
                nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));
            System.out.println("Executing request: " + httpPost.getRequestLine());
            CloseableHttpResponse response = httpClient.execute(httpPost);
            result = EntityUtils.toString(response.getEntity());
            System.out.println("Executing response: "+ result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static String httpPost(String json, String httpUrl, Map<String, String> headers){
        String result = "";
        CloseableHttpClient httpClient = getHttpClient();
        try {
            if(StringUtils.isBlank(json))
                throw new Exception("請求參數不能為空");
            HttpPost httpPost = new HttpPost(httpUrl);
            for(Iterator<Map.Entry<String, String>> iterator=headers.entrySet().iterator();iterator.hasNext();){
                Map.Entry<String, String> entry = iterator.next();
                Header header = new BasicHeader(entry.getKey(), entry.getValue());
                httpPost.setHeader(header);
            }
            httpPost.setEntity(new StringEntity(json, Charset.forName("UTF-8")));
            System.out.println("Executing request: " + httpPost.getRequestLine());
            CloseableHttpResponse response = httpClient.execute(httpPost);
            result = EntityUtils.toString(response.getEntity());
            System.out.println("Executing response: "+ result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public static String httpGet(String httpUrl, Map<String, String> headers) {
        String result = "";
        CloseableHttpClient httpClient = getHttpClient();
        try {
            HttpGet httpGet = new HttpGet(httpUrl);
            System.out.println("Executing request: " + httpGet.getRequestLine());
            for(Iterator<Map.Entry<String, String>> iterator=headers.entrySet().iterator();iterator.hasNext();){
                Map.Entry<String, String> entry = iterator.next();
                Header header = new BasicHeader(entry.getKey(), entry.getValue());
                httpGet.setHeader(header);
            }
            CloseableHttpResponse response = httpClient.execute(httpGet);
            result = EntityUtils.toString(response.getEntity());
            System.out.println("Executing response: "+ result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }


    public static String httpGet(String httpUrl) {
        String result = "";
        CloseableHttpClient httpClient = getHttpClient();
        try {
            HttpGet httpGet = new HttpGet(httpUrl);
            System.out.println("Executing request: " + httpGet.getRequestLine());
            CloseableHttpResponse response = httpClient.execute(httpGet);
            result = EntityUtils.toString(response.getEntity());
            System.out.println("Executing response: "+ result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }


  

1、twemproxy explore

      當我們有大量 Redis 或 Memcached 的時候，通常只能通過客戶端的一些數據分配算法（比如一致性哈希），來實現集群存儲的特性。雖然Redis 2.6版本已經發布Redis Cluster，但還不是很成熟適用正式生產環境。 Redis 的 Cluster 方案還沒有正式推出之前，我們通過 Proxy 的方式來實現集群存儲。

       Twitter，世界最大的Redis集群之一部署在Twitter用于為用戶提供時間軸數據。Twitter Open Source部門提供了Twemproxy。

     Twemproxy,也叫nutcraker。是一個twtter開源的一個redis和memcache代理服務器。 redis作為一個高效的緩存服務器，非常具有應用價值。但是當使用比較多的時候，就希望可以通過某種方式 統一進行管理。避免每個應用每個客戶端管理連接的松散性。同時在一定程度上變得可以控制。

      Twemproxy是一個快速的單線程代理程序，支持Memcached ASCII協議和更新的Redis協議：

     它全部用C寫成，使用Apache 2.0 License授權。項目在Linux上可以工作，而在OSX上無法編譯，因為它依賴了epoll API.

      Twemproxy 通過引入一個代理層，可以將其后端的多臺 Redis 或 Memcached 實例進行統一管理與分配，使應用程序只需要在 Twemproxy 上進行操作，而不用關心后面具體有多少個真實的 Redis 或 Memcached 存儲。 

2、twemproxy特性：

• 支持失敗節點自動刪除

  • 可以設置重新連接該節點的時間
  • 可以設置連接多少次之后刪除該節點
  • 該方式適合作為cache存儲

• 支持設置HashTag

  • 通過HashTag可以自己設定將兩個KEYhash到同一個實例上去。

• 減少與redis的直接連接數

  • 保持與redis的長連接
  • 可設置代理與后臺每個redis連接的數目

• 自動分片到后端多個redis實例上

  • 多種hash算法：能夠使用不同的策略和散列函數支持一致性hash。
  • 可以設置后端實例的權重

• 避免單點問題

  • 可以平行部署多個代理層.client自動選擇可用的一個

• 支持redis pipelining request

       支持請求的流式與批處理，降低來回的消耗
  

• 支持狀態監控

  • 可設置狀態監控ip和端口，訪問ip和端口可以得到一個json格式的狀態信息串
  • 可設置監控信息刷新間隔時間

• 高吞吐量

  • 連接復用，內存復用。
  • 將多個連接請求，組成reids pipelining統一向redis請求。

     另外可以修改redis的源代碼，抽取出redis中的前半部分，作為一個中間代理層。最終都是通過linux下的epoll 事件機制提高并發效率，其中nutcraker本身也是使用epoll的事件機制。并且在性能測試上的表現非常出色。

3、twemproxy問題與不足

• 不支持針對多個值的操作，比如取sets的子交并補等（MGET 和 DEL 除外）
• 不支持Redis的事務操作
• 出錯提示還不夠完善
• 也不支持select操作