_六道木
_六道木

Dubbo源码分析----容错

先看下Dubbo官方的一张图


Dubbo源码分析----容错_第1张图片
image.png

Cluster是容错的核心，官方的说法是

Cluster 将 Directory 中的多个 Invoker 伪装成一个 Invoker，对上层透明，伪装过程包含了容错逻辑，调用失败后，重试另一个

即Cluster是对外暴露的一个接口，内部返回一个集群版的Invoker，通过不同的容错策略，对从Directory中获取的invoker有不同的调用方式

下面看下代码实现

AvailableCluster

public class AvailableCluster implements Cluster {
    
    public static final String NAME = "available";

    public  Invoker join(Directory directory) throws RpcException {
        
        return new AbstractClusterInvoker(directory) {
            public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
                for (Invoker invoker : invokers) {
                    if (invoker.isAvailable()) {
                        return invoker.invoke(invocation);
                    }
                }
                throw new RpcException("No provider available in " + invokers);
            }
        };
        
    }

}

这个策略很简单，就是从List>中获取一个可用的Invoker来进行调用

BroadcastCluster

public class BroadcastClusterInvoker extends AbstractClusterInvoker {
    public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);
        RpcContext.getContext().setInvokers((List)invokers);
        RpcException exception = null;
        Result result = null;
        for (Invoker invoker: invokers) {
            try {
                result = invoker.invoke(invocation);
            } catch (RpcException e) {
                exception = e;
            } catch (Throwable e) {
                exception = e;
            }
        }
        if (exception != null) {
            throw exception;
        }
        return result;
    }

}

看名字就知道大概的意思，广播调用。看代码也很简单，遍历List>进行调用，如果有一个出现异常则抛出异常

FailbackCluster

public class FailbackClusterInvoker extends AbstractClusterInvoker {
    private final ConcurrentMap> failed = new ConcurrentHashMap>();

    public FailbackClusterInvoker(Directory directory){
        super(directory);
    }

    private void addFailed(Invocation invocation, AbstractClusterInvoker router) {
        if (retryFuture == null) {
            synchronized (this) {
                if (retryFuture == null) {
                    retryFuture = scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {

                        public void run() {
                            // 收集统计信息
                            try {
                                retryFailed();
                            } catch (Throwable t) { // 防御性容错
                                logger.error("Unexpected error occur at collect statistic", t);
                            }
                        }
                    }, RETRY_FAILED_PERIOD, RETRY_FAILED_PERIOD, TimeUnit.MILLISECONDS);
                }
            }
        }
        failed.put(invocation, router);
    }

    protected Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        try {
            checkInvokers(invokers, invocation);
            Invoker invoker = select(loadbalance, invocation, invokers, null);
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            addFailed(invocation, this);
            return new RpcResult(); // ignore
        }
    }

}

到这里就和上面的几种方式不一样了，上面的都是直接对List>进行操作，而这里首先需要通过负载均衡策略获取到一个Invoker，然后才进行调用，这个方法是普遍的，那么出错怎么处理才是核心。
这里出错的时候，会调用addFailed方法
首先addFailed方法，使用了double-check的方式来初始化retryFuture，保证其是单例的。如果是已经初始化的，直接放入map中等待定时重试，如何重试那么要看retryFailed方法

    void retryFailed() {
        if (failed.size() == 0) {
            return;
        }
        for (Map.Entry> entry : new HashMap>(
                                                                                                                         failed).entrySet()) {
            Invocation invocation = entry.getKey();
            Invoker invoker = entry.getValue();
            try {
                invoker.invoke(invocation);
                failed.remove(invocation);
            } catch (Throwable e) {
                logger.error("Failed retry to invoke method " + invocation.getMethodName() + ", waiting again.", e);
            }
        }
    }

重试逻辑也很简单，从map中拿出失败的Invoker进行调用，成功则从failed中移除

FailfastCluster

public class FailfastClusterInvoker extends AbstractClusterInvoker{
    public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);
        Invoker invoker = select(loadbalance, invocation, invokers, null);
        try {
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            if (e instanceof RpcException && ((RpcException)e).isBiz()) { // biz exception.
                throw (RpcException) e;
            }
            throw new RpcException(e instanceof RpcException ? ((RpcException)e).getCode() : 0, "Failfast invoke providers " + invoker.getUrl() + " " + loadbalance.getClass().getSimpleName() + " select from all providers " + invokers + " for service " + getInterface().getName() + " method " + invocation.getMethodName() + " on consumer " + NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e.getCause() != null ? e.getCause() : e);
        }
    }

这个策略也很简单，从名字也可以猜出是什么功能：快速失败。
从代码中看，选出一个Invoker进行调用，如果失败，那么不重试

FailoverCluster

类上的注释：

失败转移，当出现失败，重试其它服务器，通常用于读操作，但重试会带来更长延迟。
看到注释，有几个问题：

  1. 重试其他服务器，这个其他服务器是随机挑选的吗？
  2. 如果所有服务器都失败，还会继续重试吗？
  3. 会重试几次呢？

我们看下代码具体是怎么实现的：

public class FailoverClusterInvoker extends AbstractClusterInvoker {

    public Result doInvoke(Invocation invocation, final List> invokers, LoadBalance loadbalance) throws RpcException {
        List> copyinvokers = invokers;
        checkInvokers(copyinvokers, invocation);
        int len = getUrl().getMethodParameter(invocation.getMethodName(), Constants.RETRIES_KEY, Constants.DEFAULT_RETRIES) + 1;
        if (len <= 0) {
            len = 1;
        }
        // retry loop.
        RpcException le = null; // last exception.
        List> invoked = new ArrayList>(copyinvokers.size()); // 已经调用过的Invoker集合.
        Set providers = new HashSet(len);
        for (int i = 0; i < len; i++) {
            //重试时，进行重新选择，避免重试时invoker列表已发生变化.
            //注意：如果列表发生了变化，那么invoked判断会失效，因为invoker示例已经改变
            if (i > 0) {
                        //进行到这里，证明第一次已经失败
                checkWheatherDestoried();
                copyinvokers = list(invocation);
                //重新检查一下
                checkInvokers(copyinvokers, invocation);
            }
            Invoker invoker = select(loadbalance, invocation, copyinvokers, invoked);
            invoked.add(invoker);
            RpcContext.getContext().setInvokers((List)invoked);
            try {
                Result result = invoker.invoke(invocation);
                return result;
            } catch (RpcException e) {
                if (e.isBiz()) { // biz exception.
                    throw e;
                }
                le = e;
            } catch (Throwable e) {
                le = new RpcException(e.getMessage(), e);
            } finally {
                providers.add(invoker.getUrl().getAddress());
            }
        }
        throw new RpcException(...);
    }

}

首先，从url中获取重试次数，在这个基础上+1，进行len次调用。
调用的过程和其他策略，都是先使用LoadBalance策略选出一个Invoker进行调用，但是有没有注意到，select方法在其他策略里传入的是null，这里传入的是List，这会导致什么不同的结果，那么需要看下select的实现

    protected Invoker select(LoadBalance loadbalance, Invocation invocation, List> invokers, List> selected) throws RpcException {
        if (invokers == null || invokers.size() == 0)
            return null;
        String methodName = invocation == null ? "" : invocation.getMethodName();
        
        boolean sticky = invokers.get(0).getUrl().getMethodParameter(methodName,Constants.CLUSTER_STICKY_KEY, Constants.DEFAULT_CLUSTER_STICKY) ;
        {
            //ignore overloaded method
            if ( stickyInvoker != null && !invokers.contains(stickyInvoker) ){
                stickyInvoker = null;
            }
            //ignore cucurrent problem
            if (sticky && stickyInvoker != null && (selected == null || !selected.contains(stickyInvoker))){
                if (availablecheck && stickyInvoker.isAvailable()){
                    return stickyInvoker;
                }
            }
        }
        Invoker invoker = doselect(loadbalance, invocation, invokers, selected);
        
        if (sticky){
            stickyInvoker = invoker;
        }
        return invoker;
    }

select不是核心所在，而是sticky这个参数的实现，有兴趣的可以研究一下，我们主要看核心方法doselect

    private Invoker doselect(LoadBalance loadbalance, Invocation invocation, List> invokers, List> selected) throws RpcException {
        if (invokers == null || invokers.size() == 0)
            return null;
        if (invokers.size() == 1)// 如果只有一个invoker，那么没法负载均衡了，只能选这个了
            return invokers.get(0);
        // 如果只有两个invoker，退化成轮循
        // 如果有两个Invoker，那么不需要进行复杂的负载均衡计算，这个不行就选另外一个
        if (invokers.size() == 2 && selected != null && selected.size() > 0) {
            return selected.get(0) == invokers.get(0) ? invokers.get(1) : invokers.get(0);
        }
        // 使用LB策略选出一个Invoker
        Invoker invoker = loadbalance.select(invokers, getUrl(), invocation);
        
        //如果 selected中包含（优先判断） 或者 不可用&&availablecheck=true 则重试.
        if( (selected != null && selected.contains(invoker))
                ||(!invoker.isAvailable() && getUrl()!=null && availablecheck)){
            try{
                // 重新选择
                Invoker rinvoker = reselect(loadbalance, invocation, invokers, selected, availablecheck);
                if(rinvoker != null){
                    invoker =  rinvoker;
                }else{
                    //看下第一次选的位置，如果不是最后，选+1位置.
                    int index = invokers.indexOf(invoker);
                    try{
                        //最后在避免碰撞
                        invoker = index

通过LB选出一个Invoker之后，会判断改Invoker是否符合条件，不符合条件会进行重新选择，如果选出的不为空那么直接返回，如果重新选择之后还是返回null，那么如果原来选中的这个Invoker是List>最后一个元素，那么还是使用这个Invoker，否则在该Invoker后找一个Invoker(这里为什么是List>最后一个元素那么还是选回原来的Invoker，而不是另外的元素，例如第一个，或者)，是看下reselect的实现

    private Invoker reselect(LoadBalance loadbalance,Invocation invocation,
                                List> invokers, List> selected ,boolean availablecheck)
            throws RpcException {
        
        List> reselectInvokers = new ArrayList>(invokers.size()>1?(invokers.size()-1):invokers.size());
        
        //先从非select中选
        if( availablecheck ){ //选isAvailable 的非select
            for(Invoker invoker : invokers){
                if(invoker.isAvailable()){
                    if(selected ==null || !selected.contains(invoker)){
                        reselectInvokers.add(invoker);
                    }
                }
            }
            if(reselectInvokers.size()>0){
                return  loadbalance.select(reselectInvokers, getUrl(), invocation);
            }
        }else{ //选全部非select
            for(Invoker invoker : invokers){
                if(selected ==null || !selected.contains(invoker)){
                    reselectInvokers.add(invoker);
                }
            }
            if(reselectInvokers.size()>0){
                return  loadbalance.select(reselectInvokers, getUrl(), invocation);
            }
        }
        //到了这里，证明 reselectInvokers为空，那么从已选的列表中选择
        {
            if(selected != null){
                for(Invoker invoker : selected){
                    if((invoker.isAvailable()) //优先选available 
                            && !reselectInvokers.contains(invoker)){
                        reselectInvokers.add(invoker);
                    }
                }
            }
            if(reselectInvokers.size()>0){
                return  loadbalance.select(reselectInvokers, getUrl(), invocation);
            }
        }
        return null;
    }

总的分3个分支

  1. 选择不在selected中的Invoker
  2. 选择不在selected中的Invoker且可用的invoker
  3. 上面选择出来的invokers为空，那么从已选的列表中选择

如果上面3种情况都不能返回一个invoker，那么才会执行这部操作

invoker = index

那么到这里，整个选择流程就结束了，上面几个问题也有了答案

  1. 重试其他的服务器，这个不是随机挑选的，需要根据LB策略，提供方是否可用等策略进行判断，重试过的在下一次重试的时候，基本不会从这个重试过的服务器选择(看到代码中，某些情况还是会选择已经选择过的)
  2. 重试有一定的次数，次数为retries参数+1，如果都失败了，那么只能抛出异常了
  3. 重试有一定的次数，次数为retries参数+1

另外，重试的时候有个注意点

      if (i > 0) {
                   //进行到这里，证明第一次已经失败
          checkWheatherDestoried();
          copyinvokers = list(invocation);
          checkInvokers(copyinvokers, invocation);
      }

由于invoker会动态变化(例如某个服务器挂了，或者某个服务器被禁用了，甚至整个Dubbo实例已经关闭了)，而在一开始的时候拿到的invokers是当时的可用的invoker列表，所以可能存在某个invoker已经不可用了，那么需要检查一下，然后从Directory中获取最新的Invoker列表

FailsafeCluster

public class FailsafeClusterInvoker extends AbstractClusterInvoker{

    public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        try {
            checkInvokers(invokers, invocation);
            Invoker invoker = select(loadbalance, invocation, invokers, null);
            return invoker.invoke(invocation);
        } catch (Throwable e) {
            logger.error("Failsafe ignore exception: " + e.getMessage(), e);
            return new RpcResult(); // ignore
        }
    }
}

这个比较简单，失败了记录日志....

ForkingCluster

这也是一种比较有意思的容错策略，先看下官方描述

并行调用，只要一个成功即返回，通常用于实时性要求较高的操作，但需要浪费更多服务资源

看了描述，有几个问题

  1. 并行调用是把所有invoker拿来并行调用吗？
  2. 如何进行并行调用？
  3. 有一个成功即返回，这个怎么做？
  4. 如果有失败的怎么处理？

带着问题去看源码

public class ForkingClusterInvoker extends AbstractClusterInvoker{

    private final ExecutorService executor = Executors.newCachedThreadPool(new NamedThreadFactory("forking-cluster-timer", true)); 
    public Result doInvoke(final Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        checkInvokers(invokers, invocation);
        final List> selected;
        final int forks = getUrl().getParameter(Constants.FORKS_KEY, Constants.DEFAULT_FORKS);
        final int timeout = getUrl().getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT);
        //如果并行数大于invoker的数量或小于0，那么直接用并行调用所有invoker
        // 因为如果并行为4，而invoker数量为3，那么其实最大并行量也只有3
        if (forks <= 0 || forks >= invokers.size()) {
            selected = invokers;
        } else {
            // 如果并行数大于invoker的数量，那么就需要挑选invoker了，例如并行为4，invoker数量为5，那么从5个挑4个进行并行调用
            // 这里和failover类似，通过select选出一个invoker，然后放到selected里，保证不重复
            selected = new ArrayList>();//并行调用的invoker集合
            for (int i = 0; i < forks; i++) {
                //在invoker列表(排除selected)后,如果没有选够,则存在重复循环问题.见select实现.
                Invoker invoker = select(loadbalance, invocation, invokers, selected);
                if(!selected.contains(invoker)){//防止重复添加invoker
                    selected.add(invoker);
                }
            }
        }
        RpcContext.getContext().setInvokers((List)selected);
        // 记录失败次数
        final AtomicInteger count = new AtomicInteger();
        //返回结果放到队列中
        final BlockingQueue ref = new LinkedBlockingQueue();
        // 每个invoker调用都使用一个线程调用
        for (final Invoker invoker : selected) {
            executor.execute(new Runnable() {
                public void run() {
                    try { 
                        Result result = invoker.invoke(invocation);
                        ref.offer(result);
                    } catch(Throwable e) {
                        int value = count.incrementAndGet();
                        if (value >= selected.size()) {//当所有的invoker都调用失败则把异常加入到队列中
                            ref.offer(e);
                        }
                    }
                }
            });
        }
        try {
            // 从队列中获取结果，该过程阻塞
            Object ret = ref.poll(timeout, TimeUnit.MILLISECONDS);
            if (ret instanceof Throwable) {// 当所有
                Throwable e = (Throwable) ret;
                throw new RpcException(e instanceof RpcException ? ((RpcException)e).getCode() : 0, "Failed to forking invoke provider " + selected + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e.getCause() != null ? e.getCause() : e);
            }
            return (Result) ret;
        } catch (InterruptedException e) {
            throw new RpcException("Failed to forking invoke provider " + selected + ", but no luck to perform the invocation. Last error is: " + e.getMessage(), e);
        }
    }
}
 
 
看到源码，答案就出来了
 
 
     
  
  1. 如果并行数大于invoker数或者小于0，那么拿全部invoker进行调用
    2.  
  
  2. 每个invoker使用一个线程执行
    3.  
  
  3. 每个invoker调用后，会返回结果，结果会放到队列中，主线程会使用poll从队列获取值，只要有一个线程从invoker中获取到数据，那么就返回结果
    4.  
  
  4. 当所有的invoker都失败了，那么队列就放的是异常，而不是结果，主线程poll会判断该返回值，如果是异常则抛出
    5.  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Dubbo源码分析----容错)

        

            

                
    
                    
  • Hadoop
                        傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式
                        
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    
                    
    • 
                    
  • 重读《新生-七年就是一辈子》- 26 不能容错的系统肯定是脆弱的
                        greenorchid

                        
    读后感想：我觉得自己的容错能力在学生，同事、朋友方面都还好，毕竟我很少和他们交流。但是，我对家人有时做的不好，容错能力反而较差，因此，有时会影响心情、注意力等。看了这篇文章，我能做到平心静气，不乱发脾气吗？我觉得有时能做到，很多时候可能还是做不到。读书笔记：今天的计算机科学里（包括它的“邻居”工程学里），都有一个重要的概念：容错（Faulttolerance）如果一个系统不能容错，那么它就是脆弱的
    
                    
    • 
                    
  • 微服务架构下的服务治理实现方案详解
                        星辰@Sea
系统架构架构微服务云原生
                        
    在微服务架构中，服务治理是确保系统稳定运行、提高服务间通信效率和灵活性的关键环节。它涉及服务的发现、负载均衡、容错、监控等多个方面。本文将深入探讨几种常见的服务治理实现方案：Zookeeper、Nacos、Consul、以及Eureka，分析它们的特点、工作原理及应用场景，帮助开发者根据实际需求选择合适的工具。一、服务治理概述服务治理，简而言之，就是对微服务架构中的服务进行有效管理的过程，包括服务
    
                    
    • 
                    
  • Hystrix&Feign
                        快乐肥翟z
hystrixjava运维
                        
    Hystrix1，概念Hystrix是一个用于处理分布式系统的延迟和容错的开源库，可以保证一个服务出现故障时，不会导致整个系统出现雪崩效应，以提高分布式系统弹性；作为“断路器”，在一个服务出现故障时，可以通过短路器监控，返回一个可以处理的响应结果，保证服务调用线程不会长时间被占用，避免故障蔓延。雪崩当一个服务器中要同时处理多个请求时，当一个请求无法正确响应，请求超时。会将请求阻塞到该服务的线程池中
    
                    
    • 
                    
  • Eureka介绍与使用，超级详细
                        康斯坦丁·奥尔基耶维奇·洛夫斯基
eureka
                        
    Eureka介绍与使用指南Eureka是由Netflix开发的一个RESTful服务，主要用于中间层服务的发现，具有高可用性、可扩展性和容错性。在微服务架构中，服务发现机制是至关重要的，Eureka正是为了解决这一问题而诞生的。1.Eureka介绍1.1Eureka的核心组件EurekaServer:服务注册中心，负责服务实例的注册和管理。EurekaClient:注册到EurekaServer上
    
                    
    • 
                    
  • 算法设计目标
                        XNT7584
算法数据结构c语言c++数据结构
                        
    算法设计应满足以下几个目标。（1）正确性：要求算法能够正确地执行预先规定的功能和性能要求。这是最重要也是最基本的标准。（2）砰使用性：要求算法能够很方便地使用。这个特性也叫用户友好性。（3）砰读性：算法应该易于使人理解，也就是可读性好。为了达到这个要求，算法的逻辑必须是清晰的、简单的和结构化的。（4）健壮性：要求算法具有很好的容错性，即提供异常处理，能够对不合理的数据进行检查，不经常岀现异常中断或
    
                    
    • 
                    
  • uibot中级实践题，订单录入
                        嗳车
机器学习ui
                        
    题目：步骤：系统登录、容错判断、数据抓取、数据清洗、数据筛选、数据表、信息录入、容错判断运行结果关注公众号：auto__BOT，输入：订单录入，获取源码
    
                    
    • 
                    
  • 【软考】软件容错技术
                        王佑辉
软考软考
                        
    目录1.说明2.容错软件的定义3.容错的一般方法3.1说明3.2结构冗余3.2.1说明3.2.2静态冗余3.2.3动态冗余3.2.4混合冗余4.信息冗余5.时间冗余6.冗余附加技术7.例题7.1例题11.说明1.提高软件质量和可靠性的技术大致可分为两类，一类是避开错误，即在开发的过程中不让差错潜入软件的技术;另一类是容错技术，即对某些无法避开的差错，使其影响减至最小的技术。2.3.4.5.6.7.
    
                    
    • 
                    
  • eureka核心操作解析：集群间数据同步、自我保护、三级缓存
                        dejavu111
eurekajava
                        
    1.什么是注册中心？Eureka是springcloud中的一个负责服务注册与发现的组件。遵循着CAP理论中的A(可用性)P(分区容错性)。一个Eureka中分为eurekaserver和eurekaclient。其中eurekaserver是作为服务的注册与发现中心。eurekaclient既可以作为服务的生产者，又可以作为服务的消费者。具体结构如下图：Eureka是一个基于REST（表述性状态
    
                    
    • 
                    
  • Go Web 编程 PDF
                        book_longker
资源golangpdf开发语言
                        
    GoWeb开发必读:《BuildingWebApplicationswithGo》PDF资源分享找寻良久,终于寻得这本珍贵资源!现在我免费分享给大家你是否正在学习Go语言开发Web应用?是否想要提升Go并发编程能力?这本书绝对不容错过!关于这本书《BuildingWebApplicationswithGo》是一本非常实用的GoWeb开发指南:以构建网络论坛为案例,全面讲解GoWeb开发️深入剖析请
    
                    
    • 
                    
  • SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程...
                        暴力小萝莉
springcloudeureka架构spring后端
                        
    SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
    
                    
    • 
                    
  • SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程
                        招风的黑耳
后端eureka微服务
                        
    SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
    
                    
    • 
                    
  • Redis应用缓存穿透、缓存击穿、缓存雪崩问题的原因及解决方案
                        luffylv
缓存redis
                        
    一、缓存穿透1、原因所谓缓存穿透，可以理解为请求DB中不存在的key对应的数据。通常情况下，当请求redis中某个key时，如果redis中没有，会请求DB，若DB上有key对应的数据，那么就会将这条数据缓存到redis中。但是当DB上也没有key对应的数据时，出于容错考虑，不会回写DB中不存在的数据到redis中。如果请求DB中不存在的key的并发量很小的时候还好，如果并发量很大，那么大量的请求
    
                    
    • 
                    
  • Spring Cloud全解析：注册中心之Eureka架构介绍
                        拾光师
springcloudjava
                        
    Eureka架构介绍Eureka在设计时采用的是AP原则，是Netflix的一个子模块，用于微服务的服务注册与发现P:Partitiontolerance,网络分区容错。类似多机房部署，保证服务稳定性A:Availability，可用性C:Consistency，一致性对于任意一个系统只能同时满足两个，一个分布式系统不可能同时很好的满足一致性、可用性和分区容错性CA单点集群，满足一致性和可用性，在
    
                    
    • 
                    
  • c语言中char16_t是什么类型,错误[Pe167]：类型为“uint16_t *”的参数与类型为“unsigned char *”的参数不兼容...
                        于西奥

                        
    我想通过usb建立tablet与stm32之间的通信，为此我在代码中添加了usb库。在代码中添加库我得到了这个错误。错误[Pe167]：类型为“uint16_t*”的参数与类型为“unsignedchar*”的参数不兼容错误[Pe167]：类型的参数“uint16_t*”是类型为“无符号字符*”我使用的参数不兼容的IAREmbeddedWorkbenchEWARM工具STM32coding.Err
    
                    
    • 
                    
  • 微服务——服务治理
                        一个搬砖的农民工
微服务解决方案微服务服务治理javaspringcloudnacos
                        
    目录1什么是服务治理？2为什么需要服务治理？3服务治理的关键点3.1服务注册与发现3.2负载均衡3.3容错与熔断3.4服务监控与告警3.5服务配置管理4示例说明5总结1什么是服务治理？简单来说，服务治理就是对微服务架构中的服务进行管理、监控和控制的一系列技术和方法。它确保服务之间的调用、依赖和协作能够顺利进行，从而保障整个系统的稳定、可靠和高效。2为什么需要服务治理？随着微服务数量的增加，服务之间
    
                    
    • 
                    
  • Postman接口测试，从入门到实战（一）
                        追忆袍泽
学习笔记自动化测试自动化测试postman测试工具
                        
    一、什么是接口测试？接口测试分为两种：测试外部接口：系统和外部系统之间的接口。如：电商网站：支付宝支付。测试内部接口：系统内部的模块之间的联调，或者子系统之间的数据交互。测试重点：测试接口参数传递的正确性，接口功能的正确性，输出结果的正确性，以及对各种异常情况的容错性和权限控制。接口测试过程？比如我们出去吃饭，餐饮服务接口请求过程：饭馆地址（接口地址）选择菜系：东北菜、四川菜、湖南菜（接口请求方式
    
                    
    • 
                    
  • 推荐开源项目：Python Poetry Installer —— 简化你的Python包管理之旅
                        黎情卉Desired

                        
    推荐开源项目：PythonPoetryInstaller——简化你的Python包管理之旅在纷繁复杂的Python项目开发中，高效的包管理和依赖性控制一直是开发者关注的焦点。今天，我们为你带来了一个不容错过的神器——PythonPoetryInstaller，它正静静地躺在GitHub上，等待着与每一位追求代码艺术的你相遇。项目介绍PythonPoetryInstaller是一个官方支持的安装脚本
    
                    
    • 
                    
  • 云架构（六）隔离模式
                        _isPan
架构java开发语言
                        
    Bulkheadpattern-AzureArchitectureCenter|MicrosoftLearnBulkhead模式是一种容错的应用程序设计类型。在隔离架构中，应用程序的元素被隔离到池中，这样即使其中一个出现故障，其他元素也可以继续工作。它是以船体的分段(舱壁)命名的。如果船体受损，只有受损部分充满水，从而防止船舶沉没。背景和问题基于云的应用程序可能包括多个服务，每个服务有一个或多个消
    
                    
    • 
                    
  • jedis 与 redission 实现分布式锁
                        不知言愁
项目实战分布式redisjava
                        
    本文为博主原创，未经允许不得转载：1.Jedis实现分布式锁2.Redission实现分布式锁为了确保分布式锁可用，至少要保证锁的实现同时满足以下几个条件互斥性：在任意时刻只有一个客户端能持有锁不会死锁：即使有一个客户端在持有锁的期间发生崩溃而没有主动解锁，也能保证后续其它客户端能加锁容错性：只要大部分的Redis节点正常运行，客户端就可以加锁和解锁解铃还须系铃人：加锁和解锁必须是同一个客户端，客
    
                    
    • 
                    
  • PySpark数据分析基础：PySpark基础功能及DataFrame操作基础语法详解_pyspark rdd(2)
                        2401_84181403
程序员数据分析数据挖掘
                        
    轻松切换到pandasAPI和PySparkAPI上下文，无需任何开销。有一个既适用于pandas（测试，较小的数据集）又适用于Spark（分布式数据集）的代码库。熟练使用pandas的话很快上手3.StreamingApacheSpark中的Streaming功能运行在Spark之上，支持跨Streaming和历史数据的强大交互和分析应用程序，同时继承了Spark的易用性和容错特性。SparkS
    
                    
    • 
                    
  • 别人的话(二)
                        白_自在

                        
    如果一个冬日堪称完美，必须要有明净的空气和因白雪反射行成的耀眼光线，还要足够冷，风要极小或完全没有风，热度全部直接来自阳光，但又没有温暖到使冰雪消融的程度。大自然的恩赐不容错过。——亨利·梭罗《日记》今天的天气很好，午后，太阳打在阳台上，我窝在阳台上的沙发里看自己喜欢的剧，看累了就睡下…有明净的空气，风很小，热度全部直接来自阳光，一个堪称完美的午后。图片发自App
    
                    
    • 
                    
  • 淘宝客系统的容错与恢复机制
                        微赚淘客系统开发者@聚娃科技
java开发语言
                        
    淘宝客系统的容错与恢复机制大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在构建淘宝客系统时，容错与恢复机制是保证系统稳定性和可靠性的关键。这些机制能够确保在遇到错误或故障时，系统能够优雅地处理问题，并尽可能快地恢复正常运行。本文将介绍几种常见的容错与恢复策略，并提供Java代码示例。1.重试机制重试是处理暂时性故障的常用方法。当一个操作失败时，系统可以自动重试该
    
                    
    • 
                    
  • 开课吧：深入了解微服务的优点与缺点
                        88b0c6858840

                        
    微服务架构（MicroserviceArchitecture）是一种架构概念，旨在通过将功能分解到各个离散的服务中以实现对解决方案的解耦。你可以将其看作是在架构层次而非获取服务的类上应用很多SOLID原则。微服务架构是个很有趣的概念，它的主要作用是将功能分解到离散的各个服务当中，从而降低系统的耦合性，并提供更加灵活的服务支持。1、微服务的优点：关键点：复杂度可控，独立按需扩展，技术选型灵活，容错，
    
                    
    • 
                    
  • Java 7.1 - 理论 & 算法 & 协议
                        没有韭菜的饺子
java开发语言
                        
    什么是CAP理论？C：Consistency一致性A：Availability可用性P：Partition分区容错性对于理论计算机科学，CAP定理指出，对于一个分布式系统而言，CAP中的三个只能同时满足两个。分区容错性：分布式系统出现网络分区的时候，仍然可以向外提供服务。*网络分区分布式系统中，多个节点之间的网络本来是相连的。但现在因为某些原因，某些节点之间不再连通，网络会被分成多个区域，这就叫网
    
                    
    • 
                    
  • Spark基础
                        Tom无敌宇宙猫
spark大数据分布式
                        
    一.基础1.RDD机制  1.rdd分布式弹性数据集，简单的理解成⼀种数据结构，是spark框架上的通⽤货币。所有算⼦都是基于rdd来执⾏的，不同的场景会有不同的rdd实现类，但是都可以进⾏互相转换。rdd执⾏过程中会形成dag图，然后形成lineage血缘关系保证容错性等。从物理的⾓度来看rdd存储的是block和node之间的映射。  2.RDD是spark提供的核⼼抽象，全称为弹性分布式数据
    
                    
    • 
                    
  • spark streaming优点和缺点
                        scott_alpha

                        
    优点：sparkstreaming会被转化为spark作业执行，由于spark作业依赖DAGScheduler和RDD，所以是粗粒度方式而不是细粒度方式，可以快速处理小批量数据，获得准实时的特性；以spark作业提交和执行，很方便的实现容错机制；DStreaming是在RDD上的抽象，更容易与RDD进行交互操作。需要将流式数据与批数据结合分析的情况下，非常方便。缺点：不可避免的延迟
    
                    
    • 
                    
  • Spark
                        傲雪凌霜，松柏长青
后端大数据spark大数据分布式
                        
    Spark是一个快速的、通用的集群计算系统，主要用于大规模数据处理。它最早由加州大学伯克利分校的AMPLab开发，并于2010年开源，后来由Apache软件基金会管理。1.核心概念RDD（ResilientDistributedDataset）：RDD是Spark的核心抽象，表示一个分布式的、不变的集合。它提供了对大数据集的容错机制，支持并行操作。DataFrame：DataFrame是基于RDD
    
                    
    • 
                    
  • Hadoop-MapReduce机制原理
                        H.S.T不想卷
大数据hadoopmapreduce大数据
                        
    MapReduce机制原理1、MapReduce概述2、MapReduce特点3、MapReduce局限性4、MapTask5、Map阶段步骤：6、Reduce阶段步骤：7、MapReduce阶段图1、MapReduce概述  HadoopMapReduce是一个分布式计算框架，用于轻松编写分布式应用程序，这些应用程序以可靠，容错的方式并行处理大型硬件集群（数千个节点）上的大量数据（多TB数据集）
    
                    
    • 
                    
  • 前端之路，与大师同行：不容错过的技术大牛博客精选
                        芭拉拉小魔仙
程序员成长札记前端
                        
    前端程序员在不断提升自己的过程中，需要关注多个方面，包括技术能力的提升、职业素养的增强以及持续学习的态度。以下是一些具体的建议：（一）前端程序员应该如何提升自己一、技术能力的提升深入学习基础技术：HTML、CSS、JavaScript：作为前端开发的基础，必须深入理解和掌握。可以通过阅读官方文档、经典书籍、参与在线课程等方式，不断巩固和提升自己的基础能力。前端框架和库：熟悉并掌握当前流行的前端框架
    
                    
    • 
                                
  • apache 安装linux windows
                                    墙头上一根草
apacheinuxwindows
                                    
    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式 
  
  
通过二进制文件安装Apache需要的软件有apr,apr-util,pcre 
 1，安装 apr        下载地址：htt
    
                                
    • 
                                
  • fill_parent、wrap_content和match_parent的区别
                                    Cb123456
match_parentfill_parent
                                    
    fill_parent、wrap_content和match_parent的区别: 
  
1）fill_parent 
  设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 
2） wrap_conte
    
                                
    • 
                                
  • 网页自适应设计
                                    天子之骄
htmlcss响应式设计页面自适应
                                    
    网页自适应设计 
       网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
    
                                
    • 
                                
  • [sql server] 分组取最大最小常用sql
                                    一炮送你回车库
SQL Server
                                    
    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
    
                                
    • 
                                
  • ImageIO写图片输出到硬盘
                                    3213213333332132
javaimage
                                    
    package awt; 
 
import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
 
import javax.imagei
    
                                
    • 
                                
  • 自己的String动态数组
                                    宝剑锋梅花香
java动态数组数组
                                    
    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
    
                                
    • 
                                
  • pinyin4j工具类
                                    darkranger
.net
                                    
    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小 
引入pinyin4j-2.5.0.jar包: 
pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。 
 
本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
    
                                
    • 
                                
  • StarUML学习笔记----基本概念
                                    aijuans
UML建模
                                    
    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。 
        模型、视与图（Model, View and Diagram） 
       &
    
                                
    • 
                                
  • Activiti最终总结
                                    avords
Activiti id 工作流
                                    
    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 
2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 
3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 
4、TaskDefinitionKey和（ActivityImpl activityId 
    
                                
    • 
                                
  • 从省市区多重级联想到的，react和jquery的差别
                                    bee1314
jqueryUIreact
                                    
    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。       针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
    
                                
    • 
                                
  • Eclipse快捷键大全
                                    bijian1013
javaeclipse快捷键
                                    
    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
    
                                
    • 
                                
  • js 笔记 函数
                                    征客丶
JavaScript
                                    
    一、函数的使用 
1.1、定义函数变量 
var vName = funcation(params){ 
} 
 
1.2、函数的调用 
函数变量的调用：      vName(params); 
函数定义时自发调用：(function(params){})(params); 
 
1.3、函数中变量赋值 
var a = 'a'; 
var ff
    
                                
    • 
                                
  • 【Scala四】分析Spark源代码总结的Scala语法二
                                    bit1129
scala
                                    
    1. Some操作 
  
在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， 
Some的文档说明： 
  
/** Class `Some[A]` represents existin
    
                                
    • 
                                
  • java 匿名内部类
                                    BlueSkator
java匿名内部类
                                    
    组合优先于继承 
Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系 
继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。 
  
在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 
内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
    
                                
    • 
                                
  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用
                                    ljy325
游戏applewindowsXPOS
                                    
    Mac mini 型号: MC270CH-A RMB:5,688 
  
Apple 对windows的产品支持不好,有以下问题: 
  
1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响! 
  
2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 
&nbs
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-生成器模式-Builder
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF）
 * 个人理解：
 * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
    
                                
    • 
                                
  • JIRA与SVN插件安装
                                    chenyu19891124
SVNjira
                                    
    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 
1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 
2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
    
                                
    • 
                                
  • 常用数学思想方法
                                    comsci
工作
                                    
      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考 
 
 
 
  函数思想 
　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
    
                                
    • 
                                
  • pl/sql集合类型
                                    daizj
oracle集合typepl/sql
                                    
    --集合类型 
/* 
  单行单列的数据，使用标量变量 
  单行多列数据，使用记录 
  单列多行数据，使用集合（。。。） 
  *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 
*/ 
/* 
    --集合方法 
&n
    
                                
    • 
                                
  • [Ofbiz]ofbiz初用
                                    dinguangx
电商ofbiz
                                    
    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 
1. 加载测试库 
ofbiz内置derby，通过下面的命令初始化测试库 
./ant load-demo (与load-seed有一些区别) 
  
2. 启动内置tomcat 
./ant start 
或 
./startofbiz.sh 
或 
java -jar ofbiz.jar 
&
    
                                
    • 
                                
  • 结构体中最后一个元素是长度为0的数组
                                    dcj3sjt126com
cgcc
                                    
    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
    
                                
    • 
                                
  • Linux cp 实现强行覆盖
                                    dcj3sjt126com
linux
                                    
    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一 
 
 我们输入alias命令，看看系统给cp起了一个什么别名。 
  
  [root@localhost ~]# aliasalias cp=’cp -i’a
    
                                
    • 
                                
  • Memcached(一)、HelloWorld
                                    frank1234
memcached
                                    
    一、简介 
高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。 
二、客户端 
选择一个memcached客户端，我这里用的是memc
    
                                
    • 
                                
  • Search in Rotated Sorted Array II
                                    hcx2013
search
                                    
    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? 
Would this affect the run-time complexity? How and why? 
Write a function to determine if a given ta
    
                                
    • 
                                
  • Spring4新特性——更好的Java泛型操作API
                                    jinnianshilongnian
spring4generic type
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装JDK
                                    liuxingguome
centos
                                    
    1、行卸载原来的： 
[root@localhost opt]# rpm -qa | grep java 
tzdata-java-2014g-1.el6.noarch 
java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 
java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 
[root@localhost
    
                                
    • 
                                
  • 二分搜索专题2-在有序二维数组中搜索一个元素
                                    OpenMind
二维数组算法二分搜索
                                    
    1,设二维数组p的每行每列都按照下标递增的顺序递增。 
用数学语言描述如下：p满足 
(1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); 
(2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 
2,问题： 
给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 
3,算法分析： 
(
    
                                
    • 
                                
  • java 随机数 Math与Random
                                    SaraWon
javaMathRandom
                                    
    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 
http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 
 
产生1到10之间的随机数的两种实现方式： 
 

//Math
Math.roun
    
                                
    • 
                                
  • oracle创建表空间
                                    tugn
oracle
                                    
    create temporary tablespace TXSJ_TEMP   
tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'   
size 32m   
autoextend on   
next 32m maxsize 2048m   
extent m
    
                                
    • 
                                
  • 使用Java8实现自己的个性化搜索引擎
                                    yangshangchuan
javasuperword搜索引擎java8全文检索
                                    
    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 
1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 
2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 
3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
    
                                
    •