FinnCoal's questions

Estou criando um serviço REST com Spring Boot e estou tendo problemas no ponto em que converto solicitações JSON/DTOs para as entidades correspondentes, especificamente quando uma entidade contém uma referência a outra entidade. Digamos que temos esses objetos, por exemplo:

data class BookEntity(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Int?,

    val name: String,

    @ManyToOne
    @JoinColumn(name = "author_id")
    val author: AuthorEntity,
)

data class AuthorEntity(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Int?,

    val name: String,
)

data class BookRequestDto(
    val name: String,
    val authorId: Int,
)

O aplicativo tem camadas controlador-serviço-repositório e, até onde sei, devo executar a conversão DTO -> entidade na camada controladora e, em seguida, passar a entidade resultante para a camada de serviço. No entanto, para converter o DTO de solicitação de livro em uma entidade, primeiro preciso buscar a entidade Autor apropriada do repositório com base no authorId. Minha pergunta é: onde exatamente devo fazer isso?

Dado que a camada de serviço deve aceitar apenas entidades, parece que eu deveria fazer a busca do autor na camada do controlador. Mas isso significaria que o controlador Book precisaria ter acesso à camada de serviço Author, e é isso que não tenho certeza se é uma boa prática.

Aqui está o que quero dizer (usando funções de extensão óbvias para fazer as conversões de DTO/entidade)

@RestController
@RequestMapping(path = ["/books"])
class BookController(
    private val bookService: BookService,
    private val authorService: AuthorService,
) {
    @PostMapping
    fun createBook(@RequestBody bookDto: BookRequestDto): ResponseEntity<BookResponseDto> {
        val author = authorService.get(bookDto.authorId)
        val bookEntity = bookDto.toBookEntity(author = author)
        val createdBook = bookService.create(bookEntity)
        return ResponseEntity(createdBook.toBookResponseDto(), HttpStatus.CREATED)
    }
}

Essa é a maneira usual de fazer isso ou misturar vários serviços em um controlador é uma má ideia? Eu claramente tenho que acessar o repositório do autor em algum lugar , só não sei qual seria o melhor lugar. Existe uma maneira melhor?

Sou iniciante aprendendo sobre Spring Boot e tenho tido problemas para fazer valores gerados funcionarem. Gostaria que o banco de dados (Postgres) gerasse uma coluna de timestamp quando uma linha é inserida, em vez de o Spring gerá-la, mas o problema é que o Spring parece não selecionar o timestamp do banco de dados quando ele executa uma atualização.

Quando eu insiro save()uma nova entidade, ela é inserida corretamente no banco de dados, um timestamp é gerado e retornado ao Spring; tudo funciona bem. Quando tento find()uma entidade existente, o timestamp também é retornado, então está tudo bem também. No entanto, quando tento atualizar uma entidade existente, o Spring NÃO acessa o timestamp que está no banco de dados e, em vez disso, retorna nulo para o campo correspondente.

Aqui está a definição da entidade:

import jakarta.persistence.*
import org.hibernate.annotations.CurrentTimestamp
import org.hibernate.generator.EventType
import java.time.OffsetDateTime

@Entity(name = "users")
@Table(name = "users")
data class User(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Int?,

    val name: String,

    @Column(name = "date_created")
    @CreationTimestamp(source = SourceType.DB)
    val dateCreated: OffsetDateTime?,
)

Digamos que o banco de dados já tenha uma linha como 1 | 2025-01-02 02:03:04 | user1. Uma solicitação PUT como { name: "new user" }atualizará o namecampo no banco de dados sem alterar o timestamp, mas a entidade atualizada retornada pelo JPA será { id: 1, name: "new user", dateCreated: null }. Não tenho certeza do porquê. Sei que o JPA executa um SELECT adicional ao INSERTing uma nova linha para obter o timestamp que foi gerado pelo Postgres, mas não vejo por que ele não obteria apenas o timestamp já existente ao UPDATEing.

As classes de controlador e serviço para integridade:

import com.example.hello.User
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*

@RestController
@RequestMapping(path = ["/users"])
class UserController(private val userService: UserService) {
    @PostMapping
    fun createStaff(@RequestBody user: User): ResponseEntity<User> {
        val createdUser = userService.create(user)
        return ResponseEntity(createdUser, HttpStatus.CREATED)
    }

    @PutMapping(path = ["/{id}"])
    fun updateUser(@PathVariable("id") id: Int, @RequestBody user: User): ResponseEntity<User> {
        val updatedUser = userService.update(id, user)
        return ResponseEntity(updatedUser, HttpStatus.OK)
    }

    @GetMapping(path = ["/{id}"])
    fun readUser(@PathVariable("id") id: Int): ResponseEntity<User> {
        val user = userService.get(id)
        return user?.let { ResponseEntity.ok(it) } ?: ResponseEntity(HttpStatus.NOT_FOUND)
    }
}

import com.example.hello.User
import com.example.hello.UserRepository
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service

@Service
class UserService(private val userRepository: UserRepository) {
    fun create(user: User): User {
        return userRepository.save(user)
    }

    fun update(id: Int, user: User): User {
        val userWithId = user.copy(id = id)
        return userRepository.save(userWithId)
    }

    fun get(id: Int): User? {
        return userRepository.findByIdOrNull(id)
    }
}