Java 使用KeyClope的自定义用户联合

我是新加入keydeave的，我正在尝试自定义keydeave的用户联合。我创建了一个项目，在这个项目中，在用户选项中，一切似乎都很好。keydeave用户联合会识别我的适配器。问题是什么时候想要获得用户列表。请帮忙。我先谢谢你

在同一台keyclok wildfly服务器上，我在standalone.xml文件上创建了一个新连接，其中持久化单元是userDs，我还创建了适配器、提供程序和工厂提供程序

User.java

@NamedQueries({
    @NamedQuery(name="getUserByUsername", query="select u from User u where u.usuario = :username"),
    @NamedQuery(name="getUserByEmail", query="select u from User u where u.email = :email"),
    @NamedQuery(name="getUserCount", query="select count(u) from User u"),
    @NamedQuery(name="getAllUsers", query="select u from User u"),
    @NamedQuery(name="searchForUser", query="select u from User u where " +
            "( lower(u.usuario) like :search or u.email like :search ) order by u.usuario")})
@Table(name="usuario")
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {`
private static final long serialVersionUID = 1L;
@Id
private String id;
private String usuario;
private String nombre;
private String apellidos;
private String email;
private String password;
}

UserAdapter.java

public class UserAdapter extends AbstractUserAdapterFederatedStorage {

private static final Logger logger = Logger.getLogger(UserAdapter.class);
protected User entity;
protected String keycloakId;

public UserAdapter(KeycloakSession session, RealmModel realm, ComponentModel model, User entity) {
    super(session, realm, model);
    this.entity = entity;
    keycloakId = StorageId.keycloakId(model, entity.getId());
}

public String getPassword() {
    return entity.getPassword();
}

public void setPassword(String password) {
    entity.setPassword(password);
}

@Override
public String getUsername() {
    return entity.getUsuario();
}

@Override
public void setUsername(String username) {
    entity.setUsuario(username);

}

@Override
public void setEmail(String email) {
    entity.setEmail(email);
}

@Override
public String getEmail() {
    return entity.getEmail();
}

@Override
public String getId() {
    return keycloakId;
}

@Override
public String getFirstName() {
    return entity.getNombre();
}

@Override
public void setFirstName(String firstName) {
    entity.setNombre(firstName);
}

@Override
public String getLastName() {
    return entity.getApellidos();
}

@Override
public void setLastName(String lastName) {
    entity.setApellidos(lastName);
}

UserStorageProviderFactory.java

public class UserStorageProviderFactory implements org.keycloak.storage.UserStorageProviderFactory<UserStorageProvider> {
private static final Logger logger = Logger.getLogger(UserStorageProviderFactory.class);

@Override
public UserStorageProvider create(KeycloakSession session, ComponentModel model) {

    try {
        InitialContext ctx = new InitialContext();
        logger.info("URL: " + "java:global/keycloak-jpa/" + UserStorageProvider.class.getSimpleName());
        UserStorageProvider provider = (UserStorageProvider)ctx.lookup("java:global/keycloak-jpa/" + UserStorageProvider.class.getSimpleName());

        provider.setModel(model);
        provider.setSession(session);
        return provider;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
public String getId() {
    return "keycloak-jpa-provider";
}

@Override
public String getHelpText() {
    return "JPA Example User Storage Provider";
}

@Override
public void close() {
    logger.info("Closing factory");

}

公共类UserStorageProviderFactory实现org.keydape.storage.UserStorageProviderFactory{
私有静态最终记录器Logger=Logger.getLogger（UserStorageProviderFactory.class）；
@凌驾
public UserStorageProvider创建（keydeposition会话，ComponentModel）{
试一试{
InitialContext ctx=新的InitialContext（）；
info（“URL:”+“java:global/keydepot jpa/”+UserStorageProvider.class.getSimpleName（））；
UserStorageProvider=（UserStorageProvider）ctx.lookup（“java:global/keydepot jpa/”+UserStorageProvider.class.getSimpleName（））；
provider.setModel（model）；
提供者设置会话（会话）；
退货供应商；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
}
@凌驾
公共字符串getId（）{
返回“密钥斗篷jpa提供程序”；
}
@凌驾
公共字符串getHelpText（）{
返回“JPA示例用户存储提供程序”；
}
@凌驾
公众假期结束（）{
logger.info（“关闭工厂”）；
}

UserStorageProvider.java

@Stateful
@Local(UserStorageProvider.class)
public class UserStorageProvider implements org.keycloak.storage.UserStorageProvider,
    UserLookupProvider,
    UserQueryProvider,
    CredentialInputValidator,
    CredentialInputUpdater,
    OnUserCache {`


@PersistenceContext(unitName = "userDS")
protected EntityManager em;

private static final Logger logger = Logger.getLogger(UserStorageProvider.class);
public static final String PASSWORD_CACHE_KEY = UserAdapter.class.getName() + ".password";
protected KeycloakSession session;
protected ComponentModel model;

@Remove
@Override
public void close() {
    logger.info("ingresando close");
}

public void preRemove(RealmModel realm) {
    logger.info("ingresando preRemove(RealmModel realm)");
}

public void preRemove(RealmModel realm, GroupModel group) {
    logger.info("ingresando  preRemove(RealmModel realm, GroupModel group)");
}

public void preRemove(RealmModel realm, RoleModel role) {
    logger.info("ingresando preRemove(RealmModel realm, GroupModel group)");
}

public boolean updateCredential(RealmModel realmModel, UserModel userModel, CredentialInput credentialInput) {
    logger.info("ingresando updateCredential(RealmModel realmModel, UserModel userModel, CredentialInput credentialInput)");
    if (!supportsCredentialType(credentialInput.getType()) || !(credentialInput instanceof UserCredentialModel)) return false;
    UserCredentialModel cred = (UserCredentialModel) credentialInput;
    UserAdapter adapter = getUserAdapter(userModel);
    adapter.setPassword(cred.getValue());

    return true;
}

public void disableCredentialType(RealmModel realmModel, UserModel userModel, String s) {
    logger.info("ingresando disableCredentialType(RealmModel realmModel, UserModel userModel, String s)");
}

public Set<String> getDisableableCredentialTypes(RealmModel realmModel, UserModel userModel) {
    logger.info("ingresando getDisableableCredentialTypes(RealmModel realmModel, UserModel userModel)");
    return Collections.emptySet();
}

public boolean supportsCredentialType(String credentialType) {
    logger.info("ingresando supportsCredentialType(String credentialType)");
    return CredentialModel.PASSWORD.equals(credentialType);
}

public boolean isConfiguredFor(RealmModel realmModel, UserModel userModel, String credentialType) {
    logger.info("ingresando isConfiguredFor(RealmModel realmModel, UserModel userModel, String credentialType)");
    return supportsCredentialType(credentialType);
}

public boolean isValid(RealmModel realmModel, UserModel userModel, CredentialInput credentialInput) {
    logger.info("ingresando isValid(RealmModel realmModel, UserModel userModel, CredentialInput credentialInput)");
    if (!supportsCredentialType(credentialInput.getType()) || !(credentialInput instanceof UserCredentialModel)) return false;
    UserCredentialModel cred = (UserCredentialModel)credentialInput;
    String password = getPassword(userModel);
    return password != null && password.equals(cred.getValue());
}

public UserModel getUserById(String id, RealmModel realmModel) {
    logger.info("ingresando getUserById: " + id);
    String persistenceId = StorageId.externalId(id);
    User entity = em.find(User.class, persistenceId);
    if (entity == null) {
        logger.info("could not find user by id: " + id);
        return null;
    }
    return new UserAdapter(session, realmModel, model, entity);
}

public UserModel getUserByUsername(String userName, RealmModel realmModel) {
    logger.info("getUserByUsername: " + userName);
    TypedQuery<User> query = em.createNamedQuery("getUserByUsername", User.class);
    query.setParameter("username", userName);
    List<User> result = query.getResultList();
    if (result.isEmpty()) {
        logger.info("could not find username: " + userName);
        return null;
    }

    return new UserAdapter(session, realmModel, model, result.get(0));
}

public UserModel getUserByEmail(String s, RealmModel realmModel) {
    logger.info("ingresando getUserByEmail(String s, RealmModel realmModel)");
    return getUserByUsername(s, realmModel);
}

@Override
public int getUsersCount(RealmModel realmModel) {
    logger.info("ingresando getUsersCount(RealmModel realmModel)");
    Object count = em.createNamedQuery("getUserCount")
            .getSingleResult();
    return ((Number)count).intValue();
}

@Override
public List<UserModel> getUsers(final RealmModel realmModel) {
    logger.info("ingresando getUsers(final RealmModel realmModel)");
    return getUsers(realmModel, -1, -1);
}

@Override
public List<UserModel> getUsers(RealmModel realmModel, int firstResult, int maxResults) {
    TypedQuery<User> query = em.createNamedQuery("getAllUsers", User.class);
    return getUserModels(realmModel, firstResult, maxResults, query);
}

@Override
public List<UserModel> searchForUser(String search, RealmModel realmModel) {
    return searchForUser(search, realmModel, -1, -1);
}

@Override
public List<UserModel> searchForUser(String search, RealmModel realmModel,  int firstResult, int maxResults) {
    TypedQuery<User> query = em.createNamedQuery("searchForUser", User.class);
    query.setParameter("search", "%" + search.toLowerCase() + "%");
    return getUserModels(realmModel, firstResult, maxResults, query);
}

private List<UserModel> getUserModels(RealmModel realmModel, int firstResult, int maxResults, TypedQuery<User> query) {
    if (firstResult != -1) {
        query.setFirstResult(firstResult);
    }
    if (maxResults != -1) {
        query.setMaxResults(maxResults);
    }
    List<User> results = query.getResultList();
    List<UserModel> users = new LinkedList<>();
    for (User entity : results) users.add(new UserAdapter(session, realmModel, model, entity));
    return users;
}

@Override
public List<UserModel> searchForUser(Map<String, String> map, RealmModel realmModel) {
    System.out.println("ingresando searchForUser(Map<String, String> map, RealmModel realmModel)");
    return searchForUser("", realmModel);
}

@Override
public List<UserModel> searchForUser(Map<String, String> map, RealmModel realmModel, int i, int i1) {
    System.out.println("ingresando searchForUser(Map<String, String> map, RealmModel realmModel, int i, int i1)");
    return searchForUser("", realmModel);
}

@Override
public List<UserModel> getGroupMembers(RealmModel realmModel, GroupModel groupModel, int i, int i1) {
    System.out.println("ingresando getGroupMembers(RealmModel realmModel, GroupModel groupModel, int i, int i1)");
    return Collections.emptyList();
}

@Override
public List<UserModel> getGroupMembers(RealmModel realmModel, GroupModel groupModel) {
    System.out.println("ingresando getGroupMembers(RealmModel realmModel, GroupModel groupModel)");
    return Collections.emptyList();
}

@Override
public List<UserModel> searchForUserByUserAttribute(String s, String s1, RealmModel realmModel) {
    System.out.println("ingresando searchForUserByUserAttribute(String s, String s1, RealmModel realmModel)");
    return null;
}

@Override
public void onCache(RealmModel realmModel, CachedUserModel cachedUserModel, UserModel userModel) {
    String password = ((UserAdapter)userModel).getPassword();
    if (password != null) {
        cachedUserModel.getCachedWith().put(PASSWORD_CACHE_KEY, password);
    }
}

public String getPassword(UserModel user) {
    String password = null;
    if (user instanceof CachedUserModel) {
        password = (String)((CachedUserModel)user).getCachedWith().get(PASSWORD_CACHE_KEY);
    } else if (user instanceof UserAdapter) {
        password = ((UserAdapter)user).getPassword();
    }
    return password;
}

public UserAdapter getUserAdapter(UserModel user) {
    UserAdapter adapter = null;
    if (user instanceof CachedUserModel) {
        adapter = (UserAdapter)((CachedUserModel)user).getDelegateForUpdate();
    } else {
        adapter = (UserAdapter)user;
    }
    return adapter;
}

public void setModel(ComponentModel model) {
    this.model = model;`enter code here`
}

public void setSession(KeycloakSession session) {
    this.session = session;
}

@Stateful
@本地（UserStorageProvider.class）
公共类UserStorageProvider实现org.keydape.storage.UserStorageProvider，
UserLookupProvider，
UserQueryProvider，
认证验证者，
CredentialInputUpdater，
OnUserCache{`
@PersistenceContext（unitName=“userDS”）
受保护的实体管理器em；
私有静态最终记录器Logger=Logger.getLogger（UserStorageProvider.class）；
公共静态最终字符串密码\u缓存\u密钥=UserAdapter.class.getName（）+“.PASSWORD”；
受保护密钥会话；
受保护组件模型；
@除去
@凌驾
公众假期结束（）{
logger.info（“入口关闭”）；
}
公共void预删除（RealmModel领域）{
info（“Ingreando preRemove（RealmModel领域）”；
}
public void preRemove（RealmModel领域、GroupModel组）{
info（“Ingreando preRemove（RealmModel领域，GroupModel组）”；
}
public void preRemove（RealmModel领域，RoleModel角色）{
info（“Ingreando preRemove（RealmModel领域，GroupModel组）”；
}
public boolean updateCredential（realmodel realmodel、UserModel UserModel、CredentialInput CredentialInput）{
info（“Ingreando updateCredential（realmodel realmodel，UserModel UserModel，CredentialInput CredentialInput）”；
如果（！supportsCredentialType（credentialInput.getType（））| |！（UserCredentialModel的credentialInput实例））返回false；
UserCredentialModel cred=（UserCredentialModel）credentialInput；
UserAdapter=getUserAdapter（userModel）；
adapter.setPassword（cred.getValue（））；
返回true；
}
public void disableCredentialType（realmodel realmodel，UserModel UserModel，字符串s）{
info（“Ingreando disableCredentialType（realmodel realmodel，UserModel UserModel，String s）”；
}
公共集GetDisableCredentialTypes（RealmModel RealmModel、UserModel UserModel）{
info（“Ingreando GetDisableCredentialTypes（RealmModel RealmModel，UserModel UserModel）”；
返回集合；
}
公共布尔支持credentialType（字符串凭据类型）{
logger.info（“Ingreando supportsCredentialType（字符串凭证类型）”；
返回CredentialModel.PASSWORD.equals（credentialType）；
}
public boolean isConfiguredFor（realmodel realmodel、UserModel UserModel、String credentialType）{
info（“Ingreando配置为（realmodel realmodel，UserModel UserModel，String credentialType）”；
返回支持凭证类型（凭证类型）；
}
公共布尔值有效（realmodel realmodel、UserModel UserModel、CredentialInput CredentialInput）{
info（“Ingreando是有效的（realmodel realmodel，UserModel UserModel，CredentialInput CredentialInput）”；
如果（！supportsCredentialType（credentialInput.getType（））| |！（UserCredentialModel的credentialInput实例））返回false；
UserCredentialModel cred=（UserCredentialModel）credentialInput；
字符串password=getPassword（userModel）；
返回密码！=null&&password.equals（cred.getValue（））；
}
公共用户模型getUserById（字符串id，realmodel realmodel）{
logger.info（“Ingreando getUserById:+id”）；
字符串persistenceId=StorageId.externalId（id）；
用户实体=em.find（User.class，persistenceId）；
if（实体==null）{
logger.info（“无法通过id找到用户：“+id”）；
返回null；
}
返回新的UserAdapter（会话、realmodel、模型、实体）；
}
public UserModel getUserByUsername（字符串用户名，realmodel realmodel）{
logger.info（“getUserByUsername:+userName”）；
TypedQuery query=em.createNamedQuery（“getUserByUsername”，User.class）；
query.setParameter（“用户名”，用户名）；
List result=query.getResultList（）；
if（result.isEmpty（））{
logger.info（“找不到用户名：“+username”）；
返回null；
}
返回新的UserAdapter（session、realmodel、model、result.get（0））；
}
public UserModel getUserByEmail（字符串s，realmodel realmodel）{
info（“Ingreando getUserByEmail（字符串s，realmodel realmodel）”；
返回getUserByUsername（s，realmModel）；
}
@凌驾
public int getuserscont（realmodel realmodel）{
logger.info（“Ingreando GetUserScont（realmodel realmodel）”；
对象计数=em.createNamedQuery（“getUserCount”）
.getSingleResult（）；
返回（（数字）计数）.intV