chen7253886
chen7253886

Thrift连接池优化

#背景
        众所周知，thrift是一款很优秀的rpc框架，公司今年在部门间推行thrift框架来提高部门间的通信效率，作者本人的工作内容主要是作为客户端(本人所在组为服务端，对于提供服务的其他部门来说是客户端)调用其他部门的接口，在工作过程中发现thrift有个较大的弊端，一般情况下服务端会向客户端提供一组服务IP，所有的负载均衡工作，连接是否可用等工作都需要客户端自己来维护，而apache本身提供的thrift、GenericObjectPool 并没有提供相应的机制来保证当服务端部分机器服务不可用时及时切换，TSocket.isOpen()方法只能检测到连接是否打开，在已打开的情况下然后网络中断或服务宕机，该方法是无法检测到连接的可用性，所以整个工作需要我们自己来维护，本文作者将介绍下自己在开发过程中碰到的问题以及改进方式，欢迎有更好的处理方式的同学分享经验。
        本文前几节主要介绍优化过程中的策略，最后一节会用最新的代码来展示最新的策略实现。

#第一版大概设计
        首先确定了连接池整体框架如下图：

Thrift连接池优化_第1张图片

  • ThriftTSocket：该类继承自TSocket，创建该类而不使用原生TSocket有两点原因，1.原生的TTransport无法获取到Socket对象，进而无法获取到某条连接的ip,port信息，并且Socket在关闭时也获取不到ip,port信息，所以创建ThriftTSocket，里面添加ip,port,timeout属性,方便负载均衡时使用。2.虽然thrift底层支持多种TTransport协议，但业务中只使用TSocket，所以不必支持所有协议，连接池只支持保存ThriftTSocket。
  • AddressProvider：用于保存服务端的ip和port信息，对外提供selectOne()方法，该方法轮循所有IP并按队列形式返回其中一个IP，用于负载均衡，将连接平均地创建到服务端机器。
  • ThriftConnectionPoolFactory：连接创建工厂，从AddressProvider获取一个IP并创建ThriftTSocket，当创建一次失败时，会轮循一遍IP列表尝试创建。
  • ThriftGenericObjectPool：连接池，直接继承自GenericObjectPool，用于保存ThriftTSocket，对构造方法有小改动。
  • ThriftInvocationHandler：负责从连接池获取ThriftTSocket，转为可调用的thrift client端后执行方法调用，并进行连接响应时间统计等其他工作。
  • ThriftServiceClientProxyFactory：代理工厂，提供给业务层调用，会加载thrift服务的Client Factory相关类，并创建ThriftInvocationHandler。

        在确定了整体框架后，设计具体策略如下：

  • ThriftGenericObjectPool：连接池参数设置maxActive=maxIdle=minIdle；连接的保存形式采用队列；其他参数默认即可
  • ThriftInvocationHandler：当一条连接执行中发生timeout异常时（对方服务出现问题，网络问题可能性较小），将该连接close并返回给连接池，下次获取到尝试再open，并不从连接池中remove
  • ThriftInvocationHandler：对每条连接对应的IP做响应时间统计，当某个IP的平均响应时间超过阀值时，将该IP标记为“切服”状态，下次从连接池中取出该IP的连接时，会直接返回null，一定时间后“切服”状态自动清除

        制定策略的依据在于：虽然ThriftConnectionPoolFactory在创建连接时会轮循对方的服务IP，但是当部分服务IP宕机时，会创建新的连接集中打到正常的机器上，恢复后的机器无法收到任何请求，所以考虑到负载均衡问题，连接池采用maxActive=maxIdle=minIdle策略，项目启动时便均衡的创建到每个IP的连接，不remove有问题的连接来保证请求均匀打到对方机器，为了防止对方服务有问题造成我方大量线程阻塞的情况，又加入了“切服”机制进行降级处理。
        采用此种策略后，在压测过程中发现，当后端服务宕机时，并不影响客户端机器的运行，并且达到了负载均衡的效果，后端可以均匀的收到的请求，但产生的较大的一个问题是：由于部分IP进入“切服”状态，到该IP的连接处理的请求的速度会非常快（直接return null比调用thrift接口快得非常多），进而导致绝大数请求拿到了空数据，而不是按照“切服”IP连接在连接池中的比例数取不到数据。

#第二版优化

        为了解决部分IP进入“切服”导致的绝大多数请求拿不到数据的情况，优化策略如下：

  • ThriftGenericObjectPool：连接池参数设置maxActive=maxIdle，minIdle=0；连接的保存形式使用栈结构；启用监控线程，每隔1分钟清理一次空闲连接；设置获取连接策略为阻塞time时间后抛出异常
  • ThriftInvocationHandler：当某一条连接发生timeout时，认为该条连接不可用(初始化timeout值较大，所以发生 timeout时可认为服务不用)，并从连接池中remove掉该条连接
  • ThriftInvocationHandler： “切服”逻辑改为针对整个服务，不再针对某一IP，当获取连接时获取到一定量的阻塞抛出异常情况，认为整个服务不可用，对其“切服”，所有的请求均return null，一定时间后“切服”状态自动清除
  • ThriftConnectionPoolFactory:删除轮循所有IP行为，由于设置了阻塞时间，这里的创建过程用时久，代码执行不到。
            优化策略的依据：当连接发生timeout时从连接池中remove掉，并创建新的可用连接，这样可保证所有请求都会取得数据。另外，为了方便连接的重建，设置minIdle=0，在半夜QPS较低的时候可将连接回收，白天QPS提高时重新均衡地创建连接到所有服务器上。由于发生timeout时将该条连接清除(表明该IP已不可用)，所以后续是无法创建到该IP的连接，进而无法统计该IP的响应时间，也就不会进入“切服”逻辑，所以调整为针对整个服务进行“切服”，例如：6台机器3台宕机，但可以支撑起服务，就认为其服务可用，并且起到一定的负载均衡作用，当6台机器都宕机时，认为其服务不可用，进入“切服”，宕掉的机器在“切服”期间都恢复后，“切服”状态清除后，又可均衡的创建连接到6台机器。
            优化后的策略可以提高请求的正确性，也达到了一定的负载均衡效果，但还是存在以下两个问题：
  1. 当服务端需要添加服务器IP或者删除服务器IP时，需要人工通知客户端修改配置文件并重启服务
  2. 晚上QPS较高时，如果部分机器宕机后恢复，由于连接已经稳定，无法新创建到恢复后的机器连接，只能等到晚上QPS下降后清除连接，白天QPS上升才能均匀创建连接

#第三版优化

        目前优化的最后一版，额外添加了zookeeper监控服务，zookeeper由运维提供给客户端，作者这里只负责调用zookeeper集群，具体策略如下：

  • AddressProvider：添加zookeeper客户端进行实时监控，当集群注册的服务有更改时，及时修改本地的IP列表。
  • ThriftInvocationHandler：在远程方法调用结束后，加入连接统计功能，统计连接池中每个IP的连接数，并将其与本地的IP列表进行对比，发现负载不均衡时及时删除当前连接，并创建合适的连接。

        加入zookeeper监控和统计连接功能后，能够达到实时负载均衡的功能，同时保证了本服务的高可用性，目前统计连接功能还未实现，后面的代码只包括zookeeper监控功能，整个框架图改进如下：

Thrift连接池优化_第2张图片

        ZookeeperFactory：用于生成一个CuratorFramework客户端，维护更新AddressProvider的服务列表。

#代码实现

1.连接类 ThriftTSocket

package省略
import省略

public class ThriftTSocket extends TSocket {

    private String hostThrift;//连接的ip
    private int portThrift;//连接的port
    private int timeoutThrift;//连接设置的timeout时长

    public ThriftTSocket(String host, int port, int timeout) throws TTransportException {
        super(host, port, timeout);
        this.hostThrift = host;
        this.portThrift = port;
        this.timeoutThrift = timeout;
    }

    public String getHostThrift() {
        return this.hostThrift;
    }

    public int getPortThrift() {
        return this.portThrift;
    }

    public int getTimeoutThrift() {
        return this.timeoutThrift;
    }

}

2.第三方服务状态

package省略
import省略

public class ThriftServiceStatus {

    private static Log serviceStatusLoger = LogFactory.getLog("serviceStatusLoger");
    private static Log apiSwitchMonitor = LogFactory.getLog("apiSwitchMonitorLog");

    private static final int INTERFACE_TOTAL_COUNT = 30;// 服务访问次数达到该值进行切服计算
    private static final long INTERFACE_RECORD_COUNT_RESET_TIME = 1 * 60 * 1000;// 服务统计量重置时间间隔
    private static final long INTERFACE_AUTO_NORMAL_TIME = 5 * 60 * 1000;// 接口自动恢复时间5分钟

    /**
     * 第三方服务异常次数
     */
    private int count;

    /**
     * 第三方服务开始计数时间
     */
    private long recordStartTime;

    /**
     * 第三方服务最近一次关闭时间
     */
    private long closeTime;

    /**
     * 第三方服务名称
     */
    private String serviceName;

    private Lock lock;

    public ThriftServiceStatus(String serviceName) {
        this.recordStartTime = System.currentTimeMillis();
        this.count = 0;
        this.closeTime = 0;
        this.lock = new ReentrantLock();
        this.serviceName = serviceName;
    }

    /**
     * 在切服时间内，服务处于不可用状态
     * @return
     */
    public boolean ifServiceUsable() {
        return (System.currentTimeMillis() - this.closeTime) > INTERFACE_AUTO_NORMAL_TIME;
    }

    public void checkThriftServiceStatus() {
        this.lock.lock();
        try {
            this.count++;

            serviceStatusLoger.info("[this service " + this.serviceName + "]" + "  has exceptions. count:["
                    + this.count + "] recordStartTime:[" + TimeUtil.timestamp2date(recordStartTime) + "] nowTime:["
                    + TimeUtil.timestamp2date(System.currentTimeMillis()) + "]");
            // 服务异常次数 超过统计阀值时 进行 切服
            if (this.count >= INTERFACE_TOTAL_COUNT) {
                this.closeTime = System.currentTimeMillis();// 更新关闭时间
                apiSwitchMonitor.info("[" + this.serviceName + "]" + " close time:["
                        + TimeUtil.timestamp2date(this.closeTime) + "]" + "average response time:[10000]");
            }
            // 1分钟后 重置计数
            if ((System.currentTimeMillis() - recordStartTime) > INTERFACE_RECORD_COUNT_RESET_TIME) {
                this.count = 0;
                this.recordStartTime = System.currentTimeMillis();
            }
        } finally {
            this.lock.unlock();
        }
    }

}

3.CuratorFramework客户端，连接zookeeper集群

package省略
import省略

public class ZookeeperFactory implements FactoryBean, Closeable, InitializingBean {
    private static Logger LOGGER = LoggerFactory.getLogger(ZookeeperFactory.class);

    /**
     * zookeeper集群地址
     */
    private String zookeeperHosts;

    // session超时
    private int sessionTimeout = 3000;
    private int connectionTimeout = 3000;

    private CuratorFramework zkClient;

    // 第三方未提供，所以暂时用不到
    private String namespace;

    public void setZookeeperHosts(String zookeeperHosts) {
        this.zookeeperHosts = zookeeperHosts;
    }

    public void setSessionTimeout(int sessionTimeout) {
        this.sessionTimeout = sessionTimeout;
    }

    public void setConnectionTimeout(int connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public void setNamespace(String namespace) {
        this.namespace = namespace;
    }

    public void setZkClient(CuratorFramework zkClient) {
        this.zkClient = zkClient;
    }

    @Override
    public CuratorFramework getObject() throws Exception {
        return this.zkClient;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        if (StringUtil.isBlank(this.zookeeperHosts)) {
            return;
        }
        this.zkClient = this.create(zookeeperHosts, sessionTimeout, connectionTimeout, namespace);
        this.zkClient.start();
    }

    private CuratorFramework create(String connectString, int sessionTimeout, int connectionTimeout, String namespace) {
        try {
            CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder();
            return builder.connectString(connectString).sessionTimeoutMs(sessionTimeout).connectionTimeoutMs(30000)
                    .canBeReadOnly(true).namespace(namespace)
                    .retryPolicy(new ExponentialBackoffRetry(1000, Integer.MAX_VALUE)).defaultData(null).build();
        } catch (Exception e) {
            LOGGER.error("ZookeeperFactory create error", e);
            throw e;
        }
    }

    public void close() {
        if (zkClient != null) {
            zkClient.close();
        }
    }

    @Override
    public Class getObjectType() {
        return CuratorFramework.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

}

4.保存服务IP类

package省略
import省略

public class AddressProvider {
    private static Logger LOGGER = LoggerFactory.getLogger(AddressProvider.class);

    /**
     * 最新的服务器IP列表，由zookeeper来维护更新
     */
    private List serverAddresses = new CopyOnWriteArrayList();

    /**
     * 没有配置zookeeper时使用原来配置文件中的IP列表
     */
    private List backupAddresses = new LinkedList();

    /**
     * 轮循队列，获取IP时使用
     */
    private Queue loop = new LinkedList();

    private Lock loopLock = new ReentrantLock();

    /**
     * zookeeper 监控
     */
    private PathChildrenCache cachedPath;

    public AddressProvider() {
    }

    public AddressProvider(String backupAddress, CuratorFramework zkClient, String zookeeperPath) throws Exception {
        // 默认使用配置文件中的IP列表
        this.backupAddresses.addAll(this.transfer(backupAddress));
        this.serverAddresses.addAll(this.backupAddresses);
        Collections.shuffle(this.backupAddresses);
        Collections.shuffle(this.serverAddresses);

        // 配置zookeeper时，启动客户端
        if (!StringUtil.isBlank(zookeeperPath) && zkClient != null) {
            this.buildPathChildrenCache(zkClient, zookeeperPath, true);
            cachedPath.start(StartMode.POST_INITIALIZED_EVENT);
        }
    }

    public InetSocketAddress selectOne() {
        loopLock.lock();
        try {
            if (this.loop.isEmpty()) {
                this.loop.addAll(this.serverAddresses);
            }
            return this.loop.poll();
        } finally {
            loopLock.unlock();
        }
    }

    public Iterator addressIterator() {
        return this.serverAddresses.iterator();
    }

    /**
     * 初始化 cachedPath，并添加监听器，当zookeeper上任意节点数据变动时，更新本地serverAddresses
     * @param client
     * @param path
     * @param cacheData
     * @throws Exception
     */
    private void buildPathChildrenCache(final CuratorFramework client, String path, Boolean cacheData) throws Exception {
        final String logPrefix = "buildPathChildrenCache_" + path + "_";
        cachedPath = new PathChildrenCache(client, path, cacheData);
        cachedPath.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
                PathChildrenCacheEvent.Type eventType = event.getType();
                switch (eventType) {
                case CONNECTION_RECONNECTED:
                    LOGGER.info(logPrefix + "Connection is reconection.");
                    break;
                case CONNECTION_SUSPENDED:
                    LOGGER.info(logPrefix + "Connection is suspended.");
                    break;
                case CONNECTION_LOST:
                    LOGGER.warn(logPrefix + "Connection error,waiting...");
                    return;
                case INITIALIZED:
                    LOGGER.warn(logPrefix + "Connection init ...");
                default:
                }
                // 任何节点的时机数据变动,都会rebuild,此处为一个"简单的"做法.
                cachedPath.rebuild();
                rebuild();
            }

            private void rebuild() throws Exception {
                List children = cachedPath.getCurrentData();
                if (CollectionUtils.isEmpty(children)) {
                    // 有可能所有的thrift server都与zookeeper断开了链接
                    // 但是 thrift client与thrift server之间的网络是良好的
                    // 因此此处是否需要清空serverAddresses,是需要多方面考虑的.
                    // 这里我们认为zookeeper的服务是可靠的，数据为空也是正确的
                    serverAddresses.clear();
                    LOGGER.error(logPrefix + "server ips in zookeeper is empty");
                    return;
                }
                List lastServerAddress = new LinkedList();
                for (ChildData data : children) {
                    String address = new String(data.getData(), "utf-8");
                    lastServerAddress.add(transferSingle(address));
                }

                // 更新本地IP列表
                serverAddresses.clear();
                serverAddresses.addAll(lastServerAddress);
                Collections.shuffle(serverAddresses);
            }
        });
    }

    /**
     * 将String地址转换为InetSocketAddress
     * @param serverAddress
     *            10.183.222.59:1070
     * @return
     */
    private InetSocketAddress transferSingle(String serverAddress) {
        if (StringUtil.isBlank(serverAddress)) {
            return null;
        }
        String[] address = serverAddress.split(":");
        return new InetSocketAddress(address[0], Integer.valueOf(address[1]));
    }

    /**
     * 将多个String地址转为InetSocketAddress集合
     * @param serverAddresses
     *            ip:port;ip:port;ip:port;ip:port
     * @return
     */
    private List transfer(String serverAddresses) {
        if (StringUtil.isBlank(serverAddresses)) {
            return null;
        }
        List tempServerAdress = new LinkedList();
        String[] hostnames = serverAddresses.split(";");
        for (String hostname : hostnames) {
            tempServerAdress.add(this.transferSingle(hostname));
        }
        return tempServerAdress;
    }

}

5.连接创建工厂

package省略
import省略

public class ThriftConnectionPoolFactory extends BasePoolableObjectFactory {
    private static Logger LOGGER = LoggerFactory.getLogger(ThriftConnectionPoolFactory.class);

    private final AddressProvider addressProvider;
    private int timeout = 2000;

    protected ThriftConnectionPoolFactory(AddressProvider addressProvider) throws Exception {
        this.addressProvider = addressProvider;
    }

    @Override
    public ThriftTSocket makeObject() throws Exception {
        String logPrefix = "makeObject_";
        ThriftTSocket thriftTSocket = null;
        InetSocketAddress address = null;
        Exception exception = null;
        try {
            address = this.addressProvider.selectOne();
            thriftTSocket = new ThriftTSocket(address.getHostName(), address.getPort(), timeout);
            thriftTSocket.open();
            LOGGER.info(logPrefix + "connect server:[" + address.getHostName() + ":" + address.getPort() + "] success");
        } catch (Exception e) {
            LOGGER.error(logPrefix + "connect server[" + address.getHostName() + ":" + address.getPort() + "] error: ",
                    e);
            exception = e;
            thriftTSocket = null;// 这里是为了下面连接其他服务器
        }
        // 轮循所有ip
        if (thriftTSocket == null) {
            String hostName = address.getHostName();
            int port = address.getPort();
            Iterator addressIterator = this.addressProvider.addressIterator();
            while (addressIterator.hasNext()) {
                try {
                    address = addressIterator.next();
                    // 不再尝试连接之前已经连接失败的主机
                    if (address.getHostName().equals(hostName) && address.getPort() == port) {
                        continue;
                    }
                    thriftTSocket = new ThriftTSocket(address.getHostName(), address.getPort(), timeout);
                    thriftTSocket.open();
                    LOGGER.info(logPrefix + "connect server:[" + address.getHostName() + ":" + address.getPort()
                            + "] success");
                    break;
                } catch (Exception e) {
                    LOGGER.error(logPrefix + "connect server[" + address.getHostName() + ":" + address.getPort()
                            + "] error: ", e);
                    exception = e;
                    thriftTSocket = null;
                }
            }
        }
        // 所有服务均无法建立连接时抛出异常
        if (thriftTSocket == null) {
            throw exception;
        }
        return thriftTSocket;

    }

    @Override
    public void destroyObject(ThriftTSocket tsocket) throws Exception {
        if (tsocket != null) {
            try {
                tsocket.close();
            } catch (Exception e) {
            }
        }

    }

    @Override
    public boolean validateObject(ThriftTSocket tsocket) {
        if (tsocket == null) {
            return false;
        }
        // 在成功创建连接后，将网络断掉，这里调用还是true
        return tsocket.isOpen();
    }
}

6.连接池

package省略
import省略

public class ThriftGenericObjectPool extends GenericObjectPool {

    public ThriftGenericObjectPool(AddressProvider addressProvider, int maxActive, int maxIdle, int minIdle,
            long maxWait) throws Exception {
        /**
         * 池策略：最大连接数，最大等待时间，最大空闲数，最小空闲数由人工配置，
         * 最大连接数尽量=最大空闲数，最小空闲数尽量为0，以便清除无用线程
         * 其他参数写死：
         * GenericObjectPool.WHEN_EXHAUSTED_BLOCK：获取连接时阻塞超时时抛出异常
         * GenericObjectPool.DEFAULT_TEST_ON_BORROW
         * GenericObjectPool.DEFAULT_TEST_ON_RETURN
         * 60*1000，检测空闲线程60秒运行一次
         * 5，检测空闲线程运行一次检测 5条连接
         * 60*10*1000，空闲线程最小空闲时间10分钟，超过10分钟后会被检测线程 remove
         * GenericObjectPool.DEFAULT_TEST_WHILE_IDLE
         * GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS
         * GenericObjectPool.DEFAULT_LIFO 后入先出队列，保证不是所有的连接都在使用，及时被清除
         */
        super(new ThriftConnectionPoolFactory(addressProvider), maxActive, GenericObjectPool.WHEN_EXHAUSTED_BLOCK,
                maxWait, maxIdle, minIdle, GenericObjectPool.DEFAULT_TEST_ON_BORROW,
                GenericObjectPool.DEFAULT_TEST_ON_RETURN, 60 * 1000, 5, 60 * 10 * 1000,
                GenericObjectPool.DEFAULT_TEST_WHILE_IDLE,
                GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS, GenericObjectPool.DEFAULT_LIFO);
    }
}

7.执行器

package省略
import省略

public class ThriftInvocationHandler implements InvocationHandler {
    private static Logger LOGGER = LoggerFactory.getLogger(ThriftInvocationHandler.class);
    private static Log httpClientUtilLogger = LogFactory.getLog(HttpClientUtil.class);

    private GenericObjectPool pool; // 连接池
    private TServiceClientFactory tServiceClientFactory = null;
    private Integer protocol;
    private ThriftServiceStatus thriftServiceStatus;// 服务状态
    private AddressProvider addressProvider;

    public ThriftInvocationHandler(GenericObjectPool pool,
            TServiceClientFactory tServiceClientFactory, Integer protocol, String serviceName,
            AddressProvider addressProvider) {
        this.pool = pool;
        this.tServiceClientFactory = tServiceClientFactory;
        this.protocol = protocol;
        this.thriftServiceStatus = new ThriftServiceStatus(serviceName);
        this.addressProvider = addressProvider;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
        String logPrefix = "ThriftInvocationHandler_";
        ThriftTSocket thriftTSocket = null;
        boolean ifBorrowException = true;
        try {
            // 服务处于“切服”状态时 直接返回null
            if (!this.thriftServiceStatus.ifServiceUsable()) {
                return null;
            }

            // 当第三方服务不可用时，会阻塞在这里一定时间后抛出异常，并进行服务状态统计
            thriftTSocket = this.pool.borrowObject();
            ifBorrowException = false;

            String interfaceWholeName = this.getInterfaceName(method) + "&ip=" + thriftTSocket.getHostThrift() + ":"
                    + thriftTSocket.getPortThrift();
            LOGGER.info(logPrefix + interfaceWholeName + " borrowed:" + this.pool.getNumActive() + "  idle:"
                    + this.pool.getNumIdle() + " total :" + (this.pool.getNumActive() + this.pool.getNumIdle()));

            long startTime = System.currentTimeMillis();
            long costTime;
            Object o = null;
            try {
                o = method.invoke(this.tServiceClientFactory.getClient(this.getTProtocol(thriftTSocket)), args);
                costTime = System.currentTimeMillis() - startTime;
                httpClientUtilLogger.info(this.getUrl(interfaceWholeName, args) + "|200|0|" + costTime + "|0");
            } catch (Exception e) {
                costTime = System.currentTimeMillis() - startTime;
                httpClientUtilLogger.error(this.getUrl(interfaceWholeName, args) + "|000|0|" + costTime + "|1");
                // 抛出异常的连接认为不可用，从池中remove掉
                this.pool.invalidateObject(thriftTSocket);
                thriftTSocket = null;
                o = null;
            }

            return o;
        } catch (Exception e) {
            LOGGER.error("thrift invoke error", e);
            if (ifBorrowException) {
                this.thriftServiceStatus.checkThriftServiceStatus();
            }
            return null;
        } finally {
            if (thriftTSocket != null) {
                this.pool.returnObject(thriftTSocket);
            }
        }
    }

    private String getInterfaceName(Method method) {
        String interfaceName = method.getDeclaringClass().toString();
        interfaceName = interfaceName.substring(10, interfaceName.length());
        return interfaceName + "$" + method.getName();
    }

    private String getUrl(String service, Object[] args) {
        StringBuilder wholeUrl = new StringBuilder("thrift://");
        wholeUrl.append(service.substring(service.lastIndexOf("$") + 1, service.indexOf("&ip="))).append("/?")
                .append("service=").append(service);
        if (args != null) {
            wholeUrl.append("&allParams=[ ");
            for (Object object : args) {
                wholeUrl.append(object);
            }
            wholeUrl.append(" ]");
        }
        return wholeUrl.toString();
    }

    private TProtocol getTProtocol(TSocket tSocket) {
        // 服务端均为非阻塞类型
        TTransport transport = new TFramedTransport(tSocket);
        TProtocol tProtocol = null;
        switch (this.protocol) {
        case 1:
            tProtocol = new TBinaryProtocol(transport);
            break;
        case 2:
            tProtocol = new TCompactProtocol(transport);
            break;
        case 3:
            tProtocol = new TJSONProtocol(transport);
            break;
        case 4:
            tProtocol = new TSimpleJSONProtocol(transport);
            break;
        default:
            tProtocol = new TBinaryProtocol(transport);
        }
        return tProtocol;
    }
}

8.代理工厂

package省略
import省略

public class ThriftServiceClientProxyFactory implements FactoryBean, InitializingBean {
    /**
     * 接口的完整路径
     */
    private String service;

    /**
     * 连接池
     */
    private ThriftGenericObjectPool thriftGenericObjectPool;

    private Object proxyClient;

    private Class objectClass;

    /**
     * 传输协议
     * 1.TBinaryProtocol – 二进制格式.
     * 2.TCompactProtocol – 压缩格式
     * 3.TJSONProtocol – JSON格式
     * 4.TSimpleJSONProtocol –提供JSON只写协议, 生成的文件很容易通过脚本语言解析。
     */
    private Integer protocol;

    private AddressProvider addressProvider;

    @SuppressWarnings("unchecked")
    @Override
    public void afterPropertiesSet() throws Exception {
        // 加载第三方提供的接口和Client.Factory类
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        this.objectClass = (Class) classLoader.loadClass(this.service + "$Iface");
        Class> tServiceClientFactoryClass = (Class>) classLoader
                .loadClass(this.service + "$Client$Factory");
        // 设置创建handler
        InvocationHandler clientHandler = new ThriftInvocationHandler(this.thriftGenericObjectPool,
                tServiceClientFactoryClass.newInstance(), this.protocol, this.service, this.addressProvider);
        this.proxyClient = Proxy.newProxyInstance(classLoader, new Class[] { this.objectClass }, clientHandler);
    }

    @Override
    public Object getObject() throws Exception {
        return this.proxyClient;
    }

    @Override
    public Class getObjectType() {
        return this.objectClass;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    public void setProtocol(Integer protocol) {
        this.protocol = protocol;
    }

    public void setService(String service) {
        this.service = service;
    }

    public void setAddressProvider(AddressProvider addressProvider) {
        this.addressProvider = addressProvider;
    }

    public void setThriftGenericObjectPool(ThriftGenericObjectPool thriftGenericObjectPool) {
        this.thriftGenericObjectPool = thriftGenericObjectPool;
    }
}

 
  
9.调用类
 
  
package省略
import省略

@Component
public class SearchTpDao {
    private final static Logger log = LoggerFactory.getLogger(SearchTpDao.class);

    @Resource
    private GenericServing.Iface searchServing;

    /**
     * 搜索接口
     */
    public GenericServingResponse search(String from, String dt, Integer page, Integer pageSize, String word,
            Integer categoryId, Integer subCategoryId, String ph, String src, Integer mix, String order,
            String searchContent, String splatid, String leIds, String eid, String repo_type, String ispay,
            String albumFilter, String videoFilter, String jf, String sf, String stat, String countryArea,
            String displayAppId, String displayPlatformId, CommonParam commonParam) {
        String logPrefix = "search_" + from + "_" + dt + "_" + page + "_" + pageSize + "_" + word + "_" + categoryId
                + "_" + ph + "_" + src + "_" + mix + "_" + order + "_" + searchContent + "_" + splatid + "_" + leIds
                + "_" + eid + "_" + repo_type + "_" + ispay + "_" + albumFilter + "_" + videoFilter + "_" + jf + "_"
                + sf + "_" + stat + "_" + countryArea + "_" + displayAppId + "_" + displayPlatformId;
        GenericServingResponse response = null;
        try {
        //getSearchRequest省略
            response = this.searchServing.Serve(this.getSearchRequest(from, dt, page, pageSize, word, categoryId,
                    subCategoryId, ph, src, mix, order, searchContent, splatid, leIds, eid, repo_type, ispay,
                    albumFilter, videoFilter, jf, sf, stat, countryArea, null, displayAppId, displayPlatformId,
                    commonParam));
            if (response != null && response.getSearch_response() != null) {
                log.info(logPrefix + " " + response.getSearch_response().getEid());
            }
        } catch (Exception e) {
            response = null;
            log.error(logPrefix, e);
        }
        return response;
    }
}    

 
  
10.配置文件
 
  



        
       
       
         
            
            
            
       
       
        
            
           
            
       
        
       
           
           
           
           
           
       
              
       
       
        
        
        
        
        


 
  
11.thrift配置文件，
 
  
search.search.server.zookeeper=2.2.2.2:2222
search.search.server=1.1.1.1:1111

 
  
        addressProvider已传递给Handler类，后期在连接执行完加入统计算法，给出该IP是否需要被remove。希望有thrift负载均衡、服务发现、高可用心得的同学分享下比较厉害的框架之类的。
 
  
今天看到有在服务端做负载均衡的Haproxy和nginx相关资料：
 http://blog.csdn.net/dengzhilong_cpp/article/details/51729918
 http://blog.csdn.net/ceasadan/article/details/52369045
 http://www.07net01.com/2015/04/819651.html
 参考：
 http://blog.csdn.net/zhu_tianwei/article/details/44115667/
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(thrift)

        

            

                
    
                    
  • 【橘子分布式】Thrift RPC(编程篇)
                        当年明日
分布式分布式rpc网络协议
                        
    一、简介之前我们研究了一下thrift的一些知识，我们知道他是一个rpc框架，他作为rpc自然是提供了客户端到服务端的访问以及两端数据传输的消息序列化，消息的协议解析和传输，所以我们今天就来了解一下他是如何实现这些功能，并且如何在实际代码中使用。我们需要搭建环境。1.安装Thrift作用：把IDL语言描述的接口内容，生成对应编程语言的代码，简化开发。我们已经介绍了在mac如何使用brew安装了。2
    
                    
    • 
                    
  • Flink读取Kafka写入Paimon
                        

                        
    FlinkSQL--1）注册Paimon源CREATECATALOGpaimon_hiveWITH('type'='paimon','warehouse'='hdfs://xxxxx/paimon','metastore'='hive','hive-conf-dir'='/xxxxx/conf','uri'='thrift://域名1:9083,thrift://域名2:9083');--2）声明
    
                    
    • 
                    
  • 深度剖析后端领域的 Thrift 性能优势
                        后端开发笔记
SpringBoot开发实战ai
                        
    深度剖析后端领域的Thrift性能优势关键词：Thrift、RPC框架、序列化、跨语言通信、性能优化、二进制协议、服务治理摘要：在后端系统中，高效的服务间通信是高并发、低延迟架构的核心。作为Facebook开源的跨语言RPC框架，Thrift凭借其“二进制序列化+灵活协议栈”的设计，在性能表现上长期处于行业第一梯队。本文将从Thrift的核心设计入手，通过生活类比、源码解析、实战测试等方式，深度拆
    
                    
    • 
                    
  • 接口自动化测试完整版
                        互联网杂货铺
测试用例职场和发展软件测试python自动化测试接口测试
                        
    点击文末小卡片，免费获取软件测试全套资料，资料在手，涨薪更快1.什么是接口测试顾名思义，接口测试是对系统或组件之间的接口进行测试，主要是校验数据的交换，传递和控制管理过程，以及相互逻辑依赖关系。其中接口协议分为HTTP,WebService,Dubbo,Thrift,Socket等类型，测试类型又主要分为功能测试，性能测试，稳定性测试，安全性测试等。在分层测试的“金字塔”模型中，接口测试属于第二层
    
                    
    • 
                    
  • HBase 架构与数据模型深度解析
                        北漂老男人
HBasehbase架构数据库学习方法
                        
    HBase架构与数据模型深度解析一、前言在大数据时代，HBase以其高扩展性和实时读写能力，成为电商、金融、物联网等行业的核心NoSQL数据库。本文将系统梳理HBase的架构、数据模型、底层原理与最佳实践，助你“知其然，亦知其所以然”。二、HBase架构全景图+-------------------++----------------------+|Client||REST/Thrift|+---
    
                    
    • 
                    
  • 【Netty系列】消息编码解码框架
                        漫步者TZ
Nettynetty编码解码protobuf网络编程
                        
    目录1.ProtocolBuffers(Protobuf)2.ApacheThrift3.FlatBuffers4.MessagePack5.文本协议方案选型决策树新兴趋势在网络通信中，消息的编码（序列化）和解码（反序列化）是核心环节，直接影响通信性能和开发效率。以下是主流的消息编解码框架及其技术对比：1.ProtocolBuffers(Protobuf)特点：二进制协议：高压缩率，传输体积小ID
    
                    
    • 
                    
  • ArgoDB表类型及常用命令
                        sunny05296
数据库数据库argodb
                        
    ArgoDB表类型及常用命令beeline连接ArgoDBbeeline-u"jdbc:transwarp2://:/"-n-p：需要连接的Quark服务中，QuarkServer角色所在节点的IP地址或主机名。：需要连接的Quark服务中，配置参数hive.server2.thrift.port的值，默认为10000。：要连接到的数据库，部署时会默认自动创建default和system数据库。：
    
                    
    • 
                    
  • LUA--thrift--lib库的创建生成
                        senlin1202
LINUXlua
                        
    首选先参考这个作者些的：thrift是一个比较流行的rpc框架，很多公司都有大规模使用的经验，不过网上很少有关于thrift－lua的介绍和exampleapache的thrift－lua也是刚刚从fbthrift项目引入，在安装过程中踩了一些坑，记录一下首先是版本问题，apache-thrift的最新版本是0.9.3，这个版本支持的lua版本是5.2不过由于nginx－lua模块用的是luaji
    
                    
    • 
                    
  • spark start-thriftserver.sh & Kubernetes
                        zhixingheyi_tian
spark大数据云计算sparkkubernetes大数据
                        
    启动命令shsbin/start-thriftserver.sh–masterk8s://https://192.168.99.108:8443–namespark-thriftserver–confspark.executor.instances=1–confspark.kubernetes.container.image=zhixingheyitian/spark:spark2.4.1如果默认
    
                    
    • 
                    
  • hadoop的序列化
                        嘟嘟嘟嘟嘟嘟嘟.
hadoop
                        
    Hadoop中的序列化是指将数据转换为字节流的过程，以便在网络上传输或存储。Hadoop使用自定义的序列化和反序列化机制来处理大量的数据，这有助于在分布式环境中高效地进行数据传输和处理。Hadoop中常用的序列化框架是ApacheAvro、ApacheThrift和GoogleProtocolBuffers。这些框架可以帮助开发人员定义数据结构，然后自动生成相应的序列化和反序列化代码。通过序列化，
    
                    
    • 
                    
  • C++ RPC以及cmake
                        李匠2024
rpc网络协议网络c++
                        
    目录1.RPC概念2.RPC实现计算举例3.python进行rpc调用4.thrift实现分布式容器创建5.阶段总结6.cmake简介7.cmake使用的一般步骤8.cmake编译多层次文件9.cmake编译多种交付件1.RPC概念#1.需求分析靠谱的商用项目不是只有一个可执行程序就够了的。好的商用项目应该遵守的原则：-客户端（方便使用）：启动器，安装包等-服务器（方便部署和扩展）：依赖库，启动脚
    
                    
    • 
                    
  • 微服务的服务调用详解以及常见解决方案对比
                        爱的叹息
微服务SpringBootJava基础整理微服务架构云原生
                        
    微服务服务调用详解1.服务调用分类服务调用根据通信方式、同步性、实现模式可分为以下类型：按通信协议分类类型典型协议/框架特点RPC（远程过程调用）Dubbo、gRPC、ApacheThrift高性能、二进制协议、强类型定义HTTP/RESTSpringRestTemplate、Feign文本协议、无状态、广泛兼容消息队列RabbitMQ、Kafka、RocketMQ异步、解耦、支持高并发按同步性分
    
                    
    • 
                    
  • completablefuture使用案例代码
                        小甄笔记
线程java
                        
    就是将回调方法转为CompletableFuture，然后再依赖CompletableFure的能力进行调用编排@FunctionalInterfacepublicinterfaceThriftAsyncCall{voidinvoke()throwsTException;}/***OctoThriftCallback为thrift回调方法*ThriftAsyncCall为自定义函数，用来表示一次t
    
                    
    • 
                    
  • C++ 实现 MIT6.824 环境配置
                        
分布式
                        
    环境配置Thrift库这个Thrift是一个轻量级的，跨语言的rpc库。安装这个库，我们首先需要安装它需要的依赖。#相关依赖工具sudoyuminstallautomake\libtool\flex\bison\pkgconfig\gcc-c++\boost-devel\libevent-devel\zlib-devel\python-devel\ruby-devel然后下载对应的Thrift的版
    
                    
    • 
                    
  • 【软件架构】分布式架构简介
                        阿寻寻
软件架构分布式架构
                        
    分布式架构简介1、分布式架构简介2、适用场景3、工作原理4、使用的技术和工具5、优点6、缺点7、举例8、更多实例应用电商平台金融服务物联网（IoT）9、技术和工具的进一步说明10、总结11、服务间的调用gRPCRESTfulAPIThrift使用场景举例使用Feign的场景使用SRPC的场景选择考虑1、分布式架构简介分布式架构指的是一种软件架构模式，其中应用程序的不同部分分布在多个网络计算机上，这
    
                    
    • 
                    
  • DBEAVER 连接hive老是掉线
                        dogplays
hive数据仓库
                        
    问题描述：连接生产环境的VPN后用dbeaver连上hive后，经常查询无响应掉线，报错：org.apache.thrift.transport.TTransportException:java.net.SocketException:你的主机中的软件中止了一个已建立的连接。解决方法：如果电脑开启了类似火绒、360这样的安全软件，尝试关闭后执行查询即可（也可以研究此类软件的安全策略），猜测是此类安
    
                    
    • 
                    
  • python import 踩坑指南 / sys.path失效解决方案
                        karmayh
pythonthriftpythonthriftsys.pathsys.modules
                        
    不关心故事背景的朋友们可以直接跳到“解决方案”～文章目录故事背景历史方案解决方案故事背景最近在用thrift的时候遇到一个问题，thrift生成的python文件之间的引用都是相对引用的：thrift_folder├──base│├──constants.py│├──__init__.py│└──ttypes.py├──model│├──__init__.py│├──constants.py│├─
    
                    
    • 
                    
  • HiveMetastore 的架构简析
                        houzhizhen
hivehive
                        
    HiveMetastore的架构简析HiveMetastore是Hive元数据管理的服务。可以把元数据存储在数据库中。对外通过api访问。hive_metastore.thrift对外提供的Thrift接口定义在文件standalone-metastore/src/main/thrift/hive_metastore.thrift中。内容包括用到的结构体和枚举，和常量，和rpcService。如分
    
                    
    • 
                    
  • Hive与Spark的UDF：数据处理利器的对比与实践
                        窝窝和牛牛
hivesparkhadoop
                        
    文章目录Hive与Spark的UDF：数据处理利器的对比与实践一、UDF概述二、HiveUDF解析实现原理代码示例业务应用三、SparkUDF剖析-JDBC方式使用SparkThriftServer设置通过JDBC使用UDFSparkUDF的Java实现（用于JDBC方式）通过beeline客户端连接使用业务应用场景四、Hive与SparkUDF在JDBC模式下的对比五、实际部署与最佳实践六、总结
    
                    
    • 
                    
  • 如何自定义协议
                        kshzhaohui
后端java
                        
    前言何为自定义协议，其实是相对标准协议来说的，这里主要针对的是应用层协议；常见的标准的应用层协议如http、ftp、smtp等，如果我们在网络通信的过程中不去使用这些标准协议，那就需要自定义协议，比如我们常用的RPC框架(dubbo，thrift)，分布式缓存(redis，memcached)等都是自定义协议；本文就来讲讲如何去自定义私有协议，在此之前我们先考虑一下为什么要自定义协议。为什么要自定
    
                    
    • 
                    
  • thrift软件、.thrif文件和thrift协议是什么关系，有什么用
                        fzip
DorisDoris内部通信协议
                        
    Thrift软件、.thrift文件和Thrift协议是ApacheThrift框架的三个核心组成部分，它们协同实现跨语言服务的高效开发与通信。以下是三者关系及作用的详细解析：一、核心组件关系1.Thrift软件（框架）•定位：ApacheThrift是一个跨语言的RPC（远程过程调用）框架，用于不同编程语言编写的服务之间的通信。•功能：•提供IDL（接口定义语言）编译器，将.thrift文件转换
    
                    
    • 
                    
  • 【大数据分析】Spark SQL查询：使用SQL命令
                        sword_csdn
Sparkspark数据分析sql
                        
    对于使用关系型数据库或分布式数据库的用户可能更容易和更自然地使用SQL，比如Hive。在SparkSQL编写SQL命令时，它们将被转换为DataFrame上的操作。通过连接到Spark的Thrift服务器，它们可以通过标准的JDBC或ODBC协议从应用服务器连接到Spark。Spark支持两种SQL方言：SQL和HQL。Spark社区推荐的是HQL，因为HQL具有更丰富的功能。要使用HQL，需要使
    
                    
    • 
                    
  • maven插件学习(maven-shade-plugin和maven-antrun-plugin插件)
                        catcher92
javamavenmaven学习大数据
                        
    整合spark3.3.x和hive2.1.1-cdh6.3.2碰到个问题，就是spark官方支持的hive是2.3.x，但是cdh中的hive确是2.1.x的，项目中又计划用spark-thrift-server，导致编译过程中有部分报错。其中OperationLog这个类在hive2.3中新增加了几个方法，导致编译报错。这个时候有两种解决办法：修改spark源码，注释掉调用OperationLo
    
                    
    • 
                    
  • java获取hive表所有字段,Hive Sql从表中动态获取空列计数
                        拾亿年
java获取hive表所有字段
                        
    我正在使用datastaxspark集成和sparkSQLthrift服务器,它为我提供了一个HiveSQL接口来查询Cassandra中的表.我的数据库中的表是动态创建的,我想要做的是仅根据表名在表的每列中获取空值的计数.我可以使用describedatabase.table获取列名,但在hiveSQL中,如何在另一个为所有列计数null的select查询中使用其输出.更新1：使用Dudu的解决
    
                    
    • 
                    
  • 【TTransportException: java.net.SocketException: Broken pipe (Write failed))】
                        WSSWWWSSW
大数据java.netmybatishive
                        
    @[TOC](org.apache.thrift.transport.TTransportException:java.net.SocketException:Brokenpipe(Writefailed))Errorqueryingdatabase.Cause:java.sql.SQLException:org.apache.thrift.transport.TTransportExceptio
    
                    
    • 
                    
  • 讲解一下SpringBoot的RPC连接
                        陈老师还在写代码
SpringBoot100问springbootrpc后端
                        
    SpringBoot本身并不直接提供RPC（RemoteProcedureCall，远程过程调用）功能，但可以通过集成其他框架或库来实现RPC通信。常见的RPC框架包括Dubbo、gRPC、Thrift、SpringCloud等。下面我将讲解如何在SpringBoot中集成和使用这些RPC框架。1.使用Dubbo实现RPCDubbo是阿里巴巴开源的一个高性能RPC框架，广泛应用于分布式系统中。Sp
    
                    
    • 
                    
  • Ranger Hive Service连接测试失败问题解决
                        一张假钞
hivehadoop数据仓库
                        
    个人博客地址：RangerHiveService连接测试失败问题解决|一张假钞的真实世界异常信息如下：org.apache.ranger.plugin.client.HadoopException:UnabletoconnecttoHiveThriftServerinstance..UnabletoconnecttoHiveThriftServerinstance..Couldnotopencli
    
                    
    • 
                    
  • python操作hbase创建表（一）
                        金融小白数据分析之路
大数据hbasepython数据库
                        
    python通过thrift来操作hbase在开发环境安装python库pipinstallthriftpipinstallhbase-thrifthbase中需要开启hbase-daemon.shstartthrifthadoop、hbse、Zookeeper都需要开启fromhbaseimportHbasefromthrift.transportimportTSocketfromhbase.t
    
                    
    • 
                    
  • Workerman-Thrift 使用教程
                        沈韬淼Beryl

                        
    Workerman-Thrift使用教程workerman-thriftThriftRPCforphpbasedonworkerman.项目地址:https://gitcode.com/gh_mirrors/wo/workerman-thrift1、项目介绍Workerman-Thrift是一个基于Workerman的高性能PHPThriftRPC框架。Workerman是一个高性能的PHPsoc
    
                    
    • 
                    
  • python操作HBase
                        王壮_
大数据Pythonhbase数据库大数据
                        
    1.安装happybase和thriftpipinstallhappybasepipinstallthrift2.启动hbase的thrift进程，并指定端口9090hbase-daemon.shstartthrift-p90903.操作HBaseimporthappybaseconnection=happybase.Connection(host='hadoop10',port=9090)tab
    
                    
    • 
                                
  • java封装继承多态等
                                    麦田的设计者
javaeclipsejvmcencapsulatopn
                                    
           最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。 
    1、final关键字 
      译为：最终的 
       &
    
                                
    • 
                                
  • F5与集群的区别
                                    bijian1013
weblogic集群F5
                                    
            http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。 
        F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
    
                                
    • 
                                
  • LeetCode[Math] - #7 Reverse Integer
                                    Cwind
java题解MathLeetCodeAlgorithm
                                    
    原题链接：#7 Reverse Integer 
  
要求： 
按位反转输入的数字 
例1： 输入 x = 123, 返回 321 
例2： 输入 x = -123, 返回 -321 
  
难度：简单 
  
分析： 
对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
    
                                
    • 
                                
  • BufferedOutputStream
                                    周凡杨

                                    
         首先说一下这个大批量，是指有上千万的数据量。 
     例子： 
     有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！ 
     select t.msisd
    
                                
    • 
                                
  • linux下模拟按键输入和鼠标
                                    被触发
linux
                                    
    查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 
设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 
 
linux/in
    
                                
    • 
                                
  • ContentProvider初体验
                                    肆无忌惮_
ContentProvider
                                    
    ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。 
在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。 
如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
    
                                
    • 
                                
  • 关于Spring MVC项目（maven）中通过fileupload上传文件
                                    843977358
mybatisspring mvc修改头像上传文件upload
                                    
    Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。 
  
1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 
因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） 
<!-- 文件上传 start by zhangyd-c --&g
    
                                
    • 
                                
  • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作
                                    aigo
svnkit
                                    
     原文：http://blog.csdn.net/hardwin/article/details/7963318 
  
import java.io.File;  
  
import org.apache.log4j.Logger;  
import org.tmatesoft.svn.core.SVNCommitInfo;  
import org.tmateso
    
                                
    • 
                                
  • 对比浏览器，casperjs，httpclient的Header信息
                                    alleni123
爬虫crawlerheader
                                    
    		@Override
		protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException
		{
			String type=req.getParameter("type");
			Enumeration es=re
    
                                
    • 
                                
  • java.io操作 DataInputStream和DataOutputStream基本数据流
                                    百合不是茶
java流
                                    
    1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到 
  
  
2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
    
                                
    • 
                                
  • 车辆保险理赔案例
                                    bijian1013
车险
                                    
    理赔案例： 
一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。 
赔付建议和方案： 
客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”； 
如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
    
                                
    • 
                                
  • 学习Spring必学的Java基础知识(5)—注解
                                    bijian1013
javaspring
                                    
            文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。 
  
        有必要对
    
                                
    • 
                                
  • 【Struts2一】Struts2 Hello World
                                    bit1129
Hello world
                                    
    Struts2 Hello World应用的基本步骤 
创建Struts2的Hello World应用，包括如下几步： 
1.配置web.xml 
2.创建Action 
3.创建struts.xml，配置Action 
4.启动web server，通过浏览器访问 
  配置web.xml 
<?xml version="1.0" encoding="
    
                                
    • 
                                
  • 【Avro二】Avro RPC框架
                                    bit1129
rpc
                                    
    1. Avro RPC简介 1.1. RPC 
 
 RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包 
 从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
    
                                
    • 
                                
  • lua　set get cookie
                                    ronin47
lua cookie
                                    
    lua:
local access_token = ngx.var.cookie_SGAccessToken
if access_token then
    ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000"
end
    
                                
    • 
                                
  • java-打印不大于N的质数
                                    bylijinnan
java
                                    
    

public class PrimeNumber {

	/**
	 * 寻找不大于N的质数
	 */
	public static void main(String[] args) {
		int n=100;
		PrimeNumber pn=new PrimeNumber();
		pn.printPrimeNumber(n);
		System.out.print
    
                                
    • 
                                
  • Spring源码学习-PropertyPlaceholderHelper
                                    bylijinnan
javaspring
                                    
    今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 
当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复： 
详见： 
http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug 
 

    
                                
    • 
                                
  • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么?
                                    comsci
拓扑
                                    
     
   如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢? 
 
   是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
    
                                
    • 
                                
  • ITEYE 都换百度推广了
                                    cuisuqiang
GoogleAdSense百度推广广告外快
                                    
    以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。 
  
为什么个人博客设置里面还是Google AdSense呢？ 
  
都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。 
  
什么时候能从ITEYE上来点外快，哪怕少点
    
                                
    • 
                                
  • 新浪微博技术架构分析
                                    dalan_123
新浪微博架构
                                    
    新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
    
                                
    • 
                                
  • 玩转ARP攻击
                                    dcj3sjt126com
r
                                    
    我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
    
                                
    • 
                                
  • PHP编码规范
                                    dcj3sjt126com
编码规范
                                    
    一、文件格式 
1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
    
                                
    • 
                                
  • linux 脱机管理（nohup）
                                    eksliang
linux nohupnohup
                                    
    脱机管理 nohup 
转载请出自出处：http://eksliang.iteye.com/blog/2166699 
nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 
nohup [命令与参数]   --在终端机前台工作
nohup [命令与参数] & --在终端机后台工作 
  
但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
    
                                
    • 
                                
  • BusinessObjects Enterprise Java SDK
                                    greemranqq
javaBOSAPCrystal Reports
                                    
    最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。 
  
首先，我是尝试用JAVA JSP 去访问的。 
  
官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
    
                                
    • 
                                
  • 系统负载剧变下的管控策略
                                    iamzhongyong
高并发
                                    
    假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 
1、水平扩展 
这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 
2、系统分组 
假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
    
                                
    • 
                                
  • BitTorrent DHT 协议中文翻译
                                    justjavac
bit
                                    
    前言 
做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 
 
 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
    
                                
    • 
                                
  • Ubuntu下Java环境的搭建
                                    macroli
java工作ubuntu
                                    
    配置命令： 
　　$sudo apt-get install ubuntu-restricted-extras 
　　再运行如下命令： 
　　$sudo apt-get install sun-java6-jdk 
　　待安装完毕后选择默认Java. 
　　$sudo update- alternatives --config java 
　　安装过程提示选择，输入“2”即可，然后按回车键确定。 
    
                                
    • 
                                
  • js字符串转日期（兼容IE所有版本）
                                    qiaolevip
TODateStringIE
                                    
    	/**
	 * 字符串转时间（yyyy-MM-dd HH:mm:ss）
	 * result （分钟）
	 */
	stringToDate : function(fDate){
		var fullDate = fDate.split(" ")[0].split("-");
		var fullTime = fDate.split("
    
                                
    • 
                                
  • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析
                                    superlxw1234
sql数据挖掘关联规则
                                    
    关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 
关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。 
例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%]  支持度3%：意味3%顾客同时购买牛奶和面包。   置信度40%：意味购买牛奶的顾客40%也购买面包。   规则的支持度和置信度是两个规则兴
    
                                
    • 
                                
  • Spring 5.0 的系统需求，期待你的反馈
                                    wiselyman
spring
                                    
            
       Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。 
  
       Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。 
 
    
                                
    •