Gradle是什么就不多说了，跟Maven是同类型的工具。Spring和Hibernate都早已经迁移了过来。官网地址：http://www.gradle.org。最新稳定版为1.4

Gradle Eclipse Plugin是spring的sts支持的。安装之：

Installing Gradle Tooling from update site
Alternatively you can install from update sites. The following update sites are available:

   * http://dist.springsource.com/snapshot/TOOLS/nightly/gradle (latest development snapshot)
   * http://dist.springsource.com/milestone/TOOLS/gradle (latest milestone build.)
   * http://dist.springsource.com/release/TOOLS/gradle (latest release)

Gradle的配置文件脚本是groovy语法的，Eclipse插件也安装之

http://dist.springsource.org/release/GRECLIPSE/e4.2/

将工程转换为Gradle工程。

然后编辑，配置文件即可。Gradle吸引人的地方就是文档相当的完善，对于一般使用者，最常用的就是依赖管理功能，文档地址：http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html

根据文档，先配置Gradle环境，

PATH=D:\Develop Software\gradle-1.4\bin

这里是为了能够在命令行中使用gradle。对于Eclipse 插件来说，其默认下载是使用的是1.2版本，如果强制指定我们下载的1.4版本，在某些操作的时候会报错。

可编辑gradle.bat(.sh)文件，设置JVM参数。

我们就在Eclipse中尝试gradle，通过configure->convert to gradle project，将工程变为Gradle管理的工程。

然后编写build.gradle配置文件。

apply plugin: 'java'
group='onecoder'
version='1.0'
repositories {
mavenCentral()
mavenRepo url: "https://oss.sonatype.org/content/repositories/opensymphony-releases"
mavenRepo url: "http://dev.anyframejava.org/maven/repo"
}
sourceSets {
main
}
dependencies {
compile "io.netty:netty:3.6.3.Final"
compile "ch.qos.logback:logback-core:1.0.7"
compile "org.slf4j:slf4j-api:1.7.3"
compile "javax.mail:mail:1.4.4"
compile "org.apache.httpcomponents:httpclient:4.2.2"
compile "org.hyperic:sigar:1.6.4"
compile "net.sourceforge.groboutils:groboutils-core:5"
}

然后fresh all一下，即可自动下载依赖了。相对pom.xml来说，配置文件看起来确实清晰简单多了。这里有很多配置，OneCoder还没有弄清楚，这里只是简单的试用，并且把个人联系的工程迁移了过来。细节问题，留待以后使用中慢慢研究吧。
 

最近在利用mysqlslap对MySQL进行性能测试，但是测得的TPS、QPS的benchmark数据，从趋势上就跟网上“权威”的测试数据不同。这让OneCoder十分怀疑测试数据的准确性。

在定位问题的过程中，在独立于MySQL Server的机器上执行mysqlslap测试，测得的数据趋势正常。即初始随着并发数增大（一定范围内），TPS和QPS成上升趋势。这让我怀疑我之前在同一台服务器进行的测试，可能mysqlslap和MySQL Server争夺了CPU资源。

在一篇MySQL的测试报告中看到这样的话：

此外测试的机器具有 16 核，其中 12 核运行 mysqld ，另外 4 核运行 sysbench。

立马上网搜索指定方法。搜得Linux下的taskset命令

taskset -cp cpu序号 mysqld-pid  

即可指定mysqld服务使用的cpu核心。例如:

taskset -cp 0-47 12345

执行mysqlslap的时候，只需通过

taskset -c 48-63 mysqlslap xxxxxx

指定使用的cpu核心即可。准备给MySQL Server分配48核， mysqlslap 16核，测试看看效果。
 

一般存储矩阵，自然想到二维数据。但是对于稀疏矩阵（0项很多），这无疑浪费的大量的空间。所以，这里考虑换一种表示方法。用一个三元组表示矩阵中的非零元素。

//(稀疏)矩阵数据结构, 待表示矩阵如下
// 15     0     0     22     0     -15
// 0     11     3     0     0     0
// 0     0     0     -6     0     0
// 0     0     0     0     0     0
// 91     0     0     0     0     0
// 0     0     28     0     0     0

#include <stdio.h>
#include <stdbool.h>
typedef struct {
     int col; // 列号
     int row; // 行号
     int value; // 值
} sparse_matrix;
void createMatrix(sparse_matrix *matrix);
void printMatrix(sparse_matrix *matrix);
void transposeMatrix(sparse_matrix *matrix, sparse_matrix *transposeMatrix);
#define GET_ARRAY_LEN(array,len) (len=(sizeof(array)/sizeof(array[0])));
int main() {   
     int length;
     sparse_matrix smatrix[9], transMatrix[9];
     createMatrix(smatrix);
     GET_ARRAY_LEN(smatrix,length);
     printMatrix(smatrix);
     printf("Array length is %d\n",length);
     transposeMatrix(smatrix, transMatrix);
     printf("Print transpose matrix: \n");
     printMatrix(transMatrix);
    return 0;
}
// 初始化稀疏矩阵
void createMatrix(sparse_matrix *matrix) {
     matrix[0].row = 6;// 0行元素存储行数
     matrix[0].col = 6;// 0列元素存储列数
     matrix[0].value = 8;
     matrix[1].row = 0;
     matrix[1].col = 0;
     matrix[1].value = 15;
     matrix[2].row = 0;
     matrix[2].col = 3;
     matrix[2].value = 22;
     matrix[3].row = 0;
     matrix[3].col = 5;
     matrix[3].value = -15;
     matrix[4].row = 1;
     matrix[4].col = 1;
     matrix[4].value = 11;
     matrix[5].row = 1;
     matrix[5].col = 2;
     matrix[5].value = 3;
     matrix[6].row = 2;
     matrix[6].col = 3;
     matrix[6].value = -6;
     matrix[7].row = 4;
     matrix[7].col = 0;
     matrix[7].value = 91;
     matrix[8].row = 5;
     matrix[8].col = 2;
     matrix[8].value = 28;
}

//打印稀疏矩阵
//最差时间复杂度：O(row * col * valueCount);
void printMatrix(sparse_matrix *matrix) {
     int i,j,k;
     int row = (*matrix).row;
     int col = (*matrix).col;
     int valueCount = (*matrix).value;
     int startIndex = 1;
     for (i = 0; i < row; i++) {
          for (k = 0; k < col; k++) {
               bool print = false;
               for (j = startIndex; j <= valueCount; j++) {
                    int curRow = (*(matrix + j)).row,
                    curCol = (*(matrix + j)).col;
                    if (i == curRow && k == curCol) {
                         printf("%d\t", (*(matrix+j)).value);
                         print = true;
                         startIndex++;
                    }
               }
               if (!print) {
                    printf("%d\t", 0);
               }
          }
          printf("\n");
     }
}
// 求稀疏矩阵的转置矩阵，即交换行列的位置
// 最差时间复杂度：O(col * valueCount);
void transposeMatrix(sparse_matrix *smatrix, sparse_matrix *transposeMatrix) {
     int i,n, rowNum = (*smatrix).row, colNum = (*smatrix).col, valueNum = (*smatrix).value;
     (*transposeMatrix).row = colNum;
     (*transposeMatrix).col = rowNum;
     (*transposeMatrix).value = valueNum;
     int index = 1;
     for (i = 0; i < colNum; i++) {
          for (n = 1; n <= valueNum; n++) {
               int curRow = (*(smatrix + n)).row,
                    curCol = (*(smatrix + n)).col,
                    curValue = (*(smatrix + n)).value;
               if (i == curCol) {
                    (*(transposeMatrix + index)).row = curCol;
                    (*(transposeMatrix + index)).col = curRow;
                    (*(transposeMatrix + index)).value = curValue;
                    index++;
               }
          }
     }
}

可以看到，相对于传统的使用二维数据的方式存储矩阵，该存储方式对于稀疏矩阵来说，无疑节省了大量空间。  但是对于矩阵的打印和转置来说，从数据量级看浪费了时间。所以，此种表示方式适用于矩阵中非零元素少的稀疏矩阵。尤其当矩阵中非零元素数量为cols * rows时，转置的时间复杂性为O(rows * cols * cols)。用时间换空间。

考虑再用少量空间，换一些时间。实现时间复杂度的为O(cols + elements)的快速转置：

// 快速转置算法，浪费少量空间，换取时间
// 直接计算转置后元素的存放位置
void fastTranspose(sparse_matrix *smatrix, sparse_matrix *transposeMatrix) {
     int i, rowNum = (*smatrix).row, colNum = (*smatrix).col, valueNum = (*smatrix).value;
     int row_terms[colNum + 1],
          startPos[colNum + 1];
     (*transposeMatrix).row = colNum;
     (*transposeMatrix).col = rowNum;
     (*transposeMatrix).value = valueNum;
     for (i = 0; i< colNum; i++) {
          row_terms[i] = 0; // 数组中的元素必须初始化
     }
     for (i = 1; i <= valueNum; i++) {
          int     curCol = (*(smatrix + i)).col;
          row_terms[curCol]++;//记录转置后，每行的元素个数
     }
     startPos[0] = 1;//初始化起始位置
     for (i = 1; i < colNum; i++) {
          startPos[i] = startPos[i-1] + row_terms[i-1];
     }
      for (i = 1; i <= valueNum; i++) {
           int curRow = (*(smatrix + i)).row,
                curCol = (*(smatrix + i)).col,
                curValue = (*(smatrix + i)).value;
           int j = startPos[curCol]++;// 计算出原矩阵中的元素在转置矩阵数据中的位置
           (*(transposeMatrix + j)).row = curCol;
           (*(transposeMatrix + j)).col = curRow;
           (*(transposeMatrix + j)).value = curValue;
      }
}

可见快速转置的主要思想就是直接计算出元素在转置矩阵中的顺序位置，直接存储。接下来是稀疏矩阵的乘法。

// 稀疏矩阵乘法运算, 以下面矩阵为例
// 0     0     1     1 * 0     0
//                         0     0 = 2     5
//                         0     2
//                         2     3
void matrixMulti(sparse_matrix *amatrix, sparse_matrix *bmatrix, sparse_matrix *resultMatrix) {
     int i, aRowNum = (*amatrix).row, aValueNum = (*amatrix).value;
     int j, bColNum = (*bmatrix).col, bValueNum = (*bmatrix).value;
     (*resultMatrix).row = aRowNum;//首先可知结果矩阵的行列数
     (*resultMatrix).col = bColNum;
     sparse_matrix tbMatrix[9];// 为了计算方便先求出被乘矩阵的转置矩阵，下面计算都利用转置矩阵
     fastTranspose(bmatrix, tbMatrix);
         int temp_sum = 0,
          row = (*(amatrix + 1)).row, // 矩阵A的起始行，即为结果的起始行
          col,
          rowBegin = 1,
          rIndex = 0;
     // 在循环内部控制循环的次数和起始
     for (i = 1; i <= aValueNum; ) {
          col = (*(tbMatrix + 1)).row; // 矩阵B的转置矩阵的行，即对应的列
          for (j = 1; j <= bValueNum + 1; ) {
               if (amatrix[i].row != row) {
                    storeValue(resultMatrix, row, col, temp_sum, &rIndex);
                i = rowBegin;
                    for (; col == tbMatrix[j].row; j++)
                         ;
                    col = tbMatrix[j].row;
                    temp_sum = 0;
               } else if (col != tbMatrix[j].row) {
                    storeValue(resultMatrix, row, col, temp_sum, &rIndex);
                i = rowBegin;
                col = tbMatrix[j].row;
                    temp_sum = 0;
               } else {
                    if (amatrix[i].col < tbMatrix[j].col) {
                         i++;
                    } else if (amatrix[i].col == tbMatrix[j].col) {
                         temp_sum += amatrix[i].value * tbMatrix[j].value;
                         i++;
                         j++;
                    } else {
                         j++;
                    }
               }
          }
          for (; row == (*(amatrix + i)).row; i++)
               ;
          rowBegin = i;
          row = (*(amatrix + i)).row;
     }
    (*resultMatrix).value = rIndex;
}

void storeValue(sparse_matrix *resultMatrix, int row, int col, int value, int *index) {
     if (value) {
          (*(resultMatrix + ++*index)).row = row;
          (*(resultMatrix + *index)).col = col;
          (*(resultMatrix + *index)).value = value;
     }
}

没有做太多错误边界的判断。计算结果：

初学乍练，如果有错误还望大家指出。这个乘法，OneCoder着实写了好久。算法的时间复杂度为：O(bColNum * aValueNum + aRowNum * bValueNum)。相对于传统的二维数组表示矩阵的计算来说，实现逻辑复杂好多。传统方式的时间复杂度为：O(aRowNum * aColNum * bColNum)。

对MySQL进行并发测试过程中遇到的一个小问题，记录一下。

用mysqlslap进行并发访问测试，在1024线程的时候报错：

bin/mysqlslap: Error when connecting to server: 1135 Can't create a new thread (errno 11); if you are not out of available memory, you can consult the manual for a possible OS-dependent bug

Linux系统的open files数已经修改。当然仍然报错。ulimit -a命令，可查看当前系统限制情况

max user processes = 1024

通过ulimit -u 10000命令修改当前session的限制值，然后重启MySQL，问题解决。如果你想使此值永久生效，可配置在/etc/profile 中。

MySQL 近期发布5.6的GA版本，其中确实有很多不错的特性值得关注和尝试。NoSQL API的支持就是其中一个比较不错的亮点，我们这就来尝试一下。详细的特性介绍可访问：http://dev.mysql.com/tech-resources/articles/mysql-5.6.html 。

从MySQL官网了解到，通过Memcache的API即可访问MySQL的NoSQL API。

Many of the latest generation of web, cloud, social and mobile applications require fast operations against simple Key/Value pairs. At the same time, they must retain the ability to run complex queries against the same data, as well as ensure the data is protected with ACID guarantees. With the new NoSQL API for InnoDB, developers have all the benefits of a transactional RDBMS, coupled with the performance capabilities of Key/Value store.
MySQL 5.6 provides simple, key-value interaction with InnoDB data via the familiar Memcached API. Implemented via a new Memcached daemon plug-in to mysqld, the new Memcached protocol is mapped directly to the native InnoDB API and enables developers to use existing Memcached clients to bypass the expense of query parsing and go directly to InnoDB data for lookups and transactional compliant updates. The API makes it possible to re-use standard Memcached libraries and clients, while extending Memcached functionality by integrating a persistent, crash-safe, transactional database back-end. The implementation is shown here:

So does this option provide a performance benefit over SQL? Internal performance benchmarks using a customized Java application and test harness show some very promising results with a 9X improvement in overall throughput for SET/INSERT operations:

首先部署Server端的Memcache plugin集成环境。目前支持的系统为Linux, Solaris, and OS X，不支持windows。文档地址：http://dev.mysql.com/doc/refman/5.6/en/innodb-memcached-setup.html

由于我采用的tar包安装的MySQL，所以在安装memcache plugin的时候需要先安装libevent包。

yum install libevent

即可。

然后，安装libmemcached所需要的表

将插件设置成随服务启动而启动的守护插件

重启MySQL服务，安装完成。默认访问端口为11211。

下面来验证一下安装，简单的可以采用telnet的方式发送memcached命令

然后通过sql，在demo_test表中查询数据：

再通过Java代码操作一下，我们采用xmemcached作为client api。官方地址：https://code.google.com/p/xmemcached。Maven依赖：

<dependency >     
      <groupId >com.googlecode.xmemcached</groupId >
      <artifactId >xmemcached</artifactId >
      <version >1.4.1</version >
</dependency >

代码如下：

 /**
      * @param args
      * @author lihzh(OneCoder)
      * @blog http://www.coderli.com
      * @throws MemcachedException
      * @throws InterruptedException
      * @throws TimeoutException
      * @throws IOException
      * @date 2013 -3 -12 下午12:07:41
      */
     public static void main(String[] args) throws TimeoutException, InterruptedException, MemcachedException, IOException {
           MemcachedClient client = new XMemcachedClient("10.4.44.208" , 11211);
            // store a value for one hour(synchronously).
           client.set( "key", 3600, "onecoder");
            // Retrieve a value.(synchronously).
           Object someObject = client.get( "key");
            // Retrieve a value.(synchronously),operation timeout two seconds.
           someObject = client.get( "key", 2000);
           System. out.println(someObject);
     }

通过mysql客户端查询记录，成功存入：

这里测试的仅仅最基本的功能，如果想使用该功能，还需要做好传统数据表与memcache表的映射关系。具体可参考：http://dev.mysql.com/doc/refman/5.6/en/innodb-memcached-developing.html。

今天是妇女节，先祝所有过节的女同胞们节日快乐：）

即将对MySQL进行性能测试。所以事先对MySQL的测试工作进行一番了解。主要考察性能测试的工具，MySQL的关键指标，以及一些基础的Benchmark数据，为测试用例和场景的规划做些准备。

先说说考量的指标（转载，网址找不到了，抱歉）

(1)QPS(每秒Query量)
QPS = Questions(or Queries) / seconds
mysql > show /*50000 global */ status like 'Question';
(2)TPS(每秒事务量)
TPS = (Com_commit + Com_rollback) / seconds
mysql > show status like 'Com_commit';
mysql > show status like 'Com_rollback';
(3)key Buffer 命中率
key_buffer_read_hits = (1-key_reads / key_read_requests) * 100%
key_buffer_write_hits = (1-key_writes / key_write_requests) * 100%
mysql> show status like 'Key%';
(4)InnoDB Buffer命中率
innodb_buffer_read_hits = (1 - innodb_buffer_pool_reads / innodb_buffer_pool_read_requests) * 100%
mysql> show status like 'innodb_buffer_pool_read%';
(5)Query Cache命中率
Query_cache_hits = (Qcahce_hits / (Qcache_hits + Qcache_inserts )) * 100%;
mysql> show status like 'Qcache%';
(6)Table Cache状态量
mysql> show status like 'open%';
(7)Thread Cache 命中率
Thread_cache_hits = (1 - Threads_created / connections ) * 100%
mysql> show status like 'Thread%';
mysql> show status like 'Connections';
(8)锁定状态
mysql> show status like '%lock%';
(9)复制延时量
mysql > show slave status
(10) Tmp Table 状况(临时表状况)
mysql > show status like 'Create_tmp%';
(11) Binlog Cache 使用状况
mysql > show status like 'Binlog_cache%';
(12) Innodb_log_waits 量
mysql > show status like 'innodb_log_waits';

其中QPS和TPS自然是重点考察的性能指标。其他指标可以作为每次测试数据的参考数据列出。如果遇到瓶颈，可能还需要考量当时系统的cpu，网络，磁盘的利用率情况。这个遇到具体问题再具体分析。

工具方面，首选考察的自然是MySQL自带的测试工具mysqlslap。

./mysqlslap -a --concurrency=50,100 --number-of-queries 1000 --iterations=5 --engine=myisam,innodb --debug-info -uroot -proot

一个简单的示例即可说明工具的使用情况，

-a 自动生成sql
--concurrency=50,100分别执行50，100并发，
--iterations=5 执行5次，引擎分别选用myisam和innodb引擎测试。

--number-of-queries    Limit each client to this number of queries (this is not
                      exact).（一个客户端执行的测试SQL数量上限，通过--only-print观察自动生成的sql的执行情况来看，该条数限制的是准备数据以外的SQL语句的条数）
--engine=myisam,innodb 分别用myisam和innodb引擎进行测试。

当然你也可以通过-q指定你想要测试的sql脚本，测试结束后，mysqlslap会给出你测试的相关数据。

关于mysqlslap的更多参数可参考：http://dev.mysql.com/doc/refman/5.1/en/mysqlslap.html
从目前来看上手还是比较容易的。通过执行的query数量和时间，很容易计算出tps和qps等指标。

SysBench

也是MySQL官网提到的一个benchmark工具。只是在64位系统下安装困难，限于网络环境和考虑到其功能和我们即将进行的测试场景，暂时放弃。

性能测试基础准备其他话题

在思考和验证怎样使用mysqlslap规划测试场景的过程中，收获到一些离散的细节问题，也在此一并记录一下。也许哪天，哪一条就会有所帮助。

打开MySQL general_log 记录执行的sql情况

默认情况下该属性是关闭的，通过set global general_log=ON 打开后，可在log文件中查看数据库执行的sql记录。该需求是OneCoder想要考察JDBC的batch insert的提交方式，究竟是数据库中是执行的多条insert然后commit还是一个insert values大列表的时候产生的。

对比批量插入数据 多条insert和一条insert 大values列表(values(),(),())方式，性能差别

从目前通过mysqlslap执行测试的效果来看，后者明显优于前者。前者1000条平均时间大约是0.2ms，而后者在0.1ms左右。该测试想法是在通过mysqldump到处已有数据的时候发现其sql文件的生成方式的时候以及联想到oracle到mysql的数据迁移工具的处理方式的时候想到的。

写入性能瓶颈的一个大误解

曾经极大的错误的认为单线程下mysql可处理的批量插入数据量就是该节点的瓶颈，所以只认为多线程并发写入优化只在NDB的环境下才有效。今天在看MySQL的一些benchmark图表曲线的时候，猛然惊醒，并发数和tps的曲线是类抛物线的就说明在一定并发数的范围内，TPS是有明显提高的。于是用以前的JDBC的代码，增加了几个线程，对同一个mysql并发写入，果然TPS成倍提升。

今天总结的大概就这么多，由于是事后回忆总结，不免有所遗漏，想起来再补充把。热烈欢迎指导。

MySQL Cluster使用到目前为止遇到渴望得到答案的问题，也是直接影响使用的问题就是MySQL Cluster的写入效率问题和Cluster是否适合大数据存储、如何配置存储的问题。

继续我们的验证工作，这次是搭建MySQL的主从配置，再利用Amoeba实现读写分离，搭建一个相对有实际意义的MySQL集群环境。

MySQL的主从配置比较简单，网上也有很多的文章，这里不多介绍。基于之前的介绍的环境考虑：

10.4.44.206 主-写
10.4.44.207 从-读1
10.4.44.208 从-读2

MySQL的主从配置确实十分简单。主要就是配置好日志的监听。这里OneCoder是参考：http://369369.blog.51cto.com/319630/790921 的文章完成的配置。配置好后，验证一下主从环境是否可用。连接206插入一条数据，在207和208上可成功查询到该数据，证明我们的主从环境配置成功。接下来我们再来配置Amoeba，只要在amoeba.xml中配置好读写库就可以了。

然后连接205Amoeba服务端写入数据，分别直接206，207，208节点查询数据，均可查到，并且与通过Amoeba节点查询出的数据是相同的。可见数据是自动同步的。

   通过208查询效果，（205，206，207节点查询效果均相同）

通过Amoeba查询数据，可以看到只有配置的读节点有网络传输，写节点的网络是风平浪静的。

206写

208 读节点

考虑的是，Amoeba是不支持事物的，所以我们可以考虑把写节点直接暴露出来，表引擎选择InnoDB, 其他读节点通过Amoeba进行负载均衡。不过这里就需要业务自己来控制读写的数据源选择了。

至此，对于MySQL的验证工作也基本告一段落了，对于形形色色的方案及其试用场景，OneCoder也需要好好消化总结一下了。

由于MySQL Cluster自身就实现了数据的自动同步等功能，在此之上架一层Amoeba基本只起到了分担SQL层负载的的作用，所以我们很有必要基于传统的单点MySQL服务之上的 Amoeba都能帮我们做些什么。

环境搭建的过程不再赘述，我们在两个新的虚拟机上启动两个独立的MySQL服务，然后配置在 Amoeba中即可。此时SQL节点的IP分别为：

10.4.44.206 写
10.4.44.207 读
10.4.44.208 读
10.4.44.205 Amoeba节点

这里使用的MySQL版本为，mysql-5.5.29-linux2.6-x86_64。先手动分别在三个节点上创建了相同的数据库(bigdata)和表(data_house)。修改amoeba.xml和dbServers.xml配置，重启amoeba服务。

怀着好奇，先测试通过Amoeba节点写入数据和查询数据的情况，看看数据是否是各个节点自动同步的。同样，使用的之前使用的JDBC测试代码。观察写入过程中虚拟机的网络和磁盘指标情况。

write206节点监控图表

发现果然只有206写节点有网络和磁盘传输请求，207和208节点一片平静。显然数据不是这样同步的，通过Amoeba查询，果然没有数据。在这种情况下，我们应该配置Amoeba的水平切分规则，让数据分别存储在各个节点上。不过这样的话每个节点都只有一部分数据，任何一个节点的故障都会导致数据的不完整，我们来验证看看是不是这样。

修改rule.xml中的配置，

根据ID hash(2)的值水平切分数据。这里每个规则都对应自己的读写节点。这里验证就是Amoeba的路由规则功能。执行数据插入，可以看到数据平均的分配到207和208两个数据节点上，各10000条数据。

此时执行count操作，返回值始终是10000，可见此时无法查询到完整的数据。但是有了这种切分规则，你可以灵活的进行的自己的配置，比如可以进行垂直切分等。所以可见，Amoeba的主要职责是起到了一个路由的作用，把请求分发下去，数据同步不是它关心的。所以Amoeba官网中介绍的读写分离也是基于MySQL主从配置的，这也是我们接下来要进行的工作：）

龙年完成的Amoeba环境初步搭建工作，蛇年开始进行读写分离和负载均衡的验证工作。先祝大家蛇年一切顺利。上回的工作我们只是完成Amoeba框架的引入，但是并不满足读写分离场景的要求，因为最基本的，SQL节点只有一个。
所以，我们首先需要添加一个SQL节点，具体操作不再赘述。添加，重启后，MySQL Clluster集群环境如下。

修改Amoeba的环境配置dbServers.xml，增加一个dbServer节点10.4.44.200。

重启Amoeba服务使配置生效。

此时，使用之前写好的JDBC代码直接访问Amoeba的服务即可完成对数据的操作，只需修改IP地址和端口(默认为8066)即可。

通过测试发现，通过访问Amoeba服务，确实完成对了SQL层的负载均衡，观察虚拟机的网络指标，发现两个SQL节点的网络负载比较平均。

               SQL200的网络负载

SQL201相同时刻的网络负载情况

读写分离配置。

<queryRouter class="com.meidusa.amoeba.mysql.parser.MysqlQueryRouter">
                <property name="ruleLoader">
                        <bean class="com.meidusa.amoeba.route.TableRuleFileLoader">
                                <property name="ruleFile">${amoeba.home}/conf/rule.xml</property>
                                <property name="functionFile">${amoeba.home}/conf/ruleFunctionMap.xml</property>
                        </bean>
                </property>
                <property name="sqlFunctionFile">${amoeba.home}/conf/functionMap.xml</property>
                <property name="LRUMapSize">1500</property>
                <property name="defaultPool">server2</property>

                <property name="writePool">server2</property>
                <property name="readPool">multiPool</property>
                <property name="needParse">true</property>
 </queryRouter>

关键是打开默认注释掉的readPool和writePool 的配置项，这里可以配置单节点名称也可以填入在dbServers.xml中定义的虚拟节点的名称，比如这里的multiPool实际包含了server1,server2两个节点。Amoeba按照负载均衡策略进行读取。
注：上述配置是在不进行数据切分的情况下，快速进行读写分离的配置。

连接205的Amoeba节点进行读写操作，观察虚拟机监控图表，可以看到当读数据的时候，负载分担在server1和server2节点上，写数据的时候，只有server2有压力。

备注：Amoeba不能做什么

目前还不支持事务

暂时不支持存储过程（近期会支持）

不适合从amoeba导数据的场景或者对大数据量查询的query并不合适（比如一次请求返回10w以上甚至更多数据的场合）

暂时不支持分库分表，amoeba目前只做到分数据库实例，每个被切分的节点需要保持库表结构一致。

从第四点可以联想到，我们测试的环境是基于MySQL Cluster的多个SQL节点，底层的Data node自然是数据同步的，甚至都不存在他说的保持库表一致的问题。OneCoder也认为，Amoeba在设计之初的使用场景底层应该是基于独立的MySQL节点的。这也是OneCoder接下来考虑的验证工作：）