精华内容
下载资源
问答
  • 与Mapbox开发人员体验的其他部分一样,表达式都是关于粒度控制的。表达式使您能够基于数据的属性动态设置空间数据的样式。它们为您提供许多灵活而强大的操作。您可以同时使用多个特性属性对数据进行样式化,应用...

    表达式

    与Mapbox开发人员体验的其他部分一样,表达式都是关于细粒度控制的。表达式使您能够基于数据的属性动态设置空间数据的样式。它们为您提供许多灵活而强大的操作。您可以同时使用多个特性属性对数据进行样式化,应用条件逻辑,并使用算术或字符串操作操作数据,以便在数据和数据样式之间建立更复杂的关系。

    任何布局属性、画图属性或过滤器的值都可以指定为表达式。表达式定义了使用下面描述的操作符计算属性值的公式。

    Mapbox GL提供的表达式运算符集包括:

    • 对数值执行算术和其他操作的数学运算符
    • 用于操作布尔值和作出条件决策的逻辑操作符
    • 用于操作字符串的字符串操作符
    • 数据操作符,提供对源特性属性的访问
    • 相机操作符,提供对定义当前地图视图的参数的访问

    表达式表示为JSON数组。表达式数组的第一个元素是一个命名表达式运算符的字符串。例如,“*”或“case”。下一个元素(如果有的话)是表达式的参数。每个参数要么是一个文字值(字符串、数字、布尔值或null),要么是另一个表达式数组。

    Popular expressions

    虽然有许多表达式可供选择,但您应该首先熟悉以下表达式,这些表达式可能会帮助您实现数据驱动的样式目标:

    • ​​get
    • match
    • switchCase
    • equal
    • ​​literal

    Learning resources

    有几个Mapbox资源可以提供更多的指导和示例,帮助理解表达式的概念。

    数据集群

    通常,一张地图一次可以显示太多的数据。标记相互重叠。这张地图看起来杂乱无章。用户无法快速理解数据应该说什么。

    通过使用用于Android的Mapbox Maps SDK的数据驱动样式化功能,完全可以显示集群数据。

    将地图上显示的数据量调整到地图的相机缩放级别,可以为用户提供更清晰的UI体验和更少的压倒性位置数据体验。

    CircleLayer

    使用 CircleLayers 是显示数据集群的两种推荐方法之一。不同的圆形颜色可以表示不同的数据范围。例如,蓝色圆圈可能是包含100多个数据点的集群,红色圆圈包含50多个数据点,绿色圆圈包含10多个数据点。一旦地图被放大到足够大,就只能看到单独的数据点。在这里插入图片描述

    SymbolLayer

    符号层稍微复杂一些,但本质上与上面的 CircleLayer 实现相同。根据您使用的符号层图标的形状/大小,您可能必须使用 propertyfactory 的 iconTranslate 方法来确保数据计数符号层编号文本直接排列在符号层集群图标的顶部。不同的图标可以表示不同的数据范围。例如,一个图像可以是包含100多个数据点的集群,第二个图像包含50多个数据点,第三个图像包含10多个数据点。一旦地图被放大到足够大,就只能看到单独的数据点。
    在这里插入图片描述
    实现方法:
    1.使用GeoJSON数据源并将其作为GeoJsonSource添加到Mapbox Map中。

    try {
    	mapboxMap.getStyle().addSource(
    		new GeoJsonSource("GEOJSON_SOURCE_ID",
    		  new URL("URL_POINTING_TO_GEOJSON_FILE"),
    		  new GeoJsonOptions()
    		    .withCluster(true)
    		    .withClusterMaxZoom(MAX_ZOOM)
    		    .withClusterRadius(DESIRED_CLUSTER_RADIUS)
    		)
    	);
    } catch (MalformedURLException malformedUrlException) {
    	Log.e(TAG, "Check the URL " + malformedUrlException.getMessage());
    }
    

    2.创建一个符号层,其中的图标表示当点没有聚集时的单个数据点。这些图标只有当地图的摄像头离地图足够近时才会显示。记住,地图的缩放值越高,相机的缩放就越大。缩放级别12比缩放值4更接近地图。

    3.为各种数据范围创建尽可能多的额外符号层或循环层。您可能用红色的圆圈表示具有10-30个数据点的数据集群,然后用蓝色圆圈表示具有50个或更多数据点的数据集群。数据驱动的样式和表达式过滤将决定哪些集群层显示在哪个缩放级别。

    4.为隐藏的数据量文本创建一个符号层。也就是说,出现的数字告诉用户还有多少数据点隐藏在集群图标/圆圈后面,如果将地图放大,就可以看到这些数据点。不要忘记使用运行时样式来调整文本大小、文本颜色和其他文本属性:

    SymbolLayer count = new SymbolLayer("SYMBOL_LAYER_COUNT_LAYER_ID", "GEOJSON_SOURCE_ID");
        count.setProperties(
          textField(Expression.toString(get("point_count"))),
          textSize(TEXT_SIZE),
          textColor(TEXT_COLOR),
          textIgnorePlacement(true),
          textAllowOverlap(true)
        );
    mapboxMap.getStyle().addLayer(count);
    
    展开全文
  • 四、关于特征 特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。那对于特征,我们需要考虑什么呢?  4.1、特征表示的粒度 学习算法在...

    四、关于特征

            特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。那对于特征,我们需要考虑什么呢?

      4.1、特征表示的粒度

            学习算法在一个什么粒度上的特征表示,才有能发挥作用?就一个图片来说,像素级的特征根本没有价值。例如下面的摩托车,从像素级别,根本得不到任何信息,其无法进行摩托车和非摩托车的区分。而如果特征是一个具有结构性(或者说有含义)的时候,比如是否具有车把手(handle),是否具有车轮(wheel),就很容易把摩托车和非摩托车区分,学习算法才能发挥作用。

              

             

     

     

     

     

     

      4.2、初级(浅层)特征表示

            既然像素级的特征表示方法没有作用,那怎样的表示才有用呢?

            1995 年前后,Bruno Olshausen和 David Field 两位学者任职 Cornell University,他们试图同时用生理学和计算机的手段,双管齐下,研究视觉问题。

            他们收集了很多黑白风景照片,从这些照片中,提取出400个小碎片,每个照片碎片的尺寸均为 16x16 像素,不妨把这400个碎片标记为 S[i], i = 0,.. 399。接下来,再从这些黑白风景照片中,随机提取另一个碎片,尺寸也是 16x16 像素,不妨把这个碎片标记为 T。

            他们提出的问题是,如何从这400个碎片中,选取一组碎片,S[k], 通过叠加的办法,合成出一个新的碎片,而这个新的碎片,应当与随机选择的目标碎片 T,尽可能相似,同时,S[k] 的数量尽可能少。用数学的语言来描述,就是:

            Sum_k (a[k] * S[k]) --> T,     其中 a[k] 是在叠加碎片 S[k] 时的权重系数。

            为解决这个问题,Bruno Olshausen和 David Field 发明了一个算法,稀疏编码(Sparse Coding)。

            稀疏编码是一个重复迭代的过程,每次迭代分两步:

    1)选择一组 S[k],然后调整 a[k],使得Sum_k (a[k] * S[k]) 最接近 T。

    2)固定住 a[k],在 400 个碎片中,选择其它更合适的碎片S’[k],替代原先的 S[k],使得Sum_k (a[k] * S’[k]) 最接近 T。

            经过几次迭代后,最佳的 S[k] 组合,被遴选出来了。令人惊奇的是,被选中的 S[k],基本上都是照片上不同物体的边缘线,这些线段形状相似,区别在于方向。

            Bruno Olshausen和 David Field 的算法结果,与 David Hubel 和Torsten Wiesel 的生理发现,不谋而合!

            也就是说,复杂图形,往往由一些基本结构组成。比如下图:一个图可以通过用64种正交的edges(可以理解成正交的基本结构)来线性表示。比如样例的x可以用1-64个edges中的三个按照0.8,0.3,0.5的权重调和而成。而其他基本edge没有贡献,因此均为0 。

              

     

            另外,大牛们还发现,不仅图像存在这个规律,声音也存在。他们从未标注的声音中发现了20种基本的声音结构,其余的声音可以由这20种基本结构合成。

     

          

             

     

     

     

     

     

      4.3、结构性特征表示

            小块的图形可以由基本edge构成,更结构化,更复杂的,具有概念性的图形如何表示呢?这就需要更高层次的特征表示,比如V2,V4。因此V1看像素级是像素级。V2看V1是像素级,这个是层次递进的,高层表达由底层表达的组合而成。专业点说就是基basis。V1取提出的basis是边缘,然后V2层是V1层这些basis的组合,这时候V2区得到的又是高一层的basis。即上一层的basis组合的结果,上上层又是上一层的组合basis……(所以有大牛说Deep learning就是“搞基”,因为难听,所以美其名曰Deep learning或者Unsupervised Feature Learning)

            

     

            直观上说,就是找到make sense的小patch再将其进行combine,就得到了上一层的feature,递归地向上learning feature。

            在不同object上做training是,所得的edge basis 是非常相似的,但object parts和models 就会completely different了(那咱们分辨car或者face是不是容易多了):

            

     

            从文本来说,一个doc表示什么意思?我们描述一件事情,用什么来表示比较合适?用一个一个字嘛,我看不是,字就是像素级别了,起码应该是term,换句话说每个doc都由term构成,但这样表示概念的能力就够了嘛,可能也不够,需要再上一步,达到topic级,有了topic,再到doc就合理。但每个层次的数量差距很大,比如doc表示的概念->topic(千-万量级)->term(10万量级)->word(百万量级)。

            一个人在看一个doc的时候,眼睛看到的是word,由这些word在大脑里自动切词形成term,在按照概念组织的方式,先验的学习,得到topic,然后再进行高层次的learning。

     

     

     

     

     

     

      4.4、需要有多少个特征?

           我们知道需要层次的特征构建,由浅入深,但每一层该有多少个特征呢?

    任何一种方法,特征越多,给出的参考信息就越多,准确性会得到提升。但特征多意味着计算复杂,探索的空间大,可以用来训练的数据在每个特征上就会稀疏,都会带来各种问题,并不一定特征越多越好。

               

          

           好了,到了这一步,终于可以聊到Deep learning了。上面我们聊到为什么会有Deep learning(让机器自动学习良好的特征,而免去人工选取过程。还有参考人的分层视觉处理系统),我们得到一个结论就是Deep learning需要多层来获得更抽象的特征表达。那么多少层才合适呢?用什么架构来建模呢?怎么进行非监督训练呢?



    本文转自大数据躺过的坑博客园博客,原文链接:http://www.cnblogs.com/zlslch/p/6965561.html,如需转载请自行联系原作者

    展开全文
  • 在实际项目中,有个场景一个LinkedBlockingQueue后面挂了60个线程,数据量大,线程量也大,但通过堆栈信息查看,大约有五十多个线程处于WAITING状态, 都卡在LinkedBlockingQueue.take() 处。 为提高性能,细化锁...

    在线程数量比较多的时候,LinkedBlockingQueue.take() 并发性能并不是特别优秀。
    在实际项目中,有个场景一个LinkedBlockingQueue后面挂了60个线程,数据量大,线程量也大,但通过堆栈信息查看,大约有五十多个线程处于WAITING状态, 都卡在LinkedBlockingQueue.take() 处。
    为提高性能,细化锁粒度。写了下面一个类,时间紧急只实现了 add, offer, take接口。

    
    import java.util.Collection;
    import java.util.Iterator;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * 本质上就是将一个大队列,分隔成多个子队列,这样降低锁粒度
     * 但是外在的消费端线程数量有一定要求,就是必须大于等于子队列,否则会造成数据无法被消费的尴尬情况
     * @param <T>
     */
    public class FastLinkedBlockingQueue<T> implements BlockingQueue<T> {
    
        /**
         * 计算长度
         */
        private AtomicInteger size = new AtomicInteger();
    
        /**
         * 子队列数量
         */
        private int factor;
    
        /**
         * 子队列
         */
        private LinkedBlockingQueue<T>[] children;
    
        /**
         * 消费该队列的线程数量必须大于等于factor,否则会造成数据无法被消费
         * @param factor
         */
        public FastLinkedBlockingQueue(int factor){
            this.factor = factor;
            this.children = new LinkedBlockingQueue[factor];
            for (int i = 0; i < factor; i++) {
                children[i] = new LinkedBlockingQueue<>();
            }
        }
    
        @Override
        public boolean add(T t) {
            int i = size.incrementAndGet();
            return this.children[i%factor].add(t);
        }
    
        @Override
        public boolean offer(T t) {
            int i = size.incrementAndGet();
            return this.children[i%factor].offer(t);
        }
    
        /**
         * 保存每个线程消费子队列的下标,如为空,表示当前线程是第一次消费此队列,
         * 那么就需要如下算法确定此线程到底消费哪个子队列
         * 先由consumerCount按序增加,然后对子序列的个数进行取模
         */
        private ThreadLocal<Integer> threadIndex = new ThreadLocal<>();
        private AtomicInteger consumerCount = new AtomicInteger(-1);
    
        @Override
        public T take() throws InterruptedException {
            Integer index = threadIndex.get();
            //为空表示第一次取数据
            if (index == null) {
                //消费者+1
                index = consumerCount.incrementAndGet();
                // 对子序列长度取模
                index = index % factor;
                // 设置当前线程消费的子队列下标,下次消费直接根据下标找到子队列
                threadIndex.set(index);
            }
            T take = children[index].take();
            size.decrementAndGet();
            return take;
        }
    
        @Override
        public int size() {
            return size.get();
        }
    
        @Override
        public T remove() {return null;}
        @Override
        public T poll() {return null;}
        @Override
        public T element() {return null;}
        @Override
        public T peek() {return null;}
        @Override
        public void put(T t) throws InterruptedException {}
        @Override
        public boolean offer(T t, long timeout, TimeUnit unit) throws InterruptedException {return false;}
        @Override
        public T poll(long timeout, TimeUnit unit) throws InterruptedException {return null;}
        @Override
        public int remainingCapacity() {return 0;}
        @Override
        public boolean remove(Object o) {return false;}
        @Override
        public boolean containsAll(Collection<?> c) {return false;}
        @Override
        public boolean addAll(Collection<? extends T> c) {return false;}
        @Override
        public boolean removeAll(Collection<?> c) {return false;}
        @Override
        public boolean retainAll(Collection<?> c) {return false;}
        @Override
        public void clear() {}
        @Override
        public boolean isEmpty() {return false;}
        @Override
        public boolean contains(Object o) {return false;}
        @Override
        public Iterator<T> iterator() {return null;}
        @Override
        public Object[] toArray() {return new Object[0];}
        @Override
        public <T1> T1[] toArray(T1[] a) {return null;}
        @Override
        public int drainTo(Collection<? super T> c) {return 0;}
        @Override
        public int drainTo(Collection<? super T> c, int maxElements) {return 0;}
    }
    
    

    性能测试

    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class Test {
        static BlockingQueue<Integer> queue = new FastLinkedBlockingQueue<>(15);
    //    static BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        static CountDownLatch latch = new CountDownLatch(1);
        static int total = 10000000;
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < total; i++) {
                queue.offer(i);
            }
            System.out.println("放置完成");
            long start = System.currentTimeMillis();
            Comsumer comsumer = new Comsumer();
            for (int i = 0; i < 30; i++) {
                new Thread(comsumer).start();
            }
            latch.await();
            System.out.println("耗时:" + (System.currentTimeMillis() - start));
        }
    }
    
    class Comsumer implements Runnable{
    
        AtomicInteger count = new AtomicInteger();
        @Override
        public void run() {
            while (true) {
                try {
                    Test.queue.take();
                    int num = count.incrementAndGet();
                    if (num == Test.total) {
                        Test.latch.countDown();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    

    在线程数量较小的情况下,性能差别不大,但当线程数量较大时,性能差距就不一样了

    展开全文
  • 原本参考下面这篇博客来对粗糙、粒度小的源数据进行二维插值,但是插值的结果总是出现一些莫名奇妙的突起,从而导致计算的结果不对,但源数据明明是很平滑的。 链接: (数值分析)各种插值法的python实现. 按照这篇...

    interpolate.interp2d二维插值的曲面出现奇怪的突出

    网上能找到的关于二维插值的博文比较少,对插值算法函数的认识也不够深入。原本参考下面这篇博客来对粗糙、粒度小的源数据进行二维插值,但是插值的结果总是出现一些莫名奇妙的突起,从而导致计算的结果不对,但源数据明明是很平滑的。
    链接: (数值分析)各种插值法的python实现.
    在这里插入图片描述
    按照这篇博客
    链接: python脚本纠错:interpolate.interp2d的正确用法_我的博客-CSDN博客_interpolate.interp2d.
    做了一下改动,把建立插值函数的输入x、y都改成了一维的——interp2d(x,y,…) ,就得到了想要的平滑且更加细密的插值曲面,不知道这是为啥,记录一下,提供一个思路。

    在这里插入图片描述

    展开全文
  • 关于锁,有很多可以学习的,比如,锁的粒度,锁的模式,锁的兼容性,以及隔离级别等等。 但是,具体到运行一个语句时,是怎么去获取到相应的锁的呢,比如,一个select语句,那么需要加S锁,可能是对记录,也可能是...
  • 关于锁,有很多可以学习的,比如,锁的粒度,锁的模式,锁的兼容性,以及隔离级别等等。 但是,具体到运行一个语句时,是怎么去获取到相应的锁的呢,比如,一个select语句,那么需要加S锁,可能是对记录,也...
  • 四、关于特征  特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。那对于特征,我们需要考虑什么呢? 4.1、特征表示的粒度  学习...
  • An easy understanding on deep learning

    千次阅读 2013-12-02 08:06:12
    声明:本内容系转载,请尊重原创!!! 四、关于特征  特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。...例如下面
  • 深度学习之二:特征

    千次阅读 2015-07-12 15:01:41
    关于特征  特征是机器学习系统的原材料,对最终模型的影响是毋庸置疑的。如果数据被很好的表达成了特征,通常线性模型就能达到满意的精度。那对于特征,我们需要考虑什么呢? 4.1、特征表示的粒度  学习算法在...
  • spark 倾斜连接

    2018-10-14 11:51:48
    说明 并行计算中,我们总希望...硬件不同暂且不论,下面举例说明不同应用类型的情况,如Page Rank或者Data Mining中的一些计算,它的每条记录消耗的成本不太一样,这里只讨论关于关系型运算的Join连接的数据倾斜状况...
  • 同步的粒度4.线程之间的通知5.跨类的同步对象Java的线程编程非常简单。但有时会看到一些关于线程的错误用法。下面列出一些应该注意的问题。1.同步对象的恒定性All java objects are references. 对于局部变量和...
  • 关于锁,有很多可以学习的,比如,锁的粒度,锁的模式,锁的兼容性,以及隔离级别等等。 但是,具体到运行一个语句时,是怎么去获取到相应的锁的呢,比如,一个select语句,那么需要加S锁,可能是对记录,也可能...
  • 北大青鸟Oracle教程集2

    2008-01-10 21:54:25
    Oracle 更新段标题和数据词典,以显示新的 更新段标题和数据词典, 扩展区已经被分配而且分配的空间不再可用 数据块 代表数据库存储的最佳粒度级别段 2 K 2 K 展 区 2 K 2 K 2 K 2 K 2 K 2 K 2 K 2 K b b b b b b b b ...
  • 北大青鸟Oracle教程集1

    2008-01-10 21:53:37
    Oracle 更新段标题和数据词典,以显示新的 更新段标题和数据词典, 扩展区已经被分配而且分配的空间不再可用 数据块 代表数据库存储的最佳粒度级别段 2 K 2 K 展 区 2 K 2 K 2 K 2 K 2 K 2 K 2 K 2 K b b b b b b b b ...
  • 实现了细粒度数据权限控制;支持在线配置。 开放友好API服务 支持在线定义接口可读写的配置项、属性及关系;支持在线测试,验证接口准确性。 多维度日志查询 提供管理界面,支持多维度数据变迁历史查询。 ...
  • 5.4.1 UTL_*网络程序包的细粒度访问控制 200 5.4.2 Automatic Storage Management的sysasm权限 206 5.4.3 LOB加密增强 207 5.4.4 Data Pump加密 207 5.4.5 RMAN虚拟专用目录 207 5.4.6 RMAN备份粉碎 207 ...
  • 5.6 数据一致性和数据并发性 155 5.6.1 数据库写入器和写前协议 155 5.6.2 SCN 156 5.6.3 撤销管理 156 5.7 备份与恢复体系结构 157 5.7.1 用户管理的备份与恢复 157 5.7.2 RMAN 157 5.7.3 Oracle ...
  • 事务处理原理 第2版

    热门讨论 2012-12-30 10:49:38
    关于锁定机制的一章则新增了内容,包括乐观并发控制、B树锁定、多粒度锁定和嵌套事务。同时还新增了TPC-E准则、状态管理、可伸缩性、影式分页、数据共享系统、一致性算法、基于日志的复制以及多主复制等内容。面向...
  •  ·第2章提供了关于数据类型、结构、程序块、游标和语言语法的快速课程。  ·第3章介绍如何管理Oracle数据库中的事务。  ·第4章介绍如何理解并管理Oracle数据库中的错误。  第Ⅱ部分:PL/SQL编程  ·第5章...
  •  ·第2章提供了关于数据类型、结构、程序块、游标和语言语法的快速课程。  ·第3章介绍如何管理Oracle数据库中的事务。  ·第4章介绍如何理解并管理Oracle数据库中的错误。  第Ⅱ部分:PL/SQL编程  ·第5章...
  • 本系统是基于RBAC授权和基于用户授权的细粒度权限控制通用平台,并提供单点登录、会话管理和日志管理。接入的系统可自由定义组织、角色、权限、资源等。用户权限=所拥有角色权限合集+用户加权限-用户减权限,优先级...
  • 5.5 关于数据的问题 121 5.6 建立逻辑表达式 126 5.7 小结 136 第6章 SQL执行计划 137 6.1 解释计划 137 6.1.1 使用解释计划 137 6.1.2 理解解释计划可能达不到目的的方式 143 6.1.3 阅读计划 146 6.2 执行...
  • 5.5 关于数据的问题 121 5.6 建立逻辑表达式 126 5.7 小结 136 第6章 SQL执行计划 137 6.1 解释计划 137 6.1.1 使用解释计划 137 6.1.2 理解解释计划可能达不到目的的方式 143 6.1.3 阅读计划 146 6.2 执行...
  • 下面这幅图是Fiddler抓包时看到的数据: 断点续传: 建立断点txt文件,在因网络等原因中断时,重启程序,可以在断点处续爬,在中断时,已缓存的数据将保存至csv def resume(self): """ 爬取出错时,将出错url的...
  • 在 Access 表配置校验规则,默认不允许访问,需要对 每张表、每种角色、每种操作 做相应的配置,粒度细分到 Row 级 https://github.com/APIJSON/APIJSON/issues/12 3.如何校验参数? 在 Request 表配置校验规则 ...
  • 同理,由于谷歌官方发布的BERT-base, Chinese中,中文是以字为粒度进行切分,没有考虑到传统NLP中的中文分词(CWS)。 我们将全词Mask的方法应用在了中文中,使用了中文维基百科(包括简体和繁体)进行训练,并且...
  • 目前我考虑到的场景如下,我会把接口返回数据中的 token_type 和 access_token 以空格分隔连接起来,所以我会写获取路径是 body.token_type + " " + body.access_token, { "access_token": "27c72286-a4d7-42bc-...
  • 在1.x中,我们通过hookAjax() 方法(2.x中改名为hook())实现了对XMLHttpRequest对象具体属性、方法、回调的细粒度拦截,而2.x中的proxy()方法则是基于hook的一个封装,下面我们看一下如何使用hook方法来拦截...
  • 单点登录源码

    2018-01-09 20:56:08
    本系统是基于RBAC授权和基于用户授权的细粒度权限控制通用平台,并提供单点登录、会话管理和日志管理。接入的系统可自由定义组织、角色、权限、资源等。用户权限=所拥有角色权限合集+用户加权限-用户减权限,优先级...
  • 下面是一些对比。 <p>npm的优势对比: | npm | cdn combo | | --- | --- | | 模块内聚性高,对外API统一 | 模块被调用方式不可控 | | 执行期无seed,降低运行期复杂度 | seed体积庞大,也是...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

下面关于数据粒度