前端之家

  1. 首页
  2. 问答

使用带有参数的构造函数NO_CONSTRUCTOR的UsernamePasswordAuthenticationToken

• 问答

我使用OAuth2Authentication Using example from here的对流器将TokenStore存储到MongoDB中

但仍在抱怨

  

org.springframework.data.mapping.model.MappingInstantiationException：无法使用带有参数的构造函数NO_CONSTRUCTOR实例化org.springframework.security.authentication.usernamePasswordauthenticationToken

应用程序启动时，我会收到这些日志

  

2019-11-13 12：31：47.191 WARN 18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从接口com.mongodb.DBObject注册到类org.springframework.security.oauth2.provider.OAuth2Authentication作为读取转换器，尽管它不会从商店支持的类型转换！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.197警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类org.joda.time.LocalDateTime作为读取转换器，尽管它没有。不能从商店支持的类型转换！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.199警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类org.joda.time.LocalDateTime作为读取转换器，尽管它没有。不能从商店支持的类型转换！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.200 WARN 18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类java.time.Instant作为读取转换器，尽管它不会转换从商店支持的类型！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.200警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.Instant注册到类java.time.LocalDateTime作为读取转换器，尽管它不会转换从商店支持的类型！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.213警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类org.joda.time.LocalDateTime作为读取转换器，尽管它没有。不能从商店支持的类型转换！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.213警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类org.joda.time.LocalDateTime作为读取转换器，尽管它没有。不能从商店支持的类型转换！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.214 WARN 18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.LocalDateTime注册到类java.time.Instant作为读取转换器，尽管它不会转换从商店支持的类型！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.214警告18477 --- [restartedMain] osdata.convert.CustomConversions：将转换器从类java.time.Instant注册到类java.time.LocalDateTime作为读取转换器，尽管它不会转换从商店支持的类型！您可能想在转换器实现中检查注释设置。   2019-11-13 12：31：47.239信息18477 --- [restartedMain] t.g.e.p.uaa.config.MongoDbConfiguration：使用凭据配置mongoTemplate。

OAuth2AuthenticationReadConverter.java 

import com.mongodb.DBObject;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.security.authentication.usernamePasswordauthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.security.oauth2.provider.OAuth2Request;
import my.package.Users;

@ReadingConverter
public class OAuth2AuthenticationReadConverter implements Converter<DBObject,OAuth2Authentication> {

    @Override
    @SuppressWarnings("unchecked")
    public OAuth2Authentication convert(DBObject source) {
        System.out.println(source);
        DBObject storedRequest = (DBObject) source.get("storedRequest");

        OAuth2Request oAuth2Request = new OAuth2Request((Map<String,String>) storedRequest.get("requestParameters"),(String) storedRequest.get("clientId"),null,true,new HashSet((List) storedRequest.get("scope")),null);
        DBObject userauthorization = (DBObject) source.get("userauthentication");
        Object principal = getPrincipalObject(userauthorization.get("principal"));

        Authentication userauthentication = new usernamePasswordauthenticationToken(principal,(String) userauthorization.get("credentials"),getauthorities((List) userauthorization.get("authorities")));

        OAuth2Authentication authentication = new OAuth2Authentication(oAuth2Request,userauthentication);
        return authentication;
    }

    private Object getPrincipalObject(Object principal) {
        if (principal instanceof DBObject) {
            DBObject principalDBObject = (DBObject) principal;
            Users user = new Users(principalDBObject);
            return user;
        } else {
            return principal;
        }
    }

    private Collection<GrantedAuthority> getauthorities(List<Map<String,String>> authorities) {
        Set<GrantedAuthority> grantedAuthorities = new HashSet<GrantedAuthority>(authorities.size());
        for (Map<String,String> authority : authorities) {
            grantedAuthorities.add(new SimpleGrantedAuthority(authority.get("role")));
        }
        return grantedAuthorities;
    }
}

AuthorizacionServerConfiguration.java 

import lombok.extern.slf4j.Slf4j; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.Primary; 
import org.springframework.http.HttpHeaders; 
import org.springframework.http.ResponseEntity; 
import org.springframework.security.authentication.Authenticationmanager; 
import org.springframework.security.crypto.password.PasswordEncoder; 
import org.springframework.security.oauth2.common.exceptions.OAuth2Exception; 
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer; 
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter; 
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer; 
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer; 
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer; 
import org.springframework.security.oauth2.provider.error.DefaultwebresponseExceptionTranslator; import org.springframework.security.oauth2.provider.error.webresponseExceptionTranslator; 
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;

@Slf4j 
@Configuration 
@EnableAuthorizationServer 
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {

        @Autowired
        @Qualifier("authenticationmanagerBean")
        private Authenticationmanager authenticationmanager;

        @Autowired
        private CustomTokenStore tokenStore;

        @Autowired
        private PasswordEncoder passwordEncoder;

        @Autowired
        private CustomClientDetailsService oauthClientDetailsService;

        @Override
        public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
            clients.withClientDetails(oauthClientDetailsService);
        }

        @Override
        public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
            endpoints.authenticationmanager(authenticationmanager).tokenStore(tokenStore)
                    .exceptionTranslator(loggingExceptionTranslator());
        }

        @Override
        public void configure(AuthorizationServerSecurityConfigurer oauthServer) {
            oauthServer.tokenKeyaccess("permitAll()").checkTokenaccess("isAuthenticated()")
                    .passwordEncoder(passwordEncoder);
        }

        @Bean
        @Primary
        public DefaultTokenServices defaultTokenServices() {
            DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
            defaultTokenServices.setTokenStore(tokenStore);
            return defaultTokenServices;
        }

        @Bean
        public webresponseExceptionTranslator<OAuth2Exception> loggingExceptionTranslator() {
            return new DefaultwebresponseExceptionTranslator() {
                @Override
                public ResponseEntity<OAuth2Exception> translate(Exception e) throws Exception {
                    log.error("Oauth2 Exception: ",e);

                    // Carry on handling the exception
                    ResponseEntity<OAuth2Exception> responseEntity = super.translate(e);
                    HttpHeaders headers = new HttpHeaders();
                    headers.setall(responseEntity.getHeaders().toSingleValueMap());
                    OAuth2Exception excBody = responseEntity.getBody();
                    return new ResponseEntity<>(excBody,headers,responseEntity.getStatusCode());
                }
            };
        } }

MongoDbConfiguration.java 

 import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.WriteConcern;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimplemongoDbFactory;
import org.springframework.data.mongodb.core.convert.CustomConversions;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.util.StringUtils;
import my.package.OAuth2AuthenticationReadConverter;

@Configuration
public class MongoDbConfiguration extends AbstractMongoConfiguration {

    private static final Logger LOG = LoggerFactory.getLogger(MongoDbConfiguration.class);

    @Autowired
    private ApplicationContext applicationContext;

    @Value("${mongodb.authentication-database}")
    private String mongoauthDBName;
    @Value("${mongodb.host}")
    private String mongoServer;
    @Value("${mongodb.port}")
    private int mongoPort;
    @Value("${mongodb.database}")
    private String mongoDBName;
    @Value("${mongodb.username}")
    private String mongoDbLogin;
    @Value("${mongodb.password}")
    private String mongoDbPassword;

    @Autowired
    private MappingMongoConverter mongoConverter;

    @Override
    protected String getDatabaseName() {
        return mongoDBName;
    }

    @Bean
    public Mongo mongo() throws Exception {
        return new Mongo(mongoServer,mongoPort);
    }

    @Override
    @Bean
    public MongoTemplate mongoTemplate() throws Exception {
        mongoConverter.setCustomConversions(customConversions());
        if (!StringUtils.isEmpty(mongoDbLogin)) {
            LOG.info("Configuring mongoTemplate with credentials.");
            MongoDbFactory mongoDbFactory = new SimplemongoDbFactory(mongoClient(),mongoDBName);
            return new MongoTemplate(mongoDbFactory,mongoConverter);
        } else {
            LOG.info("Configuring mongoTemplate without credentials.");
            MongoDbFactory mongoDbFactory = new SimplemongoDbFactory(mongoClient(),mongoConverter);
        }
    }

    @Override
    @Bean()
    public CustomConversions customConversions() {
        List<Converter<?,?>> converterList = new ArrayList<>();
        OAuth2AuthenticationReadConverter converter = new OAuth2AuthenticationReadConverter();
        converterList.add(converter);
        return new CustomConversions(converterList);
    }

    private String getcontextProperty(final String propertyKey) {
        return applicationContext.getEnvironment().getProperty(propertyKey);
    }

    @Override
    public MongoClient mongoClient() {
        ServerAddress serverAddress = new ServerAddress(mongoServer,mongoPort);
        MongoCredential credential = MongoCredential.createCredential(mongoDbLogin,mongoauthDBName,mongoDbPassword.toCharArray());
        MongoClientOptions options = MongoClientOptions.builder()
                .writeConcern(WriteConcern.ACKNOWLEDGED)
                .build();
        return new MongoClient(serverAddress,credential,options);
    }
}

有人可以协助吗？

huanghongwang123 回答：使用带有参数的构造函数NO_CONSTRUCTOR的UsernamePasswordAuthenticationToken
暂时没有好的解决方案，如果你有好的解决方案，请发邮件至：iooj@foxmail.com
mongodbspring-bootspring-security-oauth2
本文链接：https://www.f2er.com/3111267.html

大家都在问