小编Seb*_*ber的帖子

我正在尝试验证无效方法的参数,但我找不到解决方案......

谁能告诉我该怎么办？

我正在尝试这样的事情:

  def buildNormalCategory(user: User, parent: Category, name: String, description: String): Either[Error,Category] = {
    val errors: Option[String] = for {
      _ <- Option(user).toRight("User is mandatory for a normal category").right
      _ <- Option(parent).toRight("Parent category is mandatory for a normal category").right
      _ <- Option(name).toRight("Name is mandatory for a normal category").right
      errors : Option[String] <- Option(description).toRight("Description is mandatory for a normal category").left.toOption
    } yield errors
    errors match {
      case Some(errorString) => Left( Error(Error.FORBIDDEN,errorString) )
      case None =>  Right( buildTrashCategory(user) )
    }
  }

我们通常处理OutOfMemoryError问题,因为堆或permgen大小配置问题.

但是所有JVM内存都不是permgen或堆.据我所知,它也可以与线程/堆栈,本机JVM代码相关...

但是使用pmap我可以看到进程分配了9.3G,这是3.3G的堆外内存使用情况.

我想知道监视和调整这些额外的堆外内存消耗的可能性有多大.

我不使用直接的堆外内存访问(MaxDirectMemorySize默认为64m)

Context: Load testing
Application: Solr/Lucene server
OS: Ubuntu
Thread count: 700
Virtualization: vSphere (run by us, no external hosting)

JVM

java version "1.7.0_09"
Java(TM) SE Runtime Environment (build 1.7.0_09-b05)
Java HotSpot(TM) 64-Bit Server VM (build 23.5-b02, mixed mode)

Tunning

-Xms=6g
-Xms=6g
-XX:MaxPermSize=128m

-XX:-UseGCOverheadLimit
-XX:+UseConcMarkSweepGC
-XX:+UseParNewGC
-XX:+CMSClassUnloadingEnabled

-XX:+OptimizeStringConcat
-XX:+UseCompressedStrings 
-XX:+UseStringCache 

记忆图:

https://gist.github.com/slorber/5629214

vmstat的

procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
 1 …

我正在关注Coursera的Scala课程中的功能反应编程,我们处理RxScala Observables(基于RxJava).

据我所知,Play Iteratee的库看起来有点像RxScala Observables,其中Observables有点像Enumerators和Observers有点像Iteratees.

还有Scalaz Stream库,也许还有其他一些？

所以我想知道所有这些库之间的主要区别.在哪种情况下,一个可能比另一个更好？

PS:我想知道为什么Play Iteratees库没有被Martin Odersky选择用于他的课程,因为Play在Typesafe堆栈中.这是否意味着Martin喜欢RxScala而不是Play Iteratees？

编辑:在无流举措刚刚宣布,作为一种尝试standardize a common ground for achieving statically typed, high-performance, low latency, asynchronous streams of data with built-in non-blocking back pressure

我只是想知道:使用Java 8,并且可以在接口中添加实现(有点像Scala特性),是否可以实现蛋糕模式,就像我们在Scala中可以做的那样？

如果是,有人可以提供代码片段吗？

只是想知道幕后背后是什么.实际上我们似乎可以设置编码:

• response.setContentType("text/html; charset=UTF-8")
• response.setCharacterEncoding("UTF-8")

有什么不同？

我有时会看Scalaz并发现很难理解初学者Scala程序员.

  implicit def KleisliCategory[M[_]: Monad]: Category[({type ?[?, ?]=Kleisli[M, ?, ?]})#?] = new Category[({type ?[?, ?]=Kleisli[M, ?, ?]})#?] {
    def id[A] = ?(_ ?)
    def compose[X, Y, Z](f: Kleisli[M, Y, Z], g: Kleisli[M, X, Y]) = f <=< g
  }

  implicit def CokleisliCategory[M[_]: Comonad]: Category[({type ?[?, ?]=Cokleisli[M, ?, ?]})#?] = new Category[({type ?[?, ?]=Cokleisli[M, ?, ?]})#?] {
    def id[A] = ?(_ copure)
    def compose[X, Y, Z](f: Cokleisli[M, Y, Z], g: Cokleisli[M, X, Y]) = f =<= g 
  }

Scalaz方法对于有经验的函数式程序员来说似乎是显而易见的,但对于其他任何人来说,它很难理解.

为什么Scalaz代码中的文档很少？

他们为什么要使用那么多大多数人都无法阅读的运营商？我甚至不知道如何键入 …

我拿了一个TodoList示例来反映我的问题,但显然我的真实代码更复杂.

我有一些像这样的伪代码.

var Todo = React.createClass({
  mixins: [PureRenderMixin], 
  ............ 
}

var TodosContainer = React.createClass({
  mixins: [PureRenderMixin],    

  renderTodo: function(todo) {
     return <Todo key={todo.id} todoData={todo} x={this.props.x} y={this.props.y} .../>;
  },

  render: function() {
     var todos = this.props.todos.map(this.renderTodo)
     return (
          <ReactCSSTransitionGroup transitionName="transition-todo">
                 {todos}
          </ReactCSSTransitionGroup>,
     );
  }

});

我的所有数据都是不可变的,PureRenderMixin使用得当,一切正常.修改Todo数据时,仅重新呈现父级和编辑的待办事项.

问题是,在某些时候,当用户滚动时,我的列表会变大.当一个Todo更新时,渲染父节点,调用shouldComponentUpdate所有todos,然后渲染单个todo 需要花费越来越多的时间.

如您所见,Todo组件具有除Todo数据之外的其他组件.这是所有待办事项渲染所需的数据并且是共享的(例如,我们可以想象todos有一个"displayMode").具有许多属性会使shouldComponentUpdate执行速度稍慢.

此外,使用ReactCSSTransitionGroup似乎也减慢了一点,因为ReactCSSTransitionGroup必须渲染自己 ReactCSSTransitionGroupChild甚至在shouldComponentUpdatetodos被调用之前.React.addons.Perf表明ReactCSSTransitionGroup > ReactCSSTransitionGroupChild渲染是列表中每个项目浪费的时间.

所以,据我所知,我使用PureRenderMixin但是有一个更大的列表,这可能还不够.我仍然没有那么糟糕的表现,但想知道是否有简单的方法来优化我的渲染.

任何的想法？

编辑:

到目前为止,我的大列表是分页的,所以我现在将这个大列表分成一个页面列表,而不是列出大项目.这允许具有更好的性能,因为每个页面现在可以实现shouldComponentUpdate.现在,当一个项目在页面中发生变化时,React只需要调用在页面上迭代的主渲染函数,并且只从单个页面调用渲染函数,这样可以减少迭代次数.

但是,我的渲染性能仍然与我的页码(O(n))呈线性关系.所以如果我有成千上万的页面,它仍然是同一个问题:)在我的用例中,它不太可能发生,但我仍然对更好的解决方案感兴趣.

我很确定有可能实现O(log(n))渲染性能,其中n是项目(或页面)的数量,通过将大型列表拆分为树(如持久性数据结构),以及每个节点的位置有能力短路计算 shouldComponentUpdate

是的我正在考虑类似于Scala或Clojure中的Vector等持久数据结构的东西:

但是我关心React,因为据我所知,在渲染树的内部节点时可能需要创建中间dom节点.根据用例,这可能是一个问题( …

我正在准备S(O)CJP,以及Sierra和Bates的书.

关于内部类(方法本地或匿名),他们说我们不能访问局部变量,因为它们存在于堆栈上,而类存在于堆上并且可以由方法返回,然后尝试访问这些变量在堆栈上但由于方法已经结束而不再存在...

众所周知,我们可以通过使用final关键字来绕过这一点.这就是他们在书中所说的但他们并没有真正解释最终关键字的影响...据我所知,在方法局部变量上使用final关键字并不能使它在堆上生效. ..那么如何能够访问仍然存在于堆栈中的最终变量,而不会有更多的堆栈？

我想在内部类中应该有这种最终局部变量的某种"复制".由于价值不能改变,为什么不重复这些信息...有人可以确认这个或告诉我,如果我错过了什么？

有人可以解释这段代码吗？

public class SneakyThrow {


  public static void sneakyThrow(Throwable ex) {
    SneakyThrow.<RuntimeException>sneakyThrowInner(ex);
  }

  private static <T extends Throwable> T sneakyThrowInner(Throwable ex) throws T {
    throw (T) ex;
  }



  public static void main(String[] args) {
    SneakyThrow.sneakyThrow(new Exception());
  }


}

它可能看起来很奇怪,但这不会产生强制转换异常,并且允许抛出已检查的异常而不必在签名中声明它,或者将其包装在未经检查的异常中.

请注意,两者都没有sneakyThrow(...)或主要声明任何已检查的异常,但输出为:

Exception in thread "main" java.lang.Exception
    at com.xxx.SneakyThrow.main(SneakyThrow.java:20)
    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:601)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120)

本hack在龙目岛的使用,注释@SneakyThrow,允许抛出checked异常没有声明.

我知道它与类型擦除有关,但我不确定理解黑客的每个部分.

编辑: 我知道我们可以插入一个Integera List<String>和那个checked/unchecked异常区别是编译时功能.

从非泛型类型List转换为类似于List<XXX>编译器的泛型类型时会产生警告.但是直接转换为泛型类型并不像(T) ex上面的代码那样常见.

如果你愿意,对我来说似乎很奇怪的部分是我理解JVM中的内容List<Dog>并且List<Cat> …

我对DDD存储库模式了解不多,但Spring中的实现让我很困惑.

public interface PersonRepository extends JpaRepository<Person, Long> { … }

当接口扩展JpaRepository(或MongoDBRepository ...)时,如果从一个db更改为另一个db,则还必须更改接口.

对我来说,接口是为了提供一些抽象,但在这里并不是那么抽象......

你知道为什么Spring-Data会这样吗？