小编Nic*_*aro的帖子

我正在使用hive设计一个新的基于hadoop的数据仓库,我想知道在这种情况下经典的星形/雪花模式是否仍然是"标准".

大数据系统采用冗余,因此完全规范化的模式通常性能较差(例如,在HBase或Cassandra等NoSQL数据库中).

仍然是使用配置单元制作星型模式数据仓库的最佳实践吗？

通过利用新的列式文件格式,更好地设计行范围(reduntant)表吗？

据我了解，flyweight设计模式与工厂或单例设计模式没有太大不同。

它只是产生不可变（和合并）对象的工厂。它只是一个单例，为每个类型（托管对象）提供一个实例，而不是全局的单个实例。

工厂和单例是创造模式，那么为什么将举重视为结构模式？

我正在尝试为ZooKeeper创建docker容器并在集群模式下配置它们(完整代码在这里和这里).

容器基于Alpine Linux(高山:Docker Hub上的3.2),但我要描述的问题也发生在官方Java容器(java:7)上.

我使用以下命令启动集群:

docker run -d -h zk1 --name zk1 dockmob/zookeeper -s zk1,zk2,zk3
# wait some time ...
docker run -d -h zk2 --name zk2 dockmob/zookeeper -s zk1,zk2,zk3
docker run -d -h zk3 --name zk3 dockmob/zookeeper -s zk1,zk2,zk3

(它们可以在码头集线器上使用,您可以试用它们).

如果我开始了第二和第三容器之前等待一段时间,然后在主机名zk2和zk3放入/etc/hosts太晚(由码头工人)和Java是无法找到他们:我得到java.net.UnknownHostException在日志zk1两个zk2和zk3.

我在网上发现我需要禁用JVM DNS缓存以刷新主机名,因此我在其中引入了以下命令Dockerfile以更新java.security设置:

RUN grep '^networkaddress.cache.ttl=' /usr/lib/jvm/java-1.7-openjdk/jre/lib/security/java.security || echo 'networkaddress.cache.ttl=10' >> /usr/lib/jvm/java-1.7-openjdk/jre/lib/security/java.security

它将DNS TTL属性(networkaddress.cache.ttl)设置为10 …

给定一个线程已经完成了一些工作（它的状态是 Thread.State.TERMINATED），有没有办法了解线程是否正确完成了 Thread.run()/Runnable.run() 方法或抛出了一个未捕获的可扔？

Afaik，一个线程在正常退出和抛出 throwable 时都会进入 TERMINATED 状态。

有人建议使用 UncaughtExceptionHandler。鉴于一个线程只能有一个 UncaughtExceptionHandler（所有线程的默认设置除外），并且线程代码可以更改提供的一个，使用它们是一种好习惯吗？

在Cloudera Hue中看到的HDFS目录似乎具有以下权限标志:

drwxrwxrwxt

我知道它是一个目录(d),可以被所有用户用于读/写模式(rw),并且所有用户都可以访问子节点(x).

是什么最后的标志牛逼是什么意思？

每当我尝试在Cloudera CDH 5.4.4集群上运行Spark应用程序,Yarn客户端模式时,我都会收到以下异常(在堆栈跟踪中重复多次).无论如何,该过程仍在继续(这是一个警告),但在日志中找到某些内容是不可能的.我该如何解决？

15/09/01 08:53:58 WARN net.ScriptBasedMapping: Exception running /etc/hadoop/conf.cloudera.yarn/topology.py 10.0.0.5 
java.io.IOException: Cannot run program "/etc/hadoop/conf.cloudera.yarn/topology.py" (in directory "/home/azureuser/scripts/streaming"): error=13, Permission denied
    at java.lang.ProcessBuilder.start(ProcessBuilder.java:1047)
    at org.apache.hadoop.util.Shell.runCommand(Shell.java:485)
    at org.apache.hadoop.util.Shell.run(Shell.java:455)
    at org.apache.hadoop.util.Shell$ShellCommandExecutor.execute(Shell.java:715)
    at org.apache.hadoop.net.ScriptBasedMapping$RawScriptBasedMapping.runResolveCommand(ScriptBasedMapping.java:251)
    at org.apache.hadoop.net.ScriptBasedMapping$RawScriptBasedMapping.resolve(ScriptBasedMapping.java:188)
    at org.apache.hadoop.net.CachedDNSToSwitchMapping.resolve(CachedDNSToSwitchMapping.java:119)
    at org.apache.hadoop.yarn.util.RackResolver.coreResolve(RackResolver.java:101)
    at org.apache.hadoop.yarn.util.RackResolver.resolve(RackResolver.java:81)
    at org.apache.spark.scheduler.cluster.YarnScheduler.getRackForHost(YarnScheduler.scala:38)
    at org.apache.spark.scheduler.TaskSchedulerImpl$$anonfun$resourceOffers$1.apply(TaskSchedulerImpl.scala:271)
    at org.apache.spark.scheduler.TaskSchedulerImpl$$anonfun$resourceOffers$1.apply(TaskSchedulerImpl.scala:263)
    at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
    at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:47)
    at org.apache.spark.scheduler.TaskSchedulerImpl.resourceOffers(TaskSchedulerImpl.scala:263)
    at org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend$DriverActor.makeOffers(CoarseGrainedSchedulerBackend.scala:167)
    at org.apache.spark.scheduler.cluster.CoarseGrainedSchedulerBackend$DriverActor$$anonfun$receiveWithLogging$1.applyOrElse(CoarseGrainedSchedulerBackend.scala:131)
    at scala.runtime.AbstractPartialFunction$mcVL$sp.apply$mcVL$sp(AbstractPartialFunction.scala:33)
    at scala.runtime.AbstractPartialFunction$mcVL$sp.apply(AbstractPartialFunction.scala:33)
    at scala.runtime.AbstractPartialFunction$mcVL$sp.apply(AbstractPartialFunction.scala:25)
    at org.apache.spark.util.ActorLogReceive$$anon$1.apply(ActorLogReceive.scala:53)
    at org.apache.spark.util.ActorLogReceive$$anon$1.apply(ActorLogReceive.scala:42)
    at scala.PartialFunction$class.applyOrElse(PartialFunction.scala:118)
    at org.apache.spark.util.ActorLogReceive$$anon$1.applyOrElse(ActorLogReceive.scala:42)
    at akka.actor.ActorCell.receiveMessage(ActorCell.scala:498)
    at akka.actor.ActorCell.invoke(ActorCell.scala:456)
    at akka.dispatch.Mailbox.processMailbox(Mailbox.scala:237)
    at akka.dispatch.Mailbox.run(Mailbox.scala:219)
    at akka.dispatch.ForkJoinExecutorConfigurator$AkkaForkJoinTask.exec(AbstractDispatcher.scala:386) …

我想让我的spring-boot配置类A依赖于另一个配置类B，即A仅在B评估配置时才评估配置。

在实际情况下，我有数百种Ai配置，只有一种B，并且我想Ai通过仅B在测试期间排除的方式来实现一种排除所有配置的方式。

我尝试了以下方法：

@Configuration
@ConditionalOnBean(type = "org.my.B")
public class A1AutoConfiguration {
// ...
}

哪里B是无条件的配置类。

但是，当我跑mvn spring-boot:run -Ddebug=true我看到，A是永远不会计算，因为B缺少。虽然在内部创建的Bean B在应用程序上下文中，但B本身不在。

虽然我可以使Ai配置类依赖于内部创建的bean， B但是我不太喜欢这种解决方案。

有没有更清洁（且可行）的方式来实现这种依赖机制？

我正在编写Spark应用程序,我需要拦截正在运行的作业的状态.我SparkListener为此目的实现了一个,使用以下代码:

class MyAppListener extends SparkListener {

    override def onApplicationStart(ev: SparkListenerApplicationStart): Unit = {
      println("AAA: Application Start")
    }

    override def onApplicationEnd(ev: SparkListenerApplicationEnd): Unit = {
      println("AAA: Application End")
    }
  }
}

然后,我使用以下代码启动应用程序并查看事件:

val appListener = new MyAppListener
val conf = new SparkConf().setAppName("Listener")
val sc = new SparkContext(conf) 
sc.addSparkListener(appListener)
println(sc.parallelize(1 to 10).count)
sc.stop()

在日志中,我看到字符串"AAA:Application End",但我没有看到应用程序的开始.

组态:

• Spark版本1.2.0
• 斯卡拉2.10
• 群集上的本地独立模式或YARN客户端模式(相同的行为)

我正在使用UML 2.0表示法为类图设计基于java的系统的类(使用Astah).

为了简化类之间的依赖关系,我想在一个包中组合一些类,并将来自其他一些类的依赖关系放到包中.

是将包放在类图中,然后在类和包之间编写关系,符合UML 2.0规范？

包裹是否应仅包装在包装图中？

我试图了解Cassandra用于生成复合分区键的murmur3哈希的算法。我知道我可以直接从CQL获取值，但是我想直接从Java / scala代码为任何给定的元组重现Cassandra的行为。

对于简单的分区键，以下函数计算正确的值（至少在很多情况下，通过查看源代码，我知道它是不正确的）：

long l = com.google.common.hash.Hashing.Hashing.murmur3_128（）。hashString（“ my-string”，Charset.forName（“ UTF-8”））。asLong（）;

如果我在分区键上有两列怎么办？

两个字符串的串联的哈希值不相同。

我试图用Spark读取S3文件并获得以下异常:

java.lang.NullPointerException
    at org.apache.hadoop.fs.s3native.NativeS3FileSystem.getFileStatus(NativeS3FileSystem.java:433)
    at org.apache.hadoop.fs.Globber.getFileStatus(Globber.java:57)
    at org.apache.hadoop.fs.Globber.glob(Globber.java:248)
    at org.apache.hadoop.fs.FileSystem.globStatus(FileSystem.java:1642)
    at org.apache.hadoop.mapred.FileInputFormat.singleThreadedListStatus(FileInputFormat.java:257)
    at org.apache.hadoop.mapred.FileInputFormat.listStatus(FileInputFormat.java:228)
    at org.apache.hadoop.mapred.FileInputFormat.getSplits(FileInputFormat.java:304)
    at org.apache.spark.rdd.HadoopRDD.getPartitions(HadoopRDD.scala:201)
    at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:205)
    at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:203)
    at scala.Option.getOrElse(Option.scala:120)
    at org.apache.spark.rdd.RDD.partitions(RDD.scala:203)
    at org.apache.spark.rdd.MappedRDD.getPartitions(MappedRDD.scala:28)
    at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:205)
    at org.apache.spark.rdd.RDD$$anonfun$partitions$2.apply(RDD.scala:203)
    at scala.Option.getOrElse(Option.scala:120)
    at org.apache.spark.rdd.RDD.partitions(RDD.scala:203)
    at org.apache.spark.SparkContext.runJob(SparkContext.scala:1328)
    at org.apache.spark.rdd.RDD.count(RDD.scala:910)
    at $iwC$$iwC$$iwC$$iwC.<init>(<console>:13)
    at $iwC$$iwC$$iwC.<init>(<console>:18)
    at $iwC$$iwC.<init>(<console>:20)
    at $iwC.<init>(<console>:22)
    at <init>(<console>:24)
    at .<init>(<console>:28)
    at .<clinit>(<console>)
    at .<init>(<console>:7)
    at .<clinit>(<console>)
    at $print(<console>)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at org.apache.spark.repl.SparkIMain$ReadEvalPrint.call(SparkIMain.scala:852)
    at org.apache.spark.repl.SparkIMain$Request.loadAndRun(SparkIMain.scala:1125)
    at org.apache.spark.repl.SparkIMain.loadAndRunReq$1(SparkIMain.scala:674)
    at org.apache.spark.repl.SparkIMain.interpret(SparkIMain.scala:705)
    at org.apache.spark.repl.SparkIMain.interpret(SparkIMain.scala:669)
    at …

我实现了一个带有重载方法的Scala类,该方法可以带一个Iterable[String]或一个String*varargs参数:

class StackOverflow(names: Iterable[String]) {

  // This function creates a copy of the StackOverflow object
  // copy is needed but this cannot be a case class.
  private def copy(names: Iterable[String] = names) = new StackOverflow(names) // <- line 19

  // overloaded methods

  def withNames(names: Iterable[String]) = this.copy(names = names) // <- line 24

  def withNames(names: String*) = require(names.nonEmpty); withNames(names.toIterable) // <- line 26
}

object App {

  def main(args: Array[String]) = {
    val x1 = new …