小编Zim*_*oot的帖子

我是Maven的新手.我正在尝试打包我的项目.但是,它会自动运行测试.测试在数据库中插入一些内容.这不是我想要的,我需要避免在打包应用程序时运行测试.有谁知道怎么运行包测试？

在Java应用程序中,我正在使用一些调用System.out.println().现在我想找到一种以编程方式删除这些东西的方法.

我找不到谷歌的任何解决方案,所以有任何提示吗？

我有一个Java类型的actor,它负责外部资源上可能暂时不可用的过滤器/重试逻辑.演员的领域和常用方法是:

public class MyActorImpl implements MyActor {
    private static final long MINWAIT = 50;
    private static final long MAXWAIT = 1000;
    private static final long DEFAULTWAIT = 0;
    private static final double BACKOFFMULTIPLIER = 1.5;

    private long updateWait(long currentWait) {
        return Math.min(Math.max((long) (currentWait * BACKOFFMULTIPLIER), MINWAIT), MAXWAIT);
    }

    // mutable
    private long opWait = DEFAULTWAIT;
    private final Queue<OpInput> opBuffer = new ArrayDeque<>();

    // called from external actor
    public void operation(OpInput opInput) {
        operation(opInput, DEFAULTWAIT);
    }

    // called internally
    public void …

public class Bicycle {

    private int cadence;
    private int gear;
    private int speed;
    private int id;
    private static int numberOfBicycles = 0;

    public Bicycle(int startCadence, int startSpeed, int startGear){
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;

        id = ++numberOfBicycles;
    }
       // ...
}

我在课堂上学到了这一点Static variables should be accessed by calling with class name.即ClassName.VariableName

但是在上面的代码中id = ++numberOfBicycles;,即使变量numberOfBicycles是这样的,如何编译这个语句没有错误static

我试图用否定的方法构造一个Slick查询,inSet但是我无法弄清楚正确的语法.我想做点什么

val lst = List(1, 2, 3)
Query(Table1).where(_.id1 === 1).where(!(_.id2 inSet lst)).list

要么

Query(Table1).where(_.id1 === 1).where(isNot(_.id2 inSet lst)).list

两者都没有通过集合.有可能否定inSet这样的,如果是这样,正确的语法是什么？或者是否有另一种方法来构造不需要否定的查询inSet？我正在使用Slick 1.0.1,我希望我们将在下个月内升级到Slick 2.0.(我可以filterNot(lst.contains(_.id2))对查询结果应用一个而不是在查询中放入一个否定inSet的内容,但这会使我正在编写的函数变得复杂,所以inSet如果可能的话我宁愿使用否定的.)

我的工作项目是使用Jackson JSON序列化程序将一堆Java对象转换为字符串,以便将它们发送到REST服务.

其中一些对象包含敏感数据,因此我编写了自定义序列化程序来将这些对象序列化为JSON字符串,然后对其进行gzip,然后使用加密它们AES;

这会将字符串转换为字节数组,因此我在编解码器中使用Base64编码Apache commons器将字节数组转换为字符串.REST接口背后的自定义反序列化器可以反转此过程:

base64 decode -> decrypt -> decompress -> deserialize using default Jackson deserializer.

Base64编码增加了输出的大小(序列化中的gzip步骤旨在帮助改善这种增加),所以我检查了Google是否有更有效的替代方法,这使我进入了之前的堆栈溢出线程,将Ascii85编码提升为更有效的替代方案 -

Base64增加了33%的输出大小,Ascii85增加了25%的输出大小.

我找到了一些Java Ascii85实现,例如Apache pdfbox,但我对使用编码有点怀疑 - 似乎没有人使用或实现它,这可能只是意味着Base64具有更多的惯性,或者可能意味着Ascii85有一些不稳定的问题.

有没有人对此主题有更多了解？Ascii85有什么问题,这意味着我应该使用Base64吗？

我们在Scala Play Framework应用程序中使用Elasticsearch 0.90.7,其中"doSearch"方法的结尾如下所示:

def doSearch(...) = {
  ...
  val actionRequessBuilder: ActionRequestBuilder // constructed earlier in the method
  val executedFuture: ListenableActionFuture<Response> = actionRequestBuilder.execute
  return executedFuture.actionGet
}

在哪里ListenableActionFuture延伸java.util.concurrent.Future,和ListenableActionFuture#actionGet基本相同Future#get

当我们按顺序执行搜索时,这一切都正常,但是当我们尝试并行执行多个搜索时:

val search1 = scala.concurrent.Future(doSearch(...))
val search2 = scala.concurrent.Future(doSearch(...))
return Await.result(search1, defaultDuration) -> Await.result(search2, defaultDuration))

我们有时(不到1%或2%的时间)在我们的scala期货上获得意外超时,即使在qa期间使用极长的超时(5秒,搜索总是在不到200ms内执行).使用scala全局执行上下文以及使用Play默认执行上下文时也会发生这种情况.

由于Java未来包含在scala未来中,是否存在某种意外的交互？我原本以为actionGet在结束时对java未来的调用doSearch会阻止两个期货相互干扰,但显然可能并非如此.

我有一个分布式/联邦数据库,结构如下:

1. 数据库分布在三个地理位置("节点")
2. 每个节点都聚集了多个数据库
3. 关系数据库是PostgreSQL,MySQL,Oracle和MS SQL Server的混合体; 非关系数据库是MongoDB或Cassandra
4. 通过RabbitMQ实现每个节点内和节点联合内的松散耦合,每个节点运行RabbitMQ代理

我正在为跨越节点联合的作业实现一个只读的节点间聚合作业系统(即,对于非节点本地的作业).这些作业只执行"获取"查询 - 它们不会修改数据库.(如果作业的结果打算进入一个或多个数据库,那么这是通过一个单独的作业完成的,该作业不是我试图优化的节点间作业系统的一部分.)我的目标是最小化这些作业所需的网络带宽(首先是最小化节点间/ WAN带宽,然后最小化节点内/ LAN带宽); 我假设每个WAN链路的统一成本,以及每个LAN链路的另一个统一成本.这些工作对时间不是特别敏感.我在节点内执行一些CPU负载平衡,但不在节​​点之间执行.

对于聚合作业,通过WAN/LAN传输的数据量相对于群集本地或特定数据库的数据库写入量较小,因此在联合中完全分发数据库是不切实际的.

我用来最小化网络带宽的基本算法是:

1. 如果作业运行在遍布联合的一组数据上,则管理器节点会向包含相关数据库查询的其他每个节点发送一条消息.
2. 每个节点运行其查询集,使用gzip压缩它们,缓存它们,并将它们的压缩大小发送到管理器节点.
3. 管理器移动到包含多个数据的节点(具体地说,移动到群集中具有最多数据且具有空闲核心的机器); 它从其他两个节点和集群中的其他机器请求其余数据,然后运行该作业.

在可能的情况下,作业使用分而治之的方法来最小化所需的数据共址量.例如,如果作业需要计算联合中所有销售数字的总和,则每个节点在本地计算其销售总额,然后在管理器节点聚合(而不是将所有未处理的销售数据复制到管理器节点) .但是,有时(例如,当在位于不同节点的两个表之间执行连接时)需要数据共址.

我做的第一件事就是聚合作业,并在十分钟时间内运行聚合作业(机器都运行NTP,所以我可以合理地确定"每十分钟"在每个节点上意味着相同的事情).目标是两个作业能够共享相同的数据,这降低了传输数据的总体成本.

1. 给定两个查询同一个表的作业,我生成每个作业的结果集,然后我取两个结果集的交集.
2. 如果两个作业都安排在同一节点上运行,则网络传输成本计算为两个结果集之和减去两个结果集的交集.
3. 两个结果集存储到PostgreSQL临时表(在关系数据的情况下),或者存储在选择运行作业的节点上的临时Cassandra columnfamilies/MongoDB集合(在nosql数据的情况下); 然后,针对组合的结果集执行原始查询,并且传递的数据是针对各个作业的.(此步骤仅在组合结果集上执行;单个结果集数据只是传递到其作业,而不首先存储在临时表/列族/集合中.)

这导致网络带宽的改善,但我想知道是否有一个框架/库/算法可以改善这一点.我考虑的一个选项是在确定网络带宽时将结果集缓存在节点上并考虑这些缓存的结果集(即除了当前的预先安排的共址作业集之外,尝试在作业之间重用结果集,以便例如在一个10分钟的纪元中运行的作业可以使用前一个10分钟结果集中的缓存结果集,但除非作业使用完全相同的结果集(即除非他们使用相同的where子句),否则我不知道一般情况 - 填充结果集中间隙的目的算法(例如,如果结果集使用子句"其中N> 3"而另一个作业需要带有子句"where N> 0"的结果集,那么我可以使用什么算法确定我需要将原始结果集和结果集的并集与"其中N> 0和N <= 3"的子句一起使用 - 我可以尝试编写自己的算法来执行此操作,但结果将是越野车无用的混乱.我还需要确定缓存数据何时过时 - 最简单的方法是将缓存数据的时间戳与源表上最后修改的时间戳进行比较,如果时间戳已更改,则替换所有数据,但理想情况下我希望能够仅更新已按行或每块时间戳更改的值.

我正在使用Spring-Retry进行一些数据库操作.在SQLRecoverableException我重试三次(这假设导致异常的任何内容是非瞬态的,如果它失败了三次),在SQLTransientException我无限期重试(程序无法做任何事情而无法访问数据库,所以它也可以继续重试,直到用户决定重新启动服务器),并且在任何其他异常时我都不会重试.我使用指数退避策略,基本重试为100毫秒,最大重试次数为30,000毫秒.

private static final int MAX_RECOVERABLE_RETRIES = 3;
private static final long INITIAL_INTERVAL = 100;
private static final long MAX_INTERVAL = 30 * 1000;
private static final double MULTIPLIER = 2.0;

public static RetryTemplate databaseTemplate() {
    RetryTemplate template = new RetryTemplate();
    ExceptionClassifierRetryPolicy retryPolicy = new ExceptionClassifierRetryPolicy();
    Map<Class<? extends Throwable>, RetryPolicy> policyMap = new HashMap<>();
    NeverRetryPolicy baseException = new NeverRetryPolicy();
    SimpleRetryPolicy recoverablePolicy = new SimpleRetryPolicy();
    recoverablePolicy.setMaxAttempts(MAX_RECOVERABLE_RETRIES);
    AlwaysRetryPolicy transientPolicy = new AlwaysRetryPolicy();
    policyMap.put(Exception.class, baseException);
    policyMap.put(SQLRecoverableException.class, recoverablePolicy); …

我们正在重构继承method以使用类型类 - 我们希望将所有method实现集中在一个地方,因为将它们分散在实现类中会使维护变得困难.但是,我们遇到了一些麻烦,因为我们对类型类很新.目前method被定义为

trait MethodTrait {
  def method: Map[String, Any] = // default implementation
}

abstract class SuperClass extends MethodTrait {
  override def method = super.method ++ // SuperClass implementation
}

class Clazz extends SuperClass {
  override def method = super.method ++ // Clazz implementation
}

等等,总共有50多个具体类,层次结构相当浅(abstract class SuperClass- > abstract class SubSuperClass- > abstract class SubSubSuperClass- > class ConcreteClass就像它一样深),具体类永远不会扩展另一个具体类.(在实际实现中,method返回一个Play框架JsObject而不是一个Map[String, Any].)我们试图用类型类替换它:

trait MethodTrait[T] …