小编Edw*_*rzo的帖子

我有一个场景,其中一些特殊字符存储在系统默认编码的数据库(sybase)中,我必须获取此数据并使用Java程序将其发送到UTF-8编码的第三方.

前提条件是发送给第三方的数据不应超过定义的最大大小.由于在转换为UTF-8时,一个字符可能被2或3个字符替换,然后我的逻辑规定在从数据库获取数据后,我必须将其编码为UTF-8字符串然后拆分字符串.以下是我的观察:

当遇到任何特殊字符,如中文或希腊字符或任何特殊字符> ASCII 256时,当我将其转换为UTF-8时,单个字符可能由超过1个字节表示.

那么我怎样才能确定转换是否合适？对于转换,我使用以下内容

// storing the data from database into string
string s = getdata from the database;

// converting all the data in byte array utf8 encoding
byte [] b = s.getBytes("UTF-8");

// creating a new string as my split logic is based on the string format

String newString = new String(b,"UTF-8");

但是当我将这个newString输出到控制台时,我得到?了特殊字符.

所以我有些疑惑:

• 如果我的转换逻辑错误,那我怎么能纠正它.
• 转换为UTF-8后,我可以仔细检查我的转换是否正常？我的意思是它是需要发送给第三方的正确消息,我假设如果消息在转换后不是用户可读的,那么转换有一些问题.

希望得到所有专家的一些观点.

如果我方需要进一步的信息,请告诉我.

刚刚从mySQL移动平台到firebird我发现很难找到一种可接受的方法来捕获从Java .jar应用程序传递到数据库服务器(Firebird)的SQL命令.我需要分析命令以及在执行时间等方面传递的查询的"成本".

使用MySQL可以使用maatkit工具包,但不幸的是,这似乎不适用于Firebird.

有没有人对Firebird的maatkit有适当的可比方法？或者使用strace或类似？

这些天我一直在学习Scala,今天我遇到了一些我无法理解的问题.

假设我们有以下参数函数定义:

def filter[T](source: List[T], predicate: T=>Boolean): List[T] = {
    source match {
        case Nil => Nil
        case x::xs => if(predicate(x)) x::filter(xs, predicate)
                  else filter(xs, predicate)
    }
}

现在,如果我按如下方式调用它,这可以正常工作:

filter(List(1,2,3,4,5,6), ( (n:Int) => n % 2 == 0))

但是如果删除类型标记,则看起来Scala无法推断出T的类型是Int.

filter(List(1,2,3,4,5,6), ( n => n % 2 == 0))

所以,我被迫在这次调用中提供显式类型信息.

有没有人知道为什么Scala无法在此调用中推断出T的类型.该列表显然是Ints列表,我不明白为什么它不能推断出n的类型也是Int.

我们目前有 4 个使用 Spring Security Oauth2 项目进行身份验证的 Spring 应用程序。这些应用程序是 REST API，供我工作的公司中的其他内部应用程序使用。

在开发和 QA 环境中一切正常，因为我们没有进行负载平衡，现在我们处于预生产阶段，我们正面临负载平衡器 (LB) 的问题。

这是此问题的工作流程：

1. 客户端发送对 oauth 令牌的请求
2. LB 将请求重定向到 Box 1
3. 框 1 进行身份验证并返回有效的承载令牌
4. 客户端接收令牌并将其存储以通过会话使用
5. 客户端在 REST API 中发送对服务的请求，将先前检索到的令牌添加到标头中
6. LB 将请求重定向到 Box 2
7. Box 2 无法进行身份验证，因为它无法识别令牌并返回 Invalid Credentials 响应

我们正在使用内存用户存储：

<bean id="tokenStore" class="org.springframework.security.oauth2.provider.token.InMemoryTokenStore" />

有没有办法让不同的盒子共享同一个令牌存储？我知道有一个 JdbcTokenStore 可用于将令牌持久化到数据库，但我更愿意避免持久化令牌，因为这些应用程序指向仅存储业务信息的旧数据库。

我试图了解在分布式数据库事务的上下文中处理RabbitMQ交付的正确模式是什么.

为了简单起见,我将用伪代码来说明我的想法,但实际上我正在使用Spring AMQP来实现这些想法.

什么都喜欢

void foo(message) {
   processMessageInDatabaseTransaction(message);
   sendMessageToRabbitMQ(message);
}

凡时候,我们到达sendMessageToRabbitMQ()了processMessageInDatabaseTransaction()已经成功提交了对数据库的更改,或到达消息发送代码之前的异常被抛出.

我知道,因为sendMessageToRabbitMQ()我可以使用Rabbit事务或发布者确认,以保证Rabbit得到我的消息.

我感兴趣的是理解当事情向南发生时会发生什么,即当数据库事务成功时,但确认在一定时间后(发布者确认)或Rabbit事务未能提交(使用Rabbit事务)时未到达.

一旦发生这种情况,保证传递信息的正确模式是什么？

当然,在开发了幂等消费者之后,我认为我可以重新发送消息,直到Rabbit确认成功为止:

void foo(message) {
   processMessageInDatabaseTransaction(message);
   retryUntilSuccessFull {
      sendMessagesToRabbitMQ(message);
   }
}

但是这种模式有一些我不喜欢的缺点,首先,如果故障延长,我的线程将开始阻塞,我的系统最终会变得无法响应.其次,如果我的系统崩溃或关闭会发生什么？我永远不会传递这些消息,因为它们会丢失.

所以,我想,好吧,我将首先将我的消息写入数据库,处于挂起状态,然后从那里发布我的待处理消息:

void foo(message) {
   //transaction commits leaving message in pending status
   processMessageInDatabaseTransaction(message);
}

@Poller(every="10 seconds")
void bar() {
   for(message in readPendingMessagesFromDbStore()) {
      sendPendingMessageToRabbitMQ(message);
      if(confirmed) {
          acknowledgeMessageInDatabase(message); 
      }
   }
}

如果我无法确认数据库中的消息,可能会多次发送消息.

但现在我已经介绍了其他问题:

• 需要从数据库执行I/O以发布消息,即99%的时间可以立即成功发布,而无需检查数据库.
• 由于现在我增加了消息发布的延迟,因此难以使轮询器更接近实时传送.
• 也许还有其他一些复杂因素,例如保证事件按顺序传递,轮询执行器相互衔接,多个轮询器等等.

然后我想好了,我可以让它变得更复杂,我可以从数据库发布直到我赶上事件的实时流然后发布实时,即保持大小为b的缓冲区(循环缓冲区)为我根据页面检查该消息是否在缓冲区中.如果是,则切换到实时订阅.

到目前为止,我意识到如何做到这一点并不是很明显,所以我得出结论,我需要了解解决这个问题的正确模式是什么.

那么,有没有人建议正确的方法是什么？

我正在阅读这篇文章,称为事件驱动架构中的变体,它们演示了中介和代理拓扑.

根据文章,中介拓扑看起来有点像这样:

事件流开始于客户端将事件发送到事件队列,该事件队列用于将事件传输到介体.该事件介体接收初始事件,并通过发送附加异步事件编排该事件的事件通道以执行该过程的每个步骤.监听事件通道的事件处理器从偶数调解器接收事件并执行特定的业务逻辑来处理事件[...]重要的是要注意事件调解器实际上并不执行必要的业务逻辑处理初始事件,而不是它知道处理事件所需的步骤[...]事件通道可以是消息队列o消息主题.

所以,我正在研究这个图,试图理解中介如何确定给定处理器何时完成处理给定事件,以便它可以协调下一步的过程.

它说的文章不够清楚

对于每个初始事件步骤,事件中介器创建处理事件,发送该处理事件并等待相应事件处理器处理处理事件.此过程将继续,直到处理完初始事件中的所有步骤.

现在,文章清楚地表明通信是异步的,并且事件消息将通过消息队列传播,但该图不显示从事件处理器发出并返回到调解器的任何事件.

文章说调解员等待事件处理器完成,但目前尚不清楚这应该如何在架构方面发生.

它是异步的,基于队列的RPC(例如Rabbit RPC),还是有另一个侦听器在某处等待异步响应？

有关如何从架构的角度实现这一点的任何想法？

鉴于我Flux<String>的大小未知，如何将其转换为InputStream其他库所期望的？

例如使用 WebClient 我可以使用这种方法实现

WebClient.get('example.com').exchange.flatMap { it.bodyToMono(InputStreamResource::class.java) }.map { it.inputStream }

但是当我Flux<String>作为输入时，我不知道如何做同样的事情？

在Java中,所有公共非静态方法都是虚拟的.这意味着要调用哪个方法是在运行时决定的(动态绑定).在C++中,虚函数(动态绑定)是使用vpointer和vtable实现的.我想知道Java是如何实现的.Java是否也使用vpointer和vtable如C++或其他一些技术来知道在运行时调用哪种方法？

我有一个要求，我使用 Spring Batch 从 SQL DB 读取一堆行（数千），并在将它们写入 Kafka 主题之前调用 REST 服务来丰富内容。

使用 Spring Reactive webClient 时，如何限制活动非阻塞服务调用的次数？在使用 Spring Batch 读取数据后，我应该以某种方式在循环中引入 Flux 吗？

（我理解 delayElements 的用法并且它有不同的用途，因为当单个 Get Service Call 带来大量数据并且您希望服务器减慢速度时——尽管如此，我的用例有点不同，因为我有许多 WebClient 调用要进行，并希望限制调用次数以避免内存不足问题，但仍能获得非阻塞调用的优势）。

花了几个小时阅读Http Client文档和源代码后，我决定绝对应该在这里寻求帮助。

我有一个使用轮询算法的负载均衡器服务器，如下所示

+---> RESTServer1 client --> load balancer +---> RESTServer2 +---> RESTServer3

我们的客户使用HttpClient将请求定向到我们的负载均衡器服务器，该服务器又将请求循环到相应的RESTServer。

现在，Apache HttpClient默认创建一个连接池（默认情况下每个路由2个）。由于我使用的是Http v1.1，并且我的服务器发出的是Connection：Keep-Alive标头，因此默认情况下，此连接为持久连接。

因此，问题在于，由于HttpClient创建了此持久性连接，因此这些连接不再在平衡器级别受循环算法的约束。他们总是每次都访问同一台服务器。

这产生了两个问题：

1. 我可以看到，有时一台或多台平衡服务器负载过大，而另一台或多台其他服务器却处于空闲状态。和
2. 即使我从平衡器中取出一台REST服务器，它在持久连接处于活动状态时仍会接收请求。

绝对不是预期的行为。

我想我可以Connection: close在响应中强加标头，或者可以在没有连接池或NoConnectionReuseStrategy的情况下运行HttpClient 。但是HttpClient 的文档指出，使用池背后的想法是通过避免每次都要打开套接字并进行所有TPC握手和相关操作来提高性能。因此，我必须得出结论，使用连接池对我的应用程序的性能有利。

所以我在这里的问题是，有没有一种方法可以通过负载均衡器使用持久连接，或者在这种情况下我是否不得不使用非持久连接？

我想要重用连接所带来的性能，但是我希望它们能够适当地负载均衡。关于如何尽可能使用Apache Http Client配置此方案的任何想法？