什么是MYCAT

[]一个彻底开源的，面向企业应用开发的大数据库集群[/][]支持事务、ACID、可以替代MySQL的加强版数据库[/][]一个可以视为MySQL集群的企业级数据库，用来替代昂贵的Oracle集群[/][]一个融合内存缓存技术、NoSQL技术、HDFS大数据的新型SQL Server[/][]结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品[/][]一个新颖的数据库中间件产品[/]

Mycat特性

[]支持SQL92标准[/][]遵守Mysql原生协议，跨语言，跨数据库的通用中间件代理。[/][]基于心跳的自动故障切换，支持读写分离，支持MySQL主从，以及galera cluster。[/][]支持Galera for MySQL集群，Percona Cluster或者MariaDB cluster[/][]基于Nio实现，有效管理线程，高并发问题。[/][]支持数据的多片自动路由与聚合，支持sum,count,max等常用的聚合函数。[/][]支持2表join，甚至基于caltlet的多表join。[/][]支持通过全局表，ER关系的分片策略，实现了高效的多表join查询。[/][]支持多租户方案。[/][]支持分布式事务（弱xa）。[/][]支持全局序列号，解决分布式下的主键生成问题。[/][]分片规则丰富，插件化开发，易于扩展。[/][]强大的web，命令行监控。[/][]支持前端作为mysq通用代理，后端JDBC方式支持Oracle、DB2、SQL Server 、 mongodb 、巨杉。[/][]支持密码加密[/][]支持IP白名单[/][]支持SQL黑名单、sql注入攻击拦截[/][]集群基于ZooKeeper管理，在线升级，扩容，智能优化，大数据处理（2.0开发版）。[/]

Mycat架构

Mycat高可用方案

Mycat监控

[]支持对Mycat、Mysql性能监控[/][]支持对Mycat的JVM内存提供监控服务[/][]支持对线程的监控[/][]支持对操作系统的CPU、内存、磁盘、网络的监控[/]

目标

长期规划2.0

[]完全实现分布式事务，完全的支持分布式。[/][]通过Mycat web（eye）完成可视化配置，及智能监控，自动运维。[/][]通过mysql 本地节点，完整的解决数据扩容难度，实现自动扩容机制，解决扩容难点。[/][]支持基于zookeeper的主从切换及Mycat集群化管理。[/][]通过Mycat Balance 替代第三方的Haproxy，LVS等第三方高可用，完整的兼容Mycat集群节点的动态上下线。[/][]接入Spark等第三方工具，解决数据分析及大数据聚合的业务场景。[/][]通过Mycat智能优化，分析分片热点，提供合理的分片建议，索引建议，及数据切分实时业务建议。[/]

优势

基于阿里开源的Cobar产品而研发，Cobar的稳定性、可靠性、优秀的架构和性能以及众多成熟的使用案例使得MYCAT一开始就拥有一个很好的起点，站在巨人的肩膀上，我们能看到更远。业界优秀的开源项目和创新思路被广泛融入到MYCAT的基因中，使得MYCAT在很多方面都领先于目前其他一些同类的开源项目，甚至超越某些商业产品。

MYCAT背后有一支强大的技术团队，其参与者都是5年以上资深软件工程师、架构师、DBA等，优秀的技术团队保证了MYCAT的产品质量。

MYCAT并不依托于任何一个商业公司，因此不像某些开源项目，将一些重要的特性封闭在其商业产品中，使得开源项目成了一个摆设。

Mycat关注

Mycat官方论坛：http://i.mycat.io/forum.php
Mycat Github：https://github.com/MyCATApache
Mycat权威指南第一版_V1.5.1：http://pan.baidu.com/s/1i3SFOpf

前言

日志这东西在语言里算基础组件了吧，可惜Java界第三方框架向来比原生组件好用也是事实，缺点是框架太多混战江湖，今天我们就理一理这些日志框架。Java的日志框架分为门面（Facade），或者叫通用日志接口，还有日志实现。日志接口不用说，就是定下的日志方法规范，需要具体日志组件去实现的（为啥Sun当年没有定义这东西，看看JPA、JDBC、JMS这些规范定义的多好，或者定义了被抛弃了？）。日志实现就是具体的日志组件了，可以实现日志打印到控制台、文件、数据库等等。下面咱们就具体说说这些东西。

Java日志框架分类

[]Slf4j[/]

全称Simple Logging Facade for JAVA，真正的日志门面，只提供接口方法，当配合特定的日志实现时，需要引入相应的桥接包

[]Common-logging[/]

Apache提供的一个通用的日志接口，common-logging会通过动态查找的机制，在程序运行时自动找出真正使用的日志库，自己也自带一个功能很弱的日志实现。

[]Log4j[/]

Log4j可能是Java世界里最出名的日志框架了，支持各种目的地各种级别的日志输出，从我刚接触日志就知道这个框架（呵呵，我一直不知道还有JDK Logging这个东西）。最近（也不近了……）Log4j2发布正式版了，没看到谁用，听说也很不错。

[]LogBack[/]

Log4j作者的又一力作（听说是受不了收费文档搞了个开源的，不需要桥接包完美适配Slf4j），个人感觉迄今为止最棒的日志框架了，一直都在用，配置文件够简洁，性能足够好（估计是看自己的Log4j代码差劲了，更新不能解决问题，直接重构了）。

[]JDK Logging 从JDK1.4开始引入，不得不说，你去Google下这个JDK自带的日志组件，并不如Log4j和LogBack之类好用，木有配置文件，日志级别不好理解，想顺心的用估计还得自己封装下，总之大家已经被Log4j惯坏了，JDK的设计并不能被大家认同，唯一的优点我想就是不用引入新额jar包了。[/]

为什么会有门面

看了以上介绍，如果你不是混迹（深陷）Java多年的老手，估计会蒙圈儿了吧，那你肯定会问，要门面干嘛。有了手机就有手机壳、手机膜，框架也一样，门面的作用更多的还是三个字：解耦合。说白了，加入一个项目用了一个日志框架，想换咋整啊？那就一行一行的找日志改呗，想想都是噩梦。于是，门面出来了，门面说啦， 你用我的格式写日志，把日志想写哪儿写哪儿，例如Slf4j-api加上后，想换日志框架，直接把桥接包一换就行。方便极了。

说实话，现在Slf4j基本可以是Java日志的一个标准了，按照它写基本可以实现所有日志实现通吃，但是就有人不服，还写了门面的门面（没错，这个人就是我）。

门面的门面

如果你看过Netty的源码，推荐你看下io.netty.util.internal.logging这个包里内容，会发现Netty又对日志封装了一层，于是灵感来源于此，我也对各大日志框架和门面做了封装。

Hutool-log模块

/**

 * 决定日志实现

 * @return 日志实现类

 */

public static Class detectLog(){

    List> logClassList = Arrays.asList(

            Slf4jLog.class,

            Log4jLog.class, 

            Log4j2Log.class, 

            ApacheCommonsLog.class, 

            JdkLog.class

    );

    for (Class clazz : logClassList) {

        try {

            clazz.getConstructor(Class.class).newInstance(LogFactory.class).info("Use Log Framework: [{}]", clazz.getSimpleName());

            return clazz;

        } catch (Error | Exception e) {

            continue;

        }

    }

    return JdkLog.class;

}

说白了非常简单，按顺序实例化相应的日志实现，如果实例化失败（一般是ClassNotFoundException），说明jar不存在，那实例化下一个，通过不停的尝试，最终如果没有引入日志框架，那使用JDK Logging（这个肯定会有的），当然这种方式也和Common-logging存在类似问题，不过不用到跨ClassLoader还是很好用的。

Log log = LogFactory.get();

/**

 * @return 获得调用者的日志

 */

public static Log get() {

    return getLog(new Exception().getStackTrace()[1].getClassName());

}

/**

 * 日志统一接口

 * 

 * @author Looly

 *

 */

public interface Log extends TraceLog, DebugLog, InfoLog, WarnLog, ErrorLog

分享阅读原文：http://www.xiaoleilu.com/some-thing-about-java-log/

什么是MYCAT

[]一个彻底开源的，面向企业应用开发的大数据库集群[/][]支持事务、ACID、可以替代MySQL的加强版数据库[/][]一个可以视为MySQL集群的企业级数据库，用来替代昂贵的Oracle集群[/][]一个融合内存缓存技术、NoSQL技术、HDFS大数据的新型SQL Server[/][]结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品[/][]一个新颖的数据库中间件产品[/]

Mycat特性

[]支持SQL92标准[/][]遵守Mysql原生协议，跨语言，跨数据库的通用中间件代理。[/][]基于心跳的自动故障切换，支持读写分离，支持MySQL主从，以及galera cluster。[/][]支持Galera for MySQL集群，Percona Cluster或者MariaDB cluster[/][]基于Nio实现，有效管理线程，高并发问题。[/][]支持数据的多片自动路由与聚合，支持sum,count,max等常用的聚合函数。[/][]支持2表join，甚至基于caltlet的多表join。[/][]支持通过全局表，ER关系的分片策略，实现了高效的多表join查询。[/][]支持多租户方案。[/][]支持分布式事务（弱xa）。[/][]支持全局序列号，解决分布式下的主键生成问题。[/][]分片规则丰富，插件化开发，易于扩展。[/][]强大的web，命令行监控。[/][]支持前端作为mysq通用代理，后端JDBC方式支持Oracle、DB2、SQL Server 、 mongodb 、巨杉。[/][]支持密码加密[/][]支持IP白名单[/][]支持SQL黑名单、sql注入攻击拦截[/][]集群基于ZooKeeper管理，在线升级，扩容，智能优化，大数据处理（2.0开发版）。[/]

Mycat架构

Mycat高可用方案

Mycat监控

[]支持对Mycat、Mysql性能监控[/][]支持对Mycat的JVM内存提供监控服务[/][]支持对线程的监控[/][]支持对操作系统的CPU、内存、磁盘、网络的监控[/]

目标

长期规划2.0

[]完全实现分布式事务，完全的支持分布式。[/][]通过Mycat web（eye）完成可视化配置，及智能监控，自动运维。[/][]通过mysql 本地节点，完整的解决数据扩容难度，实现自动扩容机制，解决扩容难点。[/][]支持基于zookeeper的主从切换及Mycat集群化管理。[/][]通过Mycat Balance 替代第三方的Haproxy，LVS等第三方高可用，完整的兼容Mycat集群节点的动态上下线。[/][]接入Spark等第三方工具，解决数据分析及大数据聚合的业务场景。[/][]通过Mycat智能优化，分析分片热点，提供合理的分片建议，索引建议，及数据切分实时业务建议。[/]

优势

基于阿里开源的Cobar产品而研发，Cobar的稳定性、可靠性、优秀的架构和性能以及众多成熟的使用案例使得MYCAT一开始就拥有一个很好的起点，站在巨人的肩膀上，我们能看到更远。业界优秀的开源项目和创新思路被广泛融入到MYCAT的基因中，使得MYCAT在很多方面都领先于目前其他一些同类的开源项目，甚至超越某些商业产品。

MYCAT背后有一支强大的技术团队，其参与者都是5年以上资深软件工程师、架构师、DBA等，优秀的技术团队保证了MYCAT的产品质量。

MYCAT并不依托于任何一个商业公司，因此不像某些开源项目，将一些重要的特性封闭在其商业产品中，使得开源项目成了一个摆设。

Mycat关注

Mycat官方论坛：http://i.mycat.io/forum.php
Mycat Github：https://github.com/MyCATApache
Mycat权威指南第一版_V1.5.1：http://pan.baidu.com/s/1i3SFOpf

HBase是一个分布式的、面向列的开源数据库，该技术来源于 Fay Chang 所撰写的Google论文“Bigtable：一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统（File System）所提供的分布式数据存储一样，HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。

[]大：一个表可以有上亿行，上百万列[/][]面向列:面向列(族)的存储和权限控制，列(族)独立检索[/][]稀疏:对于为空(null)的列并不占用存储空间，表可以设计非常稀疏[/]

package yoodb.hbase;

 

import java.io.IOException;

 

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;

import org.apache.hadoop.hbase.HColumnDescriptor;

import org.apache.hadoop.hbase.HTableDescriptor;

import org.apache.hadoop.hbase.KeyValue;

import org.apache.hadoop.hbase.client.Delete;

import org.apache.hadoop.hbase.client.Get;

import org.apache.hadoop.hbase.client.HBaseAdmin;

import org.apache.hadoop.hbase.client.HTable;

import org.apache.hadoop.hbase.client.HTablePool;

import org.apache.hadoop.hbase.client.Put;

import org.apache.hadoop.hbase.client.Result;

import org.apache.hadoop.hbase.client.ResultScanner;

import org.apache.hadoop.hbase.client.Scan;

import org.apache.hadoop.hbase.util.Bytes;

 

public class HBaseTest {

 

    // 声明静态配置

    static Configuration conf = null;

    static final HTablePool tablePool;

    static {

        conf = HBaseConfiguration.create();

        conf.set("hbase.zookeeper.quorum", "yoodb");

        tablePool = new HTablePool(conf, 15);

    }

 

    /*

     * 创建表

     * @tableName 表名

     * @family 列族数组

     */

    public static void creatTable(String tableName, String[] family)

            throws Exception {

        HBaseAdmin admin = new HBaseAdmin(conf);

        HTableDescriptor desc = new HTableDescriptor(tableName);

        for (int i = 0; i < family.length; i++) {

            desc.addFamily(new HColumnDescriptor(family[i]));

        }

        if (admin.tableExists(tableName)) {

            System.out.println("table Exists!");

            System.exit(0);

        } else {

            admin.createTable(desc);

            System.out.println("create table Success!");

        }

    }

 

    /*

     * 表添加数据

     * @rowKey rowKey

     * @tableName 表名

     * @column1 第一个列族数组 realname

     * @value1 第一个列的值的数组

     * @column2 第二个列族数组 address

     * @value2 第二个列的值的数组

     */

    public static void addTableData(String rowKey, String tableName,String[] column1, String[] value1, String[] column2, String[] value2)

            throws IOException {

        Put put = new Put(Bytes.toBytes(rowKey));

        HTable table = (HTable) tablePool.getTable(tableName);

        HColumnDescriptor[] columnFamilies = table.getTableDescriptor()

                .getColumnFamilies();

 

        for (int i = 0; i < columnFamilies.length; i++) {

            String familyName = columnFamilies[i].getNameAsString();

            if (familyName.equals("realname")) {

                for (int j = 0; j < column1.length; j++) {

                    put.add(Bytes.toBytes(familyName),Bytes.toBytes(column1[j]), Bytes.toBytes(value1[j]));

                }

            }

            if (familyName.equals("address")) {

                for (int j = 0; j < column2.length; j++) {

                    put.add(Bytes.toBytes(familyName),Bytes.toBytes(column2[j]), Bytes.toBytes(value2[j]));

                }

            }

        }

        table.put(put);

    }

 

    /*

     * 更新表中的某一列

     * @tableName 表名

     * @rowKey rowKey

     * @familyName 列族名

     * @columnName 列名

     * @value 更新后的值

     */

    public static void updateTable(String tableName, String rowKey,

            String familyName, String columnName, String value)

            throws IOException {

        HTable table = (HTable) tablePool.getTable(tableName);

        Put put = new Put(Bytes.toBytes(rowKey));

        put.add(Bytes.toBytes(familyName), Bytes.toBytes(columnName),Bytes.toBytes(value));

        table.put(put);

    System.out.println("update table Success!");

    }

 

    /*

     * 根据rwokey查询

     * @rowKey rowKey

     * @tableName 表名

     */

    public static Result getResult(String tableName, String rowKey)

            throws IOException {

        Get get = new Get(Bytes.toBytes(rowKey));

        HTable table = (HTable) tablePool.getTable(tableName);

        Result result = table.get(get);

        for (KeyValue kv : result.list()) {

            System.out.println("family==>" + Bytes.toString(kv.getFamily()));

            System.out.println("qualifier==>" + Bytes.toString(kv.getQualifier()));

            System.out.println("value==>" + Bytes.toString(kv.getValue()));

            System.out.println("Timestamp==>" + kv.getTimestamp());

        }

        return result;

    }

 

    /*

     * 遍历查询hbase表数组

     * @tableName 表名

     */

    public static void getResultScann(String tableName) throws IOException {

        Scan scan = new Scan();

        ResultScanner rs = null;

        HTable table = (HTable) tablePool.getTable(tableName);

        try {

            rs = table.getScanner(scan);

            for (Result r : rs) {

                for (KeyValue kv : r.list()) {

                    System.out.println("family==>" + Bytes.toString(kv.getFamily()));

                    System.out.println("qualifier==>" + Bytes.toString(kv.getQualifier()));

                    System.out.println("value==>" + Bytes.toString(kv.getValue()));

                    System.out.println("timestamp==>" + kv.getTimestamp());

                }

            }

        } finally {

            rs.close();

        }

    }

 

    /*

     * 查询表中的某单一列

     * @tableName 表名

     * @rowKey rowKey

     */

    public static void getResultByColumn(String tableName, String rowKey,

            String familyName, String columnName) throws IOException {

        HTable table = (HTable) tablePool.getTable(tableName);

        Get get = new Get(Bytes.toBytes(rowKey));

        get.addColumn(Bytes.toBytes(familyName), Bytes.toBytes(columnName)); // 获取指定列族以及列中修饰符对应列名

        Result result = table.get(get);

        for (KeyValue kv : result.list()) {

            System.out.println("family==>" + Bytes.toString(kv.getFamily()));

            System.out.println("qualifier==>" + Bytes.toString(kv.getQualifier()));

            System.out.println("value==>" + Bytes.toString(kv.getValue()));

            System.out.println("Timestamp==>" + kv.getTimestamp());

        }

    }

 

    /*

     * 查询某列数据的多个版本

     * @tableName 表名

     * @rowKey rowKey

     * @familyName 列族名

     * @columnName 列名

     */

    public static void getResultByVersion(String tableName, String rowKey,

            String familyName, String columnName) throws IOException {

        HTable table = (HTable) tablePool.getTable(tableName);

        Get get = new Get(Bytes.toBytes(rowKey));

        get.addColumn(Bytes.toBytes(familyName), Bytes.toBytes(columnName));

        get.setMaxVersions(5);

        Result result = table.get(get);

        for (KeyValue kv : result.list()) {

            System.out.println("family==>" + Bytes.toString(kv.getFamily()));

            System.out.println("qualifier==>" + Bytes.toString(kv.getQualifier()));

            System.out.println("value==>" + Bytes.toString(kv.getValue()));

            System.out.println("Timestamp==>" + kv.getTimestamp());

        }

         

    }

 

    /*

     * 删除指定的列

     * @tableName 表名

     * @rowKey rowKey

     * @familyName 列族名

     * @columnName 列名

     */

    public static void deleteColumn(String tableName, String rowKey,

            String falilyName, String columnName) throws IOException {

        HTable table = (HTable) tablePool.getTable(tableName);

        Delete deleteColumn = new Delete(Bytes.toBytes(rowKey));

        deleteColumn.deleteColumns(Bytes.toBytes(falilyName),Bytes.toBytes(columnName));

        table.delete(deleteColumn);

        System.out.println(falilyName + "==>" + columnName + "is deleted!");

    }

 

    /*

     * 删除指定的列

     * @tableName 表名

     * @rowKey rowKey

     */

    public static void deleteAllColumn(String tableName, String rowKey) throws IOException {

        HTable table = (HTable) tablePool.getTable(tableName);

        Delete deleteAll = new Delete(Bytes.toBytes(rowKey));

        table.delete(deleteAll);

        System.out.println("all columns are deleted!");

    }

 

    /*

     * 删除表

     * 

     * @tableName 表名

     */

    public static void deleteTable(String tableName) throws IOException {

        HBaseAdmin admin = new HBaseAdmin(conf);

        admin.disableTable(tableName);

        admin.deleteTable(tableName);

        System.out.println(tableName + " is deleted!");

    }

}

package com.yoodb;

 

public class Test {

    public static void main(String[] args) throws Exception {

        // 创建表

        String tableName = "yoodbblog";

        String[] family = { "realname","address" };

        HBaseTest.creatTable(tableName,family);

        // 为表添加数据

        String[] column1 = { "title", "author", "content" }; 

        String[] value1 = {"素文宅","yoodb","www.yoodb.com" }; 

        String[] column2 = { "name", "nickname" };

        String[] value2 = { "真实名称", "昵称" }; 

        HBaseTest.addTableData("rowkey1","yoodbblog",column1, value1, column2, value2);

        // 删除一列

        HBaseTest.deleteColumn("yoodbblog", "rowkey1", "realname", "name");

        // 删除所有列

        HBaseTest.deleteAllColumn("yoodbblog", "rowkey1");

        // 删除表

        HBaseTest.deleteTable("yoodbblog");

        // 查询

        HBaseTest.getResult("yoodbblog", "rowkey1");

        // 查询某一列的值

        HBaseTest.getResultByColumn("yoodbblog", "rowkey1", "realname", "nickname");

        // 修改某一列的值

        HBaseTest.updateTable("yoodbblog", "rowkey1", "realname", "nickname","假昵称");

        // 遍历表数据查询

        HBaseTest.getResultScann("yoodbblog");

        // 查询某列的多版本

        HBaseTest.getResultByVersion("yoodbblog", "rowkey1", "realname", "name");

    }

}