Re:Re: Re:Re: index about jdbc thin mode

Tue, 05 Dec 2017 17:19:38 -0800 


The code is here:
String sql = "explain SELECT FID,FNUMBER FROM  
\"customerCache\".CustomerIgniteInfo  WHERE FUSEDSTATUS = 3)"; 
Class.forName("org.apache.ignite.IgniteJdbcThinDriver"); Connection conn = 
DriverManager.getConnection("jdbc:ignite:thin://192.168.63.36?distributedJoins=true");
 PreparedStatement preparedStatement = conn.prepareStatement(sql);

The configuration can see the attachment.
Can transaction cause this problem?

I also use spring with my project.

package com.kingdee.ignite.common.config;

import javax.cache.configuration.MutableConfiguration;

import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.CacheWriteSynchronizationMode;
import org.apache.ignite.configuration.CacheConfiguration;

import com.kingdee.ignite.common.dao.SqlCustomFunction;

public abstract class AbstractCacheConfiguration<K, V> extends 
CacheConfiguration<K, V>{
        private static final long serialVersionUID = 6000710247906756326L;

        public AbstractCacheConfiguration(){

        initialization();
    }

    public void initialization(){
        //设置默认备份节点0
        setDefaultBackups();
        //设置默认分区缓存
        setDefaultCacheMode();
        //设置默认同步备份
        //等待主节点的写或者提交操作完成
        //但是不等待备份节点更新完成
        setDefaultWriteSynchronizationMode();
        //通写
        setDefaultWriteThrough();
        //默认启用后写
        setDefaultWriteBehindEnabled();
        //默认启用通读
        setDefaultReadThrough();

        //后写刷新默认设置为10240
        setDefaultWriteBehindFlushSize();

        //每隔10秒 后写刷新
        setDefaultWriteBehindFlushFrequency();
        //设置持久化到数据库的记录数：10000
        setWriteBehindBatchSize();
        
        setWriteBehindFlushThreadCount();
        
        //再平衡消息的大小，设置为4M
        setRebalanceBatchSize();
        setIndexedTypes();
        //再平衡延迟时间，设置为100 ms
        setRebalanceThrottle();
        
        //定义获取bosUid的sql函数
        setSqlFunctionBosUid();
        

    }

    /**
     * 使用默认分区模式
     * @return CacheConfiguration实例
     */
    public CacheConfiguration<K, V> setDefaultCacheMode() {

        CacheMode partitioned = CacheMode.PARTITIONED;

        return super.setCacheMode(partitioned);
    }

    /**
     * 出于性能原因, 设置备份节点为1
     * @return CacheConfiguration实例
     */
    public CacheConfiguration<K, V> setDefaultBackups() {
        return super.setBackups(1);
    }

    /**
     * 默认设置客户端节点会等待主节点的写或者
提交操纵完成，但不会等待备份节点的更新完成
     * @return CacheConfiguration实例
     */
    public CacheConfiguration<K, V> setDefaultWriteSynchronizationMode() {
        CacheWriteSynchronizationMode primarySync = 
CacheWriteSynchronizationMode.PRIMARY_SYNC;
        return super.setWriteSynchronizationMode(primarySync);
    }

    /**
     * 设置后写启用
     * @return CacheConfiguration实例
     */
    public CacheConfiguration<K, V> setDefaultWriteBehindEnabled() {
        return super.setWriteBehindEnabled(true);
    }

    /**
     * 设置通读启用
     * @return CacheConfiguration实例
     */
    public MutableConfiguration<K, V> setDefaultReadThrough() {
        return super.setReadThrough(true);
    }

    public MutableConfiguration<K, V> setDefaultWriteThrough() {
        return super.setWriteThrough(true);
    }

    /**
     * 后写缓存的最大值，如果超过了这个限值，
     * 所有的缓存数据都会被刷入缓存存储然后写缓存被清
空。
     * 如果值为0，刷新操作将会依据刷新频率间隔，
     * 注意不能将写缓存大小和刷新频率都设置为0
     * @return CacheConfiguration实例
     */
    public CacheConfiguration<K, V> setDefaultWriteBehindFlushSize() {
        return super.setWriteBehindFlushSize(10240);
    }
    
    public CacheConfiguration<K, V> setWriteBehindBatchSize() {
        return super.setWriteBehindBatchSize(10000);
    }
    
    public CacheConfiguration<K, V> setDefaultWriteBehindFlushFrequency() {
        return super.setWriteBehindFlushFrequency(10000);
    }
    
    public CacheConfiguration<K, V> setIndexedTypes(Class<?> clazz){

        return super.setIndexedTypes(String.class,clazz);
        
    }
    
    public CacheConfiguration<K, V> setWriteBehindFlushThreadCount(){
        return super.setWriteBehindFlushThreadCount(3);
    }
    
    public CacheConfiguration<K,V> setRebalanceBatchSize(){
        
        return super.setRebalanceBatchSize(4*1024*1024);
    }
    
    public CacheConfiguration<K,V> setRebalanceThrottle(){
        return super.setRebalanceThrottle(100);
    }
    
    public CacheConfiguration<K,V> setSqlFunctionBosUid(){
        return super.setSqlFunctionClasses(SqlCustomFunction.class);
    }
    
}

package com.kingdee.ignite.common.config;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi;
import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
import org.apache.log4j.Logger;

import com.kingdee.ignite.common.test.TestMain;

/**
 * 分布式缓存使用配置
 * 可以继承该配置,实现多个配置多个加载
 * 通过继承可以实现代码重用,不需要再é…
ç½®æ–‡ä»¶å¤åˆ¶ç²˜è´´å¤šä¸ªbean
 *
 * 该类定义最常用的ignite启动的配置
 */
public abstract class AbstractConfiguration extends IgniteConfiguration {

    private List<String> defaultAddresses;

    private Logger logger = Logger.getLogger(AbstractConfiguration.class);

    public AbstractConfiguration(){
        initialization();
    }

    public void initialization(){
        //setDefaultCommunicationSpi();
        //初始化默认缓存配置
        setDefaultCacheConfiguration();
        //初始化默认集群发现
        //setDefaultDiscoverySpi();
    }



    public void setDefaultCacheConfiguration() {

        CacheConfiguration[] configuration = super.getCacheConfiguration();

        configuration = configuration == null ?
                        new CacheConfiguration[]{
                            new DefaultCacheConfiguration()
                        } : configuration;

        super.setCacheConfiguration(configuration);
    }

    public IgniteConfiguration setDefaultDiscoverySpi() {

        TcpDiscoverySpi spi = new TcpDiscoverySpi();
        TcpDiscoveryVmIpFinder ipFinder = new TcpDiscoveryVmIpFinder();
        List<String> ipAddresses = getDefaultAddresses();
        ipFinder.setAddresses(ipAddresses);
        spi.setIpFinder(ipFinder);
        return super.setDiscoverySpi(spi);
    }

        /**
         * 启动集群初始节点ip 和远程发现ignite集群节点ip 
子类应该复写该方法
         * 
         * @return ip地址集合
         */
        public List<String> getDefaultAddresses() {
                if (defaultAddresses == null) {
                        defaultAddresses = new ArrayList<String>();
                }
                InputStream in = null;
                InputStreamReader reader = null;
                try {
                        in = 
AbstractConfiguration.class.getResourceAsStream("iplist.txt");
                        reader = new InputStreamReader(in, "UTF-8");
                        BufferedReader br = new BufferedReader(reader);
                        String line = null;
                        while ((line = br.readLine()) != null) {
                                defaultAddresses.add(line);
                                logger.error("line===" + line);
                        }
                } catch (Exception e) {
                } finally {
                        try {
                                in.close();
                        } catch (IOException e) {
                        }
                }
                return defaultAddresses;
        }

}

Reply via email to