小编Tei*_*raz的帖子

我正在用弹簧靴做休息api.我需要使用输入参数(使用方法,例如GET,POST等),请求路径,查询字符串,此请求的相应类方法,以及此操作的响应,成功和错误来记录所有请求.

举个例子:

成功要求:

http://example.com/api/users/1

日志应该看起来像这样:

{
   HttpStatus: 200,
   path: "api/users/1",
   method: "GET",
   clientIp: "0.0.0.0",
   accessToken: "XHGu6as5dajshdgau6i6asdjhgjhg",
   method: "UsersController.getUser",
   arguments: {
     id: 1 
   },
   response: {
      user: {
        id: 1,
        username: "user123",
        email: "user123@example.com"   
      }
   },
   exceptions: []       
}

或者请求错误:

http://example.com/api/users/9999

日志应该是这样的:

    {
       HttpStatus: 404,
       errorCode: 101,                 
       path: "api/users/9999",
       method: "GET",
       clientIp: "0.0.0.0",
       accessToken: "XHGu6as5dajshdgau6i6asdjhgjhg",
       method: "UsersController.getUser",
       arguments: {
         id: 9999 
       },
       returns: {            
       },
       exceptions: [
         {
           exception: "UserNotFoundException",
           message: "User with id 9999 not found",
           exceptionId: "adhaskldjaso98d7324kjh989",
           stacktrace: ................... …

我想在一个弹簧启动项目中混合使用mvc和rest.

我想在一个地方为所有其他控制器(例如example.com/api)设置基本路径(我不希望@RequestMapping('api/products')仅为每个控制器添加注释@RequestMapping('/products').

可以通过example.com/whatever访问Mvc控制器

可能吗？

(我不使用spring数据休息,只是spring mvc)

在我的play framework(2.5)app中,我需要为服务编写单元测试.

我需要隔离数据访问逻辑以便能够单独测试服务层,为此我想创建存储库接口并在我的单元测试中对它们进行MOCK:

class UserService {
   def signUpNewUser(username: String, memberName: String): Future[Unit] {
      val userId = 1 // Set to 1 for demo
      val user = User(userId, username)
      val member = Member(memberName, userId) 
      // ---- I NEED TO EXECUTE THIS BLOCK WITHIN TRANSACTION ----
      for {
        userResult <- userRepository.save(user)
        memberRepository.save(member)
      } yield ()     
      // ---- END OF TRANSACTION ----
   }
}

在上述例子中,userRepository.save(User)和memberRepository.save(member)操作应当事务中执行.

我不想直接在我的服务层使用光滑,因为它会使我的测试复杂化.

另外,我不想在我的单元测试中使用嵌入式数据库,在其他地方它将是一个NOT单元测试,我需要完全隔离.

我不希望我的存储库接口完全依赖于光滑,但是需要这样的东西:

trait UserRepository {
   findById(id: Long): Future[Option[User]]
   save(user: User): Future[Unit] 
}

如何用光滑实现这一目标？

rest api的JS客户端可以将int和string作为某个字段的值发送.

{
   field1: "123",
   field2: "456"
}

{
   field1: 123,
   field2: 456
}

以下是应该转换json请求正文的case类的play动作:

  case class Dto(field1: Int, field2: Int)
  object Dto {
    implicit val reads = Json.reads[Dto]
  } 

  def create = Action.async(BodyParsers.parse.json) { implicit request =>
    request.body.validate[Dto].map {
      dto => someService.doStuff(dto).map(result => Ok(Json.toJson(result)))
    }.recoverTotal {
      e => jsErrorToBadRequest(e)
    }
  }

如果我发送带有int值的json值,它可以正常工作.但是如果field1或field2是字符串("123","456"),它就会失败,因为request.body.validate需要Int.

但问题是JS客户端从输入字段发送值,输入字段转换为字符串.

处理整数或字符串的最佳方法是什么？(所以这个动作应该在两种情况下都将json转换为dto)

假设我有文字成分：

Text {      
      text: "Hello"
      wrapMode: Text.WordWrap    
}

如何使其可选？

我有界面:

public interface CommandHandler<T extends Command> {
    void handle(T command);
}

有一些命令实现Command标记接口

public class CreateCategoryCommand implements Command {
}

public class CreateCategoryCommand implements Command {
}

对于每个命令,我都有适当的CommandHandler实现:

@Component
public class CreateProductCommandHandler implements CommandHandler<CreateProductCommand> {
    @Override
    public void handle(CreateProductCommand command) {
        System.out.println("Command handled");
    }
}

@Component
public class CreateCategoryCommandHandler implements CommandHandler<CreateCategoryCommand> {

    @Override
    public void handle(CreateCategoryCommand command) {

    }
}

问题: 我有指挥巴士

@Component
public class SimpleCommandBus implements CommandBus {

    @Autowired
    private ApplicationContext context;

    @Override
    public …

如果我们遵循 DDD 原则，一个聚合根应该只引用（通过 id）到另一个聚合根。

例子：

// Product Aggregate root
class Product { 

   // References to categories Aggregate Roots (to ids)
   Set<Long> categoryIds;
}

但是如何通过 JPA/Hibernate 实现呢？例如，在 jpa 中，如果我们想拥有 OneToMany 关系，我们将其定义如下：

// Product Aggregate root
class Product { 

   // Holds category aggregate roots
   @OneToMany(mappedBy = "", cascade = CascadeType.ALL)
   Set<Category> categories;
}

因此 JPA-s 方法本身将持有类别聚合根，这在 DDD 中是不推荐的。

您将如何设计与 JPA 的关系，但要符合 DDD 原则？

PS：我想制作categories字符串类型的属性并保存逗号分隔的类别ID列表，但有没有更好的解决方案？

我是C ++的新手

我有以下课程：

class User
{
public:
    User(const string& username) {
         m_username = username;
    }

    string username() const {
        return m_username;
    }

    void setUsername(const string &username) {
        m_username = username;
    }

private:
    string m_username;
};

这是main.cpp代码

User *createUser() {
    string username = "someUser";
    User *u = new User(username);
    return u;
}

int main(int argc, char *argv[])
{
    User *u2 = createUser();
    cout << u2->username() << endl;
    return 0;
}

在函数中，createUser()我正在创建局部变量username，并将其通过引用传递给User class构造函数。函数结束时，变量username超出范围，因此应删除m_username …

我有带有受保护静态方法的java类:

package parent;

public class Parent {

    protected static void parentMethod() {
        System.out.println("I'm in parent static method");
    }

}

在Scala 2.12.4(2.12.3)之前,我可以从另一个包中调用此方法,如下所示:

package child

import parent.Parent

class Child extends Parent {

  def childMethod = {
    println("I'm in child method and calling parentMethod")
    Parent.parentMethod()
  }

}

但Scala 2.12.4不编译此代码.我收到错误:

错误:(9,12)在对象父类的方法parentMethod不能在对象parent.Parent访问访问到受保护的方法parentMethod不允许的,因为前缀类型parent.Parent.type不符合在包孩子在那里访问发生家长反对孩子.parentMethod()

这种访问模式对我来说非常重要,因为JOOQ代码生成使用它.

发生了什么？

从本教程https://github.com/slouc/concurrency-in-scala-with-ce#threading \nasync 操作分为 3 组，需要显着不同的线程池来运行：

\n

非阻塞异步操作：

\n

有界池的线程数量非常少（甚至可能只有一个），但优先级非常高。这些线程基本上大部分时间都处于空闲状态，并不断轮询是否有新的异步 IO 通知。这些线程处理请求所花费的时间直接映射到应用程序延迟，因此除了接收通知并将其转发到应用程序的其余部分之外，在此池中不执行任何其他工作非常重要。\n有界池，具有非常大的延迟线程数量较少（甚至可能只有一个），但优先级非常高。这些线程基本上大部分时间都处于空闲状态，并不断轮询是否有新的异步 IO 通知。这些线程处理请求所花费的时间直接映射到应用程序延迟，因此除了接收通知并将其转发到应用程序的其余部分之外，不要在此池中完成其他工作，这一点非常重要。

\n

\n

阻塞异步操作：

\n

无界缓存池。无限制，因为阻塞操作可以（并且将会）阻塞线程一段时间，并且我们希望能够同时服务其他 I/O 请求。缓存是因为创建太多线程可能会耗尽内存，因此重用现有线程很重要。

\n

\n

CPU 密集型操作：

\n

固定池，其中线程数等于 CPU 核心数。这非常简单。回到过去，“黄金法则”是线程数 = CPU 核心数 + 1，但“+1”来自这样一个事实：总是为 I/O 保留一个额外的线程（如上所述，我们现在有单独的池）。

\n

在我的 Cats Effect 应用程序中，我使用基于 Scala Future 的 ReactiveMongo lib 来访问 MongoDB，它在与 MongoDB 通信时不会阻塞线程，例如执行非阻塞 IO。

它需要执行上下文。\n猫效果提供默认执行上下文IOApp.executionContext

我的问题是：我应该使用哪个执行上下文来进行非阻塞 io？

IOApp.executionContext？

但是，从IOApp.executionContext文档来看：

\n

为应用程序提供默认的 ExecutionContext。

\n

JVM 顶部的默认设置是根据可用 CPU 的数量延迟构建为固定线程池（请参阅 PoolUtils）。

\n