There is no PasswordEncoder mapped for the id "null"

报错内容

java.lang.IllegalArgumentException: There is no PasswordEncoder mapped for the id "null"

这个错主要发生在Spring-Sercurity5.X版本上，例如SpringBoot2.x。导致这个错误发生主要原因就是在之前版本中的NoOpPasswordEncoder被DelegatingPasswordEncoder取代了，而你保存在数据库中的密码没有没有指定加密方式。

深入分析

1.PasswordEncoder

public interface PasswordEncoder {
    String encode(CharSequence rawPassword);
    boolean matches(CharSequence rawPassword, String encodedPassword)
}

这个接口中主要有两个方法：
encode()这个主要用来决定如何编码密码，而之前的NoOpPasswordEncoder的实现如下

public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

可以看到，它对密码没有做任何处理
matches()这个方法用来描述前端提交的密码和服务器上的密码匹配规则，返回布尔值。而NoOpPasswordEncoder中的实现如下

public boolean matches(CharSequence rawPassword, String encodedPassword) {
        return rawPassword.toString().equals(encodedPassword);
    }

可以看出，它只是简单的比较是不是一样。

DelegatingPasswordEncoder

随着安全性的要求被提高，NoOpPasswordEncoder已经不能满足我们的需求了。那么修改一种默认的PasswordEncoder需要考虑什么问题呢？

• 确保使用当前密码存储建议对密码进行编码
• 允许验证现代和传统格式的密码
• 允许将来升级编码算法

简单来说,就是新的密码编码器和旧密码的兼容性,以及自身的稳健性以及需要一定的可变性(切换到更好的法).t听起来好像很难，那么请看DelegatingPasswordEncoder是如何解决这个问题的。
事实上DelegatingPasswordEncoder并不是传统意义上的编码器,它并不使用某一特定算法进行编码,顾名思义,它是一个委派密码编码器,它将具体编码的实现根据要求委派给不同的算法,以此来实现不同编码算法之间的兼容和变化协调.下面是源码：

public class DelegatingPasswordEncoder implements PasswordEncoder {
    private static final String PREFIX = "{";
    private static final String SUFFIX = "}";
    private final String idForEncode;
    private final PasswordEncoder passwordEncoderForEncode;
    //所有的ID与PasswordEncoder的映射
    private final Map<String, PasswordEncoder> idToPasswordEncoder;
    //默认委托的PasswordEncoder
    private PasswordEncoder defaultPasswordEncoderForMatches = new UnmappedIdPasswordEncoder();

    //构造方法
    public DelegatingPasswordEncoder(String idForEncode,
        Map<String, PasswordEncoder> idToPasswordEncoder) {
        if(idForEncode == null) {
            throw new IllegalArgumentException("idForEncode cannot be null");
        }
        if(!idToPasswordEncoder.containsKey(idForEncode)) {
            throw new IllegalArgumentException("idForEncode " + idForEncode + "is not found in idToPasswordEncoder " + idToPasswordEncoder);
        }
        for(String id : idToPasswordEncoder.keySet()) {
            if(id == null) {
                continue;
            }
            if(id.contains(PREFIX)) {
                throw new IllegalArgumentException("id " + id + " cannot contain " + PREFIX);
            }
            if(id.contains(SUFFIX)) {
                throw new IllegalArgumentException("id " + id + " cannot contain " + SUFFIX);
            }
        }
        this.idForEncode = idForEncode;
        this.passwordEncoderForEncode = idToPasswordEncoder.get(idForEncode);
        this.idToPasswordEncoder = new HashMap<>(idToPasswordEncoder);
    }

    //设置默认PasswordEncoder
    public void setDefaultPasswordEncoderForMatches(
        PasswordEncoder defaultPasswordEncoderForMatches) {
        if(defaultPasswordEncoderForMatches == null) {
            throw new IllegalArgumentException("defaultPasswordEncoderForMatches cannot be null");
        }
        this.defaultPasswordEncoderForMatches = defaultPasswordEncoderForMatches;
    }
        
      //如何编码
    @Override
    public String encode(CharSequence rawPassword) {
        return PREFIX + this.idForEncode + SUFFIX + this.passwordEncoderForEncode.encode(rawPassword);
    }
      //如何匹配
    @Override
    public boolean matches(CharSequence rawPassword, String prefixEncodedPassword) {
        if(rawPassword == null && prefixEncodedPassword == null) {
            return true;
        }
        String id = extractId(prefixEncodedPassword);
        PasswordEncoder delegate = this.idToPasswordEncoder.get(id);
        if(delegate == null) {
            return this.defaultPasswordEncoderForMatches
                .matches(rawPassword, prefixEncodedPassword);
        }
        String encodedPassword = extractEncodedPassword(prefixEncodedPassword);
        return delegate.matches(rawPassword, encodedPassword);
    }
      //获取密码前缀对应的加密方式{id}XXXXXXX,id代表加密方式，XXXXX代表加密后的密码
    private String extractId(String prefixEncodedPassword) {
        if (prefixEncodedPassword == null) {
            return null;
        }
        int start = prefixEncodedPassword.indexOf(PREFIX);
        if(start != 0) {
            return null;
        }
        int end = prefixEncodedPassword.indexOf(SUFFIX, start);
        if(end < 0) {
            return null;
        }
        return prefixEncodedPassword.substring(start + 1, end);
    }
        //获取{id}XXXXXXX中的加密内容，就是XXXXXXX这部分
    private String extractEncodedPassword(String prefixEncodedPassword) {
        int start = prefixEncodedPassword.indexOf(SUFFIX);
        return prefixEncodedPassword.substring(start + 1);
    }

    //DelegatingPasswordEncoder中默认的PasswordEncoder
    private class UnmappedIdPasswordEncoder implements PasswordEncoder {

        @Override
        public String encode(CharSequence rawPassword) {
            throw new UnsupportedOperationException("encode is not supported");
        }

        @Override
        public boolean matches(CharSequence rawPassword,
            String prefixEncodedPassword) {
            String id = extractId(prefixEncodedPassword);
            throw new IllegalArgumentException("There is no PasswordEncoder mapped for the id "" + id + """);
        }
    }
}

1.如何构建DelegatingPasswordEncoder？
SpringSercurity的PasswordEncoderFactories作为一个工厂类，用来构建DelegatingPasswordEncoder，当然你也根据自己的需求来实例化自己的DelegatingPasswordEncoder。下面给出PasswordEncoderFactories的源码。

public class PasswordEncoderFactories {
    public static PasswordEncoder createDelegatingPasswordEncoder() {
        String encodingId = "bcrypt";
        Map<String, PasswordEncoder> encoders = new HashMap<>();
        encoders.put(encodingId, new BCryptPasswordEncoder());
        encoders.put("ldap", new LdapShaPasswordEncoder());
        encoders.put("MD4", new Md4PasswordEncoder());
        encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
        encoders.put("noop", NoOpPasswordEncoder.getInstance());
        encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
        encoders.put("scrypt", new SCryptPasswordEncoder());
        encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
        encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
        encoders.put("sha256", new StandardPasswordEncoder());

        return new DelegatingPasswordEncoder(encodingId, encoders);
    }
    private PasswordEncoderFactories() {}
}

idToPasswordEncoder 这个里面就存着各种PasswordEncoder。所有实际上，当你调用DelegatingPasswordEncoder的encode()方法时，它会选用构造函数第一个参数指定的那个PasswordEncoder对密码进行编码，而调用matches()方法时，它会选择idToPasswordEncoder中的一种PasswordEncoder进行编码和匹配，这样就很灵活的解决了匹配多种加密方式的问题。但是你肯定会想，DelegatingPasswordEncoder如何去选择PasswordEncoder。
2.如何选择PasswordEncoder？
要弄清楚这个问题，先要了解一下它密码存储格式。它的密码存储格式如下：
{id}encodedPassword
其中,id标识使用PaswordEncoder的种类,也就是idToPasswordEncoder这个Map的Key ,encodedPassword是原密码被编码后的密码.
例如{noop}123456，noop这个就代表NoOpPasswordEncoder编码器，123456就代表使用NoOpPasswordEncoder加密后的密码。
如果你的密码没有{id}这部分，或者{id}中的id不在idToPasswordEncoder的Key集合中，那么它找不到对应的PasswordEncoder，会调用默认的UnmappedIdPasswordEncoder。这个类是DelegatingPasswordEncoder中的私有类， 你看它的实现，就发现之前报错的信息了。

如何解决？

情况有很多种，种方案的解决方案也不同，如果你认真把上面的内容全部看完了，应该不会看到这里了。
http://www.baeldung.com/spring-security-registration-password-encoding-bcrypt