Null gdy zwracam zalogowanego użytkownika w Springu przy pomoce utworzonej klasy i metody getLoggedUser()

Witam, mam problem. Napisałem klase, która ma mi zwrócić zalogowanego uzytkownika, jednak zwróciłem uwagę, ze za każdym razem dostaje Nulla zamiast konkretnego obiektu.

package com.github.kuciax.WebLibrary.utils;

import com.github.kuciax.WebLibrary.security.User;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;


public class LoggedUserUtils {

    public static User getLoggedUser() {

        final Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        final Object principal = auth.getPrincipal();

        if (principal instanceof User) {
            return (User) principal;
        }
        return null;
    }
}

oraz jej zastosowanie :

package com.github.kuciax.WebLibrary.order;

import com.github.kuciax.WebLibrary.book.BookRepository;


import com.github.kuciax.WebLibrary.utils.LoggedUserUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class OrderServiceImpl implements OrderService {

    private BookRepository bookRepository;
    private OrderRepository orderRepository;
    private OrderMapper orderMapper;
    private final Logger LOG = LoggerFactory.getLogger(OrderServiceImpl.class);

    @Autowired
    public OrderServiceImpl(BookRepository bookRepository, OrderRepository orderRepository, OrderMapper orderMapper) {
        this.bookRepository = bookRepository;
        this.orderRepository = orderRepository;
        this.orderMapper = orderMapper;
    }

    @Override
    public OrderDto addBookToOrder(String title) {

        if (LoggedUserUtils
                .getLoggedUser()
                .getMember()
                .getOrder()
                .getBooks()
                .isEmpty()
                ) {
            return createOrder(title);
        } else {
            Order order = orderRepository.findOneByMember(LoggedUserUtils.getLoggedUser().getMember());
            order.addOneBook(bookRepository.findOneByTitle(title));
            orderRepository.save(order);
            return orderMapper.toOrderDto(order);
        }

    }

    @Override
    public OrderDto createOrder(String title) {

        Order order = new Order();
        order.addOneBook(bookRepository.findOneByTitle(title));
        LoggedUserUtils.getLoggedUser().getMember().setOrder(order);
        order.setMember(LoggedUserUtils.getLoggedUser().getMember());
        orderRepository.save(order);
        return orderMapper.toOrderDto(order);
    }
}

W zamyśle mam encję User, która obsługę logowanie, rejstrację, weryfikację po tokenie. W niej znajduje się pole member i tutaj mamy już informacje o członku biblioteki, jego imię, nazwisko, wypożyczone książki. Problem pojawia się gdy chce otrzymać zalogowanego user. Ktoś pomoże?

Może principal nie jest instancją User? wtedy if jest fałszywy

@bames

User

package com.github.kuciax.WebLibrary.security;
import com.github.kuciax.WebLibrary.common.BaseEntity;
import com.github.kuciax.WebLibrary.member.Member;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.OneToOne;
import java.util.Collection;
import java.util.Collections;

@Entity
public class User extends BaseEntity implements UserDetails {
    @Column(unique = true, nullable = false)
    private String email;
    private String password;
    private Boolean isEnabled = false;
    @OneToOne
    private Member member ;

    public String getEmail() {
        return email;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Collections.emptySet();
    }

    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return email;
    }

    @Override
    public boolean isAccountNonExpired() {  //przedawanianie konta
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return isEnabled;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void enable() {
        this.isEnabled = true;
    }

    public void setMember(Member member) {
        this.member = member;
    }

    public Member getMember() {
        return member;
    }
}

package com.github.kuciax.WebLibrary.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

public class UserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;


    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        return userRepository.findUserByEmail(username);
    }
}

i BaseEntity jakby kogoś interesowało

package com.github.kuciax.WebLibrary.common;

import javax.persistence.*;
import java.time.LocalDateTime;
import java.util.UUID;

@MappedSuperclass
public class BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @Column(unique = true, nullable = false, length = 60, updatable = false)
    private String uuid = UUID.randomUUID().toString();
    @Column(nullable = false, updatable = false)
    private LocalDateTime createdAt;
    private LocalDateTime updateAt;

    @PrePersist
    public void prePresist() {

        this.createdAt = LocalDateTime.now();
    }

    @PreUpdate
    public void preUpdate() {
        this.updateAt = LocalDateTime.now();
    }

    public Long getId() {
        return id;
    }

    public String getUuid() {
        return uuid;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    public LocalDateTime getUpdateAt() {
        return updateAt;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        BaseEntity that = (BaseEntity) o;
        return that.hashCode() == this.hashCode();
    }

    @Override
    public int hashCode() {
        return uuid.hashCode();
    }
}

Jeśli możesz to wrzuć ten projekt do jakiegoś publicznego repozytorium np. GitHub, żeby można było to całościowo ogarnąć. Najkrócej rzecz ujmując to użytkownik nie jest zalogowany.

Twój problem jest w innym miejscu. Security działa poprawnie. Postaw sobie breakpointa to zobaczysz gdzie masz nulla.