我正在使用https://github.com/eriwen/gradle-js-plugin,我希望能够运行任务'干净'.当我运行'gradle -d clean'时,它会出现以下错误

Task 'clean' not found in root project

根据我的理解,gradle带有任务 - '干净',但是gradles-js-plugin在这个时候似乎并不支持.我如何添加任务'干净'？

这是我的build.gradle:

// Pull the plugin from Maven Central
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.eriwen:gradle-js-plugin:1.5.0'
    }
}
// Invoke the plugin
apply plugin: 'js'

def jsSrcDir = 'public/js'

javascript.source {
    dev {
        js {
            srcDir jsSrcDir
            include "*.js"
            exclude "*.min.js"
        }
    }
    prod {
        js {
            srcDir jsSrcDir
            include "*.min.js"
        }
    }
}

combineJs{
    source = fileTree(javascript.source.dev.js.files)
    dest = file("${buildDir}/all.js")
}

问题描述

我们有一个Hadoop集群,我们在其上存储使用Kryo(序列化框架)序列化为字节的数据.我们用来做这个的Kryo版本已从官方版本2.21中分离出来,将我们自己的补丁应用于我们使用Kryo遇到的问题.当前的Kryo 2.22版也修复了这些问题,但使用了不同的解决方案.因此,我们不能只改变我们使用的Kryo版本,因为这意味着我们将无法再读取已存储在Hadoop集群中的数据.为了解决这个问题,我们想要运行一个Hadoop作业

1. 读取存储的数据
2. 反序列化使用旧版Kryo存储的数据
3. 使用新版本的Kryo序列化已还原的对象
4. 将新的序列化表示写回我们的数据存储

问题是在一个Java程序中使用同一个类的两个不同版本并不是一件容易的事情(更确切地说,在Hadoop作业的mapper类中).

问题简而言之

如何在一个Hadoop作业中使用同一序列化框架的两个不同版本反序列化和序列化对象？

相关事实概述

• 我们将数据存储在Hadoop CDH4集群上,使用Kryo版本2.21.2-ourpatchbranch进行序列化
• 我们希望将数据与Kryo 2.22版本序列化,这与我们的版本不兼容
• 我们使用Apache Maven构建我们的Hadoop作业JAR

可能的(也是不可能的)方法

(1)重命名包

我们想到的第一种方法是使用Maven Shade插件的重定位功能重命名我们自己的Kryo分支中的包,并使用不同的工件ID释放它,这样我们就可以依赖转换作业项目中的两个工件.然后,我们将实例化旧版本和新版本的一个Kryo对象,并使用旧版本进行反序列化,并使用新版本再次序列化对象.

问题
我们不在Hadoop作业中明确使用Kryo,而是通过我们自己的库的多个层访问它.对于这些库中的每一个,都有必要

1. 重命名涉及包和
2. 使用不同的组或工件ID创建发布

为了使事情更加混乱,我们还使用其他第三方库提供的Kryo序列化程序,我们必须做同样的事情.

(2)使用多个类加载器

我们提出的第二种方法是在包含转换作业的Maven项目中完全不依赖于Kryo,而是从每个版本的JAR加载所需的类,该版本存储在Hadoop的分布式缓存中.然后序列化对象看起来像这样:

public byte[] serialize(Object foo, JarClassLoader cl) {
    final Class<?> kryoClass = cl.loadClass("com.esotericsoftware.kryo.Kryo");
    Object k = kryoClass.getConstructor().newInstance();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    final Class<?> outputClass = cl.loadClass("com.esotericsoftware.kryo.io.Output");

    Object output = outputClass.getConstructor(OutputStream.class).newInstance(baos);
    Method writeObject = kryoClass.getMethod("writeObject", outputClass, Object.class);
    writeObject.invoke(k, output, foo);
    outputClass.getMethod("close").invoke(output);
    baos.close();
    byte[] bytes = baos.toByteArray();
    return …

假设我创建了一个用于模拟处理器内存的数组:

byte[] mem = new byte[0xF00];

该数组在仿真操作过程中使用,最终(读取:带频率)需要被丢弃或重置.我的问题是,哪个更快,为什么？

mem = new byte[0xF00];

要么:

for(int i = 0; i < mem.length; i++) mem[i] = 0;

它可能看起来并不重要,但在模拟大量处理器时,效率会有所不同.速度的差异将来自JVM的垃圾收集; 在一个中,必须转储数组并进行垃圾收集,但是,JVM不再需要分配(并且可能为零)新内存.在第二种情况下,避免了JVM成本,但我们仍然必须遍历数组中的每个元素.

作为这个问题的其他警告:

1. 成本比率是否随数据类型的大小而变化？比如,怎么样short[]？
2. 阵列的长度是否会影响成本比率？
3. 最重要的是,为什么？