数据库路由中间件MyCat - 源代码篇（11）

此文已由作者张镐薪授权网易云社区发布。

欢迎访问网易云社区，了解更多网易技术产品运营经验。

4.配置模块

每个MyCatServer初始化时，会初始化： MyCatServer.java:

public static final String NAME = "MyCat";private static final long LOG_WATCH_DELAY = 60000L;private static final long TIME_UPDATE_PERIOD = 20L;private static final MycatServer INSTANCE = new MycatServer();private static final Logger LOGGER = LoggerFactory.getLogger("MycatServer");private final RouteService routerService;private final CacheService cacheService;private Properties dnIndexProperties;//AIO连接群组private AsynchronousChannelGroup[] asyncChannelGroups;private volatile int channelIndex = 0;//全局序列号private final MyCATSequnceProcessor sequnceProcessor = new MyCATSequnceProcessor();private final DynaClassLoader catletClassLoader;private final SQLInterceptor sqlInterceptor;private volatile int nextProcessor;private BufferPool bufferPool;private boolean aio = false;//XA事务全局ID生成private final AtomicLong xaIDInc = new AtomicLong();private MycatServer() {    //读取文件配置

    this.config = new MycatConfig();    //定时线程池，单线程线程池

    scheduler = Executors.newSingleThreadScheduledExecutor();    //SQL记录器

    this.sqlRecorder = new SQLRecorder(config.getSystem()

            .getSqlRecordCount());    /**

     * 是否在线，MyCat manager中有命令控制

     * | offline | Change MyCat status to OFF |

     * | online | Change MyCat status to ON |

     */

    this.isOnline = new AtomicBoolean(true);    //缓存服务初始化

    cacheService = new CacheService();    //路由计算初始化

    routerService = new RouteService(cacheService);    // load datanode active index from properties

    dnIndexProperties = loadDnIndexProps();    try {        //SQL解析器

        sqlInterceptor = (SQLInterceptor) Class.forName(

                config.getSystem().getSqlInterceptor()).newInstance();

    } catch (Exception e) {        throw new RuntimeException(e);

    }    //catlet加载器

    catletClassLoader = new DynaClassLoader(SystemConfig.getHomePath()

            + File.separator + "catlet", config.getSystem()

            .getCatletClassCheckSeconds());    //记录启动时间

    this.startupTime = TimeUtil.currentTimeMillis();

}

第一步是读取文件配置，主要是三个文件：schema.xml，rule.xml和server.xml. 读取后的配置会加载到MyCatConfig中。 MyCatConfig.java:

public MycatConfig() {//读取schema.xml，rule.xml和server.xmlConfigInitializer confInit = new ConfigInitializer(true);this.system = confInit.getSystem();this.users = confInit.getUsers();this.schemas = confInit.getSchemas();this.dataHosts = confInit.getDataHosts();this.dataNodes = confInit.getDataNodes();for (PhysicalDBPool dbPool : dataHosts.values()) {

    dbPool.setSchemas(getDataNodeSchemasOfDataHost(dbPool.getHostName()));

}this.quarantine = confInit.getQuarantine();this.cluster = confInit.getCluster();//初始化重加载配置时间this.reloadTime = TimeUtil.currentTimeMillis();this.rollbackTime = -1L;this.status = RELOAD;//配置加载锁this.lock = new ReentrantLock();

}

它们都通过ConfigInitializer读取：

public ConfigInitializer(boolean loadDataHost) {    //读取schema.xml

    SchemaLoader schemaLoader = new XMLSchemaLoader();    //读取server.xml

    XMLConfigLoader configLoader = new XMLConfigLoader(schemaLoader);

    schemaLoader = null;    //加载配置

    this.system = configLoader.getSystemConfig();    this.users = configLoader.getUserConfigs();    this.schemas = configLoader.getSchemaConfigs();    //是否重新加载DataHost和对应的DataNode

    if (loadDataHost) {        this.dataHosts = initDataHosts(configLoader);        this.dataNodes = initDataNodes(configLoader);

    }    //权限管理

    this.quarantine = configLoader.getQuarantineConfig();    this.cluster = initCobarCluster(configLoader);    //不同类型的全局序列处理器的配置加载

    if (system.getSequnceHandlerType() == SystemConfig.SEQUENCEHANDLER_MYSQLDB) {

        IncrSequenceMySQLHandler.getInstance().load();

    }    if (system.getSequnceHandlerType() == SystemConfig.SEQUENCEHANDLER_LOCAL_TIME) {

        IncrSequenceTimeHandler.getInstance().load();

    }    //检查user与schema配置对应以及schema配置不为空

    this.checkConfig();

}

4.1 rule.xml

读取schema之前会先读取rule.xml。 XmlSchemaLoader.java:

public XMLSchemaLoader(String schemaFile, String ruleFile) {    //先读取rule.xml

    XMLRuleLoader ruleLoader = new XMLRuleLoader(ruleFile);    this.tableRules = ruleLoader.getTableRules();

    ruleLoader = null;    this.dataHosts = new HashMap<String, DataHostConfig>();    this.dataNodes = new HashMap<String, DataNodeConfig>();    this.schemas = new HashMap<String, SchemaConfig>();    //读取加载schema配置

    this.load(DEFAULT_DTD, schemaFile == null ? DEFAULT_XML : schemaFile);

}public XMLSchemaLoader() {    this(null, null);

}

XMLRuleLoader.java:

public XMLRuleLoader(String ruleFile) {    // this.rules = new HashSet<RuleConfig>();

    //rule名 -> rule

    this.tableRules = new HashMap<String, TableRuleConfig>();    //function名 -> 具体分片算法

    this.functions = new HashMap<String, AbstractPartitionAlgorithm>();    //默认为：/rule.dtd和/rule.xml

    load(DEFAULT_DTD, ruleFile == null ? DEFAULT_XML : ruleFile);

}public XMLRuleLoader() {    this(null);

}

private void load(String dtdFile, String xmlFile) {

    InputStream dtd = null;

    InputStream xml = null;    try {

        dtd = XMLRuleLoader.class.getResourceAsStream(dtdFile);

        xml = XMLRuleLoader.class.getResourceAsStream(xmlFile);        //读取出语意树

        Element root = ConfigUtil.getDocument(dtd, xml)

                .getDocumentElement();        //加载Function

        loadFunctions(root);        //加载TableRule

        loadTableRules(root);

    } catch (ConfigException e) {        throw e;

    } catch (Exception e) {        throw new ConfigException(e);

    } finally {        if (dtd != null) {            try {

                dtd.close();

            } catch (IOException e) {

            }

        }        if (xml != null) {            try {

                xml.close();

            } catch (IOException e) {

            }

        }

    }

}

ConfigUtil.java解析语意树:

public static Document getDocument(final InputStream dtd, InputStream xml) throws ParserConfigurationException,

            SAXException, IOException {

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

    factory.setValidating(true);

    factory.setNamespaceAware(false);

    DocumentBuilder builder = factory.newDocumentBuilder();

    builder.setEntityResolver(new EntityResolver() {        @Override

        public InputSource resolveEntity(String publicId, String systemId) {            return new InputSource(dtd);

        }

    });

    builder.setErrorHandler(new ErrorHandler() {        @Override

        public void warning(SAXParseException e) {

        }        @Override

        public void error(SAXParseException e) throws SAXException {            throw e;

        }        @Override

        public void fatalError(SAXParseException e) throws SAXException {            throw e;

        }

    });    return builder.parse(xml);

}

加载functions，XmlRuleLoader.java

private void loadFunctions(Element root) throws ClassNotFoundException,

            InstantiationException, IllegalAccessException,

            InvocationTargetException {

        NodeList list = root.getElementsByTagName("function");        for (int i = 0, n = list.getLength(); i < n; ++i) {

            Node node = list.item(i);            if (node instanceof Element) {

                Element e = (Element) node;                //获取name标签

                String name = e.getAttribute("name");                //如果Map已有，则function重复

                if (functions.containsKey(name)) {                    throw new ConfigException("rule function " + name

                            + " duplicated!");

                }                //获取class标签

                String clazz = e.getAttribute("class");                //根据class利用反射新建分片算法

                AbstractPartitionAlgorithm function = createFunction(name, clazz);

                ParameterMapping.mapping(function, ConfigUtil.loadElements(e));                //每个AbstractPartitionAlgorithm可能会实现init来初始化

                function.init();                //放入functions map

                functions.put(name, function);

            }

        }

    }private AbstractPartitionAlgorithm createFunction(String name, String clazz)

        throws ClassNotFoundException, InstantiationException,

        IllegalAccessException, InvocationTargetException {

    Class<?> clz = Class.forName(clazz);    //判断是否继承AbstractPartitionAlgorithm

    if (!AbstractPartitionAlgorithm.class.isAssignableFrom(clz)) {        throw new IllegalArgumentException("rule function must implements "

                + AbstractPartitionAlgorithm.class.getName() + ", name=" + name);

    }

    return (AbstractPartitionAlgorithm) clz.newInstance();

}

加载所有的function的node，每一个node就是一个AbstractPartitionAlgorithm，并放入functions这个map中；

private final Map<String, TableRuleConfig> tableRules;

对于每一个node，通过反射新建对应参数的AbstractPartitionAlgorithm。这样，所有的function就加载到了functions这个map中。
同理，加载TableRule，就加上了function是否存在的判断：

/**

* tableRule标签结构：

 * <tableRule name="sharding-by-month">

 *     <rule>

 *         <columns>create_date</columns>

 *         <algorithm>partbymonth</algorithm>

 *     </rule>

 * </tableRule>

 * @param root

 * @throws SQLSyntaxErrorException

    */private void loadTableRules(Element root) throws SQLSyntaxErrorException {    //获取每个tableRule标签

    NodeList list = root.getElementsByTagName("tableRule");    for (int i = 0, n = list.getLength(); i < n; ++i) {

        Node node = list.item(i);        if (node instanceof Element) {

            Element e = (Element) node;            //先判断是否重复

            String name = e.getAttribute("name");            if (tableRules.containsKey(name)) {                throw new ConfigException("table rule " + name

                        + " duplicated!");

            }            //获取rule标签

免费体验云安全(易盾)内容安全、验证码等服务

更多网易技术、产品、运营经验分享请点击。

相关文章：
【推荐】 JAVA异常的最佳工程学实践探索
【推荐】深入解析SQL Server高可用镜像实现原理