Java Spring Boot -- Error starting Tomcat context

Edit: added pom.xml info

 Error: *o.s.b.web.embedded.tomcat.TomcatStarter: 
    
    Error starting Tomcat context. Exception: org.springframework.beans.factory.UnsatisfiedDependencyException. 
    
    Message: Error creating bean with name 'jwtRequestFilter' defined in file [C:...\target\classes\com\...\Semen\security\JwtRequestFilter.class]: 
    
    Unsatisfied dependency expressed through constructor parameter 1: 
    
    Error creating bean with name 'jwtTokenService' defined in file [C:...\target\classes\com\...\Semen\security\JwtTokenService.class]: 
    
    Unsatisfied dependency expressed through constructor parameter 1: 
    
    Error creating bean with name 'tokenRepository' defined in com.psuti.Semen.security.token.TokenRepository defined in @EnableJpaRepositories declared on JpaRepositoriesRegistrar.EnableJpaRepositoriesConfiguration: 
    
    Cannot resolve reference to bean 'jpaSharedEM_entityManagerFactory' while setting bean property 'entityManager'

application.properties

spring.datasource.url=jdbc:postgresql://127.0.0.1:5432/testdb
spring.datasource.username=testuser
spring.datasource.password=testpassword
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=validate
spring.profiles.active=development
jwt.secret=simple

Info from pom.xml:

org.springframework.boot:spring-boot-starter-parentL3.0.4
java.version 18
spring 6.0.5
spring-security.version 6.0.2
org.springframework.boot:spring-boot-starter-web
org.springframework.boot:spring-boot-devtools:runtime:true
org.springframework.boot:spring-boot-starter-test:test
org.springframework.boot:spring-boot-starter-data-jpa
org.flywaydb:flyway-core
org.postgresql:postgresql:runtime
org.projectlombok:lombok:true
org.springframework.boot:spring-boot-starter-security
io.jsonwebtoken:jjwt-api:0.11.5
io.jsonwebtoken:jjwt-impl:0.11.5:runtime
io.jsonwebtoken:jjwt-jackson:0.11.5:runtime
org.springframework.boot:spring-boot-maven-plugin

Token

import com.fasterxml.jackson.annotation.JsonIgnore;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;
import java.util.UUID;

@Getter
@Setter
@Entity(name = "token")
@Table(name = "tokens", schema = "public")
public class Token implements Serializable {
    @Column(nullable = false, unique = true)
    private String value;
    @JsonIgnore
    private boolean killed;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "user_id")
    private UUID userId;
}

TokenRepository

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;
import java.util.UUID;

public interface TokenRepository extends JpaRepository<Token, UUID> {
    Optional<Token> findByValue(String value);
    Optional<Token> findTokenByUserId(UUID id);
}

JwtTokenService

package com.psuti.Semen.security;

import com.psuti.Semen.security.token.JwtTokenUtil;
import com.psuti.Semen.security.token.Token;
import com.psuti.Semen.security.token.TokenRepository;
import jakarta.persistence.EntityExistsException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean;

@Service
public class JwtTokenService {
    private final JwtTokenUtil<UUID> jwtUserIdTokenUtil;
    private final TokenRepository tokenRepository;
    @Autowired
    public JwtTokenService(JwtTokenUtil<UUID> jwtUserIdTokenUtil,
                           TokenRepository tokenRepository) {
        this.jwtUserIdTokenUtil = jwtUserIdTokenUtil;
        this.tokenRepository = tokenRepository;
    }
    public Token createToken(UUID userId){
        String token = jwtUserIdTokenUtil.generateToken(userId);
        Token tokenEntity = new Token();
        tokenEntity.setUserId(userId);
        tokenEntity.setValue(token);
        tokenEntity.setKilled(false);
        return tokenRepository.save(tokenEntity);
    }
    public void kill(String tokenValue){
        Token token = tokenByValue(tokenValue);
        token.setKilled(true);
        tokenRepository.save(token);
    }
    public void kill(Token token){
        token.setKilled(true);
        tokenRepository.save(token);
    }
    public boolean tokenIsKilled(String tokenValue){
        return tokenByValue(tokenValue).isKilled();
    }
    public boolean tokenExists(String tokenValue){
        AtomicBoolean exists = new AtomicBoolean(false);
        tokenRepository.findByValue(tokenValue).ifPresent(
                (t)-> exists.set(!t.isKilled())
        );
        return exists.get();
    }
    private Token tokenByValue(String val){
        Token token = tokenRepository.findByValue(val).orElseThrow(()->{
            throw new EntityExistsException("token with value: '" + val + "' doesn't exists");
        });
        return token;
    }
    public Optional<Token> findOptionalByUserId(UUID id){
        return tokenRepository.findTokenByUserId(id);
    }
    public Token findByUserId(UUID id){
        return tokenRepository.findTokenByUserId(id).orElseThrow(()->{
            throw new EntityExistsException("token by user id: " + id + " doesn't exists");
        });
    }
    public boolean validateToken(String token, UUID id){
        if(!jwtUserIdTokenUtil.validateToken(token,id)){
            if(new Date().before(jwtUserIdTokenUtil.getExpirationDateFromToken(token))){
                kill(token);
            }
            return false;
        }
        return true;
    }
    public UUID getIdFromToken(String token){
        return jwtUserIdTokenUtil.getSubjectFromToken(token);
    }
    public Token refreshToken(String tokenValue){
        Token token = tokenByValue(tokenValue);
        token.setValue(jwtUserIdTokenUtil.generateToken(token.getUserId()));
        return tokenRepository.save(token);
    }
}

I tried search info about this but nothing helped me

What means this error? How I can fix it?

> What means this error?

The first two errors are about unsatisfied dependencies to the constructor parameters. From the code we can see that this parameter is 'tokenRepository'. Unsatisfied dependency error in Spring means that the injection of a reference to an object (bean) is not possible. However both errors a just subsequent errors of the third one.

The third error shows the reason why the 'tokenRepository' can't be created (instantiated): there is an unknown reference to bean 'jpaSharedEM_entityManagerFactory' in JpaRepositoriesRegistrar.EnableJpaRepositoriesConfiguration class. This looks like a bug in a configuration class of Spring Data where we can't fix anything. Searching the web shows that there were some issue with this reference in the early versions of Spring 6, respectively Hibernate.

> How I can fix it?

Wait until the bug is fixed or try to use an earlier version of Spring. From the comment I can see that switching spring-boot-starter-parent to 3.0.1 (instead of 3.0.4) was helpful.