小编so-*_*ude的帖子

我正在使用Spring开发一个服务并在OpenShift上部署它.目前我正在使用Spring Actuator健康终端作为Kubernetes的活跃度和准备度调查.

但是,我将在Actuator健康端点中添加对另一个服务的调用,在我看来,在这种情况下,我需要为我的服务实现新的活动性探测.如果我不这样做,那么第二个服务的失败将导致活动探测失败失败,Kubernetes将在没有任何实际需要的情况下重新启动我的服务.

对于活跃度探测,是否可以实现一些简单的REST控制器,它总是返回HTTP状态200？如果它工作,服务总是可以被认为是活着的？或者有更好的方法吗？

我有一个mybatis映射文件xml,复杂的查询很多where条款的条款.

有什么办法可以创建可能的查询组合吗？

我想在所有这些查询上运行解释,因为我计划添加NOT IN所有查询.

我使用 Spring boot 创建了一个 GET/POST API，它有一个 http url 参数，比如 refid。现在这个参数在调用 GET/POST 请求之前已经被编码，例如http://localhost:8080/users/TESTFNkJXiQAH%2FJBKxigBx

但是，当我通过 Spring Boot 部署它时，编码的 refid 会再次编码，并且 refid 会发生变化。即它变成：

http://localhost:8080/users/TESTFNkJXiQAH%252FJBKxigBx

我想通过 Spring boot 抑制第二个编码。有人可以在这里提供建议吗？

在请求范围中,bean被定义为HTTP请求,而在会话范围中,它被限定为HTTP会话.所以对于一个例子,

如果bean范围是请求,并且用户在其用户会话中对网页发出多个请求,则在每个请求上都将创建一个新bean.

如果将作用域定义为bean的会话,则如果用户多次请求网页,则在每个请求中都会返回相同的bean.

如果这种理解是正确的,请告诉我？

我有一个用例:

我需要定期阅读和聚合来自kafka主题的消息,并发布到不同的主题.Localstorage不是一种选择.这就是我计划解决这个问题的方法,欢迎任何改进建议

要安排kafka消息的聚合和发布,请计划使用Aggregator EIP的completionInterval选项.这是代码.

  @Autowired ObjectMapper objectMapper;
  JacksonDataFormat jacksonDataFormat;

  @PostConstruct
  public void initialize(){
    //objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
    jacksonDataFormat = new JacksonDataFormat(objectMapper,EventMessage.class);
  }

和路线:

public void configure() throws Exception {
    from("kafka:localhost:9092?topic=item-events" +
            "&groupId=aggregator-group-id&autoCommitIntervalMs=25000&autoOffsetReset=earliest&consumersCount=1")
            .routeId("kafkapoller")
            .unmarshal(jacksonDataFormat)
            .aggregate(body().method("getItemId"), new EventAggregationStrategy()).completionInterval(20000)
            .marshal().json(JsonLibrary.Jackson)
            .to("kafka:localhost:9092?topic=item-events-aggregated&serializerClass=org.apache.kafka.common.serialization.ByteArraySerializer");
  }

我在这里Globalscope强烈建议不要使用。

我有一个简单的用例。对于我收到的每条kafka消息（比如说一个ID列表），我必须将其拆分并同时调用rest服务，等待它完成并继续执行其他同步任务。该应用程序中没有其他需要协程的东西。在这种情况下，我可以摆脱它吗？

注意：这不是android应用程序。它只是在服务器端运行的kafka流处理器。这是一个在Kubernetes中运行的临时性，无状态，容器化（Docker）应用程序（如果愿意的话，它支持Buzzword）

我有一个 Spring-Boot 应用程序，它被打包为一个带有 tomcat 依赖项的战争（所以我有两个选项 - 使用打包的 .war 在通过 java -jar 命令启动后在嵌入式容器中运行，并且还可以运行一个独立的 servlet 容器）。

下面是我的 App 主类

package com.mycompany.edsa.dgv.proxysvc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
//import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import  org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.mycompany.edsa.dgv.proxysvc.interceptor.DGVProxySvcRequestInterceptor;

//import com.mycompany.edsa.dgv.proxysvc.config.ConfigExtension;

@SpringBootApplication
@ImportResource("classpath:dgv-proxy-svc-spring-ctx.xml")
//@Import(ConfigExtension.class)
public class DGVProxySvcAppMain extends SpringBootServletInitializer {

public static void main(String[] args) {
    SpringApplication.run(DGVProxySvcAppMain.class, args);
}

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(DGVProxySvcAppMain.class);
}

@Bean
public DGVProxySvcRequestInterceptor dgvProxySvcRequestInterceptor() {
    DGVProxySvcRequestInterceptor dgvProxySvcReqInterceptor = new DGVProxySvcRequestInterceptor();
    return dgvProxySvcReqInterceptor; …

假设我们在表单中使用CSRF令牌，但是碰巧我们的网站上存在一个未被注意的XSS漏洞。

据我了解，在这种情况下，CSRF令牌保护是完全无效的，因为攻击者可以通过XSS使用XMLHttpRequest收回它。

在这种情况下，是否有一种方法可以使CSRF保护有效，使其在攻击中幸存下来？或者我们的站点在完全采取CSRF之王之前应该首先具有安全的XSS保护吗？

在每个页面请求上设置一个新令牌，而不是在登录时设置令牌会解决吗？这带来了一次打开更多表单的问题，我不喜欢它。

Kotlin_version ='1.2.41'

我对Kotlin很陌生。我想知道async和之间的区别launch。特别是在以下代码中

import kotlinx.coroutines.experimental.async
import kotlinx.coroutines.experimental.awaitAll
import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking

fun main(args: Array<String>) {
    runBlocking {
        (20..30).forEach {
            launch{
                println("main before" + it)
                val outer = it
                delay(1000L)
                val lists = (1..10)
                        .map { async{anotherMethod(outer, it)}}
                println("main after------------------Awaiting" + it)
                lists.awaitAll()
                println("Done awaiting -main after-----------------" + it)

            }


        }

        println("Hello,") // main thread continues here immediately
    }
}

。

suspend fun anotherMethod (outer: Int,index: Int){
    println("inner-b4----" + outer + "--" + index)
    delay(3000L) …

我正在开发带有弹簧靴和弹簧云的微服务.我开始了解hystrix和断路器模式.我知道断路器用于响应备用响应,以防下游微服务器出错,我依赖它来获取数据.我的问题是,如果我没有提供任何有意义的替代响应,为什么我需要一个断路器呢？