小编Mik*_*378的帖子

我正在使用Scala作为主要语言创建一个play 2项目,因此需要在Scala中实现一个rest客户端.

不幸的是,我不能轻易使用已知的Java Jersey-Client.

我在github上找到了这个可能很棒的api:sjersey-client

使用SBT作为依赖管理工具,我尝试指示播放app对sjersey的依赖:

object ApplicationBuild extends Build {

  val appName = "myWebapp"
  val appVersion = "1.0-SNAPSHOT"

  val appDependencies = Seq(
    jdbc,
    anorm
  )

  lazy val sjersey = RootProject(uri("git://github.com/FaKod/sjersey-client.git"))

  val main = play.Project(appName, appVersion, appDependencies).dependsOn(sjersey).settings(
    scalaVersion := "2.10.0"
  )

}

然后我运行命令:play reload update但更新失败:

[warn] Binary version (2.10) for dependency org.scala-lang#scala-library;2.10.0
[warn] in myWebapp#myWebapp_2.9.2;1.0-SNAPSHOT differs from Scala binary version in project (2.9.2).
[warn]  module not found: play#play_2.9.2;2.1-RC1              


[warn]  ::::::::::::::::::::::::::::::::::::::::::::::
[warn]  ::          UNRESOLVED DEPENDENCIES         ::
[warn]  :::::::::::::::::::::::::::::::::::::::::::::: …

任何优秀的软件架构师都会同意，当有人从头开始构建一个新项目时，他不能从一开始就考虑边界（数据库、GUI、外部服务等......）事实上，他应该独立于构建软件的核心任何后端并将它们视为应用程序的“插件”。

TDD 和验收测试促进了每个新功能的发展：

1. 为该功能编写失败的验收测试（端到端）
2. 通过一些单元测试推动并完成您的代码设计
3. 验收测试通过后即完成。

然而，很多文章都解释说，验收测试是真正的端到端测试，涉及 GUI（浏览器（例如使用 Selenium）或其他一些界面）。

难道验收测试不应该基于应用程序的核心并且独立于任何边界吗？例如，它会迫使我考虑 GUI...:s

什么是好的做法？为每个功能编写两种验收测试？：一种用于业务逻辑，另一种确保 GUI 正常工作？

毫无疑问,输入输出参数会导致代码混乱,因为它们可能会增加意外/不可预测的副作用.

所以,许多优秀的程序员说:

避免使用in-out参数来更改可变方法参数.希望保持参数不变.

对于一个完美主义程序员来说,他希望他的代码是最干净和最容易理解的,那么这个"规则"是否必须适用于所有情况？

例如,假设一种将元素添加到简单列表的基本方法,有两种方法:

第一种方式(带有输入参数):

private void addElementsToExistingList(List<String> myList){
  myList.add("Foo");
  myList.add("Bar");
}

并且来电者是:

List<String> myList = new ArrayList<String>();
//.......Several Instructions (or not) .....
addElementsToExistingList(myList);

没有参数的第二种方式:

private List<String> addElementsToExistingList(List<String> originalList){
      List<String> filledList = new ArrayList<String>(originalList); //add existing elements
      filledList.add("Foo");
      filledList.add("Bar");
      return filledList; 
    }

并且来电者是:

List<String> myList = new ArrayList<String>();
//.......Several Instructions (or not) .....
myList.addAll(addElementsToExistingList(myList));

第二种方式的优点:

参数未被修改=>没有新代码阅读器出现意外副作用的风险.

第二种方式:

非常冗长,可读性很差......

当然,你会告诉我,对于像这个简单的代码,第一种方法真的更方便.

但是,如果我们不考虑任何概念/代码的难度,那么对于任何读者(无论是否为初学者),我都认为第二种方式更具逻辑性和显而易见性.

然而,它违反了CQS原则,该原则认为"命令"方法具有具有潜在的空白返回(但是因为它是惯例而允许)副作用和具有返回类型且没有副作用的"查询"方法.

那么,激励程序员采用什么呢？两个混合代码案例？或者保持"法律"期望始终避免进出参数......

(当然,添加Element的方法被命名用于表示示例,并且在实际代码中将是一个错误的名称选择).

假设 MailConfiguration 类指定发送邮件的设置：

public class MailConfiguration {

  private AddressesPart addressesPart;

  private String subject;

  private FilesAttachments filesAttachments;

  private String bodyPart;

  public MailConfiguration(AddressesPart addressesPart, String subject, FilesAttachments filesAttachements,
    String bodyPart) {
    Validate.notNull(addressesPart, "addressesPart must not be null");
    Validate.notNull(subject, "subject must not be null");
    Validate.notNull(filesAttachments, "filesAttachments must not be null");
    Validate.notNull(bodyPart, "bodyPart must not be null");
    this.addressesPart = addressesPart;
    this.subject = subject;
    this.filesAttachements = filesAttachements;
    this.bodyPart = bodyPart;
  }
  // ...  some useful getters ......

}

因此，我使用两个值对象：AddressesPart 和 FilesAttachment。

这两个值对象具有相似的结构，因此我只在这里公开 AddressesPart ：

public …

总结范围链的概念:

加载网页后,Javascript会定位函数定义并为每个网页创建一个所谓的变量对象.每个VO必须引用每个局部变量(或全局),因此从第一个祖先的函数开始直到全局上下文.每个函数的作用域链都存储在名为Scope的函数属性中.

此外,在调用函数时,会创建一个新对象:激活对象.

这是什么？:

它就像一个变量对象(实际上是一个VO),负责引用所有函数内部的变量对象,包括"arguments"对象和形式参数.

当然,函数祖先的变量对象+函数的激活对象的每个链组成至少undefined首先映射所有变量.然后,只要执行进行,它就会通过更新其值(对应于引用的变量)而发展.

但是,我注意到Activation Object与变量对象的不同之处仅在于它包含Arguments对象,并且这个事实会阻止它在调用函数之前创建.

所以,我想知道为什么构建Javascript引擎的人没有在函数的定义步骤中分配每个激活对象.因此,当调用函数时,不需要创建自己的特定激活对象,因为它已经存在.引擎只会在函数执行结束时清除相应的arguments对象,以便下一次调用此对象时可以没有副作用.

它可能会提高性能吗？实际上,在每次调用时重新创建一个完整的激活对象可能会消耗..或者这个提议有问题吗？

关于这段代码:

var name = "Jaguar";
var car = {
  name:"Ferrari",
  getName:function(){
    return this.name;
  }
};

alert((car.getName = car.getName)());

输出是:Jaguar.

为什么this对象对应Window于car变量中包含的对象而不是对象？

似乎将对象的函数重新分配给自身的事实导致在this调用函数时丢失对象的赋值...

我试图猜测:它是否存在一种机制(使用变量或其他),密切关注对象函数的非重新配置,以便在发生这种情况时,这种机制会阻止this关键字的分配.平常(因为等于对象)？

在阅读Play时!框架文档,我遇到了这个片段:

def index = Action { implicit request =>
  session.get("connected").map { user =>
    Ok("Hello " + user)
  }.getOrElse {
    Unauthorized("Oops, you are not connected")
  }
}

文档说明implicit:

或者,您可以从请求中隐式检索会话

此外,我读了这篇文章:Literal with Implicit,从逻辑上看,函数不能有隐含参数.

如果我很清楚,这是因为一个函数,与方法相反总是一个契约(接口).

实际上,例如,Function1[Int, Function1[Int, Int]]具有返回类型的第一个参数a Int,因此阻止我们将此注释为implicit.这会导致对其高级返回类型的混淆:() => Int或Int => Int ......

因此,前面的代码片段代码的行为是隐含的,因为第一个Action必需参数是一个文字函数.

我想允许编译器接受此代码的原因是Action.apply()方法的多个签名:

• def apply(block: Request[AnyContent] => Result): Action[AnyContent]
• def apply(block: => Result): Action[AnyContent] (重定向到第一个)

由于第二个不需要一些参数,是否在存在文字函数的隐式参数时选择了这个参数？

当查询要搜索特定表和特定列中的特定数据时,关系数据库(如MySql)的性能优于Neo4j等图形数据库.

例如,如果查询是:" 搜索发生在巴黎的所有事件 ".

让我们假设为了简单起见,MySql将Event在"City"上有一个带有索引的表来优化这种查询.

Neo4j怎么样？有人可能会认为图形数据库必须遍历所有图形以检索相关事件......但是,可以使用Neo4j创建一些索引作为其文档准备.

为什么RDMBS会比这种分析/统计请求更快？

我曾经在我的bean上使用Spring事务注释.然而,Akka的演员不愿意.这是我在Scala中的代码片段:

@Service
@Transactional
@Scope("prototype")
class MyActor extends Actor with ActorLogging { 

   def receive = {
     //......  throwing a NotInTransaction (no matter what the calling lib is)
   }
}

但是,@Transactional适用于我所有其他非演员bean.

我添加了Java作为标记,因为它可能与Akka for Java有类似的问题.

我错过了什么？

我指出我事先遵循这种技术(我在Scala中改编)让我的演员创作意识到Spring:http: //www.typesafe.com/activator/template/akka-java-spring

更新示例-----------

@Service("eventsListenerActor")
@Scope("prototype")
class EventsListenerActor @Autowired()(val eventRepository: EventRepository) extends Actor {

  def receive = {
    case RetrieveNewEvents =>
      val newEvents = eventRepository.findNewEvents(EventBatchSizeProperty)
  }

}

@Repository
class MyEventRepository extends EventRepository {

   @Transactional       //transactional annotation here
   def findNewEvents(batchSize: Int): List[Event] = {
    //................ …

使用Neo4j 2.1.X,让我们假设这个查询,返回用户123购买汽车的朋友:

MATCH (u1:User("123"))-[:KNOWS]-(friend)
MATCH (friend)-[:BUYS]->(c:Car)
RETURN friend

在本文中,它是关于该WITH条款的:

那么它是怎样工作的？好吧,基本上只是一个流,尽管它可以是懒惰的(像返回一样懒惰),将结果传递给下一个查询.

所以我似乎应该像这样转换查询:

MATCH (u1:User("123"))-[:KNOWS]-(friend)
WITH friend
MATCH (friend)-[:BUYS]->(c:Car)
RETURN friend

我是不是该？或者当前版本的Cypher是否已经MATCH通过它们传递值来处理链接？