Spring + JWT多方式可选登录（用户名/手机号/邮箱）实现遇阻求助

Hey there! Let's work through your multi-login implementation issue. Your current code has some critical syntax and logical mistakes—let's break them down and build a working version step by step.

First, Let's Identify the Issues in Your Code #

• Invalid Method Structure: You can't define multiple loadUserByUsername methods inside an if/elseif block in Java. The UserDetailsService interface requires exactly one implementation of this method, and you can't nest methods inside other methods.
• Incorrect Repository Calls: All three branches use findByUsername, which defeats the purpose of checking phone/email separately. You need distinct repository methods for each credential type.
• Exception Handling Mistakes: You can't "return" an exception like ex.CredentialNotFoundExptions—you need to throw exceptions, and custom exceptions should extend Spring's AuthenticationException (or a subclass like BadCredentialsException) for Security to handle them properly.

Step 1: Update Your UserRepository #

First, make sure your repository has dedicated query methods for each credential type:

import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    Optional<User> findByPhone(String phone);
    Optional<User> findByEmail(String email);
}

Step 2: Implement the Correct UserDetailsService #

We'll use a single loadUserByUsername method that tries each credential type in sequence. Note that the parameter name credential is more accurate here (since it can be username/phone/email), but we keep the method name as required by the interface.

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Optional;

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String credential) throws AuthenticationException {
        // 1. Try to find user by username first
        Optional<User> userOpt = userRepository.findByUsername(credential);
        if (userOpt.isPresent()) {
            return new MyUserPrincipal(userOpt.get());
        }

        // 2. If username fails, try phone number
        userOpt = userRepository.findByPhone(credential);
        if (userOpt.isPresent()) {
            return new MyUserPrincipal(userOpt.get());
        }

        // 3. If phone fails, try email
        userOpt = userRepository.findByEmail(credential);
        if (userOpt.isPresent()) {
            return new MyUserPrincipal(userOpt.get());
        }

        // 4. None of the credentials matched
        throw new BadCredentialsException("Invalid username, phone number, or email: " + credential);
    }
}

Step 3: Optional Custom Exceptions (If You Want Them) #

If you prefer custom exceptions for each credential type (like your original PhoneNotFoundException), create them by extending BadCredentialsException (so Spring Security recognizes them as authentication errors):

import org.springframework.security.authentication.BadCredentialsException;

public class PhoneNotFoundException extends BadCredentialsException {
    public PhoneNotFoundException(String phone) {
        super("Phone number not found: " + phone);
    }
}

public class EmailNotFoundException extends BadCredentialsException {
    public EmailNotFoundException(String email) {
        super("Email address not found: " + email);
    }
}

You can then throw these in the respective steps if you want more granular error messages:

// Replace the phone check block with this:
userOpt = userRepository.findByPhone(credential);
if (userOpt.isPresent()) {
    return new MyUserPrincipal(userOpt.get());
}
// If you want to throw immediately when phone isn't found
// throw new PhoneNotFoundException(credential);

How This Works #

Spring Security's AuthenticationManager will pass the user's input (from the login form) to loadUserByUsername. Our method checks each credential type in order until it finds a match, or throws an exception if none are found.

内容的提问来源于stack exchange，提问作者user8529149