小编Geo*_*ins的帖子

我有一个GWT应用程序,用户可以无限期地打开应用程序的浏览器端.我们经常升级应用程序 - 如果用户在完成此操作后在浏览器中重新加载,那么一切都会顺利进行.然而,通常会发生的是,他们继续使用已经打开的应用程序版本,即升级之前提供的版本,然后遇到模糊的RPC相关错误,因为客户端Javascript不再与服务器上的内容同步.

GWT是否有任何机制,您可以启用或合并到您的代码中,以应对此问题.我不需要任何巧妙处理的情况,例如尝试重新加载应用程序并重新建立用户的当前状态,一个简单的对话框解释客户端和服务器不再同步并且Web应用程序需要重新加载就足够了.

我可以将多种类型的实例写入给定的目的地，例如：

JmsTemplate template = ...
Alpha alpha = new Alpha(...);
Beta beta = new Beta(...);

template.convertAndSend("my-destination", alpha);
template.convertAndSend("my-destination", beta);

我以为我可以提供多种带@JmsListener注释的方法来接收不同的消息有效负载，如下所示：

@JmsListener(destination = "my-destination")
public void receiveAlpha(Alpha alpha) { ... }

@JmsListener(destination = "my-destination")
public void receiveBeta(Beta beta) { ... }

但是，如果我尝试这种方法PayloadArgumentResolver.resolveArgument，则会出现异常，因为它无法区分Beta应将值发送到一种方法，而将Alpha值发送到另一种方法。

我应该如何处理呢？当我将有效负载类型编码为消息属性时，我可以指定一个选择器来使事情像这样工作：

@JmsListener(destination = "my-destination", selector = "_type = 'Alpha'")
public void receiveAlpha(Alpha alpha) { ... }

@JmsListener(destination = "my-destination", selector = "_type = 'Beta'")
public void receiveBeta(Beta beta) { ... } …

如果我有一组有用的可重用 Spring 组件，如何将它们作为库提供，以便其他项目可以使用这些组件中对它们有用的任何子集？

例如，我有 4 个类，X1、X2和X3，每个类都用（或，或其他）X4注释，我想将它们捆绑到一个库中。@Component@Service@Controller

然后我有一个项目 A 只对使用X1和感兴趣X3，另一个项目 B 只对使用X3和感兴趣X4。

项目 A 和 B 如何选择性地启用他们感兴趣的组件？

我正在使用 Spring Boot，所以我想我可以用 注释我的每个组件@ConditionalOnProperty，例如我可以注释X1等，如下所示：

@ConditionalOnProperty("x1.enabled")
@Component
public class X1 {

然后下游项目x1.enabled = true如果application.properties想要使用X1.

这是做事的方式还是有其他一些标准方法来捆绑组件以供重用？

我可以想到其他方法，例如：

• 将每个组件放在自己的包中，然后下游项目可以用来@ComponentScan仅扫描他们想要使用的组件的包。
• 我可以放弃@Component组件类并将它们标记为抽象，然后将其留给任何下游项目，以简单地对它们想要的组件进行子类化并添加@Component到子类中。

第一个想法听起来像是一个完整的黑客，第二个听起来并没有那么糟糕，但人们必须简单地创建子类才能启用某些功能（但至少它相当明确你正在做什么）。

请注意 - 我使用的是完全基于注释的配置，没有 XML。

而不是有一个 REST 控制器，在每个方法中我根据当前用户是否通过身份验证采取不同的操作，我想根据用户的身份验证状态委托给完全不同的控制器实现。

即，我将提供一个包含一组方法签名的接口，每个签名都有一个@RequestMapping注释，然后提供此接口的一个实现以用于经过身份验证的用户和另一个用于未经过身份验证的用户的实现。然后一些逻辑会为当前用户选择合适的实现并分派给它。

对于大多数语言,我不会问"他们为什么这样做X？" 因为它通常基于意见.

对于像C++这样的语言,通常的答案是引用一些规范,并且所有人都可以说,在做出特定选择之前,有人可能认为很长很难(但可能做出了不同的选择).

Scala是不同的 - 通常答案是指出你可以用一些更简单的结构Y和Z来思考X,因此在这种情况下看X的表达是有意义的.

因此,我会问为什么Scala允许定义引入多个名称并为每个名称计算一次给定的表达式？

如果你让Java程序员猜测这里会发生什么,他们可能会猜错:

var x, y, z = 3

也就是说,他们猜测只会z分配一个值.

如果你解释val然后告诉他们以下是合法的:

val x, y, z = 3

然后他们可能会猜测更多是正在进行的,x并且y必须在此行之后有值,因为以后不能为它们分配不同的值.

他们可能会假设x并y为其类型采用默认值,例如0表示整数,但因为这里没有明确的类型,这是一个飞跃.

他们可能会认为它被处理为:

val z = 3
val x = z
val y = z

当左边的表达式=产生原始值或不可变对象时,这并不重要.但以下可能会让他们怀疑:

val x, y, z = new StringBuilder

为什么有人想为同一个StringBuilder实例引入三个名字？

如果你向他们展示了以下内容,他们可能会从构造中猜出,甚至在运行代码之前出现了奇怪的事情:

var i = 0

def f: Int = {
  i += 1
  println(i)
  i
}

val x, …

Corda 对共识的介绍说"公证人提供了唯一性共识".

我们是否说过没有公证人说A有可能说服B将事务提交到涉及状态X作为输入的分类账,同时或稍后说服C提交涉及X 的不同事务分类帐？

在这种情况下,A的分类帐将与C(或B或两者的分类帐)不一致,具体取决于它选择提交的事务(如果有的话),并且A会创建一个现在不一致的情况,并且永远不会在A之间变得一致,B和C.

据推测,Corda框架试图尽可能地防止这种事情,所有这些都是关于诚实的吗？也就是说,我们正在讨论A完全颠覆自己的基础设施的情况,即不按预期使用Corda,并且在其发送给其他各方的所有消息中？

更新:这个问题最初被问到,因为我错误地认为公证人是Corda系统的可选元素.它们不是,但它们的参与对于特定交易可能是可选的,例如那些不涉及输入状态的交易(因此其本质上没有双重支出问题).

@joel在他的回答中明确指出的重要一点是,即使所有各方都相互信任,即双重花费问题也可能是一个问题,即预期不会出现恶意行为.

一旦Corda中的一方确定已达成交易的有效性共识,它就可以立即将交易提交给其自己的分类账,即它不会首先尝试与其他方达成某种额外的BFT风格共识,他们可以并且将会肯定会将交易提交给各自的分类账.

所以在上面的场景中,A可以诚实地/错误地向B和C提出两个不同的交易.B和C都会在各自的交易中达成有效共识并将它们提交给他们自己的分类账,而A只会面临双重支出问题.之后它尝试将两笔交易中的第二笔交易提交给自己的分类账.

公证人避免了这种情况(无论是否是恶意的结果).